Revert "cleanup resolveMember and get/set"

frog/member.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /** A formal parameter to a [Method]. */
 class Parameter {
   FormalNode definition;
   Member method;
 
   String name;
@@ skipping 142 matching lines @@
       // I hope this trust is well placed!
       return world.nonNullBool;
     }
     return t;
   }
 
   Definition get definition() => null;
 
   List<Parameter> get parameters() => [];
 
-  MemberSet _preciseMemberSet, _potentialMemberSet;
-
-  MemberSet get preciseMemberSet() {
-    if (_preciseMemberSet === null) {
-      _preciseMemberSet = new MemberSet(this);
-    }
-    return _preciseMemberSet;
-  }
-
-  MemberSet get potentialMemberSet() {
-    if (_potentialMemberSet === null) {
-      if (declaringType.isObject) {
-        _potentialMemberSet = world._members[name];
-        return _potentialMemberSet;
-      }
-
-      final mems = new Set<Member>();
-      if (declaringType.isClass) mems.add(this);
-
-
-      for (var subtype in declaringType.subtypes) {
-        if (!subtype.isClass) continue;
-        var mem = subtype.members[name];
-        if (mem !== null) {
-          mems.add(mem);
-        } else if (!declaringType.isClass) {
-          // Handles weird interface case.
-          mem = subtype.getMember(name);
-          if (mem !== null) {
-            mems.add(mem);
-          }
-        }
-      }
-
-      if (mems.length != 0) {
-        for (var mem in mems) {
-          if (_potentialMemberSet === null) {
-            _potentialMemberSet = new MemberSet(mem);
-          } else {
-            _potentialMemberSet.add(mem);
-          }
-        }
-      }
-    }
-    return _potentialMemberSet;
-  }
-
-  // If I have an object of [type] could I be invoking this member?
-  bool isDefinedOn(Type type) {
-    if (type.isClass) {
-      if (declaringType.isSubtypeOf(type)) {
-        return true;
-      } else if (type.isSubtypeOf(declaringType)) {
-        // maybe - but not if overridden somewhere
-        // !!! horrible hack for today - awful perf props
-        return type.getMember(name) == this;
-        //return true;
-      } else {
-        return false;
-      }
-    } else {
-       if (declaringType.isSubtypeOf(type)) {
-         return true;
-       } else {
-         // If this is an interface, the actual implementation may
-         // come from a class that does not implement this interface.
-         for (var t in declaringType.subtypes) {
-           if (t.isSubtypeOf(type) && t.getMember(name) == this) {
-             return true;
-           }
-         }
-         return false;
-       }
-    }
-  }
-
   // TODO(jmesserly): isDynamic isn't a great name for this, something better?
   abstract Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic]);
 
   abstract Value _set(MethodGenerator context, Node node, Value target,
       Value value, [bool isDynamic]);
 
   bool canInvoke(MethodGenerator context, Arguments args) {
     // No source location needed because canInvoke may not produce errors.
     return canGet &&
@@ skipping 94 matching lines @@
 
   bool isStatic;
   bool isFinal;
   bool isNative;
 
   // TODO(jimhug): Better notion of fields that need special handling...
   bool get overridesProperty() {
     if (isStatic) return false;
 
     if (declaringType.parent != null) {
-      var p = declaringType.parent.getProperty(name);
-      if (p != null && p.isProperty) return true;
-      if (p is FieldMember && p != this) return p.overridesProperty;
+      var p = declaringType.parent.resolveMember(name);
+      if (p != null && p.containsProperties) {
+        return true;
+      }
     }
     return false;
   }
 
   bool override(Member other) {
     if (!super.override(other)) return false;
 
       // fields can override properties - but nothing else?
     if (other.isProperty) {
       // TODO(jimhug):
@@ skipping 1031 matching lines @@
       }
     }
     return _treatAsField;
   }
 
   Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
     // If this is the global MemberSet from world, always bind dynamically.
     // Note: we need this for proper noSuchMethod and REPL behavior.
     Value returnValue;
-    if (members.length == 1 && !isVar) {
-      return members[0]._get(context, node, target, isDynamic);
-    }
-
-
     final targets = members.filter((m) => m.canGet);
     if (isVar) {
       targets.forEach((m) => m._get(context, node, target, isDynamic: true));
       returnValue = new Value(_foldTypes(targets), null, node.span);
     } else {
       if (members.length == 1) {
         return members[0]._get(context, node, target, isDynamic);
       } else if (targets.length == 1) {
         return targets[0]._get(context, node, target, isDynamic);
       }
@@ skipping 16 matching lines @@
             node.span);
       }
     }
     return returnValue;
   }
 
   Value _set(MethodGenerator context, Node node, Value target, Value value,
       [bool isDynamic=false]) {
     // If this is the global MemberSet from world, always bind dynamically.
     // Note: we need this for proper noSuchMethod and REPL behavior.
-    if (members.length == 1 && !isVar) {
-      return members[0]._set(context, node, target, value, isDynamic);
-    }
-
     Value returnValue;
     final targets = members.filter((m) => m.canSet);
     if (isVar) {
       targets.forEach((m) =>
           m._set(context, node, target, value, isDynamic: true));
       returnValue = new Value(_foldTypes(targets), null, node.span);
     } else {
       if (members.length == 1) {
         return members[0]._set(context, node, target, value, isDynamic);
       } else if (targets.length == 1) {
@@ skipping 22 matching lines @@
   }
 
   Value invoke(MethodGenerator context, Node node, Value target,
       Arguments args, [bool isDynamic=false]) {
     // If this is the global MemberSet from world, always bind dynamically.
     // Note: we need this for proper noSuchMethod and REPL behavior.
     if (isVar && !isOperator) {
       return invokeOnVar(context, node, target, args);
     }
 
-    if (members.length == 1 && !isVar) {
+    if (members.length == 1) {
       return members[0].invoke(context, node, target, args, isDynamic);
     }
-
     final targets = members.filter((m) => m.canInvoke(context, args));
     if (targets.length == 1) {
       return targets[0].invoke(context, node, target, args, isDynamic);
     }
 
     Value returnValue = null;
-    if (targets.length < 1000) {
-      for (var member in targets) {
-        final res = member.invoke(context, node, target, args, isDynamic:true);
-        // TODO(jmesserly): If the code has different type checks, it will fail to
-        // unify and go through a dynamic stub. Good so far. However, we'll end
-        // up with a bogus unused temp generated (usually "var $0"). We need a way
-        // to throw away temps when we throw away the code.
-        returnValue = _tryUnion(returnValue, res, node);
-      }
+    for (var member in targets) {
+      final res = member.invoke(context, node, target, args, isDynamic:true);
+      // TODO(jmesserly): If the code has different type checks, it will fail to
+      // unify and go through a dynamic stub. Good so far. However, we'll end
+      // up with a bogus unused temp generated (usually "var $0"). We need a way
+      // to throw away temps when we throw away the code.
+      returnValue = _tryUnion(returnValue, res, node);
+    }
 
-      if (returnValue == null) {
-        return _makeError(node, target, 'method');
-      }
-    } else {
-      returnValue = new Value(world.varType, null, node.span);
+    if (returnValue == null) {
+      return _makeError(node, target, 'method');
     }
 
     if (returnValue.code == null) {
       if (name == ':call') {
         // TODO(jmesserly): reconcile this with similar code in Value
         return target._varCall(context, node, args);
       } else if (isOperator) {
         // TODO(jmesserly): make operators less special.
         return invokeSpecial(target, args, returnValue.type);
       } else {
@@ skipping 153 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }