Generate static calls for Object fields and methods

lib/src/checker/resolver.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.
 
 /// Encapsulates how to invoke the analyzer resolver and overrides how it
 /// computes types on expressions to use our restricted set of types.
 library dev_compiler.src.checker.resolver;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 551 matching lines @@
     visitor.overrideManager.currentScope = overrideScope;
     visitor.nameScope = nameScope;
   }
 }
 
 /// Overrides the default [StaticTypeAnalyzer] to adjust rules that are stricter
 /// in the restricted type system and to infer types for untyped local
 /// variables.
 class RestrictedStaticTypeAnalyzer extends StaticTypeAnalyzer {
   final TypeProvider _typeProvider;
+  Map<String, DartType> _objectMembers;
 
   RestrictedStaticTypeAnalyzer(ResolverVisitor r)
       : _typeProvider = r.typeProvider,
-        super(r);
+        super(r) {
+    _objectMembers = getObjectMemberMap(_typeProvider);
+  }
 
   static constructor(ResolverVisitor r) => new RestrictedStaticTypeAnalyzer(r);
 
   @override // to infer type from initializers
   visitVariableDeclaration(VariableDeclaration node) {
     _inferType(node);
     return super.visitVariableDeclaration(node);
   }
 
   /// Infer the type of a variable based on the initializer's type.
@@ skipping 55 matching lines @@
     var element = node.element as LocalVariableElementImpl;
     var exprType = expr.staticType;
     if (exprType is InterfaceType) {
       var iteratedType = _findIteratedType(exprType);
       if (iteratedType != null) {
         element.type = iteratedType;
       }
     }
   }
 
-  Map<String, DartType> _objectMemberMap = null;
-
-  Map<String, DartType> _getObjectMemberMap() {
-    if (_objectMemberMap == null) {
-      _objectMemberMap = new Map<String, DartType>();
-      var objectType = _typeProvider.objectType;
-      var element = objectType.element;
-      // Only record methods (including getters) with no parameters.  As parameters are contravariant wrt
-      // type, using Object's version may be too strict.
-      // Add instance methods.
-      element.methods
-          .where((method) => !method.isStatic && method.parameters.isEmpty)
-          .forEach((method) {
-        _objectMemberMap[method.name] = method.type;
-      });
-      // Add getters.
-      element.accessors
-          .where((member) => !member.isStatic && member.isGetter)
-          .forEach((member) {
-        _objectMemberMap[member.name] = member.type.returnType;
-      });
-    }
-    return _objectMemberMap;
-  }
-
   List<DartType> _sealedTypes = null;
 
   bool _isSealed(DartType t) {
     if (_sealedTypes == null) {
       // TODO(vsm): Use the analyzer's list - see dartbug.com/23125.
       _sealedTypes = <DartType>[
         _typeProvider.nullType,
         _typeProvider.numType,
         _typeProvider.intType,
         _typeProvider.doubleType,
         _typeProvider.boolType,
         _typeProvider.stringType
       ];
     }
     return _sealedTypes.contains(t);
   }
 
   @override // to propagate types to identifiers
   visitMethodInvocation(MethodInvocation node) {
     // TODO(jmesserly): we rely on having a staticType propagated to the
     // methodName identifier. This shouldn't be necessary for method calls, so
     // analyzer doesn't do it by default. Conceptually what we're doing here
     // is asking for a tear off. We need this until we can fix #132, and rely
     // on `node.staticElement == null` instead of `rules.isDynamicCall(node)`.
     visitSimpleIdentifier(node.methodName);
 
     super.visitMethodInvocation(node);
 
     // Search for Object methods.
-    var objectMap = _getObjectMemberMap();
     var name = node.methodName.name;
     if (node.staticType.isDynamic &&
-        objectMap.containsKey(name) &&
+        _objectMembers.containsKey(name) &&
         isDynamicTarget(node.target)) {
-      var type = objectMap[name];
-      if (type is FunctionType && node.argumentList.arguments.isEmpty) {
+      var type = _objectMembers[name];
+      if (type is FunctionType &&
+          type.parameters.isEmpty &&
+          node.argumentList.arguments.isEmpty) {
         node.target.staticType = _typeProvider.objectType;
         node.methodName.staticType = type;
         // Only infer the type of the overall expression if we have an exact
         // type - e.g., a sealed type.  Otherwise, it may be too strict.
         if (_isSealed(type.returnType)) {
           node.staticType = type.returnType;
         }
       }
     }
 
@@ skipping 13 matching lines @@
         var coreLib = _typeProvider.objectType.element.library;
         var classElem = coreLib.getType(args.first.stringValue);
         if (classElem != null) node.staticType = classElem.type;
       }
     }
   }
 
   void _inferObjectAccess(
       Expression node, Expression target, SimpleIdentifier id) {
     // Search for Object accesses.
-    var objectMap = _getObjectMemberMap();
     var name = id.name;
     if (node.staticType.isDynamic &&
-        objectMap.containsKey(name) &&
+        _objectMembers.containsKey(name) &&
         isDynamicTarget(target)) {
       target.staticType = _typeProvider.objectType;
-      var type = objectMap[name];
+      var type = _objectMembers[name];
       id.staticType = type;
       // Only infer the type of the overall expression if we have an exact
       // type - e.g., a sealed type.  Otherwise, it may be too strict.
       if (_isSealed(type)) {
         node.staticType = type;
       }
     }
   }
 
   @override
@@ skipping 29 matching lines @@
     }
   }
 
   // Review note: no longer need to override visitFunctionExpression, this is
   // handled by the analyzer internally.
   // TODO(vsm): in visitbinaryExpression: check computeStaticReturnType result?
   // TODO(vsm): in visitFunctionDeclaration: Should we ever use the expression
   // type in a (...) => expr or just the written type?
 
 }