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;
@@ skipping 31 matching lines @@
       if (e.isFunction()) world.addToWorkList(e);
     });
   }
 
   abstract void enqueueHelpers(Enqueuer world);
   abstract CodeBuffer codegen(WorkItem work);
   abstract void processNativeClasses(Enqueuer world,
                                      Collection<LibraryElement> libraries);
   abstract void assembleProgram();
   abstract List<CompilerTask> get tasks();
+
+  WorkItem createWorkItem(Element element, TreeElements elements) {
+    return new WorkItem(element, elements);
+  }
+}
+
+class JavaScriptWorkItem extends WorkItem {
+  HTypeMap types;
+
+  JavaScriptWorkItem(Element element, TreeElements elements)
+      : types = new HTypeMap(),
+        super(element, elements);
 }
 
 class JavaScriptBackend extends Backend {
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
   final Map<Element, Map<Element, HType>> fieldInitializers;
   final Map<Element, Map<Element, HType>> fieldConstructorSetters;
   final Map<Element, Map<Element, HType>> fieldSettersType;
@@ skipping 135 matching lines @@
   HType fieldSettersTypeSoFar(Element field) {
     assert(field.isField());
     assert(field.enclosingElement.isClass());
     if (!fieldSettersType.containsKey(field.enclosingElement)) {
       return HType.CONFLICTING;
     }
     Map<Element, HType> fields = fieldSettersType[field.enclosingElement];
     if (!fields.containsKey(field)) return HType.CONFLICTING;
     return fields[field];
   }
+
+  JavaScriptWorkItem createWorkItem(Element element, TreeElements elements) {
+    return new JavaScriptWorkItem(element, elements);
+  }
 }
 
 class Compiler implements DiagnosticListener {
   final Map<String, LibraryElement> libraries;
   int nextFreeClassId = 0;
   World world;
   String assembledCode;
   Namer namer;
   Types types;
   final bool enableTypeAssertions;
@@ skipping 848 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, WorkItem work) {
   }
 
   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)';
 }