No longer store the compilation-context in WorkItem.

pkg/compiler/lib/src/ssa/optimize.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 '../common/codegen.dart' show CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../core_types.dart' show CoreClasses;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
 import '../native/native.dart' as native;
 import '../tree/dartstring.dart' as ast;
 import '../types/types.dart';
 import '../universe/selector.dart' show Selector;
 import '../universe/side_effects.dart' show SideEffects;
 import '../util/util.dart';
 import '../world.dart' show ClassWorld, World;
+import 'context.dart';
 import 'interceptor_simplifier.dart';
 import 'nodes.dart';
 import 'types.dart';
 import 'types_propagation.dart';
 import 'value_range_analyzer.dart';
 import 'value_set.dart';
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaOptimizerTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler.measurer);
   String get name => 'SSA optimizer';
   Compiler get compiler => backend.compiler;
   Map<HInstruction, Range> ranges = <HInstruction, Range>{};
 
-  void optimize(CodegenWorkItem work, HGraph graph) {
+  void optimize(HGraph graph, CodegenWorkItem work,
+      SsaCompilationContext context) {
     void runPhase(OptimizationPhase phase) {
       measureSubtask(phase.name, () => phase.visitGraph(graph));
       compiler.tracer.traceGraph(phase.name, graph);
       assert(graph.isValid());
     }
 
     ConstantSystem constantSystem = compiler.backend.constantSystem;
-    JavaScriptItemCompilationContext context = work.compilationContext;
     bool trustPrimitives = compiler.options.trustPrimitives;
     measure(() {
       List<OptimizationPhase> phases = <OptimizationPhase>[
         // Run trivial instruction simplification first to optimize
         // some patterns useful for type conversion.
-        new SsaInstructionSimplifier(constantSystem, backend, this, work),
+        new SsaInstructionSimplifier(constantSystem, backend, this, context),
         new SsaTypeConversionInserter(compiler),
         new SsaRedundantPhiEliminator(),
         new SsaDeadPhiEliminator(),
         new SsaTypePropagator(compiler),
         // After type propagation, more instructions can be
         // simplified.
-        new SsaInstructionSimplifier(constantSystem, backend, this, work),
+        new SsaInstructionSimplifier(constantSystem, backend, this, context),
         new SsaCheckInserter(
-            trustPrimitives, backend, work, context.boundsChecked),
-        new SsaInstructionSimplifier(constantSystem, backend, this, work),
+            trustPrimitives, backend, context.boundsChecked),
+        new SsaInstructionSimplifier(constantSystem, backend, this, context),
         new SsaCheckInserter(
-            trustPrimitives, backend, work, context.boundsChecked),
+            trustPrimitives, backend, context.boundsChecked),
         new SsaTypePropagator(compiler),
         // Run a dead code eliminator before LICM because dead
         // interceptors are often in the way of LICM'able instructions.
         new SsaDeadCodeEliminator(compiler, this),
         new SsaGlobalValueNumberer(compiler),
         // After GVN, some instructions might need their type to be
         // updated because they now have different inputs.
         new SsaTypePropagator(compiler),
         new SsaCodeMotion(),
         new SsaLoadElimination(compiler),
         new SsaRedundantPhiEliminator(),
         new SsaDeadPhiEliminator(),
         new SsaTypePropagator(compiler),
-        new SsaValueRangeAnalyzer(compiler, constantSystem, this, work),
+        new SsaValueRangeAnalyzer(compiler, constantSystem, this),
         // Previous optimizations may have generated new
         // opportunities for instruction simplification.
-        new SsaInstructionSimplifier(constantSystem, backend, this, work),
+        new SsaInstructionSimplifier(constantSystem, backend, this, context),
         new SsaCheckInserter(
-            trustPrimitives, backend, work, context.boundsChecked),
+            trustPrimitives, backend, context.boundsChecked),
       ];
       phases.forEach(runPhase);
 
       // Simplifying interceptors is not strictly just an optimization, it is
       // required for implementation correctness because the code generator
       // assumes it is always performed.
-      runPhase(new SsaSimplifyInterceptors(compiler, constantSystem, work));
+      runPhase(new SsaSimplifyInterceptors(
+            compiler, constantSystem, work.element));
 
       SsaDeadCodeEliminator dce = new SsaDeadCodeEliminator(compiler, this);
       runPhase(dce);
       if (dce.eliminatedSideEffects) {
         phases = <OptimizationPhase>[
           new SsaTypePropagator(compiler),
           new SsaGlobalValueNumberer(compiler),
           new SsaCodeMotion(),
-          new SsaValueRangeAnalyzer(compiler, constantSystem, this, work),
-          new SsaInstructionSimplifier(constantSystem, backend, this, work),
+          new SsaValueRangeAnalyzer(compiler, constantSystem, this),
+          new SsaInstructionSimplifier(constantSystem, backend, this, context),
           new SsaCheckInserter(
-              trustPrimitives, backend, work, context.boundsChecked),
-          new SsaSimplifyInterceptors(compiler, constantSystem, work),
+              trustPrimitives, backend, context.boundsChecked),
+          new SsaSimplifyInterceptors(compiler, constantSystem, work.element),
           new SsaDeadCodeEliminator(compiler, this),
         ];
       } else {
         phases = <OptimizationPhase>[
           new SsaTypePropagator(compiler),
           // Run the simplifier to remove unneeded type checks inserted by
           // type propagation.
-          new SsaInstructionSimplifier(constantSystem, backend, this, work),
+          new SsaInstructionSimplifier(constantSystem, backend, this, context),
         ];
       }
       phases.forEach(runPhase);
     });
   }
 }
 
 /// Returns `true` if [mask] represents only types that have a length that
 /// cannot change.  The current implementation is conservative for the purpose
 /// of identifying gvn-able lengths and mis-identifies some unions of fixed
@@ skipping 21 matching lines @@
  */
 class SsaInstructionSimplifier extends HBaseVisitor
     implements OptimizationPhase {
   // We don't produce constant-folded strings longer than this unless they have
   // a single use.  This protects against exponentially large constant folded
   // strings.
   static const MAX_SHARED_CONSTANT_FOLDED_STRING_LENGTH = 512;
 
   final String name = "SsaInstructionSimplifier";
   final JavaScriptBackend backend;
-  final CodegenWorkItem work;
   final ConstantSystem constantSystem;
   HGraph graph;
   Compiler get compiler => backend.compiler;
   final SsaOptimizerTask optimizer;
+  final SsaCompilationContext context;
 
   SsaInstructionSimplifier(
-      this.constantSystem, this.backend, this.optimizer, this.work);
+      this.constantSystem, this.backend, this.optimizer, this.context);
 
   CoreClasses get coreClasses => compiler.coreClasses;
 
   BackendHelpers get helpers => backend.helpers;
 
   void visitGraph(HGraph visitee) {
     graph = visitee;
     visitDominatorTree(visitee);
   }
 
@@ skipping 651 matching lines @@
   VariableElement findConcreteFieldForDynamicAccess(
       HInstruction receiver, Selector selector) {
     TypeMask receiverType = receiver.instructionType;
     return compiler.world.locateSingleField(selector, receiverType);
   }
 
   HInstruction visitFieldGet(HFieldGet node) {
     if (node.isNullCheck) return node;
     var receiver = node.receiver;
     if (node.element == helpers.jsIndexableLength) {
-      JavaScriptItemCompilationContext context = work.compilationContext;
       if (context.allocatedFixedLists.contains(receiver)) {
         // TODO(ngeoffray): checking if the second input is an integer
         // should not be necessary but it currently makes it easier for
         // other optimizations to reason about a fixed length constructor
         // that we know takes an int.
         if (receiver.inputs[0].isInteger(compiler)) {
           return receiver.inputs[0];
         }
       } else if (receiver.isConstantList() || receiver.isConstantString()) {
         return graph.addConstantInt(receiver.constant.length, compiler);
@@ skipping 345 matching lines @@
           // If there are type arguments, all type arguments are 'dynamic'.
           (int i) => graph.addConstantNull(compiler));
     }
 
     return node;
   }
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
   final Set<HInstruction> boundsChecked;
-  final CodegenWorkItem work;
   final bool trustPrimitives;
   final JavaScriptBackend backend;
   final String name = "SsaCheckInserter";
   HGraph graph;
 
   SsaCheckInserter(
-      this.trustPrimitives, this.backend, this.work, this.boundsChecked);
+      this.trustPrimitives, this.backend, this.boundsChecked);
 
   BackendHelpers get helpers => backend.helpers;
 
   void visitGraph(HGraph graph) {
     this.graph = graph;
 
     // In --trust-primitives mode we don't add bounds checks.  This is better
     // than trying to remove them later as the limit expression would become
     // dead and require DCE.
     if (trustPrimitives) return;
@@ skipping 1366 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }