Cleanup universe to not have backend related things.

sdk/lib/_internal/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.
 
 part of dart2js;
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
   final CodegenEnqueuer codegen;
 
@@ skipping 13 matching lines @@
         compiler.backend.nativeResolutionEnqueuer(resolution);
   }
 }
 
 abstract class Enqueuer {
   final String name;
   final Compiler compiler; // TODO(ahe): Remove this dependency.
   final Function itemCompilationContextCreator;
   final Map<String, Link<Element>> instanceMembersByName;
   final Set<ClassElement> seenClasses;
+  final Universe universe;
 
   bool queueIsClosed = false;
   EnqueueTask task;
   native.NativeEnqueuer nativeEnqueuer;  // Set by EnqueueTask
 
   Enqueuer(this.name, this.compiler,
            ItemCompilationContext itemCompilationContextCreator())
     : this.itemCompilationContextCreator = itemCompilationContextCreator,
       instanceMembersByName = new Map<String, Link<Element>>(),
+      universe = new Universe(),
       seenClasses = new Set<ClassElement>();
 
-  Universe get universe;
-
   /// Returns [:true:] if this enqueuer is the resolution enqueuer.
   bool get isResolutionQueue => false;
 
   /// Returns [:true:] if [member] has been processed by this enqueuer.
   bool isProcessed(Element member);
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
@@ skipping 285 matching lines @@
   }
 
   void registerDynamicGetter(SourceString methodName, Selector selector) {
     registerInvokedGetter(methodName, selector);
   }
 
   void registerDynamicSetter(SourceString methodName, Selector selector) {
     registerInvokedSetter(methodName, selector);
   }
 
+  void registerFieldGetter(SourceString getterName,
+                           LibraryElement library,
+                           DartType type) {
+    task.measure(() {
+      Selector getter = new Selector.getter(getterName, library);
+      registerNewSelector(getterName,
+                          new TypedSelector(type, getter),
+                          universe.fieldGetters);
+    });
+  }
+
+  void registerFieldSetter(SourceString setterName,
+                           LibraryElement library,
+                           DartType type) {
+    task.measure(() {
+      Selector setter = new Selector.setter(setterName, library);
+      registerNewSelector(setterName,
+                          new TypedSelector(type, setter),
+                          universe.fieldSetters);
+    });
+  }
+
   void registerIsCheck(DartType type) {
     universe.isChecks.add(type);
   }
 
   void forEach(f(WorkItem work));
 
   void logSummary(log(message)) {
     _logSpecificSummary(log);
     nativeEnqueuer.logSummary(log);
   }
 
   /// Log summary specific to the concrete enqueuer.
   void _logSpecificSummary(log(message));
 
   String toString() => 'Enqueuer($name)';
 }
 
 /// [Enqueuer] which is specific to resolution.
 class ResolutionEnqueuer extends Enqueuer {
-  final ResolutionUniverse universe;
-
   /**
    * Map from declaration elements to the [TreeElements] object holding the
    * resolution mapping for the element implementation.
    *
    * Invariant: Key elements are declaration elements.
    */
   final Map<Element, TreeElements> resolvedElements;
 
   final Queue<ResolutionWorkItem> queue;
 
   ResolutionEnqueuer(Compiler compiler,
                      ItemCompilationContext itemCompilationContextCreator())
       : super('resolution enqueuer', compiler, itemCompilationContextCreator),
         resolvedElements = new Map<Element, TreeElements>(),
-        universe = new ResolutionUniverse(),
         queue = new Queue<ResolutionWorkItem>();
 
   bool get isResolutionQueue => true;
 
   bool isProcessed(Element member) => resolvedElements.containsKey(member);
 
   TreeElements getCachedElements(Element element) {
     // TODO(ngeoffray): Get rid of this check.
     if (element.enclosingElement.isClosure()) {
       closureMapping.ClosureClassElement cls = element.enclosingElement;
@@ skipping 89 matching lines @@
     nativeEnqueuer.registerJsCall(node, resolver);
   }
 
   void _logSpecificSummary(log(message)) {
     log('Resolved ${resolvedElements.length} elements.');
   }
 }
 
 /// [Enqueuer] which is specific to code generation.
 class CodegenEnqueuer extends Enqueuer {
-  final CodegenUniverse universe;
-
   final Queue<CodegenWorkItem> queue;
+  final Map<Element, js.Expression> generatedCode =
+      new Map<Element, js.Expression>();
 
   CodegenEnqueuer(Compiler compiler,
                   ItemCompilationContext itemCompilationContextCreator())
       : super('codegen enqueuer', compiler, itemCompilationContextCreator),
-        universe = new CodegenUniverse(),
         queue = new Queue<CodegenWorkItem>();
 
-  bool isProcessed(Element member) =>
-      universe.generatedCode.containsKey(member);
-
-  /**
-   * Unit test hook that returns code of an element as a String.
-   *
-   * Invariant: [element] must be a declaration element.
-   */
-  String assembleCode(Element element) {
-    assert(invariant(element, element.isDeclaration));
-    return js.prettyPrint(universe.generatedCode[element], compiler).getText();
-  }
-
-  /**
-   * Documentation wanted -- johnniwinther
-   *
-   * Invariant: [element] must be a declaration element.
-   */
-  void eagerRecompile(Element element) {
-    assert(invariant(element, element.isDeclaration));
-    universe.generatedCode.remove(element);
-    universe.generatedBailoutCode.remove(element);
-    addToWorkList(element);
-  }
+  bool isProcessed(Element member) => generatedCode.containsKey(member);
 
   bool addElementToWorkList(Element element, [TreeElements elements]) {
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
                                           "Codegen work list is closed.");
     }
     elements =
         compiler.enqueuer.resolution.ensureCachedElements(element, elements);
 
     CodegenWorkItem workItem = new CodegenWorkItem(
         element, elements, itemCompilationContextCreator());
     queue.add(workItem);
 
     return true;
   }
 
-  void registerFieldGetter(SourceString getterName,
-                           LibraryElement library,
-                           DartType type) {
-    task.measure(() {
-      Selector getter = new Selector.getter(getterName, library);
-      registerNewSelector(getterName,
-                          new TypedSelector(type, getter),
-                          universe.fieldGetters);
-    });
-  }
-
-  void registerFieldSetter(SourceString setterName,
-                           LibraryElement library,
-                           DartType type) {
-    task.measure(() {
-      Selector setter = new Selector.setter(setterName, library);
-      registerNewSelector(setterName,
-                          new TypedSelector(type, setter),
-                          universe.fieldSetters);
-    });
-  }
-
   void forEach(f(WorkItem work)) {
     while(!queue.isEmpty) {
       // TODO(johnniwinther): Find an optimal process order for codegen.
       f(queue.removeLast());
     }
   }
 
   void _logSpecificSummary(log(message)) {
-    log('Compiled ${universe.generatedCode.length} methods.');
+    log('Compiled ${generatedCode.length} methods.');
   }
 }