Change inference element invariants

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 294 matching lines @@
     if (compiler.options.verbose) {
       compiler.progress.reset();
     }
     sortResolvedAsts().forEach((ResolvedAst resolvedAst) {
       if (compiler.shouldPrintProgress) {
         reporter.log('Added $addedInGraph elements in inferencing graph.');
         compiler.progress.reset();
       }
       // This also forces the creation of the [ElementTypeInformation] to ensure
       // it is in the graph.
-      types.withMember(
-          resolvedAst.element.implementation, () => analyze(resolvedAst, null));
+      types.withMember(resolvedAst.element, () => analyze(resolvedAst, null));
     });
     reporter.log('Added $addedInGraph elements in inferencing graph.');
 
     TypeGraphDump dump = debug.PRINT_GRAPH ? new TypeGraphDump(this) : null;
 
     dump?.beforeAnalysis();
     buildWorkQueue();
     refine();
 
     // Try to infer element types of lists and compute their escape information.
     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<MethodElement> bailedOutOn = new Set<MethodElement>();
+    Set<FunctionEntity> bailedOutOn = new Set<FunctionEntity>();
 
     // Trace closures to potentially infer argument types.
     types.allocatedClosures.forEach((dynamic info) {
       void trace(
-          Iterable<MethodElement> elements, ClosureTracerVisitor tracer) {
+          Iterable<FunctionEntity> elements, ClosureTracerVisitor tracer) {
         tracer.run();
         if (!tracer.continueAnalyzing) {
-          elements.forEach((MethodElement e) {
-            closedWorldRefiner.registerMightBePassedToApply(e);
-            if (debug.VERBOSE) print("traced closure $e as ${true} (bail)");
-            e.functionSignature.forEachParameter((parameter) {
+          elements.forEach((FunctionEntity _element) {
+            MethodElement element = _element;
+            MethodElement implementation = element.implementation;
+            closedWorldRefiner.registerMightBePassedToApply(element);
+            if (debug.VERBOSE) {
+              print("traced closure $element as ${true} (bail)");
+            }
+            implementation.functionSignature.forEachParameter((parameter) {
               types
                   .getInferredTypeOfParameter(parameter)
                   .giveUp(this, clearAssignments: false);
             });
           });
           bailedOutOn.addAll(elements);
           return;
         }
         elements
             .where((e) => !bailedOutOn.contains(e))
-            .forEach((MethodElement e) {
-          e.functionSignature.forEachParameter((parameter) {
+            .forEach((FunctionEntity _element) {
+          MethodElement element = _element;
+          MethodElement implementation = element.implementation;
+          implementation.functionSignature.forEachParameter((parameter) {
             var info = types.getInferredTypeOfParameter(parameter);
             info.maybeResume();
             workQueue.add(info);
           });
           if (tracer.tracedType.mightBePassedToFunctionApply) {
-            closedWorldRefiner.registerMightBePassedToApply(e);
+            closedWorldRefiner.registerMightBePassedToApply(element);
           }
           if (debug.VERBOSE) {
-            print("traced closure $e as "
+            print("traced closure $element as "
                 "${closedWorldRefiner
-                .getCurrentlyKnownMightBePassedToApply(e)}");
+                .getCurrentlyKnownMightBePassedToApply(element)}");
           }
         });
       }
 
       if (info is ClosureTypeInformation) {
         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;
+          MethodElement calledElement = info.calledElement;
+          assert(calledElement.isGenerativeConstructor);
+          ClassElement cls = calledElement.enclosingClass;
           MethodElement callMethod = cls.lookupMember(Identifiers.call);
           assert(callMethod != null, failedAt(cls));
-          Iterable<MethodElement> elements = [callMethod];
+          Iterable<FunctionEntity> 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<MethodElement> elements = new List<MethodElement>.from(
+          Iterable<FunctionEntity> elements = new List<FunctionEntity>.from(
               info.callees.where((e) => e.isFunction));
           trace(elements, new ClosureTracerVisitor(elements, info, this));
         }
       } else if (info is MemberTypeInformation) {
-        trace([info.member],
+        trace(<FunctionEntity>[info.member],
             new StaticTearOffClosureTracerVisitor(info.member, info, this));
       } else if (info is ParameterTypeInformation) {
         throw new SpannableAssertionFailure(
             NO_LOCATION_SPANNABLE, 'Unexpected closure allocation info $info');
       }
     });
 
     dump?.beforeTracing();
 
     // Reset all nodes that use lists/maps that have been inferred, as well
@@ skipping 58 matching lines @@
       });
     }
     dump?.afterAnalysis();
 
     reporter.log('Inferred $overallRefineCount types.');
 
     processLoopInformation();
   }
 
   void analyze(ResolvedAst resolvedAst, ArgumentsTypes arguments) {
-    MemberElement element = resolvedAst.element.implementation;
+    MemberElement element = resolvedAst.element;
     if (analyzedElements.contains(element)) return;
     analyzedElements.add(element);
 
     dynamic visitor = compiler.options.kernelGlobalInference
         ? new KernelTypeGraphBuilder(element, resolvedAst, compiler, this)
         : new ElementGraphBuilder(element, resolvedAst, compiler, this);
     TypeInformation type;
     reporter.withCurrentElement(element, () {
       // ignore: UNDEFINED_METHOD
       type = visitor.run();
@@ skipping 67 matching lines @@
       }
     } else {
       recordReturnType(element, type);
     }
   }
 
   void processLoopInformation() {
     types.allocatedCalls.forEach((dynamic info) {
       if (!info.inLoop) return;
       if (info is StaticCallSiteTypeInformation) {
-        MemberElement member = info.calledElement.declaration;
+        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) {
           closedWorldRefiner.addFunctionCalledInLoop(element);
         });
       }
@@ skipping 36 matching lines @@
     workQueue.addAll(types.allocatedTypes);
     workQueue.addAll(types.allocatedClosures);
     workQueue.addAll(types.allocatedCalls);
   }
 
   /**
    * Update the assignments to parameters in the graph. [remove] tells
    * wheter assignments must be added or removed. If [init] is false,
    * parameters are added to the work queue.
    */
-  void updateParameterAssignments(TypeInformation caller, Element callee,
+  void updateParameterAssignments(TypeInformation caller, MemberEntity callee,
       ArgumentsTypes arguments, Selector selector, TypeMask mask,
       {bool remove, bool addToQueue: true}) {
     if (callee.name == Identifiers.noSuchMethod_) return;
     if (callee.isField) {
       if (selector.isSetter) {
         ElementTypeInformation info = types.getInferredTypeOfMember(callee);
         if (remove) {
           info.removeAssignment(arguments.positional[0]);
         } else {
           info.addAssignment(arguments.positional[0]);
         }
         if (addToQueue) workQueue.add(info);
       }
     } else if (callee.isGetter) {
       return;
     } else if (selector != null && selector.isGetter) {
       // We are tearing a function off and thus create a closure.
       assert(callee.isFunction);
-      MemberTypeInformation info = types.getInferredTypeOfMember(callee);
+      MethodElement method = callee;
+      MemberTypeInformation info = types.getInferredTypeOfMember(method);
       if (remove) {
         info.closurizedCount--;
       } else {
         info.closurizedCount++;
-        if (Elements.isStaticOrTopLevel(callee)) {
+        if (Elements.isStaticOrTopLevel(method)) {
           types.allocatedClosures.add(info);
         } else {
           // We add the call-site type information here so that we
           // can benefit from further refinement of the selector.
           types.allocatedClosures.add(caller);
         }
-        FunctionElement function = callee.implementation;
+        FunctionElement function = method.implementation;
         FunctionSignature signature = function.functionSignature;
         signature.forEachParameter((Element parameter) {
           ParameterTypeInformation info =
               types.getInferredTypeOfParameter(parameter);
           info.tagAsTearOffClosureParameter(this);
           if (addToQueue) workQueue.add(info);
         });
       }
     } else {
-      FunctionElement function = callee.implementation;
+      MethodElement method = callee;
+      FunctionElement function = method.implementation;
       FunctionSignature signature = function.functionSignature;
       int parameterIndex = 0;
       bool visitingRequiredParameter = true;
       signature.forEachParameter((Element parameter) {
         if (signature.hasOptionalParameters &&
             parameter == signature.optionalParameters.first) {
           visitingRequiredParameter = false;
         }
         TypeInformation type = visitingRequiredParameter
             ? arguments.positional[parameterIndex]
@@ skipping 420 matching lines @@
   /**
    * 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) {}
 }