Prepare to have more than one universe.

dart/lib/compiler/implementation/ssa/builder.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 Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 839 matching lines @@
         if (body.constructor == constructor) {
           bodyElement = backendMember;
           break;
         }
       }
     }
     if (bodyElement === null) {
       bodyElement = new ConstructorBodyElement(constructor);
       TreeElements treeElements =
           compiler.resolver.resolveMethodElement(constructor);
-      compiler.addToWorkList(bodyElement, treeElements);
+      compiler.enqueuer.codegen.addToWorkList(bodyElement, treeElements);
       classElement.backendMembers =
           classElement.backendMembers.prepend(bodyElement);
     }
     assert(bodyElement.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY);
     return bodyElement;
   }
 
   void inlineSuperOrRedirect(FunctionElement constructor,
                              Selector selector,
                              Link<Node> arguments,
@@ skipping 609 matching lines @@
     if (nestedClosureData === null) {
       // TODO(floitsch): we can only assume that the reason for not having a
       // closure data here is, because the function is inside an initializer.
       compiler.unimplemented("Closures inside initializers", node: node);
     }
     assert(nestedClosureData !== null);
     assert(nestedClosureData.closureClassElement !== null);
     ClassElement closureClassElement =
         nestedClosureData.closureClassElement;
     FunctionElement callElement = nestedClosureData.callElement;
-    compiler.addToWorkList(callElement, elements);
+    compiler.enqueuer.codegen.addToWorkList(callElement, elements);
     compiler.registerInstantiatedClass(closureClassElement);
     assert(closureClassElement.members.isEmpty());
 
     List<HInstruction> capturedVariables = <HInstruction>[];
     for (Element member in closureClassElement.backendMembers) {
       // The backendMembers also contains the call method(s). We are only
       // interested in the fields.
       if (member.kind == ElementKind.FIELD) {
         Element capturedLocal = nestedClosureData.capturedFieldMapping[member];
         assert(capturedLocal != null);
@@ skipping 411 matching lines @@
       bool isNot = false;
       // TODO(ngeoffray): Duplicating pattern in resolver. We should
       // add a new kind of node.
       if (typeAnnotation == null) {
         typeAnnotation = argument.asSend().receiver;
         isNot = true;
       }
 
       Type type = elements.getType(typeAnnotation);
       HInstruction typeInfo = null;
-      if (compiler.universe.rti.hasTypeArguments(type)) {
+      if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
         HInstruction typeInfoGetter =
             new HStatic(interceptors.getGetRuntimeTypeInfo());
         add(typeInfoGetter);
         typeInfo = new HInvokeStatic(Selector.INVOCATION_1,
                                      <HInstruction>[typeInfoGetter,
                                                     expression]);
         add(typeInfo);
       }
       if (type.element.kind === ElementKind.TYPE_VARIABLE) {
         // TODO(karlklose): We emulate the frog behavior and answer
@@ skipping 399 matching lines @@
     HType elementType = computeType(element);
     HInstruction newInstance = new HInvokeStatic(selector, inputs, elementType);
     push(newInstance);
 
     TypeAnnotation annotation = getTypeAnnotationFromSend(node);
     Type type = elements.getType(annotation);
     generateSetRuntimeTypeInformation(newInstance, type);
   }
 
   generateSetRuntimeTypeInformation(HInstruction instance, Type type) {
-    if (compiler.universe.rti.hasTypeArguments(type)) {
-      String typeString = compiler.universe.rti.asJsString(type);
+    if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
+      String typeString = compiler.codegenWorld.rti.asJsString(type);
       HInstruction typeInfo = new HForeign(new LiteralDartString(typeString),
                                            new LiteralDartString('Object'),
                                            <HInstruction>[]);
       add(typeInfo);
       HInstruction typeInfoSetter =
           new HStatic(interceptors.getSetRuntimeTypeInfo());
       add(typeInfoSetter);
       Selector setSelector = Selector.INVOCATION_2;
       var inputs = <HInstruction>[typeInfoSetter, instance, typeInfo];
       add(new HInvokeStatic(setSelector, inputs));
@@ skipping 1022 matching lines @@
                                    <HInstruction>[target, input],
                                    HType.STRING));
     return builder.pop();
   }
 
   HInstruction result(Node node) {
     flushLiterals(node);
     return prefix;
   }
 }