Revert "Emit warning on import of dart:mirrors."

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.
 
 part of dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 410 matching lines @@
           checkNativeAnnotation(compiler, element);
         }
       });
     }
     return new Future.value();
   }
 
   /// This method is called when all new libraries loaded through
   /// [LibraryLoader.loadLibrary] has been loaded and their imports/exports
   /// have been computed.
-  Future onLibrariesLoaded(LoadedLibraries loadedLibraries) {
+  Future onLibrariesLoaded(Map<Uri, LibraryElement> loadedLibraries) {
     return new Future.value();
   }
 
   /// Called by [MirrorUsageAnalyzerTask] after it has merged all @MirrorsUsed
   /// annotations. The arguments corresponds to the unions of the corresponding
   /// fields of the annotations.
   void registerMirrorUsage(Set<String> symbols,
                            Set<Element> targets,
                            Set<Element> metaTargets) {}
 
@@ skipping 472 matching lines @@
   final Selector symbolValidatedConstructorSelector = new Selector.call(
       'validated', null, 1);
   final Selector fromEnvironmentSelector = new Selector.callConstructor(
       'fromEnvironment', null, 2);
 
   bool enabledNoSuchMethod = false;
   bool enabledRuntimeType = false;
   bool enabledFunctionApply = false;
   bool enabledInvokeOn = false;
   bool hasIsolateSupport = false;
-  final bool enableExperimentalMirrors;
 
   Stopwatch progress;
 
   bool get shouldPrintProgress {
     return verbose && progress.elapsedMilliseconds > 500;
   }
 
   static const int PHASE_SCANNING = 0;
   static const int PHASE_RESOLVING = 1;
   static const int PHASE_DONE_RESOLVING = 2;
@@ skipping 28 matching lines @@
             this.verbose: false,
             this.sourceMapUri: null,
             this.outputUri: null,
             this.buildId: UNDETERMINED_BUILD_ID,
             this.terseDiagnostics: false,
             this.dumpInfo: false,
             this.showPackageWarnings: false,
             this.useContentSecurityPolicy: false,
             this.suppressWarnings: false,
             bool hasIncrementalSupport: false,
-            this.enableExperimentalMirrors: false,
             this.enableAsyncAwait: false,
             this.enableEnums: false,
             api.CompilerOutputProvider outputProvider,
             List<String> strips: const []})
       : this.disableTypeInferenceFlag =
           disableTypeInferenceFlag || !emitJavaScript,
         this.analyzeOnly =
             analyzeOnly || analyzeSignaturesOnly || analyzeAllFlag,
         this.analyzeSignaturesOnly = analyzeSignaturesOnly,
         this.analyzeAllFlag = analyzeAllFlag,
@@ skipping 234 matching lines @@
   }
 
   /// 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) {
+  Future onLibrariesLoaded(Map<Uri, LibraryElement> loadedLibraries) {
     return new Future.sync(() {
-      if (!loadedLibraries.containsLibrary(DART_CORE)) {
-        return null;
-      }
-      if (!enableExperimentalMirrors &&
-          loadedLibraries.containsLibrary(DART_MIRRORS)) {
-        // TODO(johnniwinther): Move computation of dependencies to the library
-        // loader.
-        Uri rootUri = loadedLibraries.rootUri;
-        Set<String> importChains = new Set<String>();
-        loadedLibraries.forEachImportChain(
-            (LibraryElement library, Link<Uri> importChainReversed) {
-          if (library.canonicalUri != DART_MIRRORS) return;
-          Link<CodeLocation> compactImportChain = const Link<CodeLocation>();
-          CodeLocation currentCodeLocation = new UriLocation(DART_MIRRORS);
-          compactImportChain = compactImportChain.prepend(currentCodeLocation);
-          for (Link<Uri> link = importChainReversed;
-               !link.isEmpty;
-               link = link.tail) {
-            Uri uri = link.head;
-            if (!currentCodeLocation.inSameLocation(uri)) {
-              currentCodeLocation =
-                  verbose ? new UriLocation(uri) : new CodeLocation(uri);
-              compactImportChain =
-                  compactImportChain.prepend(currentCodeLocation);
-            }
-          }
-          importChains.add(compactImportChain.map((CodeLocation codeLocation) {
-            return codeLocation.relativize(rootUri);
-          }).join(' => '));
-        });
-        reportWarning(NO_LOCATION_SPANNABLE,
-            MessageKind.IMPORT_EXPERIMENTAL_MIRRORS,
-            {'importChain': importChains.join(
-                 MessageKind.IMPORT_EXPERIMENTAL_MIRRORS_PADDING)});
-      }
+      if (!loadedLibraries.containsKey(DART_CORE)) return new Future.value();
 
       functionClass.ensureResolved(this);
       functionApplyMethod = functionClass.lookupLocalMember('apply');
 
       proxyConstant =
           resolver.constantCompiler.compileConstant(
               coreLibrary.find('proxy')).value;
 
       // TODO(johnniwinther): Move this to the JavaScript backend.
-      LibraryElement jsHelperLibrary = loadedLibraries.getLibrary(
-              js_backend.JavaScriptBackend.DART_JS_HELPER);
+      LibraryElement jsHelperLibrary =
+          loadedLibraries[js_backend.JavaScriptBackend.DART_JS_HELPER];
       if (jsHelperLibrary != null) {
         patchConstant = resolver.constantCompiler.compileConstant(
             jsHelperLibrary.find('patch')).value;
       }
 
       if (preserveComments) {
         return libraryLoader.loadLibrary(DART_MIRRORS)
             .then((LibraryElement libraryElement) {
           documentClass = libraryElement.find('Comment');
         });
@@ skipping 706 matching lines @@
   /// canonical URI starts with 'package:foo/' is in user code.
   ///
   /// If an entrypoint URI uses another scheme than 'package' then every library
   /// with that scheme is in user code. For instance, an entry point URI is
   /// 'file:///foo.dart' then every library whose canonical URI scheme is
   /// 'file' is in user code.
   ///
   /// If [assumeInUserCode] is `true`, [element] is assumed to be in user code
   /// if no entrypoints have been set.
   bool inUserCode(Element element, {bool assumeInUserCode: false}) {
-    if (element == null) return false;
-    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>[];
+    List<Uri> entrypoints = <Uri>[];
     if (mainApp != null) {
-      userCodeLocations.add(new CodeLocation(mainApp.canonicalUri));
+      entrypoints.add(mainApp.canonicalUri);
     }
     if (librariesToAnalyzeWhenRun != null) {
-      userCodeLocations.addAll(librariesToAnalyzeWhenRun.map(
-          (Uri uri) => new CodeLocation(uri)));
+      entrypoints.addAll(librariesToAnalyzeWhenRun);
     }
-    if (userCodeLocations.isEmpty && assumeInUserCode) {
+    if (entrypoints.isEmpty && assumeInUserCode) {
       // Assume in user code since [mainApp] has not been set yet.
-      userCodeLocations.add(const AnyLocation());
+      return true;
     }
-    return userCodeLocations;
+    if (element == null) return false;
+    Uri libraryUri = element.library.canonicalUri;
+    if (libraryUri.scheme == 'package') {
+      for (Uri uri in entrypoints) {
+        if (uri.scheme != 'package') continue;
+        int slashPos = libraryUri.path.indexOf('/');
+        if (slashPos != -1) {
+          String packageName = libraryUri.path.substring(0, slashPos + 1);
+          if (uri.path.startsWith(packageName)) {
+            return true;
+          }
+        } else {
+          if (libraryUri.path == uri.path) {
+            return true;
+          }
+        }
+      }
+    } else {
+      for (Uri uri in entrypoints) {
+        if (libraryUri.scheme == uri.scheme) return true;
+      }
+    }
+    return false;
   }
 
   /// Return a canonical URI for the source of [element].
   ///
   /// For a package library with canonical URI 'package:foo/bar/baz.dart' the
   /// return URI is 'package:foo'. For non-package libraries the returned URI is
   /// the canonical URI of the library itself.
   Uri getCanonicalUri(Element element) {
     if (element == null) return null;
     Uri libraryUri = element.library.canonicalUri;
@@ skipping 171 matching lines @@
   int warnings = 0;
   int hints = 0;
 }
 
 class GenericTask extends CompilerTask {
   final String name;
 
   GenericTask(this.name, Compiler compiler)
       : super(compiler);
 }
-
-/// [CodeLocation] divides uris into different classes.
-///
-/// These are used to group uris from user code, platform libraries and
-/// packages.
-abstract class CodeLocation {
-  /// Returns `true` if [uri] is in this code location.
-  bool inSameLocation(Uri uri);
-
-  /// Returns the uri of this location relative to [baseUri].
-  String relativize(Uri baseUri);
-
-  factory CodeLocation(Uri uri) {
-    if (uri.scheme == 'package') {
-      int slashPos = uri.path.indexOf('/');
-      if (slashPos != -1) {
-        String packageName = uri.path.substring(0, slashPos);
-        return new PackageLocation(packageName);
-      } else {
-        return new UriLocation(uri);
-      }
-    } else {
-      return new SchemeLocation(uri);
-    }
-  }
-}
-
-/// A code location defined by the scheme of the uri.
-///
-/// Used for non-package uris, such as 'dart', 'file', and 'http'.
-class SchemeLocation implements CodeLocation {
-  final Uri uri;
-
-  SchemeLocation(this.uri);
-
-  bool inSameLocation(Uri uri) {
-    return this.uri.scheme == uri.scheme;
-  }
-
-  String relativize(Uri baseUri) {
-    return uri_extras.relativize(baseUri, uri, false);
-  }
-}
-
-/// A code location defined by the package name.
-///
-/// Used for package uris, separated by their `package names`, that is, the
-/// 'foo' of 'package:foo/bar.dart'.
-class PackageLocation implements CodeLocation {
-  final String packageName;
-
-  PackageLocation(this.packageName);
-
-  bool inSameLocation(Uri uri) {
-    return uri.scheme == 'package' && uri.path.startsWith('$packageName/');
-  }
-
-  String relativize(Uri baseUri) => 'package:$packageName';
-}
-
-/// A code location defined by the whole uri.
-///
-/// Used for package uris with no package name. For instance 'package:foo.dart'.
-class UriLocation implements CodeLocation {
-  final Uri uri;
-
-  UriLocation(this.uri);
-
-  bool inSameLocation(Uri uri) => this.uri == uri;
-
-  String relativize(Uri baseUri) {
-    return uri_extras.relativize(baseUri, uri, false);
-  }
-}
-
-/// A code location that contains any uri.
-class AnyLocation implements CodeLocation {
-  const AnyLocation();
-
-  bool inSameLocation(Uri uri) => true;
-
-  String relativize(Uri baseUri) => '$baseUri';
-}