Prepare to have more than one universe.

dart/lib/compiler/implementation/compiler.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 WorkItem {
   final Element element;
   TreeElements resolutionTree;
   bool allowSpeculativeOptimization = true;
   List<HTypeGuard> guards = const <HTypeGuard>[];
 
   WorkItem(this.element, this.resolutionTree);
 
   bool isAnalyzed() => resolutionTree !== null;
 
   int hashCode() => element.hashCode();
 
   String run(Compiler compiler) {
-    String code = compiler.universe.generatedCode[element];
+    String code = compiler.codegenWorld.generatedCode[element];
     if (code !== null) return code;
     try {
       if (!isAnalyzed()) compiler.analyze(this);
       return compiler.codegen(this);
     } catch (CompilerCancelledException ex) {
       throw;
     } catch (var ex) {
       compiler.unhandledExceptionOnElement(element);
       throw;
     }
@@ skipping 23 matching lines @@
     optimizer = new SsaOptimizerTask(this);
     generator = new SsaCodeGeneratorTask(this);
   }
 
   String codegen(WorkItem work) {
     HGraph graph = builder.build(work);
     optimizer.optimize(work, graph);
     if (work.allowSpeculativeOptimization
         && optimizer.trySpeculativeOptimizations(work, graph)) {
       String code = generator.generateBailoutMethod(work, graph);
-      compiler.universe.addBailoutCode(work, code);
+      compiler.codegenWorld.addBailoutCode(work, code);
       optimizer.prepareForSpeculativeOptimizations(work, graph);
       optimizer.optimize(work, graph);
     }
     return generator.generateMethod(work, graph);
   }
 
   void processNativeClasses(libraries) {
     native.processNativeClasses(emitter, libraries);
   }
 
   void assembleProgram() => emitter.assembleProgram();
 }
 
 class Compiler implements DiagnosticListener {
-  Queue<WorkItem> codegenQueue;
-  Universe universe;
+  final Map<String, LibraryElement> libraries;
+  int nextFreeClassId = 0;
   World world;
   String assembledCode;
   Namer namer;
   Types types;
   bool enableTypeAssertions = false;
 
   final Tracer tracer;
 
   CompilerTask measuredTask;
   Element _currentElement;
@@ skipping 39 matching lines @@
   EnqueueTask enqueuer;
 
   static final SourceString MAIN = const SourceString('main');
   static final SourceString NO_SUCH_METHOD = const SourceString('noSuchMethod');
   static final SourceString NO_SUCH_METHOD_EXCEPTION =
       const SourceString('NoSuchMethodException');
   static final SourceString START_ROOT_ISOLATE =
       const SourceString('startRootIsolate');
   bool enabledNoSuchMethod = false;
 
-  bool codegenQueueIsClosed = false;
-
   Stopwatch codegenProgress;
 
   Compiler([this.tracer = const Tracer()])
-      : universe = new Universe(),
+      : libraries = new Map<String, LibraryElement>(),
         world = new World(),
-        codegenQueue = new Queue<WorkItem>(),
         codegenProgress = new Stopwatch.start() {
     namer = new Namer(this);
     constantHandler = new ConstantHandler(this);
     scanner = new ScannerTask(this);
     dietParser = new DietParserTask(this);
     parser = new ParserTask(this);
     validator = new TreeValidatorTask(this);
     resolver = new ResolverTask(this);
     checker = new TypeCheckerTask(this);
     backend = new JavaScriptBackend(this);
     enqueuer = new EnqueueTask(this);
     tasks = [scanner, dietParser, parser, resolver, checker,
              constantHandler, enqueuer];
   }
 
+  Universe get codegenWorld() => enqueuer.codegen.universe;
+
+  int getNextFreeClassId() => nextFreeClassId++;
+
   void ensure(bool condition) {
     if (!condition) cancel('failed assertion in leg');
   }
 
   void unimplemented(String methodName,
                      [Node node, Token token, HInstruction instruction,
                       Element element]) {
     internalError("$methodName not implemented",
                   node, token, instruction, element);
   }
@@ skipping 56 matching lines @@
     }
     tracer.close();
     log('compilation succeeded');
     return true;
   }
 
   void enableNoSuchMethod(Element element) {
     if (enabledNoSuchMethod) return;
     if (element.enclosingElement == objectClass) return;
     enabledNoSuchMethod = true;
-    enqueuer.registerInvocation(NO_SUCH_METHOD, new Selector.invocation(2));
+    enqueuer.codegen.registerInvocation(NO_SUCH_METHOD,
+                                        new Selector.invocation(2));
   }
 
   void enableIsolateSupport(LibraryElement element) {
     isolateLibrary = element;
-    addToWorkList(element.find(START_ROOT_ISOLATE));
+    enqueuer.codegen.addToWorkList(element.find(START_ROOT_ISOLATE));
   }
 
   bool hasIsolateSupport() => isolateLibrary !== null;
 
   void onLibraryLoaded(LibraryElement library, Uri uri) {
     if (uri.toString() == 'dart:isolate') {
       enableIsolateSupport(library);
     }
     if (dynamicClass !== null) {
       // When loading the built-in libraries, dynamicClass is null. We
@@ skipping 45 matching lines @@
     // built. So we add the implicit import of coreLibrary now. This
     // can be cleaned up when we have proper support for "dart:core"
     // and don't need to access it through the field "coreLibrary".
     // TODO(ahe): Clean this up as described above.
     scanner.importLibrary(coreImplLibrary, coreLibrary, null);
     scanner.importLibrary(jsHelperLibrary, coreLibrary, null);
     scanner.importLibrary(interceptorsLibrary, coreLibrary, null);
     addForeignFunctions(jsHelperLibrary);
     addForeignFunctions(interceptorsLibrary);
 
-    universe.libraries['dart:core'] = coreLibrary;
-    universe.libraries['dart:coreimpl'] = coreImplLibrary;
+    libraries['dart:core'] = coreLibrary;
+    libraries['dart:coreimpl'] = coreImplLibrary;
 
     initializeSpecialClasses();
   }
 
   /** Define the JS helper functions in the given library. */
   void addForeignFunctions(LibraryElement library) {
     library.define(new ForeignElement(
         const SourceString('JS'), library), this);
     library.define(new ForeignElement(
         const SourceString('UNINTERCEPTED'), library), this);
@@ skipping 14 matching lines @@
     if (main === null) {
       reportFatalError('Could not find $MAIN', mainApp);
     } else {
       if (!main.isFunction()) reportFatalError('main is not a function', main);
       FunctionElement mainMethod = main;
       FunctionSignature parameters = mainMethod.computeSignature(this);
       parameters.forEachParameter((Element parameter) {
         reportFatalError('main cannot have parameters', parameter);
       });
     }
-    Collection<LibraryElement> libraries = universe.libraries.getValues();
+    Collection<LibraryElement> libraries = libraries.getValues();
     backend.processNativeClasses(libraries);
     world.populate(this, libraries);
-    addToWorkList(main);
+    enqueuer.codegen.addToWorkList(main);
     codegenProgress.reset();
-    while (!codegenQueue.isEmpty()) {
-      WorkItem work = codegenQueue.removeLast();
+    while (!enqueuer.codegen.queue.isEmpty()) {
+      WorkItem work = enqueuer.codegen.queue.removeLast();
       withCurrentElement(work.element, () => work.run(this));
     }
-    codegenQueueIsClosed = true;
-    assert(enqueuer.checkNoEnqueuedInvokedInstanceMethods());
-    enqueuer.registerFieldClosureInvocations();
+    enqueuer.codegen.queueIsClosed = true;
+    assert(enqueuer.codegen.checkNoEnqueuedInvokedInstanceMethods());
+    enqueuer.codegen.registerFieldClosureInvocations();
     backend.assembleProgram();
-    if (!codegenQueue.isEmpty()) {
-      internalErrorOnElement(codegenQueue.first().element,
+    if (!enqueuer.codegen.queue.isEmpty()) {
+      internalErrorOnElement(enqueuer.codegen.queue.first().element,
                              "work list is not empty");
     }
   }
 
   TreeElements analyzeElement(Element element) {
     assert(parser !== null);
     Node tree = parser.parse(element);
     validator.validate(tree);
     TreeElements elements = resolver.resolve(element);
     checker.check(tree, elements);
     return elements;
   }
 
   TreeElements analyze(WorkItem work) {
     work.resolutionTree = analyzeElement(work.element);
     return work.resolutionTree;
   }
 
   String codegen(WorkItem work) {
     if (codegenProgress.elapsedInMs() > 500) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
-      log('compiled ${universe.generatedCode.length} methods');
+      log('compiled ${codegenWorld.generatedCode.length} methods');
       codegenProgress.reset();
     }
     if (work.element.kind.category == ElementCategory.VARIABLE) {
       constantHandler.compileWorkItem(work);
       return null;
     } else {
       String code = backend.codegen(work);
-      universe.addGeneratedCode(work, code);
+      codegenWorld.addGeneratedCode(work, code);
       return code;
     }
   }
 
-  void addToWorkList(Element element, [TreeElements elements]) {
-    if (codegenQueueIsClosed) {
-      internalErrorOnElement(element, "work list is closed");
-    }
-    if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
-      registerInstantiatedClass(element.enclosingElement);
-    }
-    codegenQueue.add(new WorkItem(element, elements));
-  }
-
   void registerStaticUse(Element element) {
-    addToWorkList(element);
+    enqueuer.codegen.addToWorkList(element);
   }
 
   void registerGetOfStaticFunction(FunctionElement element) {
     registerStaticUse(element);
-    universe.staticFunctionsNeedingGetter.add(element);
+    codegenWorld.staticFunctionsNeedingGetter.add(element);
   }
 
   void registerDynamicInvocation(SourceString methodName, Selector selector) {
     assert(selector !== null);
-    enqueuer.registerInvocation(methodName, selector);
+    enqueuer.codegen.registerInvocation(methodName, selector);
   }
 
   void registerDynamicInvocationOf(Element element) {
-    addToWorkList(element);
+    enqueuer.codegen.addToWorkList(element);
   }
 
   void registerDynamicGetter(SourceString methodName, Selector selector) {
-    enqueuer.registerGetter(methodName, selector);
+    enqueuer.codegen.registerGetter(methodName, selector);
   }
 
   void registerDynamicSetter(SourceString methodName, Selector selector) {
-    enqueuer.registerSetter(methodName, selector);
+    enqueuer.codegen.registerSetter(methodName, selector);
   }
 
-  void registerInstantiatedClass(ClassElement element) {
-    universe.instantiatedClasses.add(element);
-    enqueuer.onRegisterInstantiatedClass(element);
+  void registerInstantiatedClass(ClassElement cls) {
+    enqueuer.codegen.registerInstantiatedClass(cls);
   }
 
   // TODO(ngeoffray): This should get a type.
   void registerIsCheck(Element element) {
-    universe.isChecks.add(element);
+    codegenWorld.isChecks.add(element);
   }
 
   void resolveClass(ClassElement element) {
     withCurrentElement(element, () => resolver.resolveClass(element));
   }
 
   Type resolveTypeAnnotation(Element element, TypeAnnotation annotation) {
     return resolver.resolveTypeAnnotation(element, annotation);
   }
 
@@ skipping 139 matching lines @@
   }
 }
 
 class SourceSpan {
   final Uri uri;
   final int begin;
   final int end;
 
   const SourceSpan(this.uri, this.begin, this.end);
 }