fixes #192, encode dynamic info in checker

lib/src/checker/checker.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.checker.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/scanner.dart' show Token, TokenType;
@@ skipping 527 matching lines @@
       arg = (arg as NamedExpression).expression;
     }
     checkAssignment(arg, expectedType);
   }
 
   void checkFunctionApplication(
       Expression node, Expression f, ArgumentList list) {
     if (_rules.isDynamicCall(f)) {
       // If f is Function and this is a method invocation, we should have
       // gotten an analyzer error, so no need to issue another error.
-      _recordDynamicInvoke(node);
+      _recordDynamicInvoke(node, f);
     } else {
       checkArgumentList(list, _rules.getTypeAsCaller(f));
     }
   }
 
   @override
-  void visitMethodInvocation(MethodInvocation node) {
-    checkFunctionApplication(node, node.methodName, node.argumentList);
+  visitMethodInvocation(MethodInvocation node) {
+    var target = node.realTarget;
+    if (_rules.isDynamicTarget(target)) {
+      _recordDynamicInvoke(node, target);
+
+      // Mark the tear-off as being dynamic, too. This lets us distinguish
+      // cases like:
+      //
+      //     dynamic d;
+      //     d.someMethod(...); // the whole method call must be a dynamic send.
+      //
+      // ... from case like:
+      //
+      //     SomeType s;
+      //     s.someDynamicField(...); // static get, followed by dynamic call.
+      //
+      // The first case is handled here, the second case is handled below when
+      // we call [checkFunctionApplication].
+      DynamicInvoke.set(node.methodName, true);
+    } else {
+      checkFunctionApplication(node, node.methodName, node.argumentList);
+    }
     node.visitChildren(this);
   }
 
   @override
   void visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     checkFunctionApplication(node, node.function, node.argumentList);
     node.visitChildren(this);
   }
 
   @override
@@ skipping 48 matching lines @@
   }
 
   @override
   void visitReturnStatement(ReturnStatement node) {
     _checkReturn(node.expression, node);
     node.visitChildren(this);
   }
 
   @override
   void visitPropertyAccess(PropertyAccess node) {
-    if (node.staticType.isDynamic && _rules.isDynamicTarget(node.realTarget)) {
-      _recordDynamicInvoke(node);
+    var target = node.realTarget;
+    if (_rules.isDynamicTarget(target)) {
+      _recordDynamicInvoke(node, target);
     }
     node.visitChildren(this);
   }
 
   @override
   void visitPrefixedIdentifier(PrefixedIdentifier node) {
     final target = node.prefix;
     if (_rules.isDynamicTarget(target)) {
-      _recordDynamicInvoke(node);
+      _recordDynamicInvoke(node, target);
     }
     node.visitChildren(this);
   }
 
   @override
   void visitDefaultFormalParameter(DefaultFormalParameter node) {
     _visitMaybeConst(node, (node) {
       // Check that defaults have the proper subtype.
       var parameter = node.parameter;
       var parameterType = _rules.elementType(parameter.element);
@@ skipping 121 matching lines @@
     _checkUnary(node);
     node.visitChildren(this);
   }
 
   void _checkUnary(/*PrefixExpression|PostfixExpression*/ node) {
     var op = node.operator;
     if (op.isUserDefinableOperator ||
         op.type == TokenType.PLUS_PLUS ||
         op.type == TokenType.MINUS_MINUS) {
       if (_rules.isDynamicTarget(node.operand)) {
-        _recordDynamicInvoke(node);
+        _recordDynamicInvoke(node, node.operand);
       }
       // For ++ and --, even if it is not dynamic, we still need to check
       // that the user defined method accepts an `int` as the RHS.
       // We assume Analyzer has done this already.
     }
   }
 
   @override
   void visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
     if (op.isUserDefinableOperator) {
       if (_rules.isDynamicTarget(node.leftOperand)) {
         // Dynamic invocation
         // TODO(vsm): Move this logic to the resolver?
         if (op.type != TokenType.EQ_EQ && op.type != TokenType.BANG_EQ) {
-          _recordDynamicInvoke(node);
+          _recordDynamicInvoke(node, node.leftOperand);
         }
       } else {
         var element = node.staticElement;
         // Method invocation.
         if (element is MethodElement) {
           var type = element.type as FunctionType;
           // Analyzer should enforce number of parameter types, but check in
           // case we have erroneous input.
           if (type.normalParameterTypes.isNotEmpty) {
             checkArgument(node.rightOperand, type.normalParameterTypes[0]);
@@ skipping 20 matching lines @@
   }
 
   @override
   void visitConditionalExpression(ConditionalExpression node) {
     checkBoolean(node.condition);
     node.visitChildren(this);
   }
 
   @override
   void visitIndexExpression(IndexExpression node) {
-    if (_rules.isDynamicTarget(node.target)) {
-      _recordDynamicInvoke(node);
+    var target = node.realTarget;
+    if (_rules.isDynamicTarget(target)) {
+      _recordDynamicInvoke(node, target);
     } else {
       var element = node.staticElement;
       if (element is MethodElement) {
         var type = element.type as FunctionType;
         // Analyzer should enforce number of parameter types, but check in
         // case we have erroneous input.
         if (type.normalParameterTypes.isNotEmpty) {
           checkArgument(node.index, type.normalParameterTypes[0]);
         }
       } else {
@@ skipping 44 matching lines @@
     }
     return normalReturnType;
   }
 
   void _checkCompoundAssignment(AssignmentExpression expr) {
     var op = expr.operator.type;
     assert(op.isAssignmentOperator && op != TokenType.EQ);
     var methodElement = expr.staticElement;
     if (methodElement == null) {
       // Dynamic invocation
-      _recordDynamicInvoke(expr);
+      _recordDynamicInvoke(expr, expr.leftHandSide);
     } else {
       // Sanity check the operator
       assert(methodElement.isOperator);
       var functionType = methodElement.type;
       var paramTypes = functionType.normalParameterTypes;
       assert(paramTypes.length == 1);
       assert(functionType.namedParameterTypes.isEmpty);
       assert(functionType.optionalParameterTypes.isEmpty);
 
       // Check the lhs type
@@ skipping 23 matching lines @@
       // Check the rhs type
       if (staticInfo is! CoercionInfo) {
         var paramType = paramTypes.first;
         staticInfo = _rules.checkAssignment(
             expr.rightHandSide, paramType, _constantContext);
         _recordMessage(staticInfo);
       }
     }
   }
 
-  void _recordDynamicInvoke(AstNode node) {
-    _reporter.log(new DynamicInvoke(_rules, node));
+  void _recordDynamicInvoke(AstNode node, AstNode target) {
+    var dinvoke = new DynamicInvoke(_rules, node);
+    _reporter.log(dinvoke);
+    // TODO(jmesserly): we may eventually want to record if the whole operation
+    // (node) was dynamic, rather than the target, but this is an easier fit
+    // with what we used to do.
+    DynamicInvoke.set(target, true);
   }
 
   void _recordMessage(StaticInfo info) {
     if (info == null) return;
     if (info.level >= logger.Level.SEVERE) _failure = true;
     _reporter.log(info);
     if (info is CoercionInfo) {
       assert(CoercionInfo.get(info.node) == null);
       CoercionInfo.set(info.node, info);
     }
   }
 }