Store library paths relative to a given application root folder.

pkg/kernel/bin/dartk.dart

 #!/usr/bin/env 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.
 
 import 'dart:async';
 import 'dart:io';
 
 import 'batch_util.dart';
 
 import 'package:args/args.dart';
 import 'package:kernel/analyzer/loader.dart';
+import 'package:kernel/application_root.dart';
 import 'package:kernel/verifier.dart';
 import 'package:kernel/kernel.dart';
 import 'package:kernel/log.dart';
 import 'package:kernel/target/targets.dart';
 import 'package:path/path.dart' as path;
 
 // Returns the path to the current sdk based on `Platform.resolvedExecutable`.
 String currentSdk() {
   // The dart executable should be inside dart-sdk/bin/dart.
   return path.dirname(path.dirname(path.absolute(Platform.resolvedExecutable)));
 }
 
 ArgParser parser = new ArgParser(allowTrailingOptions: true)
   ..addOption('format',
       abbr: 'f',
       allowed: ['text', 'bin'],
       help: 'Output format.\n'
           '(defaults to "text" unless output file ends with ".dill")')
   ..addOption('out',
       abbr: 'o',
       help: 'Output file.\n'
           '(defaults to "out.dill" if format is "bin", otherwise stdout)')
   ..addOption('sdk', defaultsTo: currentSdk(), help: 'Path to the Dart SDK.')
   ..addOption('packages',
       abbr: 'p', help: 'Path to the .packages file or packages folder.')
   ..addOption('package-root', help: 'Deprecated alias for --packages')
+  ..addOption('app-root',
+      help: 'Store library paths relative to the given directory.\n'
+          'If none is given, absolute paths are used.\n'
+          'Application libraries not inside the application root are stored '
+          'using absolute paths')
   ..addOption('target',
       abbr: 't',
       help: 'Tailor the IR to the given target.',
       allowed: targetNames,
       defaultsTo: 'vm')
   ..addFlag('strong',
       help: 'Load .dart files in strong mode.\n'
           'Does not affect loading of binary files. Strong mode support is very\n'
           'unstable and not well integrated yet.')
   ..addFlag('link', abbr: 'l', help: 'Link the whole program into one file.')
@@ skipping 188 matching lines @@
     options = parser.parse(args);
   } on FormatException catch (e) {
     return fail(e.message); // Don't puke stack traces.
   }
 
   checkIsDirectoryOrNull(options['sdk'], 'Dart SDK');
 
   String packagePath = options['packages'] ?? options['package-root'];
   checkIsFileOrDirectoryOrNull(packagePath, 'Package root or .packages');
 
+  String applicationRootOption = options['app-root'];
+  checkIsDirectoryOrNull(applicationRootOption, 'Application root');
+  if (applicationRootOption != null) {
+    applicationRootOption = new File(applicationRootOption).absolute.path;
+  }
+  var applicationRoot = new ApplicationRoot(applicationRootOption);
+
   // Set up logging.
   if (options['verbose']) {
     log.onRecord.listen((LogRecord rec) {
       stderr.writeln(rec.message);
     });
   }
 
   if (options.rest.length != 1) {
     return fail('Exactly one FILE should be given.');
   }
 
-  var file = options.rest.single;
-
+  String file = options.rest.single;
   checkIsFile(file, option: 'Input file');
+  file = new File(file).absolute.path;
+  Uri fileUri = new Uri(scheme: 'file', path: file);
 
   String format = options['format'] ?? defaultFormat();
   String outputFile = options['out'] ?? defaultOutput();
 
   List<String> urlMapping = options['url-mapping'] as List<String>;
   var customUriMappings = parseCustomUriMappings(urlMapping);
   var repository = new Repository();
 
   Program program;
 
@@ skipping 19 matching lines @@
   if (file.endsWith('.dill')) {
     program = loadProgramFromBinary(file, repository);
     getLoadedFiles = () => [file];
   } else {
     DartOptions dartOptions = new DartOptions(
         strongMode: target.strongMode,
         strongModeSdk: target.strongModeSdk,
         sdk: options['sdk'],
         packagePath: packagePath,
         customUriMappings: customUriMappings,
-        declaredVariables: declaredVariables);
+        declaredVariables: declaredVariables,
+        applicationRoot: applicationRoot);
     String packageDiscoveryPath = batchModeState.isBatchMode ? null : file;
     DartLoader loader = await batchModeState.batch.getLoader(
         repository, dartOptions,
         packageDiscoveryPath: packageDiscoveryPath);
     if (options['link']) {
-      program = loader.loadProgram(file, target: target);
+      program = loader.loadProgram(fileUri, target: target);
     } else {
-      var library = loader.loadLibrary(file);
-      assert(library == repository.getLibrary(file));
+      var library = loader.loadLibrary(fileUri);
+      assert(library ==
+          repository.getLibraryReference(applicationRoot.relativeUri(fileUri)));
       program = new Program(repository.libraries);
     }
     errors = loader.errors;
     if (errors.isNotEmpty) {
       const int errorLimit = 100;
       stderr.writeln(errors.take(errorLimit).join('\n'));
       if (errors.length > errorLimit) {
         stderr
             .writeln('[error] ${errors.length - errorLimit} errors not shown');
       }
@@ skipping 55 matching lines @@
 
   await ioFuture;
 
   if (shouldReportMetrics) {
     int flushTime = watch.elapsedMilliseconds - time;
     print('writer.flush_time = $flushTime ms');
   }
 
   return errors.length > 0 ? CompilerOutcome.Fail : CompilerOutcome.Ok;
 }