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

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

 // Copyright (c) 2013, 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 compiler.src.inferrer.node_tracer;
 
 import '../common/names.dart' show Identifiers;
 import '../compiler.dart' show Compiler;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
@@ skipping 192 matching lines @@
 
   void visitBoolLiteralTypeInformation(BoolLiteralTypeInformation info) {}
 
   void visitClosureTypeInformation(ClosureTypeInformation info) {}
 
   void visitClosureCallSiteTypeInformation(
       ClosureCallSiteTypeInformation info) {}
 
   visitStaticCallSiteTypeInformation(StaticCallSiteTypeInformation info) {
     Element called = info.calledElement;
-    if (inferrer.types.getInferredTypeOf(called) == currentUser) {
-      addNewEscapeInformation(info);
+    if (called.isLocal) {
+      if (inferrer.types.getInferredTypeOfLocalFunction(called) ==
+          currentUser) {
+        addNewEscapeInformation(info);
+      }
+    } else {
+      if (inferrer.types.getInferredTypeOfMember(called) == currentUser) {
+        addNewEscapeInformation(info);
+      }
     }

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

nit: maybe use this style to avoid duplicating the body of the branches:

TypeInformation inferred = called.isLocal
  ? inferrer.types.getInferredTypeOfLocalFunction(called)
  : inferrer.types.getInferredTypeOfMember(called)

if (inferred == currentUser) addNewEscapeInformation(info);

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

Done.

   }
 
   void analyzeStoredIntoList(ListTypeInformation list) {
     inferrer.analyzeListAndEnqueue(list);
     if (list.bailedOut) {
       bailout('Stored in a list that bailed out');
     } else {
       list.flowsInto.forEach((flow) {
         flow.users.forEach((dynamic user) {
           if (user is! DynamicCallSiteTypeInformation) return;
@@ skipping 64 matching lines @@
 
   /**
    * Checks whether the call site flows the currentUser to the value argument of
    * an indexing setter. This must be kept in sync with
    * [isParameterOfListAddingMethod] and [isParameterOfMapAddingMethod].
    */
   bool isIndexSetValue(DynamicCallSiteTypeInformation info) {
     return isIndexSetArgument(info, 1);
   }
 
-  void bailoutIfReaches(bool predicate(Element e)) {
+  void bailoutIfReaches(bool predicate(ParameterElement e)) {
     for (var user in currentUser.users) {
       if (user is ParameterTypeInformation) {
         if (predicate(user.element)) {
           bailout('Reached suppressed parameter without precise receiver');
           break;
         }
       }
     }
   }
 
@@ skipping 75 matching lines @@
     }
 
     if (info.targetsIncludeComplexNoSuchMethod(inferrer) &&
         info.arguments != null &&
         info.arguments.contains(currentUser)) {
       bailout('Passed to noSuchMethod');
     }
 
     Iterable<TypeInformation> inferredTargetTypes =
         info.targets.map((MemberEntity entity) {
-      MemberElement element = entity;
-      return inferrer.types.getInferredTypeOf(element);
+      return inferrer.types.getInferredTypeOfMember(entity);
     });
     if (inferredTargetTypes.any((user) => user == currentUser)) {
       addNewEscapeInformation(info);
     }
   }
 
   /**
    * Check whether element is the parameter of a list adding method.
    * The definition of what a list adding method is has to stay in sync with
    * [mightAddToContainer].
    */
-  bool isParameterOfListAddingMethod(Element element) {
+  bool isParameterOfListAddingMethod(ParameterElement element) {
     if (!element.isRegularParameter) return false;
     if (element.enclosingClass !=
         inferrer.closedWorld.commonElements.jsArrayClass) {
       return false;
     }
     String name = element.enclosingElement.name;
     return (name == '[]=') || (name == 'add') || (name == 'insert');
   }
 
   /**
    * Check whether element is the parameter of a list adding method.
    * The definition of what a list adding method is has to stay in sync with
    * [isIndexSetKey] and [isIndexSetValue].
    */
-  bool isParameterOfMapAddingMethod(Element element) {
+  bool isParameterOfMapAddingMethod(ParameterElement element) {
     if (!element.isRegularParameter) return false;
     if (element.enclosingClass !=
         inferrer.closedWorld.commonElements.mapLiteralClass) {
       return false;
     }
     String name = element.enclosingElement.name;
     return (name == '[]=');
   }
 
   bool isClosure(Element element) {
@@ skipping 20 matching lines @@
     }
     if (info.element.isField &&
         !inferrer.compiler.backend.canFieldBeUsedForGlobalOptimizations(
             info.element, inferrer.closedWorld)) {
       bailout('Escape to code that has special backend treatment');
     }
     addNewEscapeInformation(info);
   }
 
   void visitParameterTypeInformation(ParameterTypeInformation info) {
-    ParameterElement element = info.element;
-    if (inferrer.isNativeMember(element.functionDeclaration)) {
+    if (inferrer.isNativeMember(info.declaration)) {
       bailout('Passed to a native method');
     }
     if (!inferrer.compiler.backend
         .canFunctionParametersBeUsedForGlobalOptimizations(
-            element.functionDeclaration, inferrer.closedWorld)) {
+            info.declaration, inferrer.closedWorld)) {
       bailout('Escape to code that has special backend treatment');
     }
-    if (isParameterOfListAddingMethod(element) ||
-        isParameterOfMapAddingMethod(element)) {
+    if (isParameterOfListAddingMethod(info.element) ||
+        isParameterOfMapAddingMethod(info.element)) {
       // These elements are being handled in
       // [visitDynamicCallSiteTypeInformation].
       return;
     }
     addNewEscapeInformation(info);
   }
 }