Store library paths relative to a given application root folder.

pkg/kernel/lib/analyzer/loader.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 kernel.analyzer.loader;
 
 import 'dart:async';
 import 'dart:io' as io;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source_io.dart';
+import 'package:kernel/application_root.dart';
 import 'package:package_config/discovery.dart';
 import 'package:package_config/packages.dart';
 
 import '../ast.dart' as ast;
 import '../repository.dart';
 import '../target/targets.dart' show Target;
 import '../type_algebra.dart';
 import 'analyzer.dart';
 import 'ast_from_analyzer.dart';
 
 /// Options passed to the Dart frontend.
 class DartOptions {
   /// True if user code should be loaded in strong mode.
   bool strongMode;
 
   /// True if the Dart SDK should be loaded in strong mode.
   bool strongModeSdk;
   String sdk;
   String packagePath;
+  ApplicationRoot applicationRoot;
   Map<Uri, Uri> customUriMappings;
   Map<String, String> declaredVariables;
 
   DartOptions(
       {bool strongMode: false,
       bool strongModeSdk,
       this.sdk,
       this.packagePath,
+      ApplicationRoot applicationRoot,
       Map<Uri, Uri> customUriMappings,
       Map<String, String> declaredVariables})
       : this.customUriMappings = customUriMappings ?? <Uri, Uri>{},
         this.declaredVariables = declaredVariables ?? <String, String>{},
         this.strongMode = strongMode,
-        this.strongModeSdk = strongModeSdk ?? strongMode;
+        this.strongModeSdk = strongModeSdk ?? strongMode,
+        this.applicationRoot = applicationRoot ?? new ApplicationRoot.none();
 }
 
 abstract class ReferenceLevelLoader {
   ast.Library getLibraryReference(LibraryElement element);
   ast.Class getClassReference(ClassElement element);
   ast.Member getMemberReference(Element element);
   ast.Class getRootClassReference();
   ast.Constructor getRootClassConstructorReference();
   ast.Class getCoreClassReference(String className);
   ast.Constructor getCoreClassConstructorReference(String className,
       {String constructorName, String library});
   ast.TypeParameter tryGetClassTypeParameter(TypeParameterElement element);
   ast.Class getSharedMixinApplicationClass(
       ast.Library library, ast.Class supertype, ast.Class mixin);
   bool get strongMode;
 }
 
 class DartLoader implements ReferenceLevelLoader {
   final Repository repository;
+  final ApplicationRoot applicationRoot;
   final Bimap<ClassElement, ast.Class> _classes =
       new Bimap<ClassElement, ast.Class>();
   final Bimap<Element, ast.Member> _members = new Bimap<Element, ast.Member>();
   final Map<TypeParameterElement, ast.TypeParameter> _classTypeParameters =
       <TypeParameterElement, ast.TypeParameter>{};
   final Map<ast.Library, Map<String, ast.Class>> _mixinApplications =
       <ast.Library, Map<String, ast.Class>>{};
   final AnalysisContext context;
   LibraryElement _dartCoreLibrary;
   final List errors = [];
   final List libraryElements = [];
 
   /// Classes that have been referenced, and must be promoted to type level
   /// so as not to expose partially initialized classes.
   final List<ast.Class> temporaryClassWorklist = [];
 
   LibraryElement _libraryBeingLoaded = null;
 
   bool get strongMode => context.analysisOptions.strongMode;
 
   DartLoader(this.repository, DartOptions options, Packages packages,
       {DartSdk dartSdk})
-      : this.context = createContext(options, packages, dartSdk: dartSdk);
-
-  LibraryElement getLibraryElement(ast.Library node) {
-    return context
-        .getLibraryElement(context.sourceFactory.forUri2(node.importUri));
-  }
+      : this.context = createContext(options, packages, dartSdk: dartSdk),
+        this.applicationRoot = options.applicationRoot;
 
   String getLibraryName(LibraryElement element) {
     return element.name.isEmpty ? null : element.name;
   }
 
   ast.Library getLibraryReference(LibraryElement element) {
-    return repository.getLibraryReference(element.source.uri)
+    var uri = applicationRoot.relativeUri(element.source.uri);
+    return repository.getLibraryReference(uri)
       ..name ??= getLibraryName(element)
       ..fileUri = "file://${element.source.fullName}";
   }
 
   void _buildTopLevelMember(ast.Member member, Element element) {
     var astNode = element.computeNode();
     assert(member.parent != null);
     new MemberBodyBuilder(this, member, element).build(astNode);
   }
 
@@ skipping 456 matching lines @@
       AnalysisError error, String filename, LineInfo lines) {
     var location = lines.getLocation(error.offset);
     return '[error] ${error.message} ($filename, '
         'line ${location.lineNumber}, '
         'col ${location.columnNumber})';
   }
 
   void ensureLibraryIsLoaded(ast.Library node) {
     if (!node.isExternal) return;
     node.isExternal = false;
-    var source = context.sourceFactory.forUri2(node.importUri);
+    var source = context.sourceFactory
+        .forUri2(applicationRoot.absoluteUri(node.importUri));
     assert(source != null);
     var element = context.computeLibraryElement(source);
     context.resolveCompilationUnit(source, element);
     _buildLibraryBody(element, node);
     if (node.importUri.scheme != 'dart') {
       for (var unit in element.units) {
         LineInfo lines;
         for (var error in context.computeErrors(unit.source)) {
           if (error.errorCode is CompileTimeErrorCode ||
               error.errorCode is ParserErrorCode ||
@@ skipping 23 matching lines @@
       ensureLibraryIsLoaded(repository.libraries[i]);
     }
   }
 
   /// Builds a list of sources that have been loaded.
   ///
   /// This operation may be expensive and should only be used for diagnostics.
   List<String> getLoadedFileNames() {
     var list = <String>[];
     for (var library in repository.libraries) {
-      LibraryElement element = context.computeLibraryElement(
-          context.sourceFactory.forUri2(library.importUri));
+      LibraryElement element = context.computeLibraryElement(context
+          .sourceFactory
+          .forUri2(applicationRoot.absoluteUri(library.importUri)));
       for (var unit in element.units) {
         list.add(unit.source.fullName);
       }
     }
     return list;
   }
 
   void _iterateWorklist() {
     while (temporaryClassWorklist.isNotEmpty) {
       var element = temporaryClassWorklist.removeLast();
       promoteToTypeLevel(element);
     }
   }
 
-  ast.Program loadProgram(String mainLibrary, {Target target}) {
-    ast.Library library = repository.getLibrary(mainLibrary);
+  ast.Program loadProgram(Uri mainLibrary, {Target target}) {
+    ast.Library library = repository
+        .getLibraryReference(applicationRoot.relativeUri(mainLibrary));
     ensureLibraryIsLoaded(library);
     loadEverything(target: target);
     var program = new ast.Program(repository.libraries);
     program.mainMethod = library.procedures.firstWhere(
         (member) => member.name?.name == 'main',
         orElse: () => null);
     for (LibraryElement libraryElement in libraryElements) {
       for (CompilationUnitElement compilationUnitElement
           in libraryElement.units) {
         // TODO(jensj): Get this another way?
         LineInfo lineInfo = compilationUnitElement.computeNode().lineInfo;
         program.uriToLineStarts[
                 "file://${compilationUnitElement.source.source.fullName}"] =
             new List<int>.generate(lineInfo.lineCount, lineInfo.getOffsetOfLine,
                 growable: false);
       }
     }
     return program;
   }
 
-  ast.Library loadLibrary(String mainLibrary) {
-    ast.Library library = repository.getLibrary(mainLibrary);
+  ast.Library loadLibrary(Uri uri) {
+    ast.Library library =
+        repository.getLibraryReference(applicationRoot.relativeUri(uri));
     ensureLibraryIsLoaded(library);
     return library;
   }
 }
 
 class Bimap<K, V> {
   final Map<K, V> nodeMap = <K, V>{};
   final Map<V, K> inverse = <V, K>{};
 
   bool containsKey(K key) => nodeMap.containsKey(key);
@@ skipping 133 matching lines @@
   AnalysisContext context = AnalysisEngine.instance.createAnalysisContext()
     ..sourceFactory = new SourceFactory(resolvers)
     ..analysisOptions = createAnalysisOptions(options.strongMode);
 
   options.declaredVariables.forEach((String name, String value) {
     context.declaredVariables.define(name, value);
   });
 
   return context;
 }