Cleanup universe to not have backend related things.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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 js_backend;
 
 typedef void Recompile(Element element);
 
 class ReturnInfo {
   HType returnType;
@@ skipping 603 matching lines @@
       : types = new HTypeMap(),
         boundsChecked = new Set<HInstruction>();
 }
 
 class JavaScriptBackend extends Backend {
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
 
+  /**
+   * The generated code as a js AST for compiled methods. 

[karlklose, 2013/02/08 11:44:53]

'js' -> 'JavaScript' or 'JS'

+   */
+  Map<Element, js.Expression> get generatedCode {
+    return compiler.enqueuer.codegen.generatedCode;
+  }
+
+  /**
+   * The generated code as a js AST for compiled bailout methods. 

[karlklose, 2013/02/08 11:44:53]

ditto.

+   */
+  final Map<Element, js.Expression> generatedBailoutCode =
+      new Map<Element, js.Expression>();
+
   ClassElement jsStringClass;
   ClassElement jsArrayClass;
   ClassElement jsNumberClass;
   ClassElement jsIntClass;
   ClassElement jsDoubleClass;
   ClassElement jsFunctionClass;
   ClassElement jsNullClass;
   ClassElement jsBoolClass;
   ClassElement objectInterceptorClass;
   Element jsArrayLength;
@@ skipping 287 matching lines @@
 
     for (var helper in [const SourceString('Closure'),
                         const SourceString('ConstantMap'),
                         const SourceString('ConstantProtoMap')]) {
       var e = compiler.findHelper(helper);
       if (e != null) world.registerInstantiatedClass(e);
     }
   }
 
   void codegen(CodegenWorkItem work) {
-    if (work.element.kind.category == ElementCategory.VARIABLE) {
+    Element element = work.element;
+    if (element.kind.category == ElementCategory.VARIABLE) {
       Constant initialValue = compiler.constantHandler.compileWorkItem(work);
       if (initialValue != null) {
         return;
       } else {
         // If the constant-handler was not able to produce a result we have to
         // go through the builder (below) to generate the lazy initializer for
         // the static variable.
         // We also need to register the use of the cyclic-error helper.
         compiler.enqueuer.codegen.registerStaticUse(cyclicThrowHelper);
       }
     }
 
     HGraph graph = builder.build(work);
     optimizer.optimize(work, graph, false);
     if (work.allowSpeculativeOptimization
         && optimizer.trySpeculativeOptimizations(work, graph)) {
       js.Expression code = generator.generateBailoutMethod(work, graph);
-      compiler.codegenWorld.addBailoutCode(work, code);
+      generatedBailoutCode[element] = code;
       optimizer.prepareForSpeculativeOptimizations(work, graph);
       optimizer.optimize(work, graph, true);
     }
     js.Expression code = generator.generateCode(work, graph);
-    compiler.codegenWorld.addGeneratedCode(work, code);
-    invalidateAfterCodegen.forEach(compiler.enqueuer.codegen.eagerRecompile);
+    generatedCode[element] = code;
+    invalidateAfterCodegen.forEach(eagerRecompile);
     invalidateAfterCodegen.clear();
   }
 
   native.NativeEnqueuer nativeResolutionEnqueuer(Enqueuer world) {
     return new native.NativeResolutionEnqueuer(world, compiler);
   }
 
   native.NativeEnqueuer nativeCodegenEnqueuer(Enqueuer world) {
     return new native.NativeCodegenEnqueuer(world, compiler, emitter);
   }
 
+  /**
+   * 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(generatedCode[element], compiler).getText();
+  }
+
   void assembleProgram() {
     emitter.assembleProgram();
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void scheduleForRecompilation(Element element) {
@@ skipping 238 matching lines @@
     return compiler.findHelper(const SourceString('makeLiteralMap'));
   }
 
   Element getSetRuntimeTypeInfo() {
     return compiler.findHelper(const SourceString('setRuntimeTypeInfo'));
   }
 
   Element getGetRuntimeTypeInfo() {
     return compiler.findHelper(const SourceString('getRuntimeTypeInfo'));
   }
+
+  /**
+   * Remove [element] from the set of generated code, and put it back
+   * into the worklist.
+   *
+   * Invariant: [element] must be a declaration element.
+   */
+  void eagerRecompile(Element element) {
+    assert(invariant(element, element.isDeclaration));
+    generatedCode.remove(element);
+    generatedBailoutCode.remove(element);
+    compiler.enqueuer.codegen.addToWorkList(element);
+  }
 }