Use .callMethod instead of LocalFunctionElement as key in inference

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

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 105 matching lines @@
           element, () => new GlobalTypeInferenceElementData());
 
   GlobalTypeInferenceElementData lookupDataOfMember(MemberElement element) =>
       _memberData[element];
 
   /**
    * Update [sideEffects] with the side effects of [callee] being
    * called with [selector].
    */
   void updateSideEffects(
-      SideEffects sideEffects, Selector selector, Element callee) {
+      SideEffects sideEffects, Selector selector, MemberElement callee) {
     if (callee.isField) {
       if (callee.isInstanceMember) {
         if (selector.isSetter) {
           sideEffects.setChangesInstanceProperty();
         } else if (selector.isGetter) {
           sideEffects.setDependsOnInstancePropertyStore();
         } else {
           sideEffects.setAllSideEffects();
           sideEffects.setDependsOnSomething();
         }
       } else {
         if (selector.isSetter) {
           sideEffects.setChangesStaticProperty();
         } else if (selector.isGetter) {
           sideEffects.setDependsOnStaticPropertyStore();
         } else {
           sideEffects.setAllSideEffects();
           sideEffects.setDependsOnSomething();
         }
       }
     } else if (callee.isGetter && !selector.isGetter) {
       sideEffects.setAllSideEffects();
       sideEffects.setDependsOnSomething();
     } else {
-      sideEffects.add(
-          closedWorldRefiner.getCurrentlyKnownSideEffects(callee.declaration));
+      MethodElement method = callee.declaration;
+      sideEffects.add(closedWorldRefiner.getCurrentlyKnownSideEffects(method));
     }
   }
 
   /**
    * Returns the type for [nativeBehavior]. See documentation on
    * [native.NativeBehavior].
    */
   TypeInformation typeOfNativeBehavior(native.NativeBehavior nativeBehavior) {
     if (nativeBehavior == null) return types.dynamicType;
     List typesReturned = nativeBehavior.typesReturned;
@@ skipping 53 matching lines @@
         data.setIteratorTypeMask(node, mask);
       } else if (selector == Selectors.current) {
         data.setCurrentTypeMask(node, mask);
       } else {
         assert(selector == Selectors.moveNext);
         data.setMoveNextTypeMask(node, mask);
       }
     }
   }
 
-  bool isNativeMember(Element element) {
-    return element is MemberElement &&
-        closedWorld.nativeData.isNativeMember(element);
-  }
-
   bool checkIfExposesThis(ConstructorElement element) {
     element = element.implementation;
     return generativeConstructorsExposingThis.contains(element);
   }
 
   void recordExposesThis(ConstructorElement element, bool exposesThis) {
     element = element.implementation;
     if (exposesThis) {
       generativeConstructorsExposingThis.add(element);
     }
@@ skipping 102 matching lines @@
     types.allocatedLists.values.forEach((TypeInformation info) {
       analyzeListAndEnqueue(info);
     });
 
     // Try to infer the key and value types for maps and compute the values'
     // escape information.
     types.allocatedMaps.values.forEach((TypeInformation info) {
       analyzeMapAndEnqueue(info);
     });
 
-    Set<FunctionElement> bailedOutOn = new Set<FunctionElement>();
+    Set<MethodElement> bailedOutOn = new Set<MethodElement>();
 
     // Trace closures to potentially infer argument types.
     types.allocatedClosures.forEach((dynamic info) {
       void trace(
-          Iterable<FunctionElement> elements, ClosureTracerVisitor tracer) {
+          Iterable<MethodElement> elements, ClosureTracerVisitor tracer) {
         tracer.run();
         if (!tracer.continueAnalyzing) {
-          elements.forEach((FunctionElement e) {
+          elements.forEach((MethodElement e) {
             closedWorldRefiner.registerMightBePassedToApply(e);
             if (debug.VERBOSE) print("traced closure $e as ${true} (bail)");
             e.functionSignature.forEachParameter((parameter) {
               types
                   .getInferredTypeOfParameter(parameter)
                   .giveUp(this, clearAssignments: false);
             });
           });
           bailedOutOn.addAll(elements);
           return;
         }
         elements
             .where((e) => !bailedOutOn.contains(e))
-            .forEach((FunctionElement e) {
+            .forEach((MethodElement e) {
           e.functionSignature.forEachParameter((parameter) {
             var info = types.getInferredTypeOfParameter(parameter);
             info.maybeResume();
             workQueue.add(info);
           });
           if (tracer.tracedType.mightBePassedToFunctionApply) {
             closedWorldRefiner.registerMightBePassedToApply(e);
           }
           if (debug.VERBOSE) {
             print("traced closure $e as "
                 "${closedWorldRefiner
                 .getCurrentlyKnownMightBePassedToApply(e)}");
           }
         });
       }
 
       if (info is ClosureTypeInformation) {
-        Iterable<FunctionElement> elements = [info.closure];
+        Iterable<MethodElement> elements = [info.closure];
         trace(elements, new ClosureTracerVisitor(elements, info, this));
       } else if (info is CallSiteTypeInformation) {
         if (info is StaticCallSiteTypeInformation &&
             info.selector != null &&
             info.selector.isCall) {
           // This is a constructor call to a class with a call method. So we
           // need to trace the call method here.
           assert(info.calledElement.isGenerativeConstructor);
           ClassElement cls = info.calledElement.enclosingClass;
-          FunctionElement callMethod = cls.lookupMember(Identifiers.call);
+          MethodElement callMethod = cls.lookupMember(Identifiers.call);
           assert(callMethod != null, failedAt(cls));
-          Iterable<FunctionElement> elements = [callMethod];
+          Iterable<MethodElement> elements = [callMethod];
           trace(elements, new ClosureTracerVisitor(elements, info, this));
         } else {
           // We only are interested in functions here, as other targets
           // of this closure call are not a root to trace but an intermediate
           // for some other function.
-          Iterable<FunctionElement> elements = new List<FunctionElement>.from(
+          Iterable<MethodElement> elements = new List<MethodElement>.from(
               info.callees.where((e) => e.isFunction));
           trace(elements, new ClosureTracerVisitor(elements, info, this));
         }
       } else if (info is MemberTypeInformation) {
         trace([info.member],
             new StaticTearOffClosureTracerVisitor(info.member, info, this));
       } else if (info is ParameterTypeInformation) {
         throw new SpannableAssertionFailure(
             NO_LOCATION_SPANNABLE, 'Unexpected closure allocation info $info');
       }
@@ skipping 151 matching lines @@
       }
     } else {
       recordReturnType(element, type);
     }
   }
 
   void processLoopInformation() {
     types.allocatedCalls.forEach((dynamic info) {
       if (!info.inLoop) return;
       if (info is StaticCallSiteTypeInformation) {
-        closedWorldRefiner
-            .addFunctionCalledInLoop(info.calledElement.declaration);
+        MemberElement member = info.calledElement.declaration;
+        closedWorldRefiner.addFunctionCalledInLoop(member);
       } else if (info.mask != null && !info.mask.containsAll(closedWorld)) {
         // For instance methods, we only register a selector called in a
         // loop if it is a typed selector, to avoid marking too many
         // methods as being called from within a loop. This cuts down
         // on the code bloat.
         info.targets.forEach((MemberElement element) {
           closedWorldRefiner.addFunctionCalledInLoop(element);
         });
       }
     });
@@ skipping 184 matching lines @@
    * Returns the type of [element].
    */
   TypeInformation typeOfMember(MemberElement element) {
     if (element is MethodElement) return types.functionType;
     return types.getInferredTypeOfMember(element);
   }
 
   /**
    * Returns the return type of [element].
    */
-  @deprecated
-  TypeInformation returnTypeOfLocalFunction(LocalFunctionElement element) {
-    return types.getInferredTypeOfLocalFunction(element);
-  }
-
-  /**
-   * Returns the return type of [element].
-   */
   TypeInformation returnTypeOfMember(MemberElement element) {
     if (element is! MethodElement) return types.dynamicType;
     return types.getInferredTypeOfMember(element);
   }
 
   /**
    * Records that [node] sets final field [element] to be of type [type].
    *
    * [nodeHolder] is the element holder of [node].
    */
@@ skipping 14 matching lines @@
    */
   // TODO(johnniwinther): Merge [recordTypeOfFinalField] and
   // [recordTypeOfNonFinalField] with this?
   void recordTypeOfField(FieldElement element, TypeInformation type) {
     types.getInferredTypeOfMember(element).addAssignment(type);
   }
 
   /**
    * Records that the return type [element] is of type [type].
    */
-  @deprecated
-  void recordReturnTypeOfLocalFunction(
-      LocalFunctionElement element, TypeInformation type) {
-    TypeInformation info = types.getInferredTypeOfLocalFunction(element);
-    if (element.name == '==') {
-      // Even if x.== doesn't return a bool, 'x == null' evaluates to 'false'.
-      info.addAssignment(types.boolType);
-    }
-    // TODO(ngeoffray): Clean up. We do these checks because
-    // [SimpleTypesInferrer] deals with two different inferrers.
-    if (type == null) return;
-    if (info.assignments.isEmpty) info.addAssignment(type);
-  }
-
-  /**
-   * Records that the return type [element] is of type [type].
-   */
   void recordReturnType(MethodElement element, TypeInformation type) {
     TypeInformation info = types.getInferredTypeOfMember(element);
     if (element.name == '==') {
       // Even if x.== doesn't return a bool, 'x == null' evaluates to 'false'.
       info.addAssignment(types.boolType);
     }
     // TODO(ngeoffray): Clean up. We do these checks because
     // [SimpleTypesInferrer] deals with two different inferrers.
     if (type == null) return;
     if (info.assignments.isEmpty) info.addAssignment(type);
   }
 
   /**
    * Notifies to the inferrer that [analyzedElement] can have return
    * type [newType]. [currentType] is the type the [ElementGraphBuilder]
    * currently found.
    *
    * Returns the new type for [analyzedElement].
    */
-  @deprecated
-  TypeInformation addReturnTypeForLocalFunction(LocalFunctionElement element,
-      TypeInformation unused, TypeInformation newType) {
-    TypeInformation type = types.getInferredTypeOfLocalFunction(element);
-    // TODO(ngeoffray): Clean up. We do this check because
-    // [SimpleTypesInferrer] deals with two different inferrers.
-    if (element.isGenerativeConstructor) return type;
-    type.addAssignment(newType);
-    return type;
-  }
-
-  /**
-   * Notifies to the inferrer that [analyzedElement] can have return
-   * type [newType]. [currentType] is the type the [ElementGraphBuilder]
-   * currently found.
-   *
-   * Returns the new type for [analyzedElement].
-   */
   TypeInformation addReturnTypeForMethod(
       MethodElement element, TypeInformation unused, TypeInformation newType) {
     TypeInformation type = types.getInferredTypeOfMember(element);
     // TODO(ngeoffray): Clean up. We do this check because
     // [SimpleTypesInferrer] deals with two different inferrers.
     if (element.isGenerativeConstructor) return type;
     type.addAssignment(newType);
     return type;
   }
 
   /**
    * Registers that [caller] calls [callee] at location [node], with
    * [selector], and [arguments]. Note that [selector] is null for
    * forwarding constructors.
    *
    * [sideEffects] will be updated to incorporate [callee]'s side
    * effects.
    *
    * [inLoop] tells whether the call happens in a loop.
    */
-  @deprecated
-  TypeInformation registerCalledLocalFunction(
-      Spannable node,
-      Selector selector,
-      TypeMask mask,
-      MemberElement caller,
-      LocalFunctionElement callee,
-      ArgumentsTypes arguments,
-      SideEffects sideEffects,
-      bool inLoop) {
-    CallSiteTypeInformation info = new LocalFunctionCallSiteTypeInformation(
-        types.currentMember,
-        node,
-        caller,
-        callee,
-        selector,
-        mask,
-        arguments,
-        inLoop);
-    return _registerCalledElement(info, selector, callee, sideEffects);
-  }
-
-  /**
-   * Registers that [caller] calls [callee] at location [node], with
-   * [selector], and [arguments]. Note that [selector] is null for
-   * forwarding constructors.
-   *
-   * [sideEffects] will be updated to incorporate [callee]'s side
-   * effects.
-   *
-   * [inLoop] tells whether the call happens in a loop.
-   */
   TypeInformation registerCalledMember(
       Spannable node,
       Selector selector,
       TypeMask mask,
       MemberElement caller,
       MemberElement callee,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop) {
     CallSiteTypeInformation info = new StaticCallSiteTypeInformation(
         types.currentMember,
         node,
         caller,
         callee,
         selector,
         mask,
         arguments,
         inLoop);
-    return _registerCalledElement(info, selector, callee, sideEffects);
-  }
-
-  /**
-   * Registers that [caller] calls [callee] at location [node], with
-   * [selector], and [arguments]. Note that [selector] is null for
-   * forwarding constructors.
-   *
-   * [sideEffects] will be updated to incorporate [callee]'s side
-   * effects.
-   *
-   * [inLoop] tells whether the call happens in a loop.
-   */
-  TypeInformation _registerCalledElement(CallSiteTypeInformation info,
-      Selector selector, Element callee, SideEffects sideEffects) {
     // If this class has a 'call' method then we have essentially created a
     // closure here. Register it as such so that it is traced.
     // Note: we exclude factory constructors because they don't always create an
     // instance of the type. They are static methods that delegate to some other
     // generative constructor to do the actual creation of the object.
     if (selector != null && selector.isCall && callee.isGenerativeConstructor) {
       ClassElement cls = callee.enclosingClass;
       if (cls.callType != null) {
         types.allocatedClosures.add(info);
       }
@@ skipping 174 matching lines @@
       throw new UnsupportedError(
           "Cannot query the type inferrer when type inference is disabled.");
     }
     MemberTypeInformation info = types.getInferredTypeOfMember(element);
     return info.callers;
   }
 
   /**
    * Returns the type of [element] when being called with [selector].
    */
-  TypeInformation typeOfLocalFunctionWithSelector(
-      LocalFunctionElement element, Selector selector) {
-    return _typeOfElementWithSelector(element, selector);
-  }
-
-  /**
-   * Returns the type of [element] when being called with [selector].
-   */
   TypeInformation typeOfMemberWithSelector(
       MemberElement element, Selector selector) {
     return _typeOfElementWithSelector(element, selector);
   }
 
   /**
    * Returns the type of [element] when being called with [selector].
    */
   TypeInformation _typeOfElementWithSelector(
-      Element element, Selector selector) {
+      MemberElement element, Selector selector) {
     if (element.name == Identifiers.noSuchMethod_ &&
         selector.name != element.name) {
       // An invocation can resolve to a [noSuchMethod], in which case
       // we get the return type of [noSuchMethod].
-      if (element.isLocal) {
-        return returnTypeOfLocalFunction(element);
-      } else {
-        return returnTypeOfMember(element);
-      }
+      return returnTypeOfMember(element);
     } else if (selector.isGetter) {
       if (element.isFunction) {
         // [functionType] is null if the inferrer did not run.
         return types.functionType == null
             ? types.dynamicType
             : types.functionType;
       } else if (element.isField) {
         return typeOfMember(element);
       } else if (Elements.isUnresolved(element)) {
         return types.dynamicType;
       } else {
         assert(element.isGetter);
-        if (element.isLocal) {
-          return returnTypeOfLocalFunction(element);
-        } else {
-          return returnTypeOfMember(element);
-        }
+        return returnTypeOfMember(element);
       }
     } else if (element.isGetter || element.isField) {
       assert(selector.isCall || selector.isSetter);
       return types.dynamicType;
     } else {
-      if (element.isLocal) {
-        return returnTypeOfLocalFunction(element);
-      } else {
-        return returnTypeOfMember(element);
-      }
+      return returnTypeOfMember(element);
     }
   }
 
   /**
    * Records that the captured variable [local] is read.
    */
   void recordCapturedLocalRead(Local local) {}
 
   /**
    * Records that the variable [local] is being updated.
    */
   void recordLocalUpdate(Local local, TypeInformation type) {}
 }