Fix dispatch on MemberSets to always go dynamic if needed.

frog/member.dart

 // Copyright (c) 2011, 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;
 
   String name;
   Type type;
@@ skipping 102 matching lines @@
   bool get isField() => false;
   bool get isMethod() => false;
   bool get isProperty() => false;
   bool get isAbstract() => false;
 
   // TODO(jmesserly): these only makes sense on methods, but because of
   // ConcreteMember we need to support them on Member.
   bool get isConst() => false;
   bool get isFactory() => false;
 
+  bool get isOperator() => name.startsWith('\$');
+  bool get isCallMethod() => name == '\$call';
+
   bool get prefersPropertySyntax() => true;
   bool get requiresFieldSyntax() => false;
 
   bool get isNative() => false;
   String get constructorName() {
     world.internalError('can not be a constructor', span);
   }
 
   void provideFieldSyntax() => world.internalError('can not be field', span);
   void providePropertySyntax() =>
@@ skipping 787 matching lines @@
       return _invokeConstructor(context, node, target, args, argsString);
     }
 
     // TODO(jimhug): target really shouldn't ever be null...
     if (target != null && target.isSuper) {
       return new Value(inferredResult,
           '${declaringType.jsname}.prototype.$jsname.call($argsString)',
           node.span);
     }
 
-    if (name.startsWith('\$')) {
+    if (isOperator) {
       return _invokeBuiltin(context, node, target, args, argsCode, isDynamic);
     }
 
     if (isFactory) {
       return new Value(inferredResult, '$generatedFactoryName($argsString)',
         node.span);
     }
 
     if (isStatic) {
       if (declaringType.isTop) {
@@ skipping 271 matching lines @@
       } else if (target.type.isNum || target.type.isString) {
         // TODO(jimhug): Maybe check rhs.
         return new Value(inferredResult, '${target.code} $op ${argsCode[0]}',
           node.span);
       }
       world.gen.corejs.useOperator(name);
       return new Value(inferredResult, '$name(${target.code}, ${argsCode[0]})',
         node.span);
     }
 
-    if (name == '\$call') {
+    if (isCallMethod) {
       declaringType.markUsed();
       return new Value(inferredResult,
         '${target.code}(${Strings.join(argsCode, ", ")})', node.span);
     }
 
     if (name == '\$index') {
       world.gen.corejs.useIndex = true;
     } else if (name == '\$setindex') {
       world.gen.corejs.useSetIndex = true;
     }
@@ skipping 42 matching lines @@
           world.error('${mod} modifier not allowed on method', mod.span);
         }
       }
     }
 
     if (isFactory) {
       isStatic = true;
     }
 
     // TODO(jimhug): need a better annotation for being an operator method
-    if (name.startsWith('\$') && !name.startsWith('\$call') && isStatic) {
+    if (isOperator && isStatic && !isCallMethod) {
       world.error('operator method may not be static "${name}"', span);
     }
 
     if (isAbstract) {
       if (definition.body != null &&
           declaringType.definition is! FunctionTypeDefinition) {
         // TODO(jimhug): Creating function types for concrete methods is
         //   steadily feeling uglier...
         world.error('abstract method can not have a body', span);
       }
@@ skipping 30 matching lines @@
       library._addMember(this);
     }
   }
 }
 
 
 class MemberSet {
   final String name;
   final List<Member> members;
   final String jsname;
+  final bool isVar;
 
-  MemberSet(Member member):
-    name = member.name, members = [member], jsname = member.jsname;
+  MemberSet(Member member, [bool isVar=false]):

[nweiz, 2011/11/14 21:28:15]

Does isVar also need to be set for the library-local method sets for private
methods?

+    name = member.name, members = [member], jsname = member.jsname,
+    isVar = isVar;
 
   toString() => '$name:${members.length}';
 
   // TODO(jimhug): Still working towards the right logic for conflicts...
   bool get containsProperties() => members.some((m) => m is PropertyMember);
   bool get containsMethods() => members.some((m) => m is MethodMember);
 
+
   void add(Member member) => members.add(member);
 
   // TODO(jimhug): Always false, or is this needed?
   bool get isStatic() => members.length == 1 && members[0].isStatic;
+  bool get isOperator() => members[0].isOperator;
 
   bool canInvoke(MethodGenerator context, Arguments args) =>
     members.some((m) => m.canInvoke(context, args));
 
   Value _makeError(Node node, Value target, String action) {
     if (!target.type.isVar) {
       world.warning('could not find applicable $action for "$name"', node.span);
     }
     return new Value(world.varType,
       '${target.code}.$jsname() /*no applicable $action*/', node.span);
@@ skipping 78 matching lines @@
       } else {
         return new Value(returnValue.type,
           '${target.code}.set\$$jsname(${value.code})', node.span);
       }
     }
     return returnValue;
   }
 
   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) {
       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);
       returnValue = _tryUnion(returnValue, res, node);
     }
 
     if (returnValue == null) {
       return _makeError(node, target, 'method');
     }
 
-    // If we fail to unify the resulting code, implement as a var call.
     if (returnValue.code == null) {
-      if (name.startsWith('\$')) {
+      // TODO(jmesserly): make operators less special.
+      if (isOperator) {
         return target.invokeSpecial(name, args, returnValue.type);
       } else {
         return invokeOnVar(context, node, target, args);
       }
     }
 
     return returnValue;
   }
 
   Value invokeOnVar(MethodGenerator context, Node node, Value target,
       Arguments args) {
-    return getVarMember(context, node, args).invoke(context, node, target, args);
+    var member = getVarMember(context, node, args);
+    return member.invoke(context, node, target, args);
   }
 
   Value _union(Value x, Value y, Node node) {
     var result = _tryUnion(x, y, node);
     if (result.code == null) {
       world.internalError('mismatched code for $name (${x.code}, ${y.code})',
           node.span);
     }
     return result;
   }
@@ skipping 110 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }