passing and good perf

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.

[Jennifer Messerly, 2012/01/18 00:03:00]

might be worth expanding this comment :)

as I read it: we have an interface F and member M declared on F. We also have a
class C that is a subtype of I. If we don't find M on C, look for a member on a
supertype of C. We need that because the supertype of C, which we'll call P,
might not be a subtype of I. So we find P.M and add that to our set.

The same problem doesn't happen with classes because they don't have multiple
inheritance.

In this case, couldn't you do "var mem = subtype.getMember(name)" ? I think that
would always work. You'll get duplicates sometimes--but the Set<Member> should
already handle the de-duplication.

(I'm kind of thinking ahead here to the "implicit interface" feature of classes.
Once we have that, we won't want to be checking "isClass" in as many places. I
don't think we really support "implicit interfaces" yet in Frog)

+          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.resolveMember(name);
-      if (p != null && p.containsProperties) {
-        return true;
-      }
+      var p = declaringType.parent.getProperty(name);
+      if (p != null && p.isProperty) return true;
+      if (p is FieldMember && p != this) return p.overridesProperty;
     }
     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) {
+    if (members.length == 1 && !isVar) {
       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;
-    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 (targets.length < 1000) {

[Jennifer Messerly, 2012/01/18 00:03:00]

nice fix. I like having limits for all of these potentially expensive things.

btw do we actually have some members with 1000 possible targets? :-)

+      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');
+      if (returnValue == null) {
+        return _makeError(node, target, 'method');
+      }
+    } else {
+      returnValue = new Value(world.varType, null, node.span);
     }
 
     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);
       });
     });
   }
 }