fixes #192, encode dynamic info in checker

lib/src/codegen/js_codegen.dart

 // Copyright (c) 2015, 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.
 
 library dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 1458 matching lines @@
     Expression target = null;
     SimpleIdentifier id;
     if (lhs is PropertyAccess) {
       target = _getTarget(lhs);
       id = lhs.propertyName;
     } else if (lhs is PrefixedIdentifier) {
       target = lhs.prefix;
       id = lhs.identifier;
     }
 
-    if (target != null && rules.isDynamicTarget(target)) {
+    if (target != null && DynamicInvoke.get(target)) {
       return js.call('dart.$DPUT(#, #, #)', [
         _visit(target),
         _emitMemberName(id.name, type: getStaticType(target)),
         _visit(rhs)
       ]);
     }
 
     return _visit(rhs).toAssignExpression(_visit(lhs));
   }
 
@@ skipping 20 matching lines @@
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     var target = node.isCascaded ? _cascadeTarget : node.target;
 
     var result = _emitForeignJS(node);
     if (result != null) return result;
 
     String code;
     if (target == null || isLibraryPrefix(target)) {
-      if (rules.isDynamicCall(node.methodName)) {
+      if (DynamicInvoke.get(node.methodName)) {
         code = 'dart.$DCALL(#, #)';
       } else {
         code = '#(#)';
       }
       return js.call(
           code, [_visit(node.methodName), _visit(node.argumentList)]);
     }
 
     var type = getStaticType(target);
     var name = node.methodName.name;
     var element = node.methodName.staticElement;
     bool isStatic = element is ExecutableElement && element.isStatic;
     var memberName = _emitMemberName(name, type: type, isStatic: isStatic);
 
-    if (rules.isDynamicTarget(target)) {
+    if (DynamicInvoke.get(target)) {
       code = 'dart.$DSEND(#, #, #)';
-    } else if (rules.isDynamicCall(node.methodName)) {
+    } else if (DynamicInvoke.get(node.methodName)) {
       // This is a dynamic call to a statically know target. For example:
       //     class Foo { Function bar; }
       //     new Foo().bar(); // dynamic call
       code = 'dart.$DCALL(#.#, #)';
     } else if (_requiresStaticDispatch(target, name)) {
       assert(rules.objectMembers[name] is FunctionType);
       // Object methods require a helper for null checks.
       return js.call('dart.#(#, #)', [
         memberName,
         _visit(target),
@@ skipping 21 matching lines @@
       assert(result is JS.Expression || node.parent is ExpressionStatement);
       return result;
     }
     return null;
   }
 
   @override
   JS.Expression visitFunctionExpressionInvocation(
       FunctionExpressionInvocation node) {
     var code;
-    if (rules.isDynamicCall(node.function)) {
+    if (DynamicInvoke.get(node.function)) {
       code = 'dart.$DCALL(#, #)';
     } else {
       code = '#(#)';
     }
     return js.call(code, [_visit(node.function), _visit(node.argumentList)]);
   }
 
   @override
   List<JS.Expression> visitArgumentList(ArgumentList node) {
     var args = <JS.Expression>[];
@@ skipping 390 matching lines @@
     // See [_isTemporary].
     // TODO(jmesserly): alternatives are
     // * (ab)use Element.isSynthetic, which isn't currently used for
     //   LocalVariableElementImpl, so we could repurpose to mean "temp".
     // * add a new property to LocalVariableElementImpl.
     // * create a new subtype of LocalVariableElementImpl to mark a temp.
     var id =
         new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, -1));
     id.staticElement = new TemporaryVariableElement.forNode(id);
     id.staticType = type;
+    DynamicInvoke.set(id, type.isDynamic);

[Jennifer Messerly, 2015/06/12 18:18:09]

this is the downside, it's one more bit to copy ...

     return id;
   }
 
   JS.Expression _emitConst(JS.Expression expr()) {
     // TODO(jmesserly): emit the constants at top level if possible.
     // This wasn't quite working, so disabled for now.
     return js.call('dart.const(#)', expr());
   }
 
   /// Returns a new expression, which can be be used safely *once* on the
   /// left hand side, and *once* on the right side of an assignment.
   /// For example: `expr1[expr2] += y` can be compiled as
   /// `expr1[expr2] = expr1[expr2] + y`.
   ///
   /// The temporary scope will ensure `expr1` and `expr2` are only evaluated
   /// once: `((x1, x2) => x1[x2] = x1[x2] + y)(expr1, expr2)`.
   ///
   /// If the expression does not end up using `x1` or `x2` more than once, or
   /// if those expressions can be treated as stateless (e.g. they are
   /// non-mutated variables), then the resulting code will be simplified
   /// automatically.
   ///
   /// [scope] can be mutated to contain any new temporaries that were created,
   /// unless [expr] is a SimpleIdentifier, in which case a temporary is not
   /// needed.
   Expression _bindLeftHandSide(
       Map<String, JS.Expression> scope, Expression expr, {Expression context}) {
+    Expression result;
     if (expr is IndexExpression) {
       IndexExpression index = expr;
-      return new IndexExpression.forTarget(
+      result = new IndexExpression.forTarget(
           _bindValue(scope, 'o', index.target, context: context),
           index.leftBracket,
           _bindValue(scope, 'i', index.index, context: context),
-          index.rightBracket)..staticType = expr.staticType;
+          index.rightBracket);
     } else if (expr is PropertyAccess) {
       PropertyAccess prop = expr;
-      return new PropertyAccess(
+      result = new PropertyAccess(
           _bindValue(scope, 'o', _getTarget(prop), context: context),
-          prop.operator, prop.propertyName)..staticType = expr.staticType;
+          prop.operator, prop.propertyName);
     } else if (expr is PrefixedIdentifier) {
       PrefixedIdentifier ident = expr;
-      return new PrefixedIdentifier(
+      result = new PrefixedIdentifier(
           _bindValue(scope, 'o', ident.prefix, context: context), ident.period,
-          ident.identifier)..staticType = expr.staticType;
+          ident.identifier);
+    } else {
+      return expr as SimpleIdentifier;
     }
-    return expr as SimpleIdentifier;
+    result.staticType = expr.staticType;
+    DynamicInvoke.set(result, DynamicInvoke.get(expr));
+    return result;
   }
 
   /// Creates a temporary to contain the value of [expr]. The temporary can be
   /// used multiple times in the resulting expression. For example:
   /// `expr ** 2` could be compiled as `expr * expr`. The temporary scope will
   /// ensure `expr` is only evaluated once: `(x => x * x)(expr)`.
   ///
   /// If the expression does not end up using `x` more than once, or if those
   /// expressions can be treated as stateless (e.g. they are non-mutated
   /// variables), then the resulting code will be simplified automatically.
@@ skipping 155 matching lines @@
     var member = memberId.staticElement;
     if (member is PropertyAccessorElement) {
       member = (member as PropertyAccessorElement).variable;
     }
     bool isStatic = member is ClassMemberElement && member.isStatic;
     if (isStatic) {
       _loader.declareBeforeUse(member);
     }
     var name = _emitMemberName(memberId.name,
         type: getStaticType(target), isStatic: isStatic);
-    if (rules.isDynamicTarget(target)) {
+    if (DynamicInvoke.get(target)) {
       return js.call('dart.$DLOAD(#, #)', [_visit(target), name]);
     }
 
     String code;
     if (member != null && member is MethodElement && !isStatic) {
       // Tear-off methods: explicitly bind it.
       // TODO(leafp): Attach runtime types to these static tearoffs
       if (_requiresStaticDispatch(target, memberId.name)) {
         return js.call('dart.#.bind(#)', [name, _visit(target)]);
       }
       code = 'dart.bind(#, #)';
     } else if (_requiresStaticDispatch(target, memberId.name)) {
       return js.call('dart.#(#)', [name, _visit(target)]);
     } else {
       code = '#.#';
     }
 
     return js.call(code, [_visit(target), name]);
   }
 
   /// Emits a generic send, like an operator method.
   ///
   /// **Please note** this function does not support method invocation syntax
   /// `obj.name(args)` because that could be a getter followed by a call.
   /// See [visitMethodInvocation].
   JS.Expression _emitSend(
       Expression target, String name, List<Expression> args) {
     var type = getStaticType(target);
     var memberName = _emitMemberName(name, unary: args.isEmpty, type: type);
-    if (rules.isDynamicTarget(target)) {
+    if (DynamicInvoke.get(target)) {
       // dynamic dispatch
       var dynamicHelper = const {'[]': DINDEX, '[]=': DSETINDEX}[name];
       if (dynamicHelper != null) {
         return js.call(
             'dart.$dynamicHelper(#, #)', [_visit(target), _visitList(args)]);
       }
       return js.call('dart.$DSEND(#, #, #)', [
         _visit(target),
         memberName,
         _visitList(args)
@@ skipping 534 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }