Emit warning on import of dart:mirrors.

sdk/lib/_internal/compiler/implementation/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(Map<Uri, LibraryElement> loadedLibraries) {
+  Future onLibrariesLoaded(LoadedLibraries 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 454 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 26 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,
             api.CompilerOutputProvider outputProvider,
             List<String> strips: const []})
       : this.disableTypeInferenceFlag =
           disableTypeInferenceFlag || !emitJavaScript,
         this.analyzeOnly =
             analyzeOnly || analyzeSignaturesOnly || analyzeAllFlag,
         this.analyzeSignaturesOnly = analyzeSignaturesOnly,
         this.analyzeAllFlag = analyzeAllFlag,
         this.hasIncrementalSupport = hasIncrementalSupport,
         cacheStrategy = new CacheStrategy(hasIncrementalSupport),
@@ skipping 223 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(Map<Uri, LibraryElement> loadedLibraries) {
+  Future onLibrariesLoaded(LoadedLibraries loadedLibraries) {
     return new Future.sync(() {
-      if (!loadedLibraries.containsKey(DART_CORE)) return new Future.value();
+      if (!loadedLibraries.containsLibrary(DART_CORE)) {
+        return new Future.value();

[floitsch, 2014/09/22 20:52:59]

return null is the same, since we are already in a new Future.sync.

[Johnni Winther, 2014/11/12 13:06:26]

Done.

+      }
+      if (!enableExperimentalMirrors &&
+          loadedLibraries.containsLibrary(DART_MIRRORS)) {
+        Uri rootUri = loadedLibraries.rootUri;
+        Set<String> importChains = new Set<String>();
+        loadedLibraries.forEachImportChain(

[floitsch, 2014/09/22 20:52:59]

I would make this a function on LoadedLibraries:

loadedLibraries.importChainsForUri(DART_MIRRORS, verbose: verbose);

[Johnni Winther, 2014/11/12 13:06:26]

Added a TODO. We need to store the libraries for incremental compilation anyway.

+            (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)});
+      }
 
       functionClass.ensureResolved(this);
       functionApplyMethod = functionClass.lookupLocalMember('apply');
 
       proxyConstant =
           resolver.constantCompiler.compileConstant(coreLibrary.find('proxy'));
 
       // TODO(johnniwinther): Move this to the JavaScript backend.
-      LibraryElement jsHelperLibrary =
-          loadedLibraries[js_backend.JavaScriptBackend.DART_JS_HELPER];
+      LibraryElement jsHelperLibrary = loadedLibraries.getLibrary(
+              js_backend.JavaScriptBackend.DART_JS_HELPER);
       if (jsHelperLibrary != null) {
         patchConstant = resolver.constantCompiler.compileConstant(
             jsHelperLibrary.find('patch'));
       }
 
       if (preserveComments) {
         return libraryLoader.loadLibrary(DART_MIRRORS)
             .then((LibraryElement libraryElement) {
           documentClass = libraryElement.find('Comment');
         });
@@ skipping 709 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}) {
-    List<Uri> entrypoints = <Uri>[];
+    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>[];
     if (mainApp != null) {
-      entrypoints.add(mainApp.canonicalUri);
+      userCodeLocations.add(new CodeLocation(mainApp.canonicalUri));
     }
     if (librariesToAnalyzeWhenRun != null) {
-      entrypoints.addAll(librariesToAnalyzeWhenRun);
+      userCodeLocations.addAll(librariesToAnalyzeWhenRun.map(
+          (Uri uri) => new CodeLocation(uri)));
     }
-    if (entrypoints.isEmpty && assumeInUserCode) {
+    if (userCodeLocations.isEmpty && assumeInUserCode) {
       // Assume in user code since [mainApp] has not been set yet.
-      return true;
+      userCodeLocations.add(const AnyLocation());
     }
-    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 userCodeLocations;
   }
 
   /// 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 148 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';
+}