Split loader from the rest of the compiler. This adds several abstractions to

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;
 
@@ skipping 55 matching lines @@
     DeferredLoaderGetterElementX,
     MethodElementX,
     LibraryElementX,
     PrefixElementX;
 import 'enqueue.dart' show
     CodegenEnqueuer,
     Enqueuer,
     EnqueueTask,
     ResolutionEnqueuer,
     QueueFilter;
+import 'environment.dart';
 import 'io/source_information.dart' show
     SourceInformation;
 import 'js_backend/backend_helpers.dart' as js_backend show
     BackendHelpers;
 import 'js_backend/js_backend.dart' as js_backend show
     JavaScriptBackend;
 import 'library_loader.dart' show
+    ElementScanner,
     LibraryLoader,
     LibraryLoaderTask,
-    LoadedLibraries;
+    LoadedLibraries,
+    LibraryLoaderListener,
+    ResolvedUriTranslator,
+    ScriptLoader;
 import 'mirrors_used.dart' show
     MirrorUsageAnalyzerTask;
 import 'common/names.dart' show
     Selectors;
 import 'null_compiler_output.dart' show
     NullCompilerOutput,
     NullSink;
 import 'parser/diet_parser_task.dart' show
     DietParserTask;
 import 'parser/element_listener.dart' show
@@ skipping 43 matching lines @@
     StaticUse;
 import 'universe/world_impact.dart' show
     ImpactStrategy,
     WorldImpact;
 import 'util/util.dart' show
     Link,
     Setlet;
 import 'world.dart' show
     World;
 
-abstract class Compiler {
+abstract class Compiler implements LibraryLoaderListener {
 
   final Stopwatch totalCompileTime = new Stopwatch();
   int nextFreeClassId = 0;
   World world;
   Types types;
   _CompilerCoreTypes _coreTypes;
   _CompilerDiagnosticReporter _reporter;
   _CompilerResolution _resolution;
   _CompilerParsing _parsing;
 
@@ skipping 113 matching lines @@
 
   /// The [bool.fromEnvironment] constructor.
   ConstructorElement boolEnvironment;
 
   /// The [String.fromEnvironment] constructor.
   ConstructorElement stringEnvironment;
 
   /// Tracks elements with compile-time errors.
   final Set<Element> elementsWithCompileTimeErrors = new Set<Element>();
 
-  fromEnvironment(String name) => null;
+  final Environment environment;
+  // TODO(sigmund): delete once we migrate the rest of the compiler to use
+  // `environment` directly.
+  fromEnvironment(String name) => environment.valueOf(name);

[Harry Terkelsen, 2016/03/22 21:49:28]

add @deprecated

[Siggi Cherem (dart-lang), 2016/03/23 22:51:05]

Done.

 
   Element get currentElement => _reporter.currentElement;
 
   List<CompilerTask> tasks;
   ScannerTask scanner;
   DietParserTask dietParser;
   ParserTask parser;
   PatchParserTask patchParser;
   LibraryLoaderTask libraryLoader;
   SerializationTask serialization;
@@ skipping 47 matching lines @@
   bool get compilationFailed => compilationFailedInternal;
 
   void set compilationFailed(bool value) {
     if (value) {
       elementsWithCompileTimeErrors.add(currentElement);
     }
     compilationFailedInternal = value;
   }
 
   Compiler({api.CompilerOptions options,
-            api.CompilerOutput outputProvider})
+            api.CompilerOutput outputProvider,
+            this.environment: const _EmptyEnvironment()})
       : this.options = options,
         this.cacheStrategy = new CacheStrategy(options.hasIncrementalSupport),
         this.userOutputProvider = outputProvider == null
             ? const NullCompilerOutput() : outputProvider {
 
     world = new World(this);
     // TODO(johnniwinther): Initialize core types in [initializeCoreClasses] and
     // make its field final.
     _reporter = new _CompilerDiagnosticReporter(
         this, options.diagnosticOptions);
@@ skipping 20 matching lines @@
       backend = jsBackend;
     } else {
       backend = new dart_backend.DartBackend(this, options.strips,
           multiFile: options.dart2dartMultiFile);
       if (options.dumpInfo) {
         throw new ArgumentError('--dump-info is not supported for dart2dart.');
       }
     }
 
     tasks = [
-      libraryLoader = new LibraryLoaderTask(this),
-      serialization = new SerializationTask(this),
-      scanner = new ScannerTask(this),
       dietParser = new DietParserTask(
           this, enableConditionalDirectives: options.enableConditionalDirectives),

[Harry Terkelsen, 2016/03/22 21:49:28]

long line

+      scanner = new ScannerTask(this),
+      serialization = new SerializationTask(this),
+      libraryLoader = new LibraryLoaderTask(this,
+          new _ResolvedUriTranslator(this),
+          new _ScriptLoader(this),
+          new _ElementScanner(scanner),
+          this.serialization,
+          this,
+          environment),
       parser = new ParserTask(
           this, enableConditionalDirectives: options.enableConditionalDirectives),

[Harry Terkelsen, 2016/03/22 21:49:28]

ditto

[Siggi Cherem (dart-lang), 2016/03/23 22:51:05]

Done.

       patchParser = new PatchParserTask(
           this, enableConditionalDirectives: options.enableConditionalDirectives),

[Harry Terkelsen, 2016/03/22 21:49:27]

ditto

[Siggi Cherem (dart-lang), 2016/03/23 22:51:05]

Done.

       resolver = new ResolverTask(this, backend.constantCompilerTask),
       closureToClassMapper = new closureMapping.ClosureTask(this),
       checker = new TypeCheckerTask(this),
       typesTask = new ti.TypesTask(this),
       constants = backend.constantCompilerTask,
       deferredLoadTask = new DeferredLoadTask(this),
       mirrorUsageAnalyzerTask = new MirrorUsageAnalyzerTask(this),
       enqueuer = new EnqueueTask(this),
       dumpInfoTask = new DumpInfoTask(this),
       reuseLibraryTask = new GenericTask('Reuse library', this),
@@ skipping 733 matching lines @@
   }
 
   void fatalDiagnosticReported(DiagnosticMessage message,
                                List<DiagnosticMessage> infos,
                                api.Diagnostic kind) {
     if (markCompilationAsFailed(message, kind)) {
       compilationFailed = true;
     }
   }
 
+  // TODO(sigmund): move this dart doc somewhere else too.
   /**
    * Translates the [resolvedUri] into a readable URI.
    *
    * The [importingLibrary] holds the library importing [resolvedUri] or
    * [:null:] if [resolvedUri] is loaded as the main library. The
    * [importingLibrary] is used to grant access to internal libraries from
    * platform libraries and patch libraries.
    *
    * If the [resolvedUri] is not accessible from [importingLibrary], this method
    * is responsible for reporting errors.
    *
    * See [LibraryLoader] for terminology on URIs.
    */
   Uri translateResolvedUri(LibraryElement importingLibrary,
                            Uri resolvedUri, Spannable spannable) {
     unimplemented(importingLibrary, 'Compiler.translateResolvedUri');
     return null;
   }
 
   /**
    * Reads the script specified by the [readableUri].
    *
    * See [LibraryLoader] for terminology on URIs.
    */
-  Future<Script> readScript(Spannable node, Uri readableUri) {
+  Future<Script> readScript(Uri readableUri, [Spannable node]) {
     unimplemented(node, 'Compiler.readScript');
     return null;
   }
 
-  /// Compatible with [readScript] and used by [LibraryLoader] to create
-  /// synthetic scripts to recover from read errors and bad URIs.
-  Future<Script> synthesizeScript(Spannable node, Uri readableUri) {
-    unimplemented(node, 'Compiler.synthesizeScript');
-    return null;
-  }
-
   Element lookupElementIn(ScopeContainerElement container, String name) {
     Element element = container.localLookup(name);
     if (element == null) {
       throw 'Could not find $name in $container';
     }
     return element;
   }
 
   bool get isMockCompilation => false;
 
@@ skipping 114 matching lines @@
     if (libraryUri.scheme == 'package') {
       int slashPos = libraryUri.path.indexOf('/');
       if (slashPos != -1) {
         String packageName = libraryUri.path.substring(0, slashPos);
         return new Uri(scheme: 'package', path: packageName);
       }
     }
     return libraryUri;
   }
 
-  void diagnoseCrashInUserCode(String message, exception, stackTrace) {
-    // Overridden by Compiler in apiimpl.dart.
-  }
-
   void forgetElement(Element element) {
     enqueuer.forgetElement(element);
     if (element is MemberElement) {
       for (Element closure in element.nestedClosures) {
         // TODO(ahe): It would be nice to reuse names of nested closures.
         closureToClassMapper.forgetElement(closure);
       }
     }
     backend.forgetElement(element);
   }
@@ skipping 749 matching lines @@
     if (_otherDependencies == null) {
       _otherDependencies = new Setlet<Element>();
     }
     _otherDependencies.add(element.implementation);
   }
 
   Iterable<Element> get otherDependencies {
     return _otherDependencies != null ? _otherDependencies : const <Element>[];
   }
 }
+
+// TODO(sigmund): in the future, each of these classes should be self contained
+// and not use references to `compiler`.
+class _ResolvedUriTranslator implements ResolvedUriTranslator {
+  Compiler compiler;
+  _ResolvedUriTranslator(this.compiler);
+
+  Uri translate(LibraryElement importingLibrary, Uri resolvedUri,
+      [Spannable spannable]) =>
+    compiler.translateResolvedUri(importingLibrary, resolvedUri, spannable);
+}
+
+class _ScriptLoader implements ScriptLoader {
+  Compiler compiler;
+  _ScriptLoader(this.compiler);
+
+  Future<Script> readScript(Uri uri, [Spannable spannable]) =>
+      compiler.readScript(uri, spannable);
+}
+
+class _ElementScanner implements ElementScanner {
+  ScannerTask scanner;
+  _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;
+}