Use more entities in InferrerEngineImpl

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 96 matching lines @@
   /// synthetic constructors.
   ///
   /// TODO(johnniwinther): Remove once default values of synthetic parameters
   /// are fixed.
   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(Local parameter, TypeInformation type);
+  void setDefaultTypeOfParameter(Local parameter, TypeInformation type,
+      {bool isInstanceMember});
 
   Iterable<MemberEntity> getCallersOf(MemberEntity element);
 
   // TODO(johnniwinther): Make this private again.
   GlobalTypeInferenceElementData dataOfMember(MemberEntity element);
 
   GlobalTypeInferenceElementData lookupDataOfMember(MemberEntity element);
 
   bool checkIfExposesThis(ConstructorEntity element);
 
@@ skipping 92 matching lines @@
   TypeInformation typeOfNativeBehavior(native.NativeBehavior nativeBehavior);
 
   bool returnsListElementType(Selector selector, TypeMask mask);
 
   bool returnsMapValueType(Selector selector, TypeMask mask);
 
   void clear();
 }
 
 class InferrerEngineImpl extends InferrerEngine {
-  final Map<ParameterElement, TypeInformation> defaultTypeOfParameter =
-      new Map<ParameterElement, TypeInformation>();
+  final Map<Local, TypeInformation> defaultTypeOfParameter =
+      new Map<Local, TypeInformation>();
   final WorkQueue workQueue = new WorkQueue();
   final FunctionEntity mainElement;
-  final Set<MemberElement> analyzedElements = new Set<MemberElement>();
+  final Set<MemberEntity> analyzedElements = new Set<MemberEntity>();
 
   /// The maximum number of times we allow a node in the graph to
   /// change types. If a node reaches that limit, we give up
   /// inferencing on it and give it the dynamic type.
   final int MAX_CHANGE_COUNT = 6;
 
   int overallRefineCount = 0;
   int addedInGraph = 0;
 
   final Compiler compiler;
 
   /// 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<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>();
+  final Map<MemberEntity, GlobalTypeInferenceElementData> _memberData =
+      new Map<MemberEntity, 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(MemberEntity element)) {
     Iterable<MemberEntity> elements = closedWorld.locateMembers(selector, mask);
-    for (MemberElement e in elements) {
+    for (MemberEntity e in elements) {
       if (!f(e)) return;
     }
   }
 
   // TODO(johnniwinther): Make this private again.
   GlobalTypeInferenceElementData dataOfMember(MemberEntity element) =>
       _memberData.putIfAbsent(
           element, () => new GlobalTypeInferenceElementData());
 
   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) {
+      SideEffects sideEffects, Selector selector, MemberEntity callee) {
+    assert(!(callee is MemberElement && !callee.isDeclaration));
     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 {
-      MethodElement method = callee.declaration;
-      sideEffects.add(closedWorldRefiner.getCurrentlyKnownSideEffects(method));
+      sideEffects.add(closedWorldRefiner.getCurrentlyKnownSideEffects(callee));
     }
   }
 
   TypeInformation typeOfNativeBehavior(native.NativeBehavior nativeBehavior) {
     if (nativeBehavior == null) return types.dynamicType;
     List typesReturned = nativeBehavior.typesReturned;
     if (typesReturned.isEmpty) return types.dynamicType;
     TypeInformation returnType;
     for (var type in typesReturned) {
       TypeInformation mappedType;
@@ skipping 200 matching lines @@
           }
           if (debug.VERBOSE) {
             print("traced closure $element as "
                 "${closedWorldRefiner
                 .getCurrentlyKnownMightBePassedToApply(element)}");
           }
         });
       }
 
       if (info is ClosureTypeInformation) {
-        Iterable<MethodElement> elements = [info.closure];
+        Iterable<FunctionEntity> 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.
           MethodElement calledElement = info.calledElement;
           assert(calledElement.isGenerativeConstructor);
           ClassElement cls = calledElement.enclosingClass;
@@ skipping 55 matching lines @@
             'after ${info.refineCount}');
       });
       types.allocatedClosures.forEach((TypeInformation info) {
         if (info is ElementTypeInformation) {
           print('${info.getInferredSignature(types)} for '
               '${info.debugName}');
         } else if (info is ClosureTypeInformation) {
           print('${info.getInferredSignature(types)} for '
               '${info.debugName}');
         } else if (info is DynamicCallSiteTypeInformation) {
-          for (MemberElement target in info.targets) {
-            if (target is MethodElement) {
+          for (MemberEntity target in info.targets) {
+            if (target is FunctionEntity) {
               print(
                   '${types.getInferredSignatureOfMethod(target)} for ${target}');
             } else {
               print(
                   '${types.getInferredTypeOfMember(target).type} for ${target}');
             }
           }
         } else if (info is StaticCallSiteTypeInformation) {
           ClassElement cls = info.calledElement.enclosingClass;
           MethodElement callMethod = cls.lookupMember(Identifiers.call);
           print('${types.getInferredSignatureOfMethod(callMethod)} for ${cls}');
         } else {
           print('${info.type} for some unknown kind of closure');
         }
       });
-      analyzedElements.forEach((MemberElement elem) {
+      analyzedElements.forEach((MemberEntity elem) {
         TypeInformation type = types.getInferredTypeOfMember(elem);
         print('${elem} :: ${type} from ${type.assignments} ');
       });
     }
     dump?.afterAnalysis();
 
     reporter.log('Inferred $overallRefineCount types.');
 
     processLoopInformation();
   }
@@ skipping 87 matching lines @@
     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)) {
         // 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) {
+        info.targets.forEach((MemberEntity element) {
           closedWorldRefiner.addFunctionCalledInLoop(element);
         });
       }
     });
   }
 
   void refine() {
     while (!workQueue.isEmpty) {
       if (compiler.shouldPrintProgress) {
         reporter.log('Inferred $overallRefineCount types.');
@@ skipping 98 matching lines @@
           info.removeAssignment(type);
         } else {
           info.addAssignment(type);
         }
         parameterIndex++;
         if (addToQueue) workQueue.add(info);
       });
     }
   }
 
-  void setDefaultTypeOfParameter(
-      covariant ParameterElement parameter, TypeInformation type) {
-    assert(parameter.functionDeclaration.isImplementation);
+  void setDefaultTypeOfParameter(Local parameter, TypeInformation type,
+      {bool isInstanceMember}) {
+    assert(!(parameter is ParameterElement && !parameter.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) {
+      if (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(Local parameter) {
+    assert(!(parameter is ParameterElement && !parameter.isImplementation));
     return defaultTypeOfParameter.putIfAbsent(parameter, () {
       return new PlaceholderTypeInformation(types.currentMember);
     });
   }
 
   bool hasAlreadyComputedTypeOfParameterDefault(Local parameter) {
+    assert(!(parameter is ParameterElement && !parameter.isImplementation));
     TypeInformation seen = defaultTypeOfParameter[parameter];
     return (seen != null && seen is! PlaceholderTypeInformation);
   }
 
   TypeInformation typeOfParameter(Local element) {
     return types.getInferredTypeOfParameter(element);
   }
 
   TypeInformation typeOfMember(MemberEntity element) {
     if (element is FunctionEntity) return types.functionType;
@@ skipping 14 matching lines @@
     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(covariant MethodElement element,
-      TypeInformation unused, TypeInformation newType) {
+  TypeInformation addReturnTypeForMethod(
+      FunctionEntity 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;
+    if (element is ConstructorEntity && element.isGenerativeConstructor) {
+      return type;
+    }
     type.addAssignment(newType);
     return type;
   }
 
   TypeInformation registerCalledMember(
       Spannable node,
       Selector selector,
       TypeMask mask,
       MemberEntity caller,
-      covariant MemberElement callee,
+      MemberEntity callee,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop) {
     CallSiteTypeInformation info = new StaticCallSiteTypeInformation(
         types.currentMember,
         node,
         caller,
         callee,
         selector,
         mask,
         arguments,
         inLoop);
     // 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) {
+    if (selector != null &&
+        selector.isCall &&
+        callee is ConstructorEntity &&
+        callee.isGenerativeConstructor) {
       ClassElement cls = callee.enclosingClass;
       if (cls.callType != null) {
         types.allocatedClosures.add(info);
       }
     }
     info.addToGraph(this);
     types.allocatedCalls.add(info);
     updateSideEffects(sideEffects, selector, callee);
     return info;
   }
 
   TypeInformation registerCalledSelector(
       ast.Node node,
       Selector selector,
       TypeMask mask,
       TypeInformation receiverType,
       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) {
-      MemberElement callee = _callee;
+    closedWorld.locateMembers(selector, mask).forEach((callee) {
       updateSideEffects(sideEffects, selector, callee);
     });
 
     CallSiteTypeInformation info = new DynamicCallSiteTypeInformation(
         types.currentMember,
         node,
         caller,
         selector,
         mask,
         receiverType,
@@ skipping 245 matching lines @@
   @override
   bool checkPhiNode(ast.Node node) {
     return true;
   }
 
   @override
   bool checkClassEntity(covariant ClassElement cls) {
     return cls.isDeclaration;
   }
 }