Prepare to have more than one universe.

dart/lib/compiler/implementation/emitter.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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 329 matching lines @@
       String arguments = Strings.join(argumentsBuffer, ",");
       buffer.add('  return this.${namer.getName(member)}($arguments)');
     }
     buffer.add('\n}');
     defineInstanceMember(invocationName, buffer.toString());
   }
 
   void addParameterStubs(FunctionElement member,
                          void defineInstanceMember(String invocationName,
                                                    String definition)) {
-    Set<Selector> selectors = compiler.universe.invokedNames[member.name];
+    Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
     if (selectors == null) return;
     for (Selector selector in selectors) {
       if (!selector.applies(member, compiler)) continue;
       addParameterStub(member, selector, defineInstanceMember);
     }
   }
 
   bool instanceFieldNeedsGetter(Element member) {
     assert(member.kind === ElementKind.FIELD);
-    return compiler.universe.hasGetter(member, compiler);
+    return compiler.codegenWorld.hasGetter(member, compiler);
   }
 
   bool instanceFieldNeedsSetter(Element member) {
     assert(member.kind === ElementKind.FIELD);
     return (member.modifiers === null || !member.modifiers.isFinal())
-        && compiler.universe.hasSetter(member, compiler);
+        && compiler.codegenWorld.hasSetter(member, compiler);
   }
 
   String compiledFieldName(Element member) {
     assert(member.kind === ElementKind.FIELD);
     return member.isNative()
         ? member.name.slowToString()
         : namer.getName(member);
   }
 
   void addInstanceMember(Element member,
                          void defineInstanceMember(String invocationName,
                                                    String definition)) {
     // TODO(floitsch): we don't need to deal with members of
     // uninstantiated classes, that have been overwritten by subclasses.
 
     if (member.kind === ElementKind.FUNCTION
         || member.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY
         || member.kind === ElementKind.GETTER
         || member.kind === ElementKind.SETTER) {
       if (member.modifiers !== null && member.modifiers.isAbstract()) return;
-      String codeBlock = compiler.universe.generatedCode[member];
+      String codeBlock = compiler.codegenWorld.generatedCode[member];
       if (codeBlock == null) return;
       defineInstanceMember(namer.getName(member), codeBlock);
-      codeBlock = compiler.universe.generatedBailoutCode[member];
+      codeBlock = compiler.codegenWorld.generatedBailoutCode[member];
       if (codeBlock !== null) {
         defineInstanceMember(compiler.namer.getBailoutName(member), codeBlock);
       }
       FunctionElement function = member;
       FunctionSignature parameters = function.computeSignature(compiler);
       if (!parameters.optionalParameters.isEmpty()) {
         addParameterStubs(member, defineInstanceMember);
       }
     } else if (member.kind !== ElementKind.FIELD) {
       compiler.internalError('unexpected kind: "${member.kind}"',
                              element: member);
     }
     emitExtraAccessors(member, defineInstanceMember);
   }
 
   Set<Element> emitClassFields(ClassElement classElement, StringBuffer buffer) {
     // If the class is never instantiated we still need to set it up for
     // inheritance purposes, but we can simplify its JavaScript constructor.
     bool isInstantiated =
-        compiler.universe.instantiatedClasses.contains(classElement);
+        compiler.codegenWorld.instantiatedClasses.contains(classElement);
 
     bool isFirstField = true;
     void addField(ClassElement enclosingClass, Element member) {
       assert(!member.isNative());
       // See if we can dynamically create getters and setters.
       // We can only generate getters and setters for [classElement] since
       // the fields of super classes could be overwritten with getters or
       // setters.
       bool needsDynamicGetter = false;
       bool needsDynamicSetter = false;
@@ skipping 94 matching lines @@
 
     buffer.add('$defineClassName("$className", "$superName", [');
     emitClassFields(classElement, buffer);
     buffer.add('], {');
     emitInstanceMembers(classElement, buffer);
     buffer.add('\n});\n\n');
   }
 
   void generateTypeTests(ClassElement cls,
                          void generateTypeTest(ClassElement element)) {
-    if (compiler.universe.isChecks.contains(cls)) {
+    if (compiler.codegenWorld.isChecks.contains(cls)) {
       generateTypeTest(cls);
     }
     generateInterfacesIsTests(cls, generateTypeTest, new Set<Element>());
   }
 
   void generateInterfacesIsTests(ClassElement cls,
                                  void generateTypeTest(ClassElement element),
                                  Set<Element> alreadyGenerated) {
     for (Type interfaceType in cls.interfaces) {
       Element element = interfaceType.element;
       if (!alreadyGenerated.contains(element) &&
-          compiler.universe.isChecks.contains(element)) {
+          compiler.codegenWorld.isChecks.contains(element)) {
         alreadyGenerated.add(element);
         generateTypeTest(element);
       }
       generateInterfacesIsTests(element, generateTypeTest, alreadyGenerated);
     }
   }
 
   void emitClasses(StringBuffer buffer) {
     Set<ClassElement> instantiatedClasses =
-        compiler.universe.instantiatedClasses;
+        compiler.codegenWorld.instantiatedClasses;
     Set<ClassElement> neededClasses =
         new Set<ClassElement>.from(instantiatedClasses);
     for (ClassElement element in instantiatedClasses) {
       for (ClassElement superclass = element.superclass;
            superclass !== null;
            superclass = superclass.superclass) {
         if (neededClasses.contains(superclass)) break;
         neededClasses.add(superclass);
       }
     }
@@ skipping 27 matching lines @@
     generatedCode.forEach((Element element, String codeBlock) {
       if (!element.isInstanceMember()) {
         String functionName = functionNamer(element);
         buffer.add('$isolateProperties.$functionName = $codeBlock;\n\n');
       }
     });
   }
 
   void emitStaticFunctions(StringBuffer buffer) {
     emitStaticFunctionsWithNamer(buffer,
-                                 compiler.universe.generatedCode,
+                                 compiler.codegenWorld.generatedCode,
                                  namer.getName);
     emitStaticFunctionsWithNamer(buffer,
-                                 compiler.universe.generatedBailoutCode,
+                                 compiler.codegenWorld.generatedBailoutCode,
                                  namer.getBailoutName);
   }
 
   void emitStaticFunctionGetters(StringBuffer buffer) {
     Set<FunctionElement> functionsNeedingGetter =
-        compiler.universe.staticFunctionsNeedingGetter;
+        compiler.codegenWorld.staticFunctionsNeedingGetter;
     for (FunctionElement element in functionsNeedingGetter) {
       // The static function does not have the correct name. Since
       // [addParameterStubs] use the name to create its stubs we simply
       // create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
           new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, element);
       String staticName = namer.getName(element);
       int parameterCount = element.parameterCount(compiler);
       String invocationName =
@@ skipping 147 matching lines @@
   list.fixed$length = true;
   return list;
 };
 ''');
   }
 
   void emitExtraAccessors(Element member,
                           void defineInstanceMember(String invocationName,
                                                     String definition)) {
     if (member.kind == ElementKind.GETTER || member.kind == ElementKind.FIELD) {
-      Set<Selector> selectors = compiler.universe.invokedNames[member.name];
+      Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
       if (selectors !== null && !selectors.isEmpty()) {
         emitCallStubForGetter(member, selectors, defineInstanceMember);
       }
     } else if (member.kind == ElementKind.FUNCTION) {
-      if (compiler.universe.hasGetter(member, compiler)) {
+      if (compiler.codegenWorld.hasGetter(member, compiler)) {
         emitDynamicFunctionGetter(member, defineInstanceMember);
       }
     }
   }
 
   void emitNoSuchMethodCalls(void defineInstanceMember(String invocationName,
                                                        String definition)) {
     // Do not generate no such method calls if there is no class.
-    if (compiler.universe.instantiatedClasses.isEmpty()) return;
+    if (compiler.codegenWorld.instantiatedClasses.isEmpty()) return;
 
     ClassElement objectClass =
         compiler.coreLibrary.find(const SourceString('Object'));
     String runtimeObjectPrototype =
         '${namer.isolateAccess(objectClass)}.prototype';
     String noSuchMethodName =
         namer.instanceMethodName(null, Compiler.NO_SUCH_METHOD, 2);
-    Collection<LibraryElement> libraries =
-        compiler.universe.libraries.getValues();
+    Collection<LibraryElement> libraries = compiler.libraries.getValues();
 
     String generateMethod(String methodName, Selector selector) {
       StringBuffer buffer = new StringBuffer();
       buffer.add('function');
       StringBuffer args = new StringBuffer();
       for (int i = 0; i < selector.argumentCount; i++) {
         if (i != 0) args.add(', ');
         args.add('arg$i');
       }
       // We need to check if the object has a noSuchMethod. If not, it
       // means the object is a native object, and we can just call our
       // generic noSuchMethod. Note that when calling this method, the
       // 'this' object is not a Dart object.
       buffer.add(' ($args) {\n');
       buffer.add('  return this.$noSuchMethodName\n');
       buffer.add("      ? this.$noSuchMethodName('$methodName', [$args])\n");
       buffer.add("      : $runtimeObjectPrototype.$noSuchMethodName.call(");
       buffer.add("this, '$methodName', [$args])\n");
       buffer.add('}');
       return buffer.toString();
     }
 
-    compiler.universe.invokedNames.forEach((SourceString methodName,
+    compiler.codegenWorld.invokedNames.forEach((SourceString methodName,
                                             Set<Selector> selectors) {
       if (objectClass.lookupLocalMember(methodName) === null
           && methodName != Namer.OPERATOR_EQUALS) {
         for (Selector selector in selectors) {
           if (methodName.isPrivate()) {
             for (LibraryElement lib in libraries) {
               String jsName =
                 namer.instanceMethodInvocationName(lib, methodName, selector);
               String method =
                   generateMethod(methodName.slowToString(), selector);
               defineInstanceMember(jsName, method);
             }
           } else {
             String jsName =
               namer.instanceMethodInvocationName(null, methodName, selector);
             String method = generateMethod(methodName.slowToString(), selector);
             defineInstanceMember(jsName, method);
           }
         }
       }
     });
 
-    compiler.universe.invokedGetters.forEach((SourceString getterName,
+    compiler.codegenWorld.invokedGetters.forEach((SourceString getterName,
                                               Set<Selector> selectors) {
       if (getterName.isPrivate()) {
         for (LibraryElement lib in libraries) {
           String jsName = namer.getterName(lib, getterName);
           String method = generateMethod('get ${getterName.slowToString()}',
                                          Selector.GETTER);
           defineInstanceMember(jsName, method);
         }
       } else {
         String jsName = namer.getterName(null, getterName);
         String method = generateMethod('get ${getterName.slowToString()}',
                                        Selector.GETTER);
         defineInstanceMember(jsName, method);
       }
     });
 
-    compiler.universe.invokedSetters.forEach((SourceString setterName,
+    compiler.codegenWorld.invokedSetters.forEach((SourceString setterName,
                                               Set<Selector> selectors) {
       if (setterName.isPrivate()) {
         for (LibraryElement lib in libraries) {
           String jsName = namer.setterName(lib, setterName);
           String method = generateMethod('set ${setterName.slowToString()}',
                                          Selector.SETTER);
           defineInstanceMember(jsName, method);
         }
       } else {
         String jsName = namer.setterName(null, setterName);
         String method = generateMethod('set ${setterName.slowToString()}',
                                        Selector.SETTER);
         defineInstanceMember(jsName, method);
       }
     });
   }
 
   String buildIsolateSetup(StringBuffer buffer,
                            Element appMain,
                            Element isolateMain) {
     String mainAccess = "${namer.isolateAccess(appMain)}";
     String currentIsolate = "${namer.CURRENT_ISOLATE}";
     String mainEnsureGetter = '';
     // Since we pass the closurized version of the main method to
     // the isolate method, we must make sure that it exists.
-    if (!compiler.universe.staticFunctionsNeedingGetter.contains(appMain)) {
+    if (!compiler.codegenWorld.staticFunctionsNeedingGetter.contains(appMain)) {
       String invocationName =
           "${namer.closureInvocationName(Selector.INVOCATION_0)}";
       mainEnsureGetter = "$mainAccess.$invocationName = $mainAccess";
     }
 
     // TODO(ngeoffray): These globals are currently required by the isolate
     // library, but since leg already generates code on an Isolate object, they
     // are not really needed. We should remove them once Leg replaces Frog.
     buffer.add("""
 var \$globalThis = $currentIsolate;
@@ skipping 76 matching lines @@
       mainBuffer.add('function init() {\n');
       mainBuffer.add('  $isolateProperties = {};\n');
       addDefineClassAndFinishClassFunctionsIfNecessary(mainBuffer);
       emitFinishIsolateConstructor(mainBuffer);
       mainBuffer.add('}\n');
       compiler.assembledCode = mainBuffer.toString();
     });
     return compiler.assembledCode;
   }
 }