Don't call dinvoke on Object methods

lib/src/checker/rules.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.rules;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart';
+import 'package:dev_compiler/src/utils.dart' as utils;
 
 abstract class TypeRules {
   final TypeProvider provider;
   LibraryInfo currentLibraryInfo = null;
 
   TypeRules(TypeProvider this.provider);
 
   MissingTypeReporter reportMissingType;
 
   bool isSubTypeOf(DartType t1, DartType t2);
@@ skipping 15 matching lines @@
   bool maybeNonNullableType(DartType t) => false;
 
   StaticInfo checkAssignment(Expression expr, DartType t, bool constContext);
 
   DartType getStaticType(Expression expr) => expr.staticType;
 
   DartType elementType(Element e);
 
   bool isDynamic(DartType t);
   bool isDynamicTarget(Expression expr);
-  bool isDynamicGet(Expression expr);
   bool isDynamicCall(Expression call);
 }
 
 class DartRules extends TypeRules {
   DartRules(TypeProvider provider) : super(provider);
 
   MissingTypeReporter reportMissingType = null;
 
   bool isSubTypeOf(DartType t1, DartType t2) {
     return t1.isSubtypeOf(t2);
@@ skipping 12 matching lines @@
     return null;
   }
 
   DartType elementType(Element e) {
     return (e as dynamic).type;
   }
 
   /// By default, all invocations are dynamic in Dart.
   bool isDynamic(DartType t) => true;
   bool isDynamicTarget(Expression expr) => true;
-  bool isDynamicGet(Expression expr) => true;
   bool isDynamicCall(Expression call) => true;
 }
 
 typedef void MissingTypeReporter(Expression expr);
 
 class RestrictedRules extends TypeRules {
   MissingTypeReporter reportMissingType = null;
   final RulesOptions options;
   final List<DartType> _nonnullableTypes;
   DownwardsInference inferrer;
@@ skipping 431 matching lines @@
     return null;
   }
 
   DartType elementType(Element e) {
     return (e as dynamic).type;
   }
 
   bool isDynamic(DartType t) => options.ignoreTypes || t.isDynamic;
 
   /// Returns `true` if the target expression is dynamic.
-  bool isDynamicTarget(Expression expr) =>
-      options.ignoreTypes || getStaticType(expr).isDynamic;
-
-  /// Returns `true` if the expression is a dynamic property access or prefixed
-  /// identifier.
-  bool isDynamicGet(Expression expr) {
-    if (options.ignoreTypes) return true;
-    var t = getStaticType(expr);
-    // TODO(jmesserly): we should not allow all property gets on `Function`
-    return t.isDynamic || t.isDartCoreFunction;
-  }
+  bool isDynamicTarget(Expression target) =>

[Jennifer Messerly, 2015/04/07 23:00:20]

nice!!!

+      options.ignoreTypes || utils.isDynamicTarget(target);
 
   /// Returns `true` if the expression is a dynamic function call or method
   /// invocation.
   bool isDynamicCall(Expression call) {
     if (options.ignoreTypes) return true;
     var t = getStaticType(call);
     // TODO(jmesserly): fix handling of types with `call` methods. These are not
     // FunctionType, but they also aren't dynamic calls.
     if (t.isDynamic || t.isDartCoreFunction || t is! FunctionType) {
       return true;
@@ skipping 279 matching lines @@
     var entries = e.entries;
     bool inferEntry(MapLiteralEntry entry) {
       return _inferExpression(entry.key, kType, errors) &&
           _inferExpression(entry.value, vType, errors);
     }
     var b = entries.every(inferEntry);
     if (b) annotateMapLiteral(e, targs);
     return b;
   }
 }