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;
 
   String run(Compiler compiler, Enqueuer world) {
     CodeBuffer codeBuffer = world.universe.generatedCode[element];
     if (codeBuffer !== null) return codeBuffer.toString();
     resolutionTree = compiler.analyze(this, world);
     return 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 CodeBuffer 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 JavaScriptItemCompilationContext extends ItemCompilationContext {
+  final HTypeMap types;
+
+  JavaScriptItemCompilationContext()
+      : types = new HTypeMap();

[ngeoffray, 2012/08/16 13:07:00]

fits in one line

[floitsch, 2012/08/16 14:10:04]

Done.

 }
 
 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];
   }
+
+  JavaScriptItemCompilationContext createItemCompilationContext() {
+    return new JavaScriptItemCompilationContext();
+  }
 }
 
 class Compiler implements DiagnosticListener {
   final Map<String, LibraryElement> libraries;
   int nextFreeClassId = 0;
   World world;
   String assembledCode;
   Namer namer;
   Types types;
   final bool enableTypeAssertions;
@@ skipping 854 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)';
 }