dart2js: remove references to compiler in ResolvedUriTranslator

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;
 import 'closure.dart' as closureMapping show ClosureTask;
-import 'common.dart';
 import 'common/backend_api.dart' show Backend;
-import 'common/codegen.dart' show CodegenImpact, CodegenWorkItem;
+import 'common/codegen.dart' show CodegenWorkItem;
+import 'common/names.dart' show Selectors;
 import 'common/names.dart' show Identifiers, Uris;
 import 'common/registry.dart' show EagerRegistry, Registry;
 import 'common/resolution.dart'
     show Parsing, Resolution, ResolutionWorkItem, ResolutionImpact;
 import 'common/tasks.dart' show CompilerTask, GenericTask;
 import 'common/work.dart' show ItemCompilationContext, WorkItem;
+import 'common.dart';
 import 'compile_time_constants.dart';
 import 'constants/values.dart';
 import 'core_types.dart' show CoreClasses, CoreTypes;
 import 'dart_backend/dart_backend.dart' as dart_backend;
 import 'dart_types.dart' show DartType, DynamicType, InterfaceType, Types;
-import 'deferred_load.dart' show DeferredLoadTask, OutputUnit;
+import 'deferred_load.dart' show DeferredLoadTask;
 import 'diagnostics/code_location.dart';
 import 'diagnostics/diagnostic_listener.dart' show DiagnosticReporter;
 import 'diagnostics/invariant.dart' show REPORT_EXCESS_RESOLUTION;
 import 'diagnostics/messages.dart' show Message, MessageTemplate;
 import 'dump_info.dart' show DumpInfoTask;
 import 'elements/elements.dart';
-import 'elements/modelx.dart'
-    show
-        ErroneousElementX,
-        ClassElementX,
-        CompilationUnitElementX,
-        DeferredLoaderGetterElementX,
-        MethodElementX,
-        LibraryElementX,
-        PrefixElementX;
+import 'elements/modelx.dart' show ErroneousElementX;
 import 'enqueue.dart'
     show
         CodegenEnqueuer,
         Enqueuer,
         EnqueueTask,
         ResolutionEnqueuer,
         QueueFilter;
 import 'environment.dart';
 import 'id_generator.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,
         LibraryLoaderListener,
-        ResolvedUriTranslator,
         ScriptLoader;
 import 'mirrors_used.dart' show MirrorUsageAnalyzerTask;
-import 'common/names.dart' show Selectors;
 import 'null_compiler_output.dart' show NullCompilerOutput, NullSink;
 import 'options.dart' show CompilerOptions, DiagnosticOptions, ParserOptions;
 import 'parser/diet_parser_task.dart' show DietParserTask;
 import 'parser/element_listener.dart' show ScannerOptions;
 import 'parser/parser_task.dart' show ParserTask;
 import 'patch_parser.dart' show PatchParserTask;
 import 'resolution/registry.dart' show ResolutionRegistry;
 import 'resolution/resolution.dart' show ResolverTask;
 import 'resolution/tree_elements.dart' show TreeElementMapping;
+import 'resolved_uri_translator.dart';
 import 'scanner/scanner_task.dart' show ScannerTask;
+import 'script.dart' show Script;
 import 'serialization/task.dart' show SerializationTask;
-import 'script.dart' show Script;
 import 'ssa/nodes.dart' show HInstruction;
-import 'tracer.dart' show Tracer;
 import 'tokens/token.dart' show StringToken, Token, TokenPair;
 import 'tokens/token_map.dart' show TokenMap;
+import 'tracer.dart' show Tracer;
 import 'tree/tree.dart' show Node, TypeAnnotation;
 import 'typechecker.dart' show TypeCheckerTask;
 import 'types/types.dart' as ti;
 import 'universe/call_structure.dart' show CallStructure;
 import 'universe/selector.dart' show Selector;
 import 'universe/universe.dart' show Universe;
 import 'universe/use.dart' show StaticUse;
 import 'universe/world_impact.dart' show ImpactStrategy, WorldImpact;
 import 'util/util.dart' show Link, Setlet;
 import 'world.dart' show World;
@@ skipping 43 matching lines @@
    * If true, stop compilation after type inference is complete. Used for
    * debugging and testing purposes only.
    */
   bool stopAfterTypeInference = false;
 
   /// Output provider from user of Compiler API.
   api.CompilerOutput userOutputProvider;
 
   List<Uri> librariesToAnalyzeWhenRun;
 
-  /// The set of platform libraries reported as unsupported.
-  ///
-  /// For instance when importing 'dart:io' without '--categories=Server'.
-  Set<Uri> disallowedLibraryUris = new Setlet<Uri>();
+  ResolvedUriTranslator get resolvedUriTranslator;
 
   Tracer tracer;
 
   CompilerTask measuredTask;
   LibraryElement coreLibrary;
   LibraryElement asyncLibrary;
 
   LibraryElement mainApp;
   FunctionElement mainFunction;
 
@@ skipping 175 matching lines @@
         throw new ArgumentError('--dump-info is not supported for dart2dart.');
       }
     }
 
     if (options.dumpInfo && options.useStartupEmitter) {
       throw new ArgumentError(
           '--dump-info is not supported with the fast startup emitter');
     }
 
     tasks = [
-      dietParser = new DietParserTask(this, parsing.parserOptions, idGenerator),
+      dietParser = new DietParserTask(
+          this, parsing.parserOptions, idGenerator, backend, reporter),
       scanner = createScannerTask(),
       serialization = new SerializationTask(this),
       libraryLoader = new LibraryLoaderTask(
           this,
           new _ResolvedUriTranslator(this),
           new _ScriptLoader(this),
           new _ElementScanner(scanner),
           this.serialization,
           this,
           environment),
@@ skipping 41 matching lines @@
   @deprecated
   int getNextFreeId() => idGenerator.getNextFreeId();
 
   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
-  // succeded.
+  // succeeded.
   Future<bool> run(Uri uri) {
     totalCompileTime.start();
 
     return new Future.sync(() => runInternal(uri))
         .catchError((error) => _reporter.onError(uri, error))
         .whenComplete(() {
       tracer.close();
       totalCompileTime.stop();
     }).then((_) {
       return !compilationFailed;
@@ skipping 101 matching lines @@
       if (chainCount > chainLimit) {
         // Assume there are more import chains.
         importChains.add('...');
         return false;
       }
       return true;
     });
     return importChains;
   }
 
-  /// Register that [uri] was recognized but disallowed as a dependency.
-  ///
-  /// For instance import of 'dart:io' without '--categories=Server'.
-  void registerDisallowedLibraryUse(Uri uri) {
-    disallowedLibraryUris.add(uri);
-  }
-
   /// This method is called when all new libraries loaded through
   /// [LibraryLoader.loadLibrary] has been loaded and their imports/exports
   /// have been computed.
   ///
   /// [loadedLibraries] contains the newly loaded libraries.
   ///
   /// The method returns a [Future] allowing for the loading of additional
   /// libraries.
   Future onLibrariesLoaded(LoadedLibraries loadedLibraries) {
     return new Future.sync(() {
-      for (Uri uri in disallowedLibraryUris) {
+      var disallowedLibraries =
+          resolvedUriTranslator?.disallowedLibraryUris ?? const <Uri>[];
+      for (Uri uri in disallowedLibraries) {
         if (loadedLibraries.containsLibrary(uri)) {
           Set<String> importChains =
               computeImportChainsFor(loadedLibraries, uri);
           reporter.reportInfo(
               NO_LOCATION_SPANNABLE, MessageKind.DISALLOWED_LIBRARY_IMPORT, {
             'uri': uri,
             'importChain': importChains
                 .join(MessageTemplate.DISALLOWED_LIBRARY_IMPORT_PADDING)
           });
         }
@@ skipping 550 matching lines @@
     return !BENIGN_ERRORS.contains(message.message.kind);
   }
 
   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(Uri readableUri, [Spannable node]) {
     unimplemented(node, 'Compiler.readScript');
     return null;
   }
 
@@ skipping 759 matching lines @@
   ResolvedAst getResolvedAst(Element element) {
     if (hasResolvedAst(element)) {
       AstElement astElement = element;
       return astElement.resolvedAst;
     }
     assert(invariant(element, hasResolvedAst(element),
         message: "ResolvedAst not available for $element."));
     return null;
   }
 
-
   @override
   bool hasResolutionImpact(Element element) {
     return _resolutionImpactCache.containsKey(element);
   }
 
   @override
   ResolutionImpact getResolutionImpact(Element element) {
     ResolutionImpact resolutionImpact = _resolutionImpactCache[element];
     assert(invariant(element, resolutionImpact != null,
         message: "ResolutionImpact not available for $element."));
@@ skipping 87 matching lines @@
 
   @override
   void parsePatchClass(ClassElement cls) {
     compiler.patchParser.measure(() {
       if (cls.isPatch) {
         compiler.patchParser.parsePatchClassNode(cls);
       }
     });
   }
 
-  ScannerOptions getScannerOptionsFor(Element element) =>
-      new ScannerOptions.from(compiler, element.library);
+  ScannerOptions getScannerOptionsFor(Element element) => new ScannerOptions(
+      canUseNative: compiler.backend.canLibraryUseNative(element.library));
 
   ParserOptions get parserOptions => compiler.options;
 }
 
 class GlobalDependencyRegistry extends EagerRegistry {
   final Compiler compiler;
   Setlet<Element> _otherDependencies;
 
   GlobalDependencyRegistry(this.compiler) : super('GlobalDependencies', null);
 
@@ skipping 10 matching lines @@
     _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`.
+// TODO(het): This class is an ugly hack because we need a
+// [ResolvedUriTranslator] at compiler construction time, but the actual
+// translator isn't set until the compiler actually starts running.

[Siggi Cherem (dart-lang), 2016/04/13 15:53:35]

Some ideas to make it more self explanatory:

- rename it to indicate that it is not initialized upfront (e.g.
`LazyResolvedUriTranslator` or `UninitializedResolvedUriTranslator`)

- instead of depending on compiler.resolvedUriTranslator, make it contain the
actual translator and add a setup function that will initialize it:

   /// Once initialized, the underlying implementation of the translator.
   ResolvedUriTranslator _translator;

   void setup(x, y) {
     _translator = new ResolvedUriTranslator(x, y);
   }


- create it eagerly in apiimpl at construction time, and call setup from the
apiimpl setup function.

At that point the code will not depend on compiler, so we should be able to move
it to `resolved_uri_translator.dart` too.


An alternative: make the internal fields in
resolved_uri_translator.dart#_ResolvedUriTranslator non final and expose the
setup function there.

[Harry Terkelsen, 2016/04/13 20:23:40]

Done.

 class _ResolvedUriTranslator implements ResolvedUriTranslator {
   Compiler compiler;
   _ResolvedUriTranslator(this.compiler);
 
+  @override
   Uri translate(LibraryElement importingLibrary, Uri resolvedUri,
           [Spannable spannable]) =>
-      compiler.translateResolvedUri(importingLibrary, resolvedUri, spannable);
+      compiler.resolvedUriTranslator
+          .translate(importingLibrary, resolvedUri, spannable);
+
+  @override
+  Set<Uri> get disallowedLibraryUris =>
+      compiler.resolvedUriTranslator.disallowedLibraryUris;
+
+  @override
+  bool get mockableLibraryUsed =>
+      compiler.resolvedUriTranslator.mockableLibraryUsed;
+
+  @override
+  Map<String, Uri> get sdkLibraries =>
+      compiler.resolvedUriTranslator.sdkLibraries;
 }
 
 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;
 }