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));

[nweiz, 2011/11/15 00:04:08]

This line seems to be slowing down the compilation by about two orders of
magnitude when using the release build of the VM and frogc.dart. This slowdown
doesn't occur on Node with frog.dart, and I'm at a bit of a loss as to why it's
happening. Could it be something relating to the VM's memory limit?

[Jennifer Messerly, 2011/11/15 04:44:34]

Sounds like it. I'd try passing: --new_gen_heap_size=64

[nweiz, 2011/11/15 20:59:25]

Increasing the heap size seems to do the trick. Is it safe to commit with the
slowdown for the default heap size? Should I increase the heap size in
presubmit.py?

[Jennifer Messerly, 2011/11/16 23:42:35]

Yes, definitely increase it there too. Maybe frog.py as well.

+      returnValue = new Value(world.varType, null, node.span);

[Jennifer Messerly, 2011/11/15 04:44:34]

I think you want to use a more precise type here, when possible. Something like:
final returnType = reduce(map(targets, (t) => t.returnType), Type.union)

This same line is used in "invokeOnVar", probably can just factor it out. (I've
come close to factoring it out a few times :) )

same comment for set_

[nweiz, 2011/11/15 20:59:25]

Done. I guess I was too much in the mindset of --force-dynamic.

+    } 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(world.varType, 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;
   }
 
   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) {
+      members.filter((m) => m.canInvoke(context, args)).forEach((m) =>

[Jennifer Messerly, 2011/11/15 04:44:34]

why did you need this line?

invokeOnVar already takes care of it (via VarMember).

[nweiz, 2011/11/15 20:59:25]

Oh, I suppose it does. I had assumed that it was necessary because the methods
were getting invoked below in the non-var case, but I guess that's just for
taking the union of the return values.

+          m.invoke(context, node, target, args, isDynamic: true));
       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);
     }
@@ skipping 147 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }