Screen dynamic invokes to object properties 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 508 matching lines @@
       // gotten an analyzer error, so no need to issue another error.
       _recordDynamicInvoke(node, f);
     } else {
       checkArgumentList(list, rules.getTypeAsCaller(f));
     }
   }
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     var target = node.realTarget;
-    if (rules.isDynamicTarget(target)) {
+    if (rules.isDynamicTarget(target) &&
+        !_isObjectMethod(node, node.methodName)) {
       _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:
       //
@@ skipping 63 matching lines @@
 
   @override
   void visitYieldStatement(YieldStatement node) {
     _checkReturnOrYield(node.expression, node, yieldStar: node.star != null);
     node.visitChildren(this);
   }
 
   @override
   void visitPropertyAccess(PropertyAccess node) {
     var target = node.realTarget;
-    if (rules.isDynamicTarget(target)) {
+    if (rules.isDynamicTarget(target) &&
+        !_isObjectProperty(target, node.propertyName)) {
       _recordDynamicInvoke(node, target);
     }
     node.visitChildren(this);
   }
 
   @override
   void visitPrefixedIdentifier(PrefixedIdentifier node) {
     final target = node.prefix;
-    if (rules.isDynamicTarget(target)) {
+    if (rules.isDynamicTarget(target) &&
+        !_isObjectProperty(target, node.identifier)) {
       _recordDynamicInvoke(node, target);
     }
     node.visitChildren(this);
   }
 
   @override
   void visitDefaultFormalParameter(DefaultFormalParameter node) {
     // Check that defaults have the proper subtype.
     var parameter = node.parameter;
     var parameterType = rules.elementType(parameter.element);
@@ skipping 280 matching lines @@
 
       // Check the rhs type
       if (staticInfo is! CoercionInfo) {
         var paramType = paramTypes.first;
         staticInfo = rules.checkAssignment(expr.rightHandSide, paramType);
         _recordMessage(staticInfo);
       }
     }
   }
 
+  bool _isObjectGetter(Expression target, SimpleIdentifier id) {
+    PropertyAccessorElement element =
+        rules.provider.objectType.element.getGetter(id.name);
+    return (element != null && !element.isStatic);
+  }
+
+  bool _isObjectMethod(Expression target, SimpleIdentifier id) {
+    MethodElement element =
+        rules.provider.objectType.element.getMethod(id.name);
+    return (element != null && !element.isStatic);
+  }
+
+  bool _isObjectProperty(Expression target, SimpleIdentifier id) {
+    return _isObjectGetter(target, id) || _isObjectMethod(target, id);
+  }
+
   void _recordDynamicInvoke(AstNode node, AstNode target) {
     reporter.onError(new DynamicInvoke(rules, node).toAnalysisError());
     // 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;
     var error = info.toAnalysisError();
     if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) _failure = true;
     reporter.onError(error);
 
     if (info is CoercionInfo) {
       // TODO(jmesserly): if we're run again on the same AST, we'll produce the
       // same annotations. This should be harmless. This might go away once
       // CodeChecker is integrated better with analyzer, as it will know that
       // checking has already been performed.
       // assert(CoercionInfo.get(info.node) == null);
       CoercionInfo.set(info.node, info);
     }
   }
 }