Split inference type-info accessors into members, parameters and local functions

pkg/compiler/lib/src/inferrer/type_graph_inferrer.dart

Index: pkg/compiler/lib/src/inferrer/type_graph_inferrer.dart
diff --git a/pkg/compiler/lib/src/inferrer/type_graph_inferrer.dart b/pkg/compiler/lib/src/inferrer/type_graph_inferrer.dart
index fd26e7c09bf14c67c2e337357cdfabe56370ce6a..4021d1283e72f010d29b591b5633f0db6bac6819 100644
--- a/pkg/compiler/lib/src/inferrer/type_graph_inferrer.dart
+++ b/pkg/compiler/lib/src/inferrer/type_graph_inferrer.dart
@@ -69,19 +69,44 @@ class TypeGraphInferrer implements TypesInferrer {
     inferrer.runOverAllElements();
   }
 
-  TypeMask getReturnTypeOfElement(Element element) {
+  @deprecated
+  TypeMask getReturnTypeOfLocalFunction(LocalFunctionElement element) {
+    if (compiler.disableTypeInference) return _dynamicType;
+    return inferrer.types.getInferredTypeOfLocalFunction(element).type;
+  }
+
+  TypeMask getReturnTypeOfMember(MemberElement element) {
     if (compiler.disableTypeInference) return _dynamicType;
     // Currently, closure calls return dynamic.
     if (element is! FunctionElement) return _dynamicType;

[Siggi Cherem (dart-lang), 2017/06/28 16:30:24]

should we require the parameter to be a MethodElement instead and delete this
check here?

[Johnni Winther, 2017/06/29 12:36:48]

Done.

-    return inferrer.types.getInferredTypeOf(element).type;
+    return inferrer.types.getInferredTypeOfMember(element).type;
+  }
+
+  TypeMask getReturnTypeOfParameter(ParameterElement element) {
+    if (compiler.disableTypeInference) return _dynamicType;
+    return _dynamicType;
   }
 
-  TypeMask getTypeOfElement(Element element) {
+  @deprecated
+  TypeMask getTypeOfLocalFunction(LocalFunctionElement element) {
+    if (compiler.disableTypeInference) return _dynamicType;
+    return commonMasks.functionType;
+  }
+
+  TypeMask getTypeOfMember(MemberElement element) {
     if (compiler.disableTypeInference) return _dynamicType;
     // The inferrer stores the return type for a function, so we have to
     // be careful to not return it here.
     if (element is FunctionElement) return commonMasks.functionType;
-    return inferrer.types.getInferredTypeOf(element).type;
+    return inferrer.types.getInferredTypeOfMember(element).type;
+  }
+
+  TypeMask getTypeOfParameter(ParameterElement element) {
+    if (compiler.disableTypeInference) return _dynamicType;
+    // The inferrer stores the return type for a function, so we have to
+    // be careful to not return it here.
+    if (element is FunctionElement) return commonMasks.functionType;
+    return inferrer.types.getInferredTypeOfParameter(element).type;
   }
 
   TypeMask getTypeForNewList(Element owner, ast.Node node) {
@@ -118,14 +143,13 @@ class TypeGraphInferrer implements TypesInferrer {
     Iterable<MemberEntity> elements =
         inferrer.closedWorld.locateMembers(selector, mask);
     for (MemberElement element in elements) {
-      TypeMask type =
-          inferrer.typeOfElementWithSelector(element, selector).type;
+      TypeMask type = inferrer.typeOfMemberWithSelector(element, selector).type;
       result = result.union(type, inferrer.closedWorld);
     }
     return result;
   }
 
-  Iterable<Element> getCallersOf(Element element) {
+  Iterable<Element> getCallersOf(MemberElement element) {
     if (compiler.disableTypeInference) {
       throw new UnsupportedError(
           "Cannot query the type inferrer when type inference is disabled.");
@@ -133,9 +157,25 @@ class TypeGraphInferrer implements TypesInferrer {
     return inferrer.getCallersOf(element);
   }
 
-  bool isCalledOnce(Element element) {
+  @deprecated
+  bool isLocalFunctionCalledOnce(LocalFunctionElement element) {
+    if (compiler.disableTypeInference) return false;
+    MemberTypeInformation info =
+        inferrer.types.getInferredTypeOfLocalFunction(element);
+    return info.isCalledOnce();
+  }
+
+  bool isMemberCalledOnce(MemberElement element) {
+    if (compiler.disableTypeInference) return false;
+    MemberTypeInformation info =
+        inferrer.types.getInferredTypeOfMember(element);
+    return info.isCalledOnce();
+  }
+
+  bool isParameterCalledOnce(ParameterElement element) {
     if (compiler.disableTypeInference) return false;
-    MemberTypeInformation info = inferrer.types.getInferredTypeOf(element);
+    MemberTypeInformation info =
+        inferrer.types.getInferredTypeOfParameter(element);
     return info.isCalledOnce();
   }