dart2js: remove references to compiler in ResolvedUriTranslator

tests/compiler/dart2js/mock_compiler.dart

 // Copyright (c) 2016, 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 mock_compiler;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:compiler/compiler.dart' as api;
 import 'package:compiler/src/common/names.dart' show
     Uris;
 import 'package:compiler/src/constants/expressions.dart';
 import 'package:compiler/src/diagnostics/diagnostic_listener.dart';
 import 'package:compiler/src/diagnostics/source_span.dart';
 import 'package:compiler/src/diagnostics/spannable.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/visitor.dart';
 import 'package:compiler/src/js_backend/backend_helpers.dart' show
     BackendHelpers;
 import 'package:compiler/src/js_backend/lookup_map_analysis.dart' show
     LookupMapAnalysis;
 import 'package:compiler/src/io/source_file.dart';
 import 'package:compiler/src/options.dart' show
     CompilerOptions;
 import 'package:compiler/src/resolution/members.dart';
 import 'package:compiler/src/resolution/registry.dart';
 import 'package:compiler/src/resolution/scope.dart';
 import 'package:compiler/src/resolution/tree_elements.dart';
+import 'package:compiler/src/resolved_uri_translator.dart';
 import 'package:compiler/src/script.dart';
 import 'package:compiler/src/tree/tree.dart';
 import 'package:compiler/src/old_to_new_api.dart';
 import 'parser_helper.dart';
 
 import 'package:compiler/src/elements/modelx.dart' show
     ElementX,
     LibraryElementX,
     ErroneousElementX,
     FunctionElementX;
@@ skipping 18 matching lines @@
   /// Expected number of warnings. If `null`, the number of warnings is
   /// not checked.
   final int expectedWarnings;
   /// Expected number of errors. If `null`, the number of errors is not checked.
   final int expectedErrors;
   final Map<String, SourceFile> sourceFiles;
   Node parsedTree;
   final String testedPatchVersion;
   final LibrarySourceProvider librariesOverride;
   final DiagnosticCollector diagnosticCollector = new DiagnosticCollector();
+  final ResolvedUriTranslator resolvedUriTranslator =
+      new MockResolvedUriTranslator();
 
   MockCompiler.internal(
       {Map<String, String> coreSource,
        bool enableTypeAssertions: false,
        bool enableUserAssertions: false,
        bool enableMinification: false,
        bool disableTypeInference: false,
        bool analyzeAll: false,
        bool analyzeOnly: false,
        bool emitJavaScript: true,
@@ skipping 172 matching lines @@
   Future scanBuiltinLibraries() {
     // Do nothing. The mock core library is already handled in the constructor.
     return new Future.value();
   }
 
   Future<LibraryElement> scanBuiltinLibrary(String name) {
     // Do nothing. The mock core library is already handled in the constructor.
     return new Future.value();
   }
 
-  Uri translateResolvedUri(LibraryElement importingLibrary,
-                           Uri resolvedUri, Spannable spannable) => resolvedUri;
-
   // The mock library doesn't need any patches.
   Uri resolvePatchUri(String dartLibraryName) {
     if (dartLibraryName == 'core') {
       return PATCH_CORE;
     }
     return null;
   }
 
   Future<Script> readScript(Uri uri, [Spannable spannable]) {
     SourceFile sourceFile = sourceFiles[uri.toString()];
     if (sourceFile == null) throw new ArgumentError(uri);
     return new Future.value(new Script(uri, uri, sourceFile));
   }
 
   Element lookupElementIn(ScopeContainerElement container, name) {
     Element element = container.localLookup(name);
     return element != null
         ? element
         : new ErroneousElementX(null, null, name, container);
   }
 
   /// Create a new [MockCompiler] and apply it asynchronously to [f].
   static Future create(f(MockCompiler compiler)) {
     MockCompiler compiler = new MockCompiler.internal();
     return compiler.init().then((_) => f(compiler));
   }
 }
 
+class MockResolvedUriTranslator implements ResolvedUriTranslator {
+  static final _emptySet = new Set();
+
+  Uri translate(LibraryElement importingLibrary, Uri resolvedUri,
+          [Spannable spannable]) =>
+      resolvedUri;
+  Set<Uri> get disallowedLibraryUris => _emptySet;
+  bool get mockableLibraryUsed => false;
+  Map<String, Uri> get sdkLibraries => const <String, Uri>{};
+}
+
 class CollectingTreeElements extends TreeElementMapping {
   final Map<Node, Element> map = new LinkedHashMap<Node, Element>();
 
   CollectingTreeElements(Element currentElement) : super(currentElement);
 
   operator []=(Node node, Element element) {
     map[node] = element;
   }
 
   operator [](Node node) => map[node];
@@ skipping 74 matching lines @@
       trustTypeAnnotations: trustTypeAnnotations,
       enableTypeAssertions: enableTypeAssertions,
       enableUserAssertions: enableUserAssertions,
       expectedErrors: expectedErrors,
       expectedWarnings: expectedWarnings,
       outputProvider: outputProvider);
   compiler.registerSource(uri, code);
   compiler.diagnosticHandler = createHandler(compiler, code);
   return compiler;
 }