Move types out of the HInstructions.

lib/compiler/implementation/enqueue.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.
 
 class EnqueueTask extends CompilerTask {
   final Enqueuer codegen;
   final Enqueuer resolution;
 
   String get name() => 'Enqueue';
 
   EnqueueTask(Compiler compiler)
-    : codegen = new Enqueuer(compiler),
-      resolution = new Enqueuer(compiler),
+    : codegen = new Enqueuer(compiler,
+                             compiler.backend.createItemCompilationContext),
+      resolution = new Enqueuer(compiler,
+                                compiler.backend.createItemCompilationContext),
       super(compiler) {
     codegen.task = this;
     resolution.task = this;
   }
 }
 
 class RecompilationQueue {
+  final Function itemCompilationContextCreator;
   final Queue<WorkItem> queue;
   final Set<Element> queueElements;
   int processed = 0;
 
-  RecompilationQueue()
-    : queue = new Queue<WorkItem>(),
+  RecompilationQueue(ItemCompilationContext itemCompilationContextCreator())
+    : this.itemCompilationContextCreator = itemCompilationContextCreator,
+      queue = new Queue<WorkItem>(),
       queueElements = new Set<Element>();
 
   void add(Element element, TreeElements elements) {
     if (queueElements.contains(element)) return;
     queueElements.add(element);
-    queue.add(new WorkItem(element, elements));
+    queue.add(new WorkItem(element, elements, itemCompilationContextCreator()));
   }
 
   int get length() => queue.length;
 
   bool isEmpty() => queue.isEmpty();
 
   WorkItem next() {
     WorkItem item = queue.removeLast();
     queueElements.remove(item.element);
     processed++;
     return item;
   }
 }
 
 class Enqueuer {
   final Compiler compiler; // TODO(ahe): Remove this dependency.
+  final Function itemCompilationContextCreator;
   final Map<String, Link<Element>> instanceMembersByName;
   final Set<ClassElement> seenClasses;
   final Universe universe;
   final Queue<WorkItem> queue;
   final Map<Element, TreeElements> resolvedElements;
   final RecompilationQueue recompilationCandidates;
 
   bool queueIsClosed = false;
   EnqueueTask task;
 
-  Enqueuer(this.compiler)
-    : instanceMembersByName = new Map<String, Link<Element>>(),
+  Enqueuer(this.compiler,
+           ItemCompilationContext itemCompilationContextCreator())
+    : this.itemCompilationContextCreator = itemCompilationContextCreator,
+      instanceMembersByName = new Map<String, Link<Element>>(),
       seenClasses = new Set<ClassElement>(),
       universe = new Universe(),
       queue = new Queue<WorkItem>(),
       resolvedElements = new Map<Element, TreeElements>(),
-      recompilationCandidates = new RecompilationQueue();
+      recompilationCandidates =
+          new RecompilationQueue(itemCompilationContextCreator);
 
   bool get isResolutionQueue() => compiler.enqueuer.resolution === this;
 
   TreeElements getCachedElements(Element element) {
     Element owner = element.getOutermostEnclosingMemberOrTopLevel();
     return compiler.enqueuer.resolution.resolvedElements[owner];
   }
 
   String lookupCode(Element element) =>
       universe.generatedCode[element].toString();
 
   void addToWorkList(Element element, [TreeElements elements]) {
     if (element.isForeign()) return;
     if (compiler.phase == Compiler.PHASE_RECOMPILING) return;
     if (queueIsClosed) {
       if (isResolutionQueue && getCachedElements(element) !== null) return;
       compiler.internalErrorOnElement(element, "Work list is closed.");
     }
     if (!isResolutionQueue &&
         element.kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
       registerInstantiatedClass(element.getEnclosingClass());
     }
     if (elements === null) {
       elements = getCachedElements(element);
     }
-    queue.add(new WorkItem(element, elements));
+    queue.add(new WorkItem(element, elements, itemCompilationContextCreator()));
   }
 
   void eagerRecompile(Element element) {
     universe.generatedCode.remove(element);
     universe.generatedBailoutCode.remove(element);
     addToWorkList(element);
   }
 
   bool canBeRecompiled(Element element) {
     // Only member functions can be recompiled. An exception to this is members
@@ skipping 219 matching lines @@
   void registerIsCheck(Element element) {
     universe.isChecks.add(element);
   }
 
   void forEach(f(WorkItem work)) {
     while (!queue.isEmpty()) {
       f(queue.removeLast()); // TODO(kasperl): Why isn't this removeFirst?
     }
   }
 }