Type tracing bug fix for issue 28919.

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 26 matching lines @@
 import 'type_system.dart';
 
 /**
  * An inferencing engine that computes a call graph of
  * [TypeInformation] nodes by visiting the AST of the application, and
  * then does the inferencing on the graph.
  */
 class InferrerEngine {
   final Map<Element, TypeInformation> defaultTypeOfParameter =
       new Map<Element, TypeInformation>();
-  final List<CallSiteTypeInformation> allocatedCalls =
-      <CallSiteTypeInformation>[];
   final WorkQueue workQueue = new WorkQueue();
   final Element mainElement;
   final Set<Element> analyzedElements = new Set<Element>();
 
   /// 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;
@@ skipping 489 matching lines @@
             (argument.asNewExpression() != null && !argument.isConst)) {
           recordType(element, types.nullType);
         }
       }
     } else {
       recordReturnType(element, type);
     }
   }
 
   void processLoopInformation() {
-    allocatedCalls.forEach((info) {
+    types.allocatedCalls.forEach((info) {
       if (!info.inLoop) return;
       if (info is StaticCallSiteTypeInformation) {
         closedWorldRefiner.addFunctionCalledInLoop(info.calledElement);
       } 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(closedWorldRefiner.addFunctionCalledInLoop);
       }
@@ skipping 28 matching lines @@
           info.stabilize(this);
         }
       }
     }
   }
 
   void buildWorkQueue() {
     workQueue.addAll(types.typeInformations.values);
     workQueue.addAll(types.allocatedTypes);
     workQueue.addAll(types.allocatedClosures);
-    workQueue.addAll(allocatedCalls);
+    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,
       ArgumentsTypes arguments, Selector selector, TypeMask mask,
       {bool remove, bool addToQueue: true}) {
@@ skipping 228 matching lines @@
         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.
     if (selector != null && selector.isCall && callee.isConstructor) {
       ClassElement cls = callee.enclosingClass;
       if (cls.callType != null) {
         types.allocatedClosures.add(info);
       }
     }
     info.addToGraph(this);
-    allocatedCalls.add(info);
+    types.allocatedCalls.add(info);
     updateSideEffects(sideEffects, selector, callee);
     return info;
   }
 
   /**
    * Registers that [caller] calls [selector] with [receiverType] as
    * receiver, and [arguments].
    *
    * [sideEffects] will be updated to incorporate the potential
    * callees' side effects.
@@ skipping 22 matching lines @@
         types.currentMember,
         node,
         caller,
         selector,
         mask,
         receiverType,
         arguments,
         inLoop);
 
     info.addToGraph(this);
-    allocatedCalls.add(info);
+    types.allocatedCalls.add(info);
     return info;
   }
 
   /**
    * Registers a call to await with an expression of type [argumentType] as
    * argument.
    */
   TypeInformation registerAwait(ast.Node node, TypeInformation argument) {
     AwaitTypeInformation info =
         new AwaitTypeInformation(types.currentMember, node);
@@ skipping 24 matching lines @@
     CallSiteTypeInformation info = new ClosureCallSiteTypeInformation(
         types.currentMember,
         node,
         caller,
         selector,
         mask,
         closure,
         arguments,
         inLoop);
     info.addToGraph(this);
-    allocatedCalls.add(info);
+    types.allocatedCalls.add(info);
     return info;
   }
 
   // Sorts the resolved elements by size. We do this for this inferrer
   // to get the same results for [ListTracer] compared to the
   // [SimpleTypesInferrer].
   Iterable<ResolvedAst> sortResolvedAsts() {
     int max = 0;
     Map<int, Setlet<ResolvedAst>> methodSizes = <int, Setlet<ResolvedAst>>{};
     compiler.enqueuer.resolution.processedEntities
@@ skipping 27 matching lines @@
     for (int i = 0; i <= max; i++) {
       Setlet<ResolvedAst> set = methodSizes[i];
       if (set != null) result.addAll(set);
     }
     return result;
   }
 
   void clear() {
     void cleanup(TypeInformation info) => info.cleanup();
 
-    allocatedCalls.forEach(cleanup);
-    allocatedCalls.clear();
+    types.allocatedCalls.forEach(cleanup);
+    types.allocatedCalls.clear();
 
     defaultTypeOfParameter.clear();
 
     types.typeInformations.values.forEach(cleanup);
 
     types.allocatedTypes.forEach(cleanup);
     types.allocatedTypes.clear();
 
     types.concreteTypes.clear();
 
@@ skipping 51 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) {}
 }