Add --bazel-paths option to dart2js entrypoint.

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 EventSink, Future;
 import 'dart:convert' show UTF8, LineSplitter;
 import 'dart:io' show exit, File, FileMode, Platform, stdin, stderr;
 
@@ skipping 91 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');
   List<Uri> resolutionInputs;
+  List<String> bazelPaths;
   Uri packageConfig = null;
   Uri packageRoot = null;
   List<String> options = new List<String>();
   List<String> explicitOutputArguments = <String>[];
   bool wantHelp = false;
   bool wantVersion = false;
   bool analyzeOnly = false;
   bool analyzeAll = false;
   bool resolveOnly = false;
   Uri resolutionOutput = currentDirectory.resolve('out.data');
-  bool dumpInfo = false;
   bool allowNativeExtensions = false;
   bool trustTypeAnnotations = false;
   bool trustJSInteropTypeAnnotations = false;
   bool checkedMode = false;
+  List<String> hints = <String>[];
+  bool verbose;
+  bool throwOnError;
+  int throwOnErrorCount;
+  bool showWarnings;
+  bool showHints;
+  bool enableColors;
   // List of provided options that imply that output is expected.
   List<String> optionsImplyCompilation = <String>[];
   bool hasDisallowUnsafeEval = false;
-  // TODO(johnniwinther): Measure time for reading files.
-  SourceFileProvider inputProvider = new CompilerSourceFileProvider();
-  diagnosticHandler = new FormattingDiagnosticHandler(inputProvider);
   Map<String, dynamic> environment = new Map<String, dynamic>();
 
   void passThrough(String argument) => options.add(argument);
 
   if (BUILD_ID != null) {
     passThrough("--build-id=$BUILD_ID");
   }
 
   void setLibraryRoot(String argument) {
     libraryRoot = currentDirectory.resolve(extractPath(argument));
@@ skipping 35 matching lines @@
   }
 
   void setResolutionInput(String argument) {
     resolutionInputs = <Uri>[];
     String parts = extractParameter(argument);
     for (String part in parts.split(',')) {
       resolutionInputs.add(currentDirectory.resolve(nativeToUriPath(part)));
     }
   }
 
+  void setBazelPaths(String argument) {
+    String paths = extractParameter(argument);
+    bazelPaths = <String>[]..addAll(paths.split(','));
+  }
+
   void setResolveOnly(String argument) {
     resolveOnly = true;
     passThrough(argument);
   }
 
   String getDepsOutput(Map<Uri, SourceFile> sourceFiles) {
     var filenames = sourceFiles.keys.map((uri) => '$uri').toList();
     filenames.sort();
     return filenames.join("\n");
   }
@@ skipping 17 matching lines @@
     analyzeAll = true;
     passThrough(argument);
   }
 
   void setAllowNativeExtensions(String argument) {
     allowNativeExtensions = true;
     passThrough(argument);
   }
 
   void setVerbose(_) {
-    diagnosticHandler.verbose = true;
+    verbose = true;
     passThrough('--verbose');
   }
 
-  void setDumpInfo(String argument) {
-    implyCompilation(argument);
-    dumpInfo = true;
-  }
-
   void setTrustTypeAnnotations(String argument) {
     trustTypeAnnotations = true;
     implyCompilation(argument);
   }
 
   void setTrustJSInteropTypeAnnotations(String argument) {
     trustJSInteropTypeAnnotations = true;
     implyCompilation(argument);
   }
 
@@ skipping 22 matching lines @@
         if (!["Client", "Server"].contains(category)) {
           fail('Unsupported library category "$category", '
               'supported categories are: Client, Server, all');
         }
       }
     }
     passThrough('--categories=${categories.join(",")}');
   }
 
   void handleThrowOnError(String argument) {
-    diagnosticHandler.throwOnError = true;
+    throwOnError = true;
     String parameter = extractParameter(argument, isOptionalArgument: true);
     if (parameter != null) {
-      diagnosticHandler.throwOnErrorCount = int.parse(parameter);
+      var count = int.parse(parameter);
+      throwOnErrorCount = count;
     }
   }
 
   void handleShortOptions(String argument) {
     var shortOptions = argument.substring(1).split("");
     for (var shortOption in shortOptions) {
       switch (shortOption) {
         case 'v':
           setVerbose(null);
           break;
@@ skipping 11 matching lines @@
           throw 'Internal error: "$shortOption" did not match';
       }
     }
   }
 
   List<String> arguments = <String>[];
   List<OptionHandler> handlers = <OptionHandler>[
     new OptionHandler('-[chvm?]+', handleShortOptions),
     new OptionHandler('--throw-on-error(?:=[0-9]+)?', handleThrowOnError),
     new OptionHandler(Flags.suppressWarnings, (_) {
-      diagnosticHandler.showWarnings = false;
+      showWarnings = false;
       passThrough(Flags.suppressWarnings);
     }),
     new OptionHandler(Flags.fatalWarnings, passThrough),
-    new OptionHandler(
-        Flags.suppressHints, (_) => diagnosticHandler.showHints = false),
+    new OptionHandler(Flags.suppressHints, (_) {
+      showHints = false;
+    }),
     // TODO(sigmund): remove entirely after Dart 1.20
     new OptionHandler(
         '--output-type=dart|--output-type=dart-multi|--output-type=js',
         setOutputType),
     new OptionHandler(Flags.noFrequencyBasedMinification, passThrough),
     new OptionHandler(Flags.verbose, setVerbose),
     new OptionHandler(Flags.version, (_) => wantVersion = true),
     new OptionHandler('--library-root=.+', setLibraryRoot),
     new OptionHandler('--out=.+|-o.*', setOutput, multipleArguments: true),
     new OptionHandler(Flags.allowMockCompilation, passThrough),
     new OptionHandler(Flags.fastStartup, passThrough),
     new OptionHandler(Flags.genericMethodSyntax, passThrough),
     new OptionHandler(Flags.initializingFormalAccess, passThrough),
     new OptionHandler('${Flags.minify}|-m', implyCompilation),
     new OptionHandler(Flags.preserveUris, passThrough),
     new OptionHandler('--force-strip=.*', setStrip),
-    new OptionHandler(Flags.disableDiagnosticColors,
-        (_) => diagnosticHandler.enableColors = false),
-    new OptionHandler(Flags.enableDiagnosticColors,
-        (_) => diagnosticHandler.enableColors = true),
+    new OptionHandler(Flags.disableDiagnosticColors, (_) {
+      enableColors = false;
+    }),
+    new OptionHandler(Flags.enableDiagnosticColors, (_) {
+      enableColors = true;
+    }),
     new OptionHandler('--enable[_-]checked[_-]mode|--checked',
         (_) => setCheckedMode(Flags.enableCheckedMode)),
     new OptionHandler(Flags.trustTypeAnnotations,
         (_) => setTrustTypeAnnotations(Flags.trustTypeAnnotations)),
     new OptionHandler(Flags.trustPrimitives,
         (_) => setTrustPrimitives(Flags.trustPrimitives)),
     new OptionHandler(
         Flags.trustJSInteropTypeAnnotations,
         (_) => setTrustJSInteropTypeAnnotations(
             Flags.trustJSInteropTypeAnnotations)),
     new OptionHandler(r'--help|/\?|/h', (_) => wantHelp = true),
     new OptionHandler('--packages=.+', setPackageConfig),
     new OptionHandler('--package-root=.+|-p.+', setPackageRoot),
     new OptionHandler(Flags.analyzeAll, setAnalyzeAll),
     new OptionHandler(Flags.analyzeOnly, setAnalyzeOnly),
     new OptionHandler(Flags.noSourceMaps, passThrough),
     new OptionHandler(Option.resolutionInput, setResolutionInput),
+    new OptionHandler(Option.bazelPaths, setBazelPaths),
     new OptionHandler(Flags.resolveOnly, setResolveOnly),
     new OptionHandler(Flags.analyzeSignaturesOnly, setAnalyzeOnly),
     new OptionHandler(Flags.disableNativeLiveTypeAnalysis, passThrough),
     new OptionHandler('--categories=.*', setCategories),
     new OptionHandler(Flags.disableTypeInference, implyCompilation),
     new OptionHandler(Flags.terse, passThrough),
     new OptionHandler('--deferred-map=.+', implyCompilation),
     new OptionHandler(Flags.dumpInfo, implyCompilation),
     new OptionHandler(
         '--disallow-unsafe-eval', (_) => hasDisallowUnsafeEval = true),
     new OptionHandler(Option.showPackageWarnings, passThrough),
     new OptionHandler(Flags.useContentSecurityPolicy, passThrough),
     new OptionHandler(Flags.enableExperimentalMirrors, passThrough),
     new OptionHandler(Flags.enableAssertMessage, passThrough),
 
     // TODO(floitsch): remove conditional directives flag.
     // We don't provide the info-message yet, since we haven't publicly
     // launched the feature yet.
     new OptionHandler(Flags.conditionalDirectives, (_) {}),
     new OptionHandler('--enable-async', (_) {
-      diagnosticHandler.info(
-          "Option '--enable-async' is no longer needed. "
-          "Async-await is supported by default.",
-          api.Diagnostic.HINT);
+      hints.add("Option '--enable-async' is no longer needed. "
+          "Async-await is supported by default.");
     }),
     new OptionHandler('--enable-null-aware-operators', (_) {
-      diagnosticHandler.info(
-          "Option '--enable-null-aware-operators' is no longer needed. "
-          "Null aware operators are supported by default.",
-          api.Diagnostic.HINT);
+      hints.add("Option '--enable-null-aware-operators' is no longer needed. "
+          "Null aware operators are supported by default.");
     }),
     new OptionHandler('--enable-enum', (_) {
-      diagnosticHandler.info(
-          "Option '--enable-enum' is no longer needed. "
-          "Enums are supported by default.",
-          api.Diagnostic.HINT);
+      hints.add("Option '--enable-enum' is no longer needed. "
+          "Enums are supported by default.");
     }),
     new OptionHandler(Flags.allowNativeExtensions, setAllowNativeExtensions),
     new OptionHandler(Flags.generateCodeWithCompileTimeErrors, passThrough),
     new OptionHandler(Flags.testMode, passThrough),
 
     // The following three options must come last.
     new OptionHandler('-D.+=.*', addInEnvironment),
     new OptionHandler('-.*', (String argument) {
       helpAndFail("Unknown option '$argument'.");
     }),
     new OptionHandler('.*', (String argument) {
       arguments.add(nativeToUriPath(argument));
     })
   ];
 
   parseCommandLine(handlers, argv);
+
+  // TODO(johnniwinther): Measure time for reading files.
+  SourceFileProvider inputProvider;
+  if (bazelPaths != null) {
+    inputProvider = new BazelInputProvider(bazelPaths);
+  } else {
+    inputProvider = new CompilerSourceFileProvider();
+  }
+
+  diagnosticHandler = new FormattingDiagnosticHandler(inputProvider);
+  if (verbose != null) {
+    diagnosticHandler.verbose = verbose;
+  }
+  if (throwOnError != null) {
+    diagnosticHandler.throwOnError = throwOnError;
+  }
+  if (throwOnErrorCount != null) {
+    diagnosticHandler.throwOnErrorCount = throwOnErrorCount;
+  }
+  if (showWarnings != null) {
+    diagnosticHandler.showWarnings = showWarnings;
+  }
+  if (showHints != null) {
+    diagnosticHandler.showHints = showHints;
+  }
+  if (enableColors != null) {
+    diagnosticHandler.enableColors = enableColors;
+  }
+  for (String hint in hints) {
+    diagnosticHandler.info(hint, api.Diagnostic.HINT);
+  }
+
   if (wantHelp || wantVersion) {
     helpAndExit(wantHelp, wantVersion, diagnosticHandler.verbose);
   }
 
   if (hasDisallowUnsafeEval) {
     String precompiledName = relativize(
         currentDirectory,
         RandomAccessFileOutputProvider.computePrecompiledUri(out),
         Platform.isWindows);
     helpAndFail("Option '--disallow-unsafe-eval' has been removed."
@@ skipping 428 matching lines @@
       }
       input = new _CompilerInput(input, dataMap);
       List<Uri> resolutionInputs = dataMap.keys.toList();
       if (compilerOptions.resolutionInputs != null) {
         for (Uri uri in compilerOptions.resolutionInputs) {
           if (!dataMap.containsKey(uri)) {
             resolutionInputs.add(uri);
           }
         }
       }
-      options =
-          CompilerOptions.copy(options,
-              resolutionInputs: resolutionInputs,
-              compileOnly: compileOnly);
+      options = CompilerOptions.copy(options,
+          resolutionInputs: resolutionInputs, compileOnly: compileOnly);
     }
     return oldCompileFunc(options, input, compilerDiagnostics, compilerOutput);
   }
 
   /// Serialize [entryPoint] using [serializedData] if provided.
   Future<api.CompilationResult> serialize(
       Uri entryPoint,
       Uri serializedUri,
       CompilerOptions compilerOptions,
       api.CompilerInput compilerInput,
@@ skipping 127 matching lines @@
   @override
   void close() {
     // Do nothing.
   }
 
   @override
   void addError(errorEvent, [StackTrace stackTrace]) {
     // Ignore
   }
 }