Make analyze-all imply analyze-only.

sdk/lib/_internal/compiler/implementation/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:io'
     show exit, File, FileMode, Platform, RandomAccessFile, FileSystemException;
@@ skipping 38 matching lines @@
 /**
  * Extract the parameter of an option.
  *
  * For example, in ['--out=fisk.js'] and ['-ohest.js'], the parameters
  * are ['fisk.js'] and ['hest.js'], respectively.
  */
 String extractParameter(String argument) {
   // m[0] is the entire match (which will be equal to argument). m[1]
   // is something like "-o" or "--out=", and m[2] is the parameter.
   Match m = new RegExp('^(-[a-z]|--.+=)(.*)').firstMatch(argument);
-  if (m == null) helpAndFail('Error: Unknown option "$argument".');
+  if (m == null) helpAndFail('Unknown option "$argument".');
   return m[2];
 }
 
 String extractPath(String argument) {
   String path = nativeToUriPath(extractParameter(argument));
   return path.endsWith("/") ? path : "$path/";
 }
 
 void parseCommandLine(List<OptionHandler> handlers, List<String> argv) {
   // TODO(ahe): Use ../../args/args.dart for parsing options instead.
@@ skipping 32 matching lines @@
   Uri out = currentDirectory.resolve('out.js');
   Uri sourceMapOut = currentDirectory.resolve('out.js.map');
   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;
+  // 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>();
 
   passThrough(String argument) => options.add(argument);
 
   if (BUILD_ID != null) {
     passThrough("--build-id=$BUILD_ID");
   }
 
   setLibraryRoot(String argument) {
     libraryRoot = currentDirectory.resolve(extractPath(argument));
   }
 
   setPackageRoot(String argument) {
     packageRoot = 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);
     }
     explicitOut = true;
     out = currentDirectory.resolve(nativeToUriPath(path));
     sourceMapOut = Uri.parse('$out.map');
   }
 
   setOutputType(String argument) {
+    optionsImplyCompilation.add(argument);
     if (argument == '--output-type=dart') {
       outputLanguage = OUTPUT_LANGUAGE_DART;
       if (!explicitOut) {
         out = currentDirectory.resolve('out.dart');
         sourceMapOut = currentDirectory.resolve('out.dart.map');
       }
     }
     passThrough(argument);
   }
 
   String getDepsOutput(Map<String, SourceFile> sourceFiles) {
     var filenames = new List.from(sourceFiles.keys);
     filenames.sort();
     return filenames.join("\n");
   }
 
   setStrip(String argument) {
+    optionsImplyCompilation.add(argument);
     stripArgumentSet = true;
     passThrough(argument);
   }
 
   setAnalyzeOnly(String argument) {
     analyzeOnly = true;
     passThrough(argument);
   }
 
+  setAnalyzeAll(String argument) {
+    analyzeAll = true;
+    passThrough(argument);
+  }
+
   setVerbose(_) {
     diagnosticHandler.verbose = true;
     passThrough('--verbose');
   }
 
+  implyCompilation(String argument) {
+    optionsImplyCompilation.add(argument);
+    passThrough(argument);
+  }
+
   addInEnvironment(String argument) {
     int eqIndex = argument.indexOf('=');
     String name = argument.substring(2, eqIndex);
     String value = argument.substring(eqIndex + 1);
     environment[name] = value;
   }
 
   setCategories(String argument) {
     List<String> categories = extractParameter(argument).split(',');
     Set<String> allowedCategories =
         LIBRARIES.values.map((x) => x.category).toSet();
     allowedCategories.remove('Shared');
     allowedCategories.remove('Internal');
     List<String> allowedCategoriesList =
         new List<String>.from(allowedCategories);
     allowedCategoriesList.sort();
     if (categories.contains('all')) {
       categories = allowedCategoriesList;
     } else {
       String allowedCategoriesString = allowedCategoriesList.join(', ');
       for (String category in categories) {
         if (!allowedCategories.contains(category)) {
-          fail('Error: unsupported library category "$category", '
+          fail('Unsupported library category "$category", '
                'supported categories are: $allowedCategoriesString');
         }
       }
     }
     passThrough('--categories=${categories.join(",")}');
   }
 
   handleShortOptions(String argument) {
     var shortOptions = argument.substring(1).split("");
     for (var shortOption in shortOptions) {
       switch (shortOption) {
         case 'v':
           setVerbose(null);
           break;
         case 'h':
         case '?':
           wantHelp = true;
           break;
         case 'c':
           passThrough('--enable-checked-mode');
           break;
         case 'm':
-          passThrough('--minify');
+          implyCompilation('--minify');
           break;
         default:
           throw 'Internal error: "$shortOption" did not match';
       }
     }
   }
 
   Uri computePrecompiledUri() {
     String extension = 'precompiled.js';
     String outPath = out.path;
@@ skipping 13 matching lines @@
     new OptionHandler('--suppress-warnings',
                       (_) => diagnosticHandler.showWarnings = false),
     new OptionHandler('--suppress-hints',
                       (_) => diagnosticHandler.showHints = false),
     new OptionHandler('--output-type=dart|--output-type=js', setOutputType),
     new OptionHandler('--verbose', setVerbose),
     new OptionHandler('--version', (_) => wantVersion = true),
     new OptionHandler('--library-root=.+', setLibraryRoot),
     new OptionHandler('--out=.+|-o.*', setOutput, multipleArguments: true),
     new OptionHandler('--allow-mock-compilation', passThrough),
-    new OptionHandler('--minify|-m', passThrough),
+    new OptionHandler('--minify|-m', implyCompilation),
     new OptionHandler('--force-strip=.*', setStrip),
     new OptionHandler('--disable-diagnostic-colors',
                       (_) => diagnosticHandler.enableColors = false),
     new OptionHandler('--enable-diagnostic-colors',
                       (_) => diagnosticHandler.enableColors = true),
     new OptionHandler('--enable[_-]checked[_-]mode|--checked',
                       (_) => passThrough('--enable-checked-mode')),
     new OptionHandler('--enable-concrete-type-inference',
-                      (_) => passThrough('--enable-concrete-type-inference')),
+                      (_) => implyCompilation(
+                          '--enable-concrete-type-inference')),
     new OptionHandler('--trust-type-annotations',
-                      (_) => passThrough('--trust-type-annotations')),
+                      (_) => implyCompilation('--trust-type-annotations')),
     new OptionHandler(r'--help|/\?|/h', (_) => wantHelp = true),
     new OptionHandler('--package-root=.+|-p.+', setPackageRoot),
-    new OptionHandler('--analyze-all', passThrough),
+    new OptionHandler('--analyze-all', setAnalyzeAll),
     new OptionHandler('--analyze-only', setAnalyzeOnly),
-    new OptionHandler('--analyze-signatures-only', passThrough),
+    new OptionHandler('--analyze-signatures-only', setAnalyzeOnly),
     new OptionHandler('--disable-native-live-type-analysis', passThrough),
     new OptionHandler('--categories=.*', setCategories),
-    new OptionHandler('--disable-type-inference', passThrough),
+    new OptionHandler('--disable-type-inference', implyCompilation),
     new OptionHandler('--terse', passThrough),
-    new OptionHandler('--dump-info', passThrough),
+    new OptionHandler('--dump-info', implyCompilation),
     new OptionHandler('--disallow-unsafe-eval',
                       (_) => hasDisallowUnsafeEval = true),
     new OptionHandler('--hide-package-warnings', passThrough),
     new OptionHandler('-D.+=.*', addInEnvironment),
 
     // The following two options must come last.
     new OptionHandler('-.*', (String argument) {
-      helpAndFail('Error: Unknown option "$argument".');
+      helpAndFail("Unknown option '$argument'.");
     }),
     new OptionHandler('.*', (String argument) {
       arguments.add(nativeToUriPath(argument));
     })
   ];
 
   parseCommandLine(handlers, argv);
   if (wantHelp || wantVersion) {
     helpAndExit(wantHelp, wantVersion, diagnosticHandler.verbose);
   }
 
   if (hasDisallowUnsafeEval) {
     String precompiledName =
         relativize(currentDirectory, computePrecompiledUri(), isWindows);
-    helpAndFail("Error: option '--disallow-unsafe-eval' has been removed."
+    helpAndFail("Option '--disallow-unsafe-eval' has been removed."
                 " Instead, the compiler generates a file named"
                 " '$precompiledName'.");
   }
 
   if (outputLanguage != OUTPUT_LANGUAGE_DART && stripArgumentSet) {
-    helpAndFail('Error: --force-strip may only be used with '
-        '--output-type=dart');
+    helpAndFail("Option '--force-strip' may only be used with "
+                "'--output-type=dart'.");
   }
   if (arguments.isEmpty) {
-    helpAndFail('Error: No Dart file specified.');
+    helpAndFail('No Dart file specified.');
   }
   if (arguments.length > 1) {
     var extra = arguments.sublist(1);
-    helpAndFail('Error: Extra arguments: ${extra.join(" ")}');
+    helpAndFail('Extra arguments: ${extra.join(" ")}');
   }
 
   Uri uri = currentDirectory.resolve(arguments[0]);
   if (packageRoot == null) {
     packageRoot = uri.resolve('./packages/');
   }
 
-  diagnosticHandler.info('package root is $packageRoot');
+  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) {

[floitsch, 2014/03/07 14:03:35]

*nit*: 'if' on one line.

[Johnni Winther, 2014/03/10 07:03:08]

Done.

+    analyzeOnly = true;
+  }
+
+  diagnosticHandler.info('Package root is $packageRoot');
 
   int totalCharactersWritten = 0;
 
   options.add('--source-map=$sourceMapOut');
 
   List<String> allOutputFiles = new List<String>();
 
   compilationDone(String code) {
     if (analyzeOnly) return;
     if (code == null) {
-      fail('Error: Compilation failed.');
+      fail('Compilation failed.');
     }
     writeString(Uri.parse('$out.deps'),
                 getDepsOutput(inputProvider.sourceFiles));
     diagnosticHandler.info(
          'compiled ${inputProvider.dartCharactersRead} characters Dart '
          '-> $totalCharactersWritten characters $outputLanguage '
          'in ${relativize(currentDirectory, out, isWindows)}');
     if (diagnosticHandler.verbose) {
       String input = uriPathToNative(arguments[0]);
       print('Dart file ($input) compiled to $outputLanguage.');
@@ skipping 22 matching lines @@
         uri = computePrecompiledUri();
         diagnosticHandler.info(
             "File ($uri) is compatible with header"
             " \"Content-Security-Policy: script-src 'self'\"");
       } else if (extension == 'js.map' || extension == 'dart.map') {
         uri = sourceMapOut;
       } else if (extension == 'info.html') {
         String outName = out.path.substring(out.path.lastIndexOf('/') + 1);
         uri = out.resolve('${outName}.$extension');
       } else {
-        fail('Error: Unknown extension: $extension');
+        fail('Unknown extension: $extension');
       }
     } else {
       uri = out.resolve('$name.$extension');
     }
 
     if (uri.scheme != 'file') {
-      fail('Error: Unhandled scheme ${uri.scheme} in $uri.');
+      fail('Unhandled scheme ${uri.scheme} in $uri.');
     }
 
     RandomAccessFile output;
     try {
       output = new File(uri.toFilePath()).openSync(mode: FileMode.WRITE);
     } on FileSystemException catch(e) {
       fail('$e');
     }
 
     allOutputFiles.add(relativize(currentDirectory, uri, isWindows));
@@ skipping 57 matching lines @@
 }
 
 class AbortLeg {
   final message;
   AbortLeg(this.message);
   toString() => 'Aborted due to --throw-on-error: $message';
 }
 
 void writeString(Uri uri, String text) {
   if (uri.scheme != 'file') {
-    fail('Error: Unhandled scheme ${uri.scheme}.');
+    fail('Unhandled scheme ${uri.scheme}.');
   }
   var file = new File(uri.toFilePath()).openSync(mode: FileMode.WRITE);
   file.writeStringSync(text);
   file.closeSync();
 }
 
 void fail(String message) {
   if (diagnosticHandler != null) {
     diagnosticHandler.diagnosticHandler(
         null, -1, -1, message, api.Diagnostic.ERROR);
   } else {
-    print(message);
+    print('Error: $message');
   }
   exitFunc(1);
 }
 
 Future compilerMain(List<String> arguments) {
   var root = uriPathToNative("/$LIBRARY_ROOT");
   arguments = <String>['--library-root=${Platform.script.toFilePath()}$root']
       ..addAll(arguments);
   return compile(arguments);
 }
@@ skipping 41 matching lines @@
     Define an environment variable.
 
   --version
     Display version information.
 
   -p<path>, --package-root=<path>
     Where to find packages, that is, "package:..." imports.
 
   --analyze-all
     Analyze all code.  Without this option, the compiler only analyzes
-    code that is reachable from [main].  This option is useful for
-    finding errors in libraries, but using it can result in bigger and
-    slower output.
+    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
     --analyze-only.
 
   --suppress-warnings
     Do not display any warnings.
@@ skipping 92 matching lines @@
     }
   }
 
   try {
     return compilerMain(arguments).catchError(onError);
   } catch (exception, trace) {
     onError(exception, trace);
     return new Future.value();
   }
 }