Dynamically dispatch getters and setters on dynamically-typed variables.

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 1351 matching lines @@
     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);
   }
 
   bool _treatAsField;
   bool get treatAsField() {
     if (_treatAsField == null) {
-      _treatAsField = true;
+      // If this is the global MemberSet from world, always bind dynamically.
+      // Note: we need this for proper noSuchMethod and REPL behavior.
+      _treatAsField = !isVar;
       for (var member in members) {
         if (member.requiresFieldSyntax) {
           _treatAsField = true;
           break;
         }
         if (member.prefersPropertySyntax) {
           _treatAsField = false;
         }
       }
       for (var member in members) {
         if (_treatAsField) {
           member.provideFieldSyntax();
         } else {
           member.providePropertySyntax();
         }
       }
     }
     return _treatAsField;
   }
 
   Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
-    if (members.length == 1) {
-      return members[0]._get(context, node, target, isDynamic);
-    }
+    // If this is the global MemberSet from world, always bind dynamically.
+    // Note: we need this for proper noSuchMethod and REPL behavior.
+    Value returnValue;
     final targets = members.filter((m) => m.canGet);
-    if (targets.length == 1) {
-      return targets[0]._get(context, node, target, isDynamic);
+    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);
+      }
+
+      for (var member in targets) {
+        final value = member._get(context, node, target, isDynamic:true);
+        returnValue = _tryUnion(returnValue, value, node);
+      }
+      if (returnValue == null) {
+        return _makeError(node, target, 'getter');
+      }
     }
 
-    Value returnValue = null;
-    for (var member in targets) {
-      final value = member._get(context, node, target, isDynamic:true);
-      returnValue = _tryUnion(returnValue, value, node);
-    }
-    if (returnValue == null) {
-      return _makeError(node, target, 'getter');
-    }
     if (returnValue.code == null) {
       if (treatAsField) {
         return new Value(returnValue.type, '${target.code}.$jsname',
           node.span);
       } else {
         return new Value(returnValue.type, '${target.code}.get\$$jsname()',
           node.span);
       }
     }
     return returnValue;
   }
 
   Value _set(MethodGenerator context, Node node, Value target, Value value,
       [bool isDynamic=false]) {
-    if (members.length == 1) {
-      return members[0]._set(context, node, target, value, isDynamic);
-    }
+    // If this is the global MemberSet from world, always bind dynamically.
+    // Note: we need this for proper noSuchMethod and REPL behavior.
+    Value returnValue;
     final targets = members.filter((m) => m.canSet);
-    if (targets.length == 1) {
-      return targets[0]._set(context, node, target, value, isDynamic);
+    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) {
+        return targets[0]._set(context, node, target, value, isDynamic);
+      }
+
+      for (var member in targets) {
+        final res = member._set(context, node, target, value, isDynamic:true);
+        returnValue = _tryUnion(returnValue, res, node);
+      }
+      if (returnValue == null) {
+        return _makeError(node, target, 'setter');
+      }
     }
 
-    Value returnValue = null;
-    for (var member in targets) {
-      final res = member._set(context, node, target, value, isDynamic:true);
-      returnValue = _tryUnion(returnValue, res, node);
-    }
-    if (returnValue == null) {
-      return _makeError(node, target, 'setter');
-    }
     if (returnValue.code == null) {
       if (treatAsField) {
         return new Value(returnValue.type,
           '${target.code}.$jsname = ${value.code}', node.span);
       } else {
         return new Value(returnValue.type,
           '${target.code}.set\$$jsname(${value.code})', node.span);
       }
     }
     return returnValue;
@@ skipping 91 matching lines @@
       // Ensure that we're making stub with all possible members of this name.
       // We need this canonicalization step because only one VarMemberSet can
       // live on Object.prototype
       // TODO(jmesserly): this is ugly--we're throwing away type information!
       // The right solution is twofold:
       //   1. put stubs on a more precise type when possible
       //   2. merge VarMemberSets together if necessary
       final mset = context.findMembers(name).members;
 
       final targets = mset.filter((m) => m.canInvoke(context, args));
-      final returnType = reduce(map(targets, (t) => t.returnType), Type.union);
-      stub = new VarMethodSet(stubName, targets, args, returnType);
+      stub = new VarMethodSet(stubName, targets, args, _foldTypes(targets));
       world.objectType.varStubs[stubName] = stub;
     }
     return stub;
   }
+
+  Type _foldTypes(List<Member> targets) =>
+    reduce(map(targets, (t) => t.returnType), Type.union, world.varType);
 }
 
 /**
  * A [FactoryMap] maps type names to a list of factory constructors.
  * The constructors list is actually a map that maps factory names to
  * [MethodMember]. The reason why we need both indirections are:
  * 1) A class can define factory methods for multiple interfaces.
  * 2) A factory constructor can have a name.
  *
  * For example:
@@ skipping 47 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }