Use .callMethod instead of LocalFunctionElement as key in inference

pkg/compiler/lib/src/types/types.dart

 // Copyright (c) 2012, 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 types;
 
-import '../closure.dart' show SynthesizedCallMethodElementX;
 import '../common.dart' show failedAt;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../inferrer/type_graph_inferrer.dart' show TypeGraphInferrer;
 import '../inferrer/type_system.dart';
 import '../tree/tree.dart';
 import '../universe/selector.dart' show Selector;
 import '../util/util.dart' show Maplet;
@@ skipping 173 matching lines @@
   }
 
   void setCurrentTypeMask(ForIn node, TypeMask mask) {
     _set(node.inToken, mask);
   }
 }
 
 /// API to interact with the global type-inference engine.
 abstract class TypesInferrer {
   void analyzeMain(FunctionEntity element);
-
-  // We are moving away from using LocalFunctionElement to represent closures,
-  // but plan to use the <closure-class>.callMethod instead as the
-  // representation. At that point, we should be able to use
-  // getReturnTypeOfMember(callMethod).
-  @deprecated
-  TypeMask getReturnTypeOfLocalFunction(LocalFunctionElement element);
   TypeMask getReturnTypeOfMember(MemberElement element);
   TypeMask getReturnTypeOfParameter(ParameterElement element);
-
-  // We are moving away from using LocalFunctionElement to represent closures,
-  // but plan to use the <closure-class>.callMethod instead as the
-  // representation. At that point, we should be able to use
-  // getTypeOfMember(callMethod).
-  @deprecated
-  TypeMask getTypeOfLocalFunction(LocalFunctionElement element);
   TypeMask getTypeOfMember(MemberElement element);
   TypeMask getTypeOfParameter(ParameterElement element);
   TypeMask getTypeForNewList(Node node);
   TypeMask getTypeOfSelector(Selector selector, TypeMask mask);
   void clear();
-
-  // We are moving away from using LocalFunctionElement to represent closures,
-  // but plan to use the <closure-class>.callMethod instead as the
-  // representation. At that point, we should be able to use
-  // isMemberCalledOnce(callMethod).
-  @deprecated
-  bool isLocalFunctionCalledOnce(LocalFunctionElement element);
   bool isMemberCalledOnce(MemberElement element);
   bool isParameterCalledOnce(ParameterElement element);
   bool isFixedArrayCheckedForGrowable(Node node);
 }
 
 /// Results produced by the global type-inference algorithm.
 ///
 /// All queries in this class may contain results that assume whole-program
 /// closed-world semantics. Any [TypeMask] for an element or node that we return
 /// was inferred to be a "guaranteed type", that means, it is a type that we
@@ skipping 11 matching lines @@
   // TODO(sigmund,johnniwinther): compute result objects eagerly and make it an
   // error to query for results that don't exist.
   GlobalTypeInferenceElementResult resultOfMember(MemberElement member) {
     assert(
         !member.isGenerativeConstructorBody,
         failedAt(
             member,
             "unexpected input: ConstructorBodyElements are created"
             " after global type inference, no data is avaiable for them."));
 
-    // TODO(sigmund): store closure data directly in the closure element and
-    // not in the context of the enclosing method?
-    MemberElement key = (member is SynthesizedCallMethodElementX)
-        ? member.memberContext
-        : member;
     bool isJsInterop = closedWorld.nativeData.isJsInteropMember(member);
     return _memberResults.putIfAbsent(
         member,
         () => new GlobalTypeInferenceMemberResult(
             member,
-            _inferrer.inferrer.lookupDataOfMember(key),
+            // We store data in the context of the enclosing method, even
+            // for closure elements.
+            _inferrer.inferrer.lookupDataOfMember(member.memberContext),
             _inferrer,
             isJsInterop,
             dynamicType));
   }
 
   // TODO(sigmund,johnniwinther): compute result objects eagerly and make it an
   // error to query for results that don't exist.
   GlobalTypeInferenceElementResult resultOfParameter(
       ParameterElement parameter) {
     return _parameterResults.putIfAbsent(
@@ skipping 43 matching lines @@
     measure(() {
       typesInferrerInternal ??=
           new TypeGraphInferrer(compiler, closedWorld, closedWorldRefiner);
       typesInferrerInternal.analyzeMain(mainElement);
       typesInferrerInternal.clear();
       results = new GlobalTypeInferenceResults(typesInferrerInternal,
           closedWorld, typesInferrerInternal.inferrer.types);
     });
   }
 }