Use entities in the InferrerEngine interface

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 68 matching lines @@
   void analyze(ResolvedAst resolvedAst, ArgumentsTypes arguments);
   void analyzeListAndEnqueue(ListTypeInformation info);
   void analyzeMapAndEnqueue(MapTypeInformation info);
 
   /// 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);
+      FunctionEntity element, TypeInformation unused, TypeInformation newType);
 
   /// Applies [f] to all elements in the universe that match [selector] and
   /// [mask]. If [f] returns false, aborts the iteration.
   void forEachElementMatching(
-      Selector selector, TypeMask mask, bool f(Element element));
+      Selector selector, TypeMask mask, bool f(MemberEntity element));
 
   /// Returns the [TypeInformation] node for the default value of a parameter.
   /// If this is queried before it is set by [setDefaultTypeOfParameter], a
   /// [PlaceholderTypeInformation] is returned, which will later be replaced
   /// by the actual node when [setDefaultTypeOfParameter] is called.
   ///
   /// Invariant: After graph construction, no [PlaceholderTypeInformation] nodes
   /// should be present and a default type for each parameter should exist.
-  TypeInformation getDefaultTypeOfParameter(ParameterElement parameter);
+  TypeInformation getDefaultTypeOfParameter(Local parameter);
 
   /// This helper breaks abstractions but is currently required to work around
   /// the wrong modeling of default values of optional parameters of
   /// synthetic constructors.
   ///
   /// TODO(johnniwinther): Remove once default values of synthetic parameters
   /// are fixed.
-  bool hasAlreadyComputedTypeOfParameterDefault(ParameterElement parameter);
+  bool hasAlreadyComputedTypeOfParameterDefault(Local parameter);
 
   /// Sets the type of a parameter's default value to [type]. If the global
   /// mapping in [defaultTypeOfParameter] already contains a type, it must be
   /// a [PlaceholderTypeInformation], which will be replaced. All its uses are
   /// updated.
-  void setDefaultTypeOfParameter(
-      ParameterElement parameter, TypeInformation type);
+  void setDefaultTypeOfParameter(Local parameter, TypeInformation type);
 
-  Iterable<MemberEntity> getCallersOf(MemberElement element);
+  Iterable<MemberEntity> getCallersOf(MemberEntity element);
 
   // TODO(johnniwinther): Make this private again.
-  GlobalTypeInferenceElementData dataOfMember(MemberElement element);
+  GlobalTypeInferenceElementData dataOfMember(MemberEntity element);
 
-  GlobalTypeInferenceElementData lookupDataOfMember(MemberElement element);
+  GlobalTypeInferenceElementData lookupDataOfMember(MemberEntity element);
 
-  bool checkIfExposesThis(ConstructorElement element);
+  bool checkIfExposesThis(ConstructorEntity element);
 
-  void recordExposesThis(ConstructorElement element, bool exposesThis);
+  void recordExposesThis(ConstructorEntity element, bool exposesThis);
 
   /// Records that the return type [element] is of type [type].
-  void recordReturnType(MethodElement element, TypeInformation type);
+  void recordReturnType(FunctionEntity element, TypeInformation type);
 
   /// Records that [element] is of type [type].
-  void recordTypeOfField(FieldElement element, TypeInformation type);
+  void recordTypeOfField(FieldEntity element, TypeInformation type);
 
   /// Registers a call to await with an expression of type [argumentType] as
   /// argument.
   TypeInformation registerAwait(ast.Node node, TypeInformation argument);
 
   /// Registers a call to yield with an expression of type [argumentType] as
   /// argument.
   TypeInformation registerYield(ast.Node node, TypeInformation argument);
 
   /// Registers that [caller] calls [closure] with [arguments].
   ///
   /// [sideEffects] will be updated to incorporate the potential callees' side
   /// effects.
   ///
   /// [inLoop] tells whether the call happens in a loop.
   TypeInformation registerCalledClosure(
       ast.Node node,
       Selector selector,
       TypeMask mask,
       TypeInformation closure,
-      MemberElement caller,
+      MemberEntity caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop);
 
   /// 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,
+      MemberEntity caller,
+      MemberEntity callee,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop);
 
   /// Registers that [caller] calls [selector] with [receiverType] as receiver,
   /// and [arguments].
   ///
   /// [sideEffects] will be updated to incorporate the potential callees' side
   /// effects.
   ///
   /// [inLoop] tells whether the call happens in a loop.
   TypeInformation registerCalledSelector(
       ast.Node node,
       Selector selector,
       TypeMask mask,
       TypeInformation receiverType,
-      MemberElement caller,
+      MemberEntity caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop,
       bool isConditional);
 
   /// Update the assignments to parameters in the graph. [remove] tells whether
   /// assignments must be added or removed. If [init] is false, parameters are
   /// added to the work queue.
   void updateParameterAssignments(TypeInformation caller, MemberEntity callee,
       ArgumentsTypes arguments, Selector selector, TypeMask mask,
       {bool remove, bool addToQueue: true});
 
   void updateSelectorInMember(
-      MemberElement owner, Spannable node, Selector selector, TypeMask mask);
+      MemberEntity owner, ast.Node node, Selector selector, TypeMask mask);
 
   /// Returns the return type of [element].
-  TypeInformation returnTypeOfMember(MemberElement element);
+  TypeInformation returnTypeOfMember(MemberEntity element);
 
   /// Returns the type of [element] when being called with [selector].
   TypeInformation typeOfMemberWithSelector(
-      MemberElement element, Selector selector);
+      MemberEntity element, Selector selector);
 
   /// Returns the type of [element].
-  TypeInformation typeOfMember(MemberElement element);
+  TypeInformation typeOfMember(MemberEntity element);
 
   /// Returns the type of [element].
-  TypeInformation typeOfParameter(ParameterElement element);
+  TypeInformation typeOfParameter(Local element);
 
   /// Returns the type for [nativeBehavior]. See documentation on
   /// [native.NativeBehavior].
   TypeInformation typeOfNativeBehavior(native.NativeBehavior nativeBehavior);
 
   bool returnsListElementType(Selector selector, TypeMask mask);
 
   bool returnsMapValueType(Selector selector, TypeMask mask);
 
   void clear();
@@ skipping 19 matching lines @@
   /// The [ClosedWorld] on which inference reasoning is based.
   final ClosedWorld closedWorld;
 
   final ClosedWorldRefiner closedWorldRefiner;
   final TypeSystem<ast.Node> types;
   final Map<ast.Node, TypeInformation> concreteTypes =
       new Map<ast.Node, TypeInformation>();
 
   final Map<ir.Node, TypeInformation> concreteKernelTypes =
       new Map<ir.Node, TypeInformation>();
-  final Set<ConstructorElement> generativeConstructorsExposingThis =
-      new Set<ConstructorElement>();
+  final Set<ConstructorEntity> generativeConstructorsExposingThis =
+      new Set<ConstructorEntity>();
 
   /// Data computed internally within elements, like the type-mask of a send a
   /// list allocation, or a for-in loop.
   final Map<MemberElement, GlobalTypeInferenceElementData> _memberData =
       new Map<MemberElement, GlobalTypeInferenceElementData>();
 
   InferrerEngineImpl(this.compiler, ClosedWorld closedWorld,
       this.closedWorldRefiner, this.mainElement)
       : this.types = new TypeSystem<ast.Node>(
             closedWorld, const TypeSystemStrategyImpl()),
         this.closedWorld = closedWorld;
 
   void forEachElementMatching(
-      Selector selector, TypeMask mask, bool f(Element element)) {
+      Selector selector, TypeMask mask, bool f(MemberEntity element)) {
     Iterable<MemberEntity> elements = closedWorld.locateMembers(selector, mask);
     for (MemberElement e in elements) {
-      if (!f(e.implementation)) return;
+      if (!f(e)) return;
     }
   }
 
   // TODO(johnniwinther): Make this private again.
-  GlobalTypeInferenceElementData dataOfMember(MemberElement element) =>
+  GlobalTypeInferenceElementData dataOfMember(MemberEntity element) =>
       _memberData.putIfAbsent(
           element, () => new GlobalTypeInferenceElementData());
 
-  GlobalTypeInferenceElementData lookupDataOfMember(MemberElement element) =>
+  GlobalTypeInferenceElementData lookupDataOfMember(MemberEntity element) =>
       _memberData[element];
 
   /**
    * Update [sideEffects] with the side effects of [callee] being
    * called with [selector].
    */
   void updateSideEffects(
       SideEffects sideEffects, Selector selector, MemberElement callee) {
     if (callee.isField) {
       if (callee.isInstanceMember) {
@@ skipping 56 matching lines @@
       }
       returnType = types.computeLUB(returnType, mappedType);
       if (returnType == types.dynamicType) {
         break;
       }
     }
     return returnType;
   }
 
   void updateSelectorInMember(
-      MemberElement owner, Spannable node, Selector selector, TypeMask mask) {
+      MemberEntity owner, ast.Node node, Selector selector, TypeMask mask) {
     GlobalTypeInferenceElementData data = dataOfMember(owner);
-    ast.Node astNode = node;
-    if (astNode.asSendSet() != null) {
+    if (node.asSendSet() != null) {
       if (selector.isSetter || selector.isIndexSet) {
         data.setTypeMask(node, mask);
       } else if (selector.isGetter || selector.isIndex) {
         data.setGetterTypeMaskInComplexSendSet(node, mask);
       } else {
         assert(selector.isOperator);
         data.setOperatorTypeMaskInComplexSendSet(node, mask);
       }
-    } else if (astNode.asSend() != null) {
+    } else if (node.asSend() != null) {
       data.setTypeMask(node, mask);
     } else {
-      assert(astNode.asForIn() != null);
+      assert(node.asForIn() != null);
       if (selector == Selectors.iterator) {
         data.setIteratorTypeMask(node, mask);
       } else if (selector == Selectors.current) {
         data.setCurrentTypeMask(node, mask);
       } else {
         assert(selector == Selectors.moveNext);
         data.setMoveNextTypeMask(node, mask);
       }
     }
   }
 
-  bool checkIfExposesThis(ConstructorElement element) {
-    element = element.implementation;
+  bool checkIfExposesThis(ConstructorEntity element) {
+    assert(!(element is ConstructorElement && !element.isDeclaration));
     return generativeConstructorsExposingThis.contains(element);
   }
 
-  void recordExposesThis(ConstructorElement element, bool exposesThis) {
-    element = element.implementation;
+  void recordExposesThis(ConstructorEntity element, bool exposesThis) {
+    assert(!(element is ConstructorElement && !element.isDeclaration));
     if (exposesThis) {
       generativeConstructorsExposingThis.add(element);
     }
   }
 
   bool returnsListElementType(Selector selector, TypeMask mask) {
     return mask != null &&
         mask.isContainer &&
         returnsListElementTypeSet.contains(selector);
   }
@@ skipping 246 matching lines @@
         ? new KernelTypeGraphBuilder(element, resolvedAst, compiler, this)
         : new ElementGraphBuilder(element, resolvedAst, compiler, this);
     TypeInformation type;
     reporter.withCurrentElement(element, () {
       // ignore: UNDEFINED_METHOD
       type = visitor.run();
     });
     addedInGraph++;
 
     if (element.isField) {
-      FieldElement fieldElement = element;
+      FieldElement field = element;
       ast.Node initializer = resolvedAst.body;
-      if (element.isFinal || element.isConst) {
+      if (field.isFinal || field.isConst) {
         // If [element] is final and has an initializer, we record
         // the inferred type.
         if (resolvedAst.body != null) {
           if (type is! ListTypeInformation && type is! MapTypeInformation) {
             // For non-container types, the constant handler does
             // constant folding that could give more precise results.
-            ConstantExpression constant = fieldElement.constant;
+            ConstantExpression constant = field.constant;
             if (constant != null) {
               ConstantValue value =
                   compiler.backend.constants.getConstantValue(constant);
               if (value != null) {
                 if (value.isFunction) {
                   FunctionConstantValue functionConstant = value;
                   MethodElement function = functionConstant.element;
                   type = types.allocateClosure(function);
                 } else {
                   // Although we might find a better type, we have to keep
                   // the old type around to ensure that we get a complete view
                   // of the type graph and do not drop any flow edges.
                   TypeMask refinedType = computeTypeMask(closedWorld, value);
                   assert(TypeMask.assertIsNormalized(refinedType, closedWorld));
                   type = new NarrowTypeInformation(type, refinedType);
                   types.allocatedTypes.add(type);
                 }
               } else {
                 assert(
-                    fieldElement.isInstanceMember ||
+                    field.isInstanceMember ||
                         constant.isImplicit ||
                         constant.isPotential,
                     failedAt(
-                        fieldElement,
+                        field,
                         "Constant expression without value: "
                         "${constant.toStructuredText()}."));
               }
             }
           }
-          recordTypeOfField(element, type);
+          recordTypeOfField(field, type);
         } else if (!element.isInstanceMember) {
-          recordTypeOfField(element, types.nullType);
+          recordTypeOfField(field, types.nullType);
         }
       } else if (initializer == null) {
         // Only update types of static fields if there is no
         // assignment. Instance fields are dealt with in the constructor.
         if (Elements.isStaticOrTopLevelField(element)) {
-          recordTypeOfField(element, type);
+          recordTypeOfField(field, type);
         }
       } else {
-        recordTypeOfField(element, type);
+        recordTypeOfField(field, type);
       }
-      if (Elements.isStaticOrTopLevelField(element) &&
+      if (Elements.isStaticOrTopLevelField(field) &&
           resolvedAst.body != null &&
           !element.isConst) {
         dynamic argument = resolvedAst.body;
         // TODO(13429): We could do better here by using the
         // constant handler to figure out if it's a lazy field or not.
         if (argument.asSend() != null ||
             (argument.asNewExpression() != null && !argument.isConst)) {
-          recordTypeOfField(element, types.nullType);
+          recordTypeOfField(field, types.nullType);
         }
       }
     } else {
-      recordReturnType(element, type);
+      MethodElement method = element;
+      recordReturnType(method, type);
     }
   }
 
   void processLoopInformation() {
     types.allocatedCalls.forEach((dynamic info) {
       if (!info.inLoop) return;
       if (info is StaticCallSiteTypeInformation) {
         MemberEntity member = info.calledElement;
         closedWorldRefiner.addFunctionCalledInLoop(member);
       } else if (info.mask != null && !info.mask.containsAll(closedWorld)) {
@@ skipping 114 matching lines @@
         } else {
           info.addAssignment(type);
         }
         parameterIndex++;
         if (addToQueue) workQueue.add(info);
       });
     }
   }
 
   void setDefaultTypeOfParameter(
-      ParameterElement parameter, TypeInformation type) {
+      covariant ParameterElement parameter, TypeInformation type) {
     assert(parameter.functionDeclaration.isImplementation);
     TypeInformation existing = defaultTypeOfParameter[parameter];
     defaultTypeOfParameter[parameter] = type;
     TypeInformation info = types.getInferredTypeOfParameter(parameter);
     if (existing != null && existing is PlaceholderTypeInformation) {
       // Replace references to [existing] to use [type] instead.
       if (parameter.functionDeclaration.isInstanceMember) {
         ParameterAssignments assignments = info.assignments;
         assignments.replace(existing, type);
       } else {
         List<TypeInformation> assignments = info.assignments;
         for (int i = 0; i < assignments.length; i++) {
           if (assignments[i] == existing) {
             assignments[i] = type;
           }
         }
       }
       // Also forward all users.
       type.addUsersOf(existing);
     } else {
       assert(existing == null);
     }
   }
 
-  TypeInformation getDefaultTypeOfParameter(ParameterElement parameter) {
+  TypeInformation getDefaultTypeOfParameter(Local parameter) {
     return defaultTypeOfParameter.putIfAbsent(parameter, () {
       return new PlaceholderTypeInformation(types.currentMember);
     });
   }
 
-  bool hasAlreadyComputedTypeOfParameterDefault(ParameterElement parameter) {
+  bool hasAlreadyComputedTypeOfParameterDefault(Local parameter) {
     TypeInformation seen = defaultTypeOfParameter[parameter];
     return (seen != null && seen is! PlaceholderTypeInformation);
   }
 
-  TypeInformation typeOfParameter(ParameterElement element) {
+  TypeInformation typeOfParameter(Local element) {
     return types.getInferredTypeOfParameter(element);
   }
 
-  TypeInformation typeOfMember(MemberElement element) {
-    if (element is MethodElement) return types.functionType;
+  TypeInformation typeOfMember(MemberEntity element) {
+    if (element is FunctionEntity) return types.functionType;
     return types.getInferredTypeOfMember(element);
   }
 
-  TypeInformation returnTypeOfMember(MemberElement element) {
-    if (element is! MethodElement) return types.dynamicType;
+  TypeInformation returnTypeOfMember(MemberEntity element) {
+    if (element is! FunctionEntity) return types.dynamicType;
     return types.getInferredTypeOfMember(element);
   }
 
-  void recordTypeOfField(FieldElement element, TypeInformation type) {
+  void recordTypeOfField(FieldEntity element, TypeInformation type) {
     types.getInferredTypeOfMember(element).addAssignment(type);
   }
 
-  void recordReturnType(MethodElement element, TypeInformation type) {
+  void recordReturnType(FunctionEntity 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);
   }
 
-  TypeInformation addReturnTypeForMethod(
-      MethodElement element, TypeInformation unused, TypeInformation newType) {
+  TypeInformation addReturnTypeForMethod(covariant 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;
   }
 
   TypeInformation registerCalledMember(
       Spannable node,
       Selector selector,
       TypeMask mask,
-      MemberElement caller,
-      MemberElement callee,
+      MemberEntity caller,
+      covariant MemberElement callee,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop) {
     CallSiteTypeInformation info = new StaticCallSiteTypeInformation(
         types.currentMember,
         node,
         caller,
         callee,
         selector,
         mask,
@@ skipping 14 matching lines @@
     types.allocatedCalls.add(info);
     updateSideEffects(sideEffects, selector, callee);
     return info;
   }
 
   TypeInformation registerCalledSelector(
       ast.Node node,
       Selector selector,
       TypeMask mask,
       TypeInformation receiverType,
-      MemberElement caller,
+      MemberEntity caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop,
       bool isConditional) {
     if (selector.isClosureCall) {
       return registerCalledClosure(node, selector, mask, receiverType, caller,
           arguments, sideEffects, inLoop);
     }
 
     closedWorld.locateMembers(selector, mask).forEach((_callee) {
@@ skipping 31 matching lines @@
     info.addAssignment(argument);
     types.allocatedTypes.add(info);
     return info;
   }
 
   TypeInformation registerCalledClosure(
       ast.Node node,
       Selector selector,
       TypeMask mask,
       TypeInformation closure,
-      MemberElement caller,
+      MemberEntity caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop) {
     sideEffects.setDependsOnSomething();
     sideEffects.setAllSideEffects();
     CallSiteTypeInformation info = new ClosureCallSiteTypeInformation(
         types.currentMember,
         node,
         caller,
         selector,
@@ skipping 65 matching lines @@
     types.allocatedClosures.forEach(cleanup);
     types.allocatedClosures.clear();
 
     analyzedElements.clear();
     generativeConstructorsExposingThis.clear();
 
     types.allocatedMaps.values.forEach(cleanup);
     types.allocatedLists.values.forEach(cleanup);
   }
 
-  Iterable<MemberEntity> getCallersOf(MemberElement element) {
+  Iterable<MemberEntity> getCallersOf(MemberEntity element) {
     if (compiler.disableTypeInference) {
       throw new UnsupportedError(
           "Cannot query the type inferrer when type inference is disabled.");
     }
     MemberTypeInformation info = types.getInferredTypeOfMember(element);
     return info.callers;
   }
 
   TypeInformation typeOfMemberWithSelector(
-      MemberElement element, Selector selector) {
+      covariant 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].
       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
@@ skipping 108 matching lines @@
   @override
   bool checkPhiNode(ast.Node node) {
     return true;
   }
 
   @override
   bool checkClassEntity(covariant ClassElement cls) {
     return cls.isDeclaration;
   }
 }