No longer store the compilation-context in WorkItem.

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 68 matching lines @@
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   HGraph build(CodegenWorkItem work) {
     return measure(() {
       Element element = work.element.implementation;
       return reporter.withCurrentElement(element, () {
         SsaBuilder builder = new SsaBuilder(
             work.element.implementation,
             work.resolvedAst,
-            work.compilationContext,
             work.registry,
             backend,
             emitter.nativeEmitter,
             sourceInformationFactory);
         HGraph graph = builder.build();
 
         // Default arguments are handled elsewhere, but we must ensure
         // that the default values are computed during codegen.
         if (!identical(element.kind, ElementKind.FIELD)) {
           FunctionElement function = element;
@@ skipping 10 matching lines @@
           if (element.isClassMember) {
             String className = element.enclosingClass.name;
             String memberName = element.name;
             name = "$className.$memberName";
             if (element.isGenerativeConstructorBody) {
               name = "$name (body)";
             }
           } else {
             name = "${element.name}";
           }
-          compiler.tracer.traceCompilation(name, work.compilationContext);
+          compiler.tracer.traceCompilation(name);
           compiler.tracer.traceGraph('builder', graph);
         }
         return graph;
       });
     });
   }
 }
 
 // Represents a single break/continue instruction.
 class JumpHandlerEntry {
@@ skipping 230 matching lines @@
     implements SemanticSendVisitor {
   /// The element for which this SSA builder is being used.
   final Element target;
 
   ResolvedAst resolvedAst;
 
   /// Used to report information about inlining (which occurs while building the
   /// SSA graph), when dump-info is enabled.
   final InfoReporter infoReporter;
 
-  /// If not null, the builder will store in [context] data that is used later
-  /// during the optimization phases.
-  final JavaScriptItemCompilationContext context;
-
   /// Registry used to enqueue work during codegen, may be null to avoid
   /// enqueing any work.
   // TODO(sigmund,johnniwinther): get rid of registry entirely. We should be
   // able to return the impact as a result after building and avoid enqueing
   // things here. Later the codegen task can decide whether to enqueue
   // something. In the past this didn't matter as much because the SSA graph was
   // used only for codegen, but currently we want to experiment using it for
   // code-analysis too.
   final CodegenRegistry registry;
   final Compiler compiler;
@@ skipping 36 matching lines @@
   bool get isBuildingAsyncFunction {
     Element element = sourceElement;
     return (element is FunctionElement &&
         element.asyncMarker == AsyncMarker.ASYNC);
   }
 
   // TODO(sigmund): make most args optional
   SsaBuilder(
       this.target,
       this.resolvedAst,
-      this.context,
       this.registry,
       JavaScriptBackend backend,
       this.nativeEmitter,
       SourceInformationStrategy sourceInformationFactory)
       : this.compiler = backend.compiler,
         this.infoReporter = backend.compiler.dumpInfoTask,
         this.backend = backend,
         this.constantSystem = backend.constantSystem,
         this.rti = backend.rti {
     assert(target.isImplementation);
@@ skipping 3761 matching lines @@
           typeMask: elementType,
           instanceType: expectedType,
           sourceInformation: sourceInformation);
       removeInlinedInstantiation(expectedType);
     }
     HInstruction newInstance = stack.last;
     if (isFixedList) {
       // Overwrite the element type, in case the allocation site has
       // been inlined.
       newInstance.instructionType = elementType;
-      if (context != null) {
-        context.allocatedFixedLists.add(newInstance);
-      }
+      graph.allocatedFixedLists?.add(newInstance);
     }
 
     // The List constructor forwards to a Dart static method that does
     // not know about the type argument. Therefore we special case
     // this constructor to have the setRuntimeTypeInfo called where
     // the 'new' is done.
     if (backend.classNeedsRti(coreClasses.listClass) &&
         (isFixedListConstructorCall ||
             isGrowableListConstructorCall ||
             isJSArrayTypedConstructor)) {
@@ skipping 3327 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }