Fix dispatch on MemberSets to always go dynamic if needed.

frog/var_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 dynamic member stub. */
 class VarMember {
   final String name;
 
   VarMember(this.name);
 
@@ skipping 106 matching lines @@
   VarMethodStub(String name, this.member, this.args, this.body): super(name);
 
   Type get returnType() =>
       member != null ? member.returnType : world.varType;
 
   String get typeName() =>
       member != null ? member.declaringType.jsname : 'Object';
 
   void generate(CodeWriter code) {
     code.write('$typeName.prototype.$name = ');
-    generateBody(code);
-    code.writeln(';');
+    generateBody(code, ';');
   }
 
-  void generateBody(CodeWriter code) {
+  void generateBody(CodeWriter code, String end) {
     if (_useDirectCall(member, args)) {
-      code.write('$typeName.prototype.${member.jsname}');
+      code.writeln('$typeName.prototype.${member.jsname}$end');
     } else {
       code.enterBlock('function(${args.getCode()}) {');
       code.writeln('return ${body.code};');
-      code.exitBlock('}');
+      code.exitBlock('}$end');
     }
   }
 
   bool _useDirectCall(Member member, Arguments args) {
     // TODO(jmesserly): for now disallow direct references to DOM types until we
     // figure out which types can be patched reliably.
     // I don't think our other native libs have this issue.
     if (member is MethodMember && member.declaringType.library != world.dom) {
       MethodMember method = member;
       if (method.needsArgumentConversion(args)) {
@@ skipping 37 matching lines @@
 
   Value invoke(MethodGenerator context, Node node, Value target, Arguments args) {
     _invokeMembers(context, node);
     return super.invoke(context, node, target, args);
   }
 
   /** Invokes members to ensure they're generated. */
   _invokeMembers(MethodGenerator context, Node node) {
     if (_fallbackStubs != null) return;
 
+    var objectStub = null;
     _fallbackStubs = [];
     for (var member in members) {
       // Invoke the member with the stub args (this gives us the method body),
       // then create the stub method.
       final target = new Value(member.declaringType, 'this', node.span);
       var result = member.invoke(context, node, target, args);
       var stub = new VarMethodStub(name, member, args, result);
 
       // Put the stub on the type directly if possible. Otherwise
       // put the stub on Object.prototype.
       var type = member.declaringType;
-      if (type.library != world.dom && !type.isObject) {
+      if (type.isObject) {
+        objectStub = stub;
+      } else if (type.library != world.dom) {
         _addVarStub(type, stub);
       } else {
         _fallbackStubs.add(stub);
       }
     }
 
-    // Finally, invoke noSuchMethod
-    final target = new Value(world.objectType, 'this', node.span);
-    var result = target.invokeNoSuchMethod(context, baseName, node, args);
-    var stub = new VarMethodStub(name, null, args, result);
+    // Create a noSuchMethod fallback on Object if needed.
+    // Some methods, like toString and == already have a fallback on Object.
+    if (objectStub == null) {
+      final target = new Value(world.objectType, 'this', node.span);
+      var result = target.invokeNoSuchMethod(context, baseName, node, args);
+      objectStub = new VarMethodStub(name, null, args, result);
+    }
     if (_fallbackStubs.length == 0) {
-      _addVarStub(world.objectType, stub);
+      _addVarStub(world.objectType, objectStub);
     } else {
-      _fallbackStubs.add(stub);
+      _fallbackStubs.add(objectStub);
       world.gen.corejs.useVarMethod = true;
     }
   }
 
   static _addVarStub(Type type, VarMember stub) {
     if (type.varStubs == null) type.varStubs = {};
     type.varStubs[stub.name] = stub;
   }
 
   /**
    * Generate var call fallbacks, like this:
    *
    * $varMethod('addEventListener$1$capture', {
    *   'HTMLElement': function($0, capture) {
    *     return this.addEventListener($0, capture);
    *   },
    *   'SomeOtherDOMType': function($0, capture) {
    *     return this.addEventListener($0, false, true, capture);
    *   },
    *   'Object': function($0, capture) {
    *     return this.noSuchMethod('addEventListener', [$0],
    *       {'capture': capture});
    *   }
    * });
    */
   void generate(CodeWriter code) {
     if (_fallbackStubs.length == 0) return;
 
     code.enterBlock('\$varMethod("$name", {');
-    var lastOne = _fallbackStubs[_fallbackStubs.length - 1];
+    var lastOne = _fallbackStubs.last();
     for (var stub in _fallbackStubs) {
       code.write('"${stub.typeName}": ');
-      stub.generateBody(code);
-      code.writeln(stub == lastOne ? '' : ',');
+      stub.generateBody(code, stub == lastOne ? '' : ',');
     }
     code.exitBlock('});');
   }
 }
 
 String _getCallStubName(String name, Arguments args) {
   final nameBuilder = new StringBuffer('${name}\$${args.bareCount}');
   for (int i = args.bareCount; i < args.length; i++) {
     nameBuilder.add('\$').add(args.getName(i));
   }
   return nameBuilder.toString();
 }