Move types out of the HInstructions.

lib/compiler/implementation/compiler.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.
 
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
 final bool REPORT_EXCESS_RESOLUTION = false;
 
 /**
  * If true, trace information on pass2 optimizations.
  */
 final bool REPORT_PASS2_OPTIMIZATIONS = false;
 
+/**
+ * Contains backend-specific data that is used throughout the compilation of
+ * one work item.
+ */
+class ItemCompilationContext {
+}
+
 class WorkItem {
+  final ItemCompilationContext compilationContext;
   final Element element;
   TreeElements resolutionTree;
   bool allowSpeculativeOptimization = true;
   List<HTypeGuard> guards = const <HTypeGuard>[];
 
-  WorkItem(this.element, this.resolutionTree);
+  WorkItem(this.element, this.resolutionTree, this.compilationContext);
 
   bool isAnalyzed() => resolutionTree !== null;
 
   void run(Compiler compiler, Enqueuer world) {
     CodeBuffer codeBuffer = world.universe.generatedCode[element];
     if (codeBuffer !== null) return;
     resolutionTree = compiler.analyze(this, world);
     compiler.codegen(this, world);
   }
 }
 
 class Backend {
   final Compiler compiler;
 
   Backend(this.compiler);
 
   void enqueueAllTopLevelFunctions(LibraryElement lib, Enqueuer world) {
     lib.forEachExport((Element e) {
       if (e.isFunction()) world.addToWorkList(e);
     });
   }
 
   abstract void enqueueHelpers(Enqueuer world);
   abstract void codegen(WorkItem work);
   abstract void processNativeClasses(Enqueuer world,
                                      Collection<LibraryElement> libraries);
   abstract void assembleProgram();
   abstract List<CompilerTask> get tasks();
+
+  ItemCompilationContext createItemCompilationContext() {
+    return new ItemCompilationContext();
+  }
 }
 
 class Compiler implements DiagnosticListener {
   final Map<String, LibraryElement> libraries;
   int nextFreeClassId = 0;
   World world;
   String assembledCode;
   Namer namer;
   Types types;
   final bool enableTypeAssertions;
@@ skipping 851 matching lines @@
     String banner = 'compiler cancelled';
     return (reason !== null) ? '$banner: $reason' : '$banner';
   }
 }
 
 class Tracer {
   final bool enabled = false;
 
   const Tracer();
 
-  void traceCompilation(String methodName) {
+  void traceCompilation(String methodName, ItemCompilationContext context) {
   }
 
   void traceGraph(String name, var graph) {
   }
 
   void close() {
   }
 }
 
 class SourceSpan {
   final Uri uri;
   final int begin;
   final int end;
 
   const SourceSpan(this.uri, this.begin, this.end);
 
   static withCharacterOffsets(Token begin, Token end,
                      f(int beginOffset, int endOffset)) {
     final beginOffset = begin.charOffset;
     final endOffset = end.charOffset + end.slowCharCount;
 
     // [begin] and [end] might be the same for the same empty token. This
     // happens for instance when scanning '$$'.
     assert(endOffset >= beginOffset);
     return f(beginOffset, endOffset);
   }
 
   String toString() => 'SourceSpan($uri, $begin, $end)';
 }