Generate static calls for Object fields and 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);
+  /// Map of fields / properties / methods on Object.
+  Map<String, DartType> _objectMembers;
+
+  TypeRules(TypeProvider this.provider) {

[Jennifer Messerly, 2015/04/23 21:09:30]

minor suggestion:

final Map<String, DartType> objectMembers;

TypeRules(TypeProvider provider)
  : provider = provider,
    objectMembers = utils.getObjectMemberMap(provider);

[vsm, 2015/04/23 21:23:32]

Done.

+    _objectMembers = utils.getObjectMemberMap(provider);
+  }
 
   MissingTypeReporter reportMissingType;
 
   bool isSubTypeOf(DartType t1, DartType t2);
   bool isAssignable(DartType t1, DartType t2);
 
   bool isGroundType(DartType t) => true;
   // TODO(vsm): The default implementation is not ignoring the return type,
   // only the restricted override is.
   bool isFunctionSubTypeOf(FunctionType f1, FunctionType f2,
@@ skipping 36 matching lines @@
     }
     if (t is FunctionType) return t;
     return null;
   }
 
   DartType elementType(Element e);
 
   bool isDynamic(DartType t);
   bool isDynamicTarget(Expression expr);
   bool isDynamicCall(Expression call);
+
+  Map<String, DartType> get objectMembers => _objectMembers;
 }
 
 class DartRules extends TypeRules {
   DartRules(TypeProvider provider) : super(provider);
 
   MissingTypeReporter reportMissingType = null;
 
   bool isSubTypeOf(DartType t1, DartType t2) {
     return t1.isSubtypeOf(t2);
   }
@@ skipping 753 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;
   }
 }