Make codegen and optimizations depend more directly on data objects.

pkg/compiler/lib/src/ssa/variable_allocator.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.dart';
 import '../compiler.dart' show Compiler;
 import '../js_backend/js_backend.dart';
 import 'nodes.dart';
 
 /**
@@ skipping 169 matching lines @@
       liveInstructions.containsKey(instruction);
   String toString() => liveInstructions.toString();
 }
 
 /**
  * Builds the live intervals of each instruction. The algorithm visits
  * the graph post-dominator tree to find the last uses of an
  * instruction, and computes the liveIns of each basic block.
  */
 class SsaLiveIntervalBuilder extends HBaseVisitor {
-  final Compiler compiler;
   final Set<HInstruction> generateAtUseSite;
   final Set<HInstruction> controlFlowOperators;
 
   /**
    * A counter to assign start and end ids to live ranges. The initial
    * value is not relevant. Note that instructionId goes downward to ease
    * reasoning about live ranges (the first instruction of a graph has
    * the lowest id).
    */
   int instructionId = 0;
 
   /**
    * The liveIns of basic blocks.
    */
   final Map<HBasicBlock, LiveEnvironment> liveInstructions;
 
   /**
    * The live intervals of instructions.
    */
   final Map<HInstruction, LiveInterval> liveIntervals;
 
-  SsaLiveIntervalBuilder(
-      this.compiler, this.generateAtUseSite, this.controlFlowOperators)
+  SsaLiveIntervalBuilder(this.generateAtUseSite, this.controlFlowOperators)
       : liveInstructions = new Map<HBasicBlock, LiveEnvironment>(),
         liveIntervals = new Map<HInstruction, LiveInterval>();
 
-  DiagnosticReporter get reporter => compiler.reporter;
-
   void visitGraph(HGraph graph) {
     visitPostDominatorTree(graph);
     if (!liveInstructions[graph.entry].isEmpty) {
-      reporter.internalError(CURRENT_ELEMENT_SPANNABLE, 'LiveIntervalBuilder.');
+      throw new SpannableAssertionFailure(
+          CURRENT_ELEMENT_SPANNABLE, 'LiveIntervalBuilder.');
     }
   }
 
   void markInputsAsLiveInEnvironment(
       HInstruction instruction, LiveEnvironment environment) {
     for (int i = 0, len = instruction.inputs.length; i < len; i++) {
       markAsLiveInEnvironment(instruction.inputs[i], environment);
     }
   }
 
@@ skipping 255 matching lines @@
         copyHandlers.putIfAbsent(block, () => new CopyHandler());
     handler.addAssignment(source, destination);
   }
 }
 
 /**
  * Allocates variable names for instructions, making sure they don't collide.
  */
 class VariableNamer {
   final VariableNames names;
-  final Compiler compiler;
+  final Namer _namer;
   final Set<String> usedNames;
   final List<String> freeTemporaryNames;
   int temporaryIndex = 0;
   static final RegExp regexp = new RegExp('t[0-9]+');
 
-  VariableNamer(LiveEnvironment environment, this.names, this.compiler)
+  VariableNamer(LiveEnvironment environment, this.names, this._namer)
       : usedNames = new Set<String>(),
         freeTemporaryNames = new List<String>() {
     // [VariableNames.swapTemp] is used when there is a cycle in a copy handler.
     // Therefore we make sure no one uses it.
     usedNames.add(names.swapTemp);
 
     // All liveIns instructions must have a name at this point, so we
     // add them to the list of used names.
     environment.liveInstructions.forEach((HInstruction instruction, int index) {
       String name = names.getName(instruction);
       if (name != null) {
         usedNames.add(name);
         names.addNameUsed(name);
       }
     });
   }
 
   String allocateWithHint(String originalName) {
     int i = 0;
-    JavaScriptBackend backend = compiler.backend;
-    String name = backend.namer.safeVariableName(originalName);
+    String name = _namer.safeVariableName(originalName);
     while (usedNames.contains(name)) {
-      name = backend.namer.safeVariableName('$originalName${i++}');
+      name = _namer.safeVariableName('$originalName${i++}');
     }
     return name;
   }
 
   String allocateTemporary() {
     while (!freeTemporaryNames.isEmpty) {
       String name = freeTemporaryNames.removeLast();
       if (!usedNames.contains(name)) return name;
     }
     String name = 't${temporaryIndex++}';
@@ skipping 70 matching lines @@
  * the liveIns set as well as all the live intervals of instructions.
  * It visits the graph in dominator order, so that at each entry of a
  * block, the instructions in its liveIns set have names.
  *
  * When visiting a block, it goes through all instructions. For each
  * instruction, it frees the names of the inputs that die at that
  * instruction, and allocates a name to the instruction. For each phi,
  * it adds a copy to the CopyHandler of the corresponding predecessor.
  */
 class SsaVariableAllocator extends HBaseVisitor {
-  final Compiler compiler;
+  final Namer _namer;
   final Map<HBasicBlock, LiveEnvironment> liveInstructions;
   final Map<HInstruction, LiveInterval> liveIntervals;
   final Set<HInstruction> generateAtUseSite;
 
   final VariableNames names;
 
-  SsaVariableAllocator(this.compiler, this.liveInstructions, this.liveIntervals,
+  SsaVariableAllocator(this._namer, this.liveInstructions, this.liveIntervals,
       this.generateAtUseSite)
       : this.names = new VariableNames();
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
-    VariableNamer namer =
-        new VariableNamer(liveInstructions[block], names, compiler);
+    VariableNamer variableNamer =
+        new VariableNamer(liveInstructions[block], names, _namer);
 
     block.forEachPhi((HPhi phi) {
-      handlePhi(phi, namer);
+      handlePhi(phi, variableNamer);
     });
 
     block.forEachInstruction((HInstruction instruction) {
-      handleInstruction(instruction, namer);
+      handleInstruction(instruction, variableNamer);
     });
   }
 
   /**
    * Returns whether [instruction] needs a name. Instructions that
    * have no users or that are generated at use site do not need a name.
    */
   bool needsName(instruction) {
     if (instruction is HThis) return false;
     if (instruction is HParameterValue) return true;
@@ skipping 57 matching lines @@
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }