Remove Compiler.mainApp and Compiler.mainFunction

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 Future;
 
 import '../compiler_new.dart' as api;
 import 'backend_strategy.dart';
@@ skipping 97 matching lines @@
    */
   bool stopAfterTypeInference = false;
 
   /// Output provider from user of Compiler API.
   api.CompilerOutput userOutputProvider;
 
   List<Uri> librariesToAnalyzeWhenRun;
 
   ResolvedUriTranslator get resolvedUriTranslator;
 
-  LibraryEntity mainApp;
-  FunctionEntity mainFunction;
+  Uri mainLibraryUri;
 
   DiagnosticReporter get reporter => _reporter;
   Resolution get resolution => _resolution;
   ParsingContext get parsingContext => _parsingContext;
 
   // TODO(zarah): Remove this map and incorporate compile-time errors
   // in the model.
   /// Tracks elements with compile-time errors.
   final Map<Entity, List<DiagnosticMessage>> elementsWithCompileTimeErrors =
       new Map<Entity, List<DiagnosticMessage>>();
@@ skipping 296 matching lines @@
     return loadedLibraries;
   }
 
   /**
    * Get an [Uri] pointing to a patch for the dart: library with
    * the given path. Returns null if there is no patch.
    */
   Uri resolvePatchUri(String dartLibraryPath);
 
   Future runInternal(Uri uri) async {
+    mainLibraryUri = uri;
     // TODO(ahe): This prevents memory leaks when invoking the compiler
     // multiple times. Implement a better mechanism where we can store
     // such caches in the compiler and get access to them through a
     // suitably maintained static reference to the current compiler.
     StringToken.canonicalizer.clear();
     Selector.canonicalizedValues.clear();
 
     // The selector objects held in static fields must remain canonical.
     for (Selector selector in Selectors.ALL) {
       Selector.canonicalizedValues
           .putIfAbsent(selector.hashCode, () => <Selector>[])
           .add(selector);
     }
 
     assert(uri != null || options.analyzeOnly);
     // As far as I can tell, this branch is only used by test code.
     if (librariesToAnalyzeWhenRun != null) {
       await Future.forEach(librariesToAnalyzeWhenRun, (libraryUri) async {
         reporter.log('Analyzing $libraryUri (${options.buildId})');
         LoadedLibraries loadedLibraries =
             await libraryLoader.loadLibrary(libraryUri);
         processLoadedLibraries(loadedLibraries);
       });
     }
+    LibraryEntity mainApp;
     if (uri != null) {
       if (options.analyzeOnly) {
         reporter.log('Analyzing $uri (${options.buildId})');
       } else {
         reporter.log('Compiling $uri (${options.buildId})');
       }
       LoadedLibraries libraries = await libraryLoader.loadLibrary(uri);
       processLoadedLibraries(libraries);
       mainApp = libraries.rootLibrary;
     }
@@ skipping 38 matching lines @@
     }
     resolutionEnqueuer.addDeferredActions(libraryLoader.pullDeferredActions());
     return resolutionEnqueuer;
   }
 
   /// Performs the compilation when all libraries have been loaded.
   void compileLoadedLibraries(LibraryEntity rootLibrary) =>
       selfTask.measureSubtask("Compiler.compileLoadedLibraries", () {
         ResolutionEnqueuer resolutionEnqueuer = startResolution();
         WorldImpactBuilderImpl mainImpact = new WorldImpactBuilderImpl();
-        mainFunction = frontendStrategy.computeMain(rootLibrary, mainImpact);
+        FunctionEntity mainFunction =
+            frontendStrategy.computeMain(rootLibrary, mainImpact);
 
         if (!options.loadFromDill) {
           // TODO(johnniwinther): Support mirrors usages analysis from dill.
           mirrorUsageAnalyzerTask.analyzeUsage(rootLibrary);
         }
 
         // 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);
+        deferredLoadTask.beforeResolution(rootLibrary);
         impactStrategy = backend.createImpactStrategy(
             supportDeferredLoad: deferredLoadTask.isProgramSplit,
             supportDumpInfo: options.dumpInfo,
             supportSerialization: serialization.supportSerialization);
 
         phase = PHASE_RESOLVING;
         resolutionEnqueuer.applyImpact(mainImpact);
         if (options.resolveOnly) {
           libraryLoader.libraries.where((LibraryEntity library) {
             return !serialization.isDeserialized(library);
@@ skipping 49 matching lines @@
           serialization.serializeToSink(
               userOutputProvider.createOutputSink(
                   '', 'data', api.OutputType.serializationData),
               libraryLoader.libraries.where((LibraryEntity library) {
             return !serialization.isDeserialized(library);
           }));
         }
         if (options.analyzeOnly) return;
         assert(mainFunction != null);
 
-        ClosedWorldRefiner closedWorldRefiner = closeResolution();
+        ClosedWorldRefiner closedWorldRefiner = closeResolution(mainFunction);
         ClosedWorld closedWorld = closedWorldRefiner.closedWorld;
+        mainFunction = closedWorld.elementEnvironment.mainFunction;
 
         reporter.log('Inferring types...');
         globalInference.runGlobalTypeInference(
             mainFunction, closedWorld, closedWorldRefiner);
 
         if (stopAfterTypeInference) return;
 
         backend.onTypeInferenceComplete(globalInference.results);
 
         reporter.log('Compiling...');
@@ skipping 19 matching lines @@
           dumpInfoTask.reportSize(programSize);
           dumpInfoTask.dumpInfo(closedWorld);
         }
 
         backend.onCodegenEnd();
 
         checkQueues(resolutionEnqueuer, codegenEnqueuer);
       });
 
   /// Perform the steps needed to fully end the resolution phase.
-  ClosedWorldRefiner closeResolution() {
+  ClosedWorldRefiner closeResolution(FunctionEntity mainFunction) {
     phase = PHASE_DONE_RESOLVING;
 
     ClosedWorld closedWorld = resolutionWorldBuilder.closeWorld();
     ClosedWorldRefiner closedWorldRefiner =
         backendStrategy.createClosedWorldRefiner(closedWorld);
     // Compute whole-program-knowledge that the backend needs. (This might
     // require the information computed in [world.closeWorld].)
     backend.onResolutionClosedWorld(closedWorld, closedWorldRefiner);
 
     deferredLoadTask.onResolutionComplete(mainFunction, closedWorld);
@@ skipping 252 matching lines @@
     Iterable<CodeLocation> userCodeLocations =
         computeUserCodeLocations(assumeInUserCode: assumeInUserCode);
     Uri libraryUri = element.library.canonicalUri;
     return userCodeLocations.any(
         (CodeLocation codeLocation) => codeLocation.inSameLocation(libraryUri));
   }
 
   Iterable<CodeLocation> computeUserCodeLocations(
       {bool assumeInUserCode: false}) {
     List<CodeLocation> userCodeLocations = <CodeLocation>[];
-    if (mainApp != null) {
-      userCodeLocations.add(new CodeLocation(mainApp.canonicalUri));
+    if (mainLibraryUri != null) {
+      userCodeLocations.add(new CodeLocation(mainLibraryUri));
     }
     if (librariesToAnalyzeWhenRun != null) {
       userCodeLocations.addAll(
           librariesToAnalyzeWhenRun.map((Uri uri) => new CodeLocation(uri)));
     }
     if (userCodeLocations.isEmpty && assumeInUserCode) {
       // Assume in user code since [mainApp] has not been set yet.
       userCodeLocations.add(const AnyLocation());
     }
     return userCodeLocations;
@@ skipping 23 matching lines @@
   }
 
   /// Associate [element] with a compile-time error [message].
   void registerCompileTimeError(Entity element, DiagnosticMessage message) {
     // The information is only needed if [generateCodeWithCompileTimeErrors].
     if (options.generateCodeWithCompileTimeErrors) {
       if (element == null) {
         // Record as global error.
         // TODO(zarah): Extend element model to represent compile-time
         // errors instead of using a map.
-        element = mainFunction;
+        element = frontendStrategy.elementEnvironment.mainFunction;
       }
       elementsWithCompileTimeErrors
           .putIfAbsent(element, () => <DiagnosticMessage>[])
           .add(message);
     }
   }
 
   api.OutputSink outputProvider(
       String name, String extension, api.OutputType type) {
     if (compilationFailed) {
@@ skipping 616 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;
 }