Support compilation of Hello World

pkg/compiler/lib/src/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.
 
 library dart2js.compiler_base;
 
 import 'dart:async' show EventSink, Future;
 
 import '../compiler_new.dart' as api;
 import 'cache_strategy.dart' show CacheStrategy;
@@ skipping 385 matching lines @@
 
   void unimplemented(Spannable spannable, String methodName) {
     reporter.internalError(spannable, "$methodName not implemented.");
   }
 
   // Compiles the dart script at [uri].
   //
   // The resulting future will complete with true if the compilation
   // succeeded.
   Future<bool> run(Uri uri) => selfTask.measureSubtask("Compiler.run", () {
-    measurer.startWallClock();
+        measurer.startWallClock();
 
-    return new Future.sync(() => runInternal(uri))
-        .catchError((error) => _reporter.onError(uri, error))
-        .whenComplete(() {
-      tracer.close();
-      measurer.stopWallClock();
-    }).then((_) {
-      return !compilationFailed;
-    });
-  });
+        return new Future.sync(() => runInternal(uri))
+            .catchError((error) => _reporter.onError(uri, error))
+            .whenComplete(() {
+          tracer.close();
+          measurer.stopWallClock();
+        }).then((_) {
+          return !compilationFailed;
+        });
+      });
 
   /// This method is called immediately after the [LibraryElement] [library] has
   /// been created.
   ///
   /// Use this callback method to store references to specific libraries.
   /// Note that [library] has not been scanned yet, nor has its imports/exports
   /// been resolved.
   void onLibraryCreated(LibraryElement library) {
     Uri uri = library.canonicalUri;
     if (uri == Uris.dart_core) {
@@ skipping 15 matching lines @@
   ///
   /// Use [loader] to register the creation and scanning of a patch library
   /// for [library].
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader) {
     Uri uri = library.canonicalUri;
     // If the script of the library is synthesized, the library does not exist
     // and we do not try to load the helpers.
     //
     // This could for example happen if dart:async is disabled, then loading it
     // should not try to find the given element.
-    // TODO(johnniwinther): This should just be library.isSynthesized, but that
-    // does not work yet for deserialized elements.
-    if (!library.compilationUnit.script.isSynthesized) {
+    if (!library.isSynthesized) {
       if (uri == Uris.dart_core) {
         initializeCoreClasses();
         identicalFunction = coreLibrary.find('identical');
       } else if (uri == Uris.dart_mirrors) {
         mirrorSystemClass = findRequiredElement(library, 'MirrorSystem');
         mirrorsUsedClass = findRequiredElement(library, 'MirrorsUsed');
       } else if (uri == Uris.dart_async) {
         asyncLibrary = library;
         deferredLibraryClass = findRequiredElement(library, 'DeferredLibrary');
         _coreTypes.futureClass = findRequiredElement(library, 'Future');
@@ skipping 337 matching lines @@
         .then((LibraryElement library) {
       if (library == null) return null;
       fullyEnqueueLibrary(library, enqueuer.resolution);
       emptyQueue(enqueuer.resolution);
       enqueuer.resolution.logSummary(reporter.log);
       return library;
     });
   }
 
   /// Performs the compilation when all libraries have been loaded.
-  void compileLoadedLibraries()
-      => selfTask.measureSubtask("Compiler.compileLoadedLibraries", () {
+  void compileLoadedLibraries() =>
+      selfTask.measureSubtask("Compiler.compileLoadedLibraries", () {
+        computeMain();
 
-    computeMain();
+        mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
 
-    mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
+        // In order to see if a library is deferred, we must compute the
+        // compile-time constants that are metadata.  This means adding
+        // something to the resolution queue.  So we cannot wait with
+        // this until after the resolution queue is processed.
+        deferredLoadTask.beforeResolution(this);
+        impactStrategy = backend.createImpactStrategy(
+            supportDeferredLoad: deferredLoadTask.isProgramSplit,
+            supportDumpInfo: options.dumpInfo,
+            supportSerialization: serialization.supportSerialization);
 
-    // In order to see if a library is deferred, we must compute the
-    // compile-time constants that are metadata.  This means adding
-    // something to the resolution queue.  So we cannot wait with
-    // this until after the resolution queue is processed.
-    deferredLoadTask.beforeResolution(this);
-    impactStrategy = backend.createImpactStrategy(
-        supportDeferredLoad: deferredLoadTask.isProgramSplit,
-        supportDumpInfo: options.dumpInfo,
-        supportSerialization: serialization.supportSerialization);
+        phase = PHASE_RESOLVING;
+        if (analyzeAll) {
+          libraryLoader.libraries.forEach((LibraryElement library) {
+            reporter.log('Enqueuing ${library.canonicalUri}');
+            fullyEnqueueLibrary(library, enqueuer.resolution);
+          });
+        } else if (options.analyzeMain) {
+          if (mainApp != null) {
+            fullyEnqueueLibrary(mainApp, enqueuer.resolution);
+          }
+          if (librariesToAnalyzeWhenRun != null) {
+            for (Uri libraryUri in librariesToAnalyzeWhenRun) {
+              fullyEnqueueLibrary(
+                  libraryLoader.lookupLibrary(libraryUri), enqueuer.resolution);
+            }
+          }
+        }
+        // Elements required by enqueueHelpers are global dependencies
+        // that are not pulled in by a particular element.
+        backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
+        resolveLibraryMetadata();
+        reporter.log('Resolving...');
+        processQueue(enqueuer.resolution, mainFunction);
+        enqueuer.resolution.logSummary(reporter.log);
 
-    phase = PHASE_RESOLVING;
-    if (analyzeAll) {
-      libraryLoader.libraries.forEach((LibraryElement library) {
-        reporter.log('Enqueuing ${library.canonicalUri}');
-        fullyEnqueueLibrary(library, enqueuer.resolution);
+        _reporter.reportSuppressedMessagesSummary();
+
+        if (compilationFailed) {
+          if (!options.generateCodeWithCompileTimeErrors) return;
+          if (!backend
+              .enableCodegenWithErrorsIfSupported(NO_LOCATION_SPANNABLE)) {
+            return;
+          }
+        }
+
+        if (options.analyzeOnly) {
+          if (!analyzeAll && !compilationFailed) {
+            // No point in reporting unused code when [analyzeAll] is true: all
+            // code is artificially used.
+            // If compilation failed, it is possible that the error prevents the
+            // compiler from analyzing all the code.
+            // TODO(johnniwinther): Reenable this when the reporting is more
+            // precise.
+            //reportUnusedCode();
+          }
+          return;
+        }
+        assert(mainFunction != null);
+        phase = PHASE_DONE_RESOLVING;
+
+        world.populate();
+        // Compute whole-program-knowledge that the backend needs. (This might
+        // require the information computed in [world.populate].)
+        backend.onResolutionComplete();
+
+        deferredLoadTask.onResolutionComplete(mainFunction);
+
+        reporter.log('Inferring types...');
+        typesTask.onResolutionComplete(mainFunction);
+
+        if (stopAfterTypeInference) return;
+
+        backend.onTypeInferenceComplete();
+
+        reporter.log('Compiling...');
+        phase = PHASE_COMPILING;
+        backend.onCodegenStart();
+        // TODO(johnniwinther): Move these to [CodegenEnqueuer].
+        if (hasIsolateSupport) {
+          backend.enableIsolateSupport(enqueuer.codegen);
+        }
+        if (compileAll) {
+          libraryLoader.libraries.forEach((LibraryElement library) {
+            fullyEnqueueLibrary(library, enqueuer.codegen);
+          });
+        }
+        processQueue(enqueuer.codegen, mainFunction);
+        enqueuer.codegen.logSummary(reporter.log);
+
+        int programSize = backend.assembleProgram();
+
+        if (options.dumpInfo) {
+          dumpInfoTask.reportSize(programSize);
+          dumpInfoTask.dumpInfo();
+        }
+
+        backend.sourceInformationStrategy.onComplete();
+
+        checkQueues();
       });
-    } else if (options.analyzeMain) {
-      if (mainApp != null) {
-        fullyEnqueueLibrary(mainApp, enqueuer.resolution);
-      }
-      if (librariesToAnalyzeWhenRun != null) {
-        for (Uri libraryUri in librariesToAnalyzeWhenRun) {
-          fullyEnqueueLibrary(
-              libraryLoader.lookupLibrary(libraryUri), enqueuer.resolution);
-        }
-      }
-    }
-    // Elements required by enqueueHelpers are global dependencies
-    // that are not pulled in by a particular element.
-    backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
-    resolveLibraryMetadata();
-    reporter.log('Resolving...');
-    processQueue(enqueuer.resolution, mainFunction);
-    enqueuer.resolution.logSummary(reporter.log);
-
-    _reporter.reportSuppressedMessagesSummary();
-
-    if (compilationFailed) {
-      if (!options.generateCodeWithCompileTimeErrors) return;
-      if (!backend.enableCodegenWithErrorsIfSupported(NO_LOCATION_SPANNABLE)) {
-        return;
-      }
-    }
-
-    if (options.analyzeOnly) {
-      if (!analyzeAll && !compilationFailed) {
-        // No point in reporting unused code when [analyzeAll] is true: all
-        // code is artificially used.
-        // If compilation failed, it is possible that the error prevents the
-        // compiler from analyzing all the code.
-        // TODO(johnniwinther): Reenable this when the reporting is more
-        // precise.
-        //reportUnusedCode();
-      }
-      return;
-    }
-    assert(mainFunction != null);
-    phase = PHASE_DONE_RESOLVING;
-
-    world.populate();
-    // Compute whole-program-knowledge that the backend needs. (This might
-    // require the information computed in [world.populate].)
-    backend.onResolutionComplete();
-
-    deferredLoadTask.onResolutionComplete(mainFunction);
-
-    reporter.log('Inferring types...');
-    typesTask.onResolutionComplete(mainFunction);
-
-    if (stopAfterTypeInference) return;
-
-    backend.onTypeInferenceComplete();
-
-    reporter.log('Compiling...');
-    phase = PHASE_COMPILING;
-    backend.onCodegenStart();
-    // TODO(johnniwinther): Move these to [CodegenEnqueuer].
-    if (hasIsolateSupport) {
-      backend.enableIsolateSupport(enqueuer.codegen);
-    }
-    if (compileAll) {
-      libraryLoader.libraries.forEach((LibraryElement library) {
-        fullyEnqueueLibrary(library, enqueuer.codegen);
-      });
-    }
-    processQueue(enqueuer.codegen, mainFunction);
-    enqueuer.codegen.logSummary(reporter.log);
-
-    int programSize = backend.assembleProgram();
-
-    if (options.dumpInfo) {
-      dumpInfoTask.reportSize(programSize);
-      dumpInfoTask.dumpInfo();
-    }
-
-    backend.sourceInformationStrategy.onComplete();
-
-    checkQueues();
-  });
 
   void fullyEnqueueLibrary(LibraryElement library, Enqueuer world) {
     void enqueueAll(Element element) {
       fullyEnqueueTopLevelElement(element, world);
     }
     library.implementation.forEachLocalMember(enqueueAll);
   }
 
   void fullyEnqueueTopLevelElement(Element element, Enqueuer world) {
     if (element.isClass) {
@@ skipping 15 matching lines @@
         for (MetadataAnnotation metadata in library.metadata) {
           metadata.ensureResolved(resolution);
         }
       }
     }
   }
 
   /**
    * Empty the [world] queue.
    */
-  void emptyQueue(Enqueuer world)
-      => selfTask.measureSubtask("Compiler.emptyQueue", () {
-    world.forEach((WorkItem work) {
-      reporter.withCurrentElement(
-          work.element, () => selfTask.measureSubtask("world.applyImpact", () {
-        world.applyImpact(
-            work.element,
-            selfTask.measureSubtask("work.run", () => work.run(this, world)));
-      }));
-    });
-  });
+  void emptyQueue(Enqueuer world) =>
+      selfTask.measureSubtask("Compiler.emptyQueue", () {
+        world.forEach((WorkItem work) {
+          reporter.withCurrentElement(
+              work.element,
+              () => selfTask.measureSubtask("world.applyImpact", () {
+                    world.applyImpact(
+                        work.element,
+                        selfTask.measureSubtask(
+                            "work.run", () => work.run(this, world)));
+                  }));
+        });
+      });
 
-  void processQueue(Enqueuer world, Element main)
-      => selfTask.measureSubtask("Compiler.processQueue", () {
-    world.nativeEnqueuer.processNativeClasses(libraryLoader.libraries);
-    if (main != null && !main.isMalformed) {
-      FunctionElement mainMethod = main;
-      mainMethod.computeType(resolution);
-      if (mainMethod.functionSignature.parameterCount != 0) {
-        // The first argument could be a list of strings.
-        backend.listImplementation.ensureResolved(resolution);
-        backend.registerInstantiatedType(
-            backend.listImplementation.rawType, world, globalDependencies);
-        backend.stringImplementation.ensureResolved(resolution);
-        backend.registerInstantiatedType(
-            backend.stringImplementation.rawType, world, globalDependencies);
+  void processQueue(Enqueuer world, Element main) =>
+      selfTask.measureSubtask("Compiler.processQueue", () {
+        world.nativeEnqueuer.processNativeClasses(libraryLoader.libraries);
+        if (main != null && !main.isMalformed) {
+          FunctionElement mainMethod = main;
+          mainMethod.computeType(resolution);
+          if (mainMethod.functionSignature.parameterCount != 0) {
+            // The first argument could be a list of strings.
+            backend.listImplementation.ensureResolved(resolution);
+            backend.registerInstantiatedType(
+                backend.listImplementation.rawType, world, globalDependencies);
+            backend.stringImplementation.ensureResolved(resolution);
+            backend.registerInstantiatedType(
+                backend.stringImplementation.rawType,
+                world,
+                globalDependencies);
 
-        backend.registerMainHasArguments(world);
-      }
-      world.addToWorkList(main);
-    }
-    if (options.verbose) {
-      progress.reset();
-    }
-    emptyQueue(world);
-    world.queueIsClosed = true;
-    // Notify the impact strategy impacts are no longer needed for this
-    // enqueuer.
-    impactStrategy.onImpactUsed(world.impactUse);
-    backend.onQueueClosed();
-    assert(compilationFailed || world.checkNoEnqueuedInvokedInstanceMethods());
-  });
+            backend.registerMainHasArguments(world);
+          }
+          world.addToWorkList(main);
+        }
+        if (options.verbose) {
+          progress.reset();
+        }
+        emptyQueue(world);
+        world.queueIsClosed = true;
+        // Notify the impact strategy impacts are no longer needed for this
+        // enqueuer.
+        impactStrategy.onImpactUsed(world.impactUse);
+        backend.onQueueClosed();
+        assert(
+            compilationFailed || world.checkNoEnqueuedInvokedInstanceMethods());
+      });
 
   /**
    * Perform various checks of the queues. This includes checking that
    * the queues are empty (nothing was added after we stopped
    * processing the queues). Also compute the number of methods that
    * were resolved, but not compiled (aka excess resolution).
    */
   checkQueues() {
     for (Enqueuer world in [enqueuer.resolution, enqueuer.codegen]) {
       world.forEach((WorkItem work) {
@@ skipping 20 matching lines @@
         resolved.remove(e);
       }
     }
     reporter.log('Excess resolution work: ${resolved.length}.');
     for (Element e in resolved) {
       reporter.reportWarningMessage(e, MessageKind.GENERIC,
           {'text': 'Warning: $e resolved but not compiled.'});
     }
   }
 
-  WorldImpact analyzeElement(Element element)
-      => selfTask.measureSubtask("Compiler.analyzeElement", () {
-    assert(invariant(
-        element,
-        element.impliesType ||
-            element.isField ||
-            element.isFunction ||
-            element.isConstructor ||
-            element.isGetter ||
-            element.isSetter,
-        message: 'Unexpected element kind: ${element.kind}'));
-    assert(invariant(element, element is AnalyzableElement,
-        message: 'Element $element is not analyzable.'));
-    assert(invariant(element, element.isDeclaration));
-    return resolution.computeWorldImpact(element);
-  });
+  WorldImpact analyzeElement(Element element) =>
+      selfTask.measureSubtask("Compiler.analyzeElement", () {
+        assert(invariant(
+            element,
+            element.impliesType ||
+                element.isField ||
+                element.isFunction ||
+                element.isConstructor ||
+                element.isGetter ||
+                element.isSetter,
+            message: 'Unexpected element kind: ${element.kind}'));
+        assert(invariant(element, element is AnalyzableElement,
+            message: 'Element $element is not analyzable.'));
+        assert(invariant(element, element.isDeclaration));
+        return resolution.computeWorldImpact(element);
+      });
 
-  WorldImpact analyze(ResolutionWorkItem work,
-                      ResolutionEnqueuer world)
-      => selfTask.measureSubtask("Compiler.analyze", () {
-    assert(invariant(work.element, identical(world, enqueuer.resolution)));
-    assert(invariant(work.element, !work.isAnalyzed,
-        message: 'Element ${work.element} has already been analyzed'));
-    if (shouldPrintProgress) {
-      // TODO(ahe): Add structured diagnostics to the compiler API and
-      // use it to separate this from the --verbose option.
-      if (phase == PHASE_RESOLVING) {
-        reporter.log('Resolved ${enqueuer.resolution.processedElements.length} '
-            'elements.');
-        progress.reset();
-      }
-    }
-    AstElement element = work.element;
-    if (world.hasBeenProcessed(element)) {
-      return const WorldImpact();
-    }
-    WorldImpact worldImpact = analyzeElement(element);
-    backend.onElementResolved(element);
-    world.registerProcessedElement(element);
-    return worldImpact;
-  });
+  WorldImpact analyze(ResolutionWorkItem work, ResolutionEnqueuer world) =>
+      selfTask.measureSubtask("Compiler.analyze", () {
+        assert(invariant(work.element, identical(world, enqueuer.resolution)));
+        assert(invariant(work.element, !work.isAnalyzed,
+            message: 'Element ${work.element} has already been analyzed'));
+        if (shouldPrintProgress) {
+          // TODO(ahe): Add structured diagnostics to the compiler API and
+          // use it to separate this from the --verbose option.
+          if (phase == PHASE_RESOLVING) {
+            reporter
+                .log('Resolved ${enqueuer.resolution.processedElements.length} '
+                    'elements.');
+            progress.reset();
+          }
+        }
+        AstElement element = work.element;
+        if (world.hasBeenProcessed(element)) {
+          return const WorldImpact();
+        }
+        WorldImpact worldImpact = analyzeElement(element);
+        backend.onElementResolved(element);
+        world.registerProcessedElement(element);
+        return worldImpact;
+      });
 
   WorldImpact codegen(CodegenWorkItem work, CodegenEnqueuer world) {
     assert(invariant(work.element, identical(world, enqueuer.codegen)));
     if (shouldPrintProgress) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       reporter
           .log('Compiled ${enqueuer.codegen.generatedCode.length} methods.');
       progress.reset();
     }
@@ skipping 1009 matching lines @@
   _ElementScanner(this.scanner);
   void scanLibrary(LibraryElement library) => scanner.scanLibrary(library);
   void scanUnit(CompilationUnitElement unit) => scanner.scan(unit);
 }
 
 class _EmptyEnvironment implements Environment {
   const _EmptyEnvironment();
 
   String valueOf(String key) => null;
 }