Support Package Resolution Configuration files.

pkg/compiler/lib/src/dart2js.dart

 // Copyright (c) 2013, 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 dart2js.cmdline;
 
 import 'dart:async'
     show Future, EventSink;
 import 'dart:convert' show UTF8, LineSplitter;
 import 'dart:io'
     show exit, File, FileMode, Platform, RandomAccessFile, FileSystemException,
          stdin, stderr;
 
 import '../compiler.dart' as api;
 import 'io/source_file.dart';
 import 'source_file_provider.dart';
 import 'filenames.dart';
 import 'util/uri_extras.dart';
 import 'util/util.dart' show stackTraceFilePrefix;
 import 'util/command_line.dart';
 import 'package:_internal/libraries.dart';
+import 'package:package_config/discovery.dart' show findPackages;
 
 const String LIBRARY_ROOT = '../../../../../sdk';
 const String OUTPUT_LANGUAGE_DART = 'Dart';
 
 /**
  * A string to identify the revision or build.
  *
  * This ID is displayed if the compiler crashes and in verbose mode, and is
  * an aid in reproducing bug reports.
  *
@@ skipping 66 matching lines @@
   }
 }
 
 FormattingDiagnosticHandler diagnosticHandler;
 
 Future<api.CompilationResult> compile(List<String> argv) {
   stackTraceFilePrefix = '$currentDirectory';
   Uri libraryRoot = currentDirectory;
   Uri out = currentDirectory.resolve('out.js');
   Uri sourceMapOut = currentDirectory.resolve('out.js.map');
+  Uri packageConfig = null;
   Uri packageRoot = null;
   List<String> options = new List<String>();
   bool explicitOut = false;
   bool wantHelp = false;
   bool wantVersion = false;
   String outputLanguage = 'JavaScript';
   bool stripArgumentSet = false;
   bool analyzeOnly = false;
   bool analyzeAll = false;
   bool dumpInfo = false;
@@ skipping 15 matching lines @@
   }
 
   setLibraryRoot(String argument) {
     libraryRoot = currentDirectory.resolve(extractPath(argument));
   }
 
   setPackageRoot(String argument) {
     packageRoot = currentDirectory.resolve(extractPath(argument));
   }
 
+  setPackageConfig(String argument) {
+    packageConfig = currentDirectory.resolve(extractPath(argument));
+  }
+
   setOutput(Iterator<String> arguments) {
     optionsImplyCompilation.add(arguments.current);
     String path;
     if (arguments.current == '-o') {
       if (!arguments.moveNext()) {
         helpAndFail('Error: Missing file after -o option.');
       }
       path = arguments.current;
     } else {
       path = extractParameter(arguments.current);
@@ skipping 169 matching lines @@
     new OptionHandler('--enable-concrete-type-inference',
                       (_) => implyCompilation(
                           '--enable-concrete-type-inference')),
     new OptionHandler('--trust-type-annotations',
                       (_) => setTrustTypeAnnotations(
                           '--trust-type-annotations')),
     new OptionHandler('--trust-primitives',
                       (_) => setTrustPrimitives(
                           '--trust-primitives')),
     new OptionHandler(r'--help|/\?|/h', (_) => wantHelp = true),
+    new OptionHandler('--packages=.+', setPackageConfig),
     new OptionHandler('--package-root=.+|-p.+', setPackageRoot),
     new OptionHandler('--analyze-all', setAnalyzeAll),
     new OptionHandler('--analyze-only', setAnalyzeOnly),
     new OptionHandler('--no-source-maps', passThrough),
     new OptionHandler('--analyze-signatures-only', setAnalyzeOnly),
     new OptionHandler('--disable-native-live-type-analysis', passThrough),
     new OptionHandler('--categories=.*', setCategories),
     new OptionHandler('--disable-type-inference', implyCompilation),
     new OptionHandler('--terse', passThrough),
     new OptionHandler('--deferred-map=.+', implyCompilation),
@@ skipping 55 matching lines @@
   if (arguments.length > 1) {
     var extra = arguments.sublist(1);
     helpAndFail('Extra arguments: ${extra.join(" ")}');
   }
 
   if (checkedMode && trustTypeAnnotations) {
     helpAndFail("Option '--trust-type-annotations' may not be used in "
                 "checked mode.");
   }
 
-  Uri uri = currentDirectory.resolve(arguments[0]);
-  if (packageRoot == null) {
-    packageRoot = uri.resolve('./packages/');
+  if (packageRoot != null && packageConfig != null) {
+    helpAndFail("Cannot specify both '--package-root' and '--packages.");
   }
 
   if ((analyzeOnly || analyzeAll) && !optionsImplyCompilation.isEmpty) {
     if (!analyzeOnly) {
       diagnosticHandler.info(
           "Option '--analyze-all' implies '--analyze-only'.",
           api.Diagnostic.INFO);
     }
     diagnosticHandler.info(
         "Options $optionsImplyCompilation indicate that output is expected, "
         "but compilation is turned off by the option '--analyze-only'.",
         api.Diagnostic.INFO);
   }
   if (analyzeAll) analyzeOnly = true;
   if (!analyzeOnly) {
     if (allowNativeExtensions) {
       helpAndFail("Option '--allow-native-extensions' is only supported in "
                   "combination with the '--analyze-only' option.");
     }
   }
   if (dumpInfo && outputLanguage == OUTPUT_LANGUAGE_DART) {
     helpAndFail("Option '--dump-info' is not supported in "
                 "combination with the '--output-type=dart' option.");
   }
 
-  diagnosticHandler.info('Package root is $packageRoot');
-
   options.add('--out=$out');
   options.add('--source-map=$sourceMapOut');
 
   RandomAccessFileOutputProvider outputProvider =
       new RandomAccessFileOutputProvider(
           out, sourceMapOut, onInfo: diagnosticHandler.info, onFailure: fail);
 
   api.CompilationResult compilationDone(api.CompilationResult result) {
     if (analyzeOnly) return result;
     if (!result.isSuccess) {
@@ skipping 14 matching lines @@
         print("  $filename");
       }
     } else if (!explicitOut) {
       String input = uriPathToNative(arguments[0]);
       String output = relativize(currentDirectory, out, Platform.isWindows);
       print('Dart file ($input) compiled to $outputLanguage: $output');
     }
     return result;
   }
 
-  return compileFunc(uri, libraryRoot, packageRoot,
-                     inputProvider, diagnosticHandler,
-                     options, outputProvider, environment)
+  Uri uri = currentDirectory.resolve(arguments[0]);
+  return compileFunc(uri, libraryRoot, packageRoot, inputProvider,
+                     diagnosticHandler, options, outputProvider, environment,
+                     packageConfig, findPackages)
             .then(compilationDone);
 }
 
 class AbortLeg {
   final message;
   AbortLeg(this.message);
   toString() => 'Aborted due to --throw-on-error: $message';
 }
 
 void writeString(Uri uri, String text) {
@@ skipping 61 matching lines @@
   -v, --verbose
     Display verbose information.
 
   -D<name>=<value>
     Define an environment variable.
 
   --version
     Display version information.
 
   -p<path>, --package-root=<path>
-    Where to find packages, that is, "package:..." imports.
+    Where to find packages, that is, "package:..." imports.  This option cannot
+    be used with --packages.
+
+  --packages=<path>
+    Path to the package resolution configuration file, which supplies a mapping
+    of package names to paths.  This option cannot be used with --package-root.
 
   --analyze-all
     Analyze all code.  Without this option, the compiler only analyzes
     code that is reachable from [main].  This option implies --analyze-only.
 
   --analyze-only
     Analyze but do not generate code.
 
   --analyze-signatures-only
     Skip analysis of method bodies and field initializers. This option implies
@@ skipping 179 matching lines @@
       } else if (exitCode == 253) {
         print(">>> TEST CRASH");
       } else {
         print(">>> TEST FAIL");
       }
       stderr.writeln(">>> EOF STDERR");
       subscription.resume();
     });
   });
 }