dartfmt pkg/compiler

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:async' show Future, EventSink;
 import 'dart:convert' show UTF8, LineSplitter;
 import 'dart:io'
-    show exit, File, FileMode, Platform, RandomAccessFile, FileSystemException,
-         stdin, stderr;
+    show
+        exit,
+        File,
+        FileMode,
+        Platform,
+        RandomAccessFile,
+        FileSystemException,
+        stdin,
+        stderr;
 
 import '../compiler.dart' as api;
 import 'commandline_options.dart';
 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:package_config/discovery.dart' show findPackages;
@@ skipping 143 matching lines @@
 
   setOutputType(String argument) {
     optionsImplyCompilation.add(argument);
     if (argument == '--output-type=dart' ||
         argument == '--output-type=dart-multi') {
       outputLanguage = OUTPUT_LANGUAGE_DART;
       if (!explicitOut) {
         out = currentDirectory.resolve('out.dart');
         sourceMapOut = currentDirectory.resolve('out.dart.map');
       }
-      diagnosticHandler(null, null, null,
+      diagnosticHandler(
+          null,
+          null,
+          null,
           "--output-type=dart is deprecated. It will remain available "
           "in Dart 1.11, but will be removed in Dart 1.12.",
           api.Diagnostic.WARNING);
     }
     passThrough(argument);
   }
 
   String getDepsOutput(Map<Uri, SourceFile> sourceFiles) {
     var filenames = sourceFiles.keys.map((uri) => '$uri').toList();
     filenames.sort();
@@ skipping 63 matching lines @@
   }
 
   setCategories(String argument) {
     List<String> categories = extractParameter(argument).split(',');
     if (categories.contains('all')) {
       categories = ["Client", "Server"];
     } else {
       for (String category in categories) {
         if (!["Client", "Server"].contains(category)) {
           fail('Unsupported library category "$category", '
-               'supported categories are: Client, Server, all');
+              'supported categories are: Client, Server, all');
         }
       }
     }
     passThrough('--categories=${categories.join(",")}');
   }
 
   void handleThrowOnError(String argument) {
     diagnosticHandler.throwOnError = true;
     String parameter = extractParameter(argument, isOptionalArgument: true);
     if (parameter != null) {
@@ skipping 26 matching lines @@
 
   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;
       passThrough(Flags.suppressWarnings);
     }),
     new OptionHandler(Flags.fatalWarnings, passThrough),
-    new OptionHandler(Flags.suppressHints,
-                      (_) => diagnosticHandler.showHints = false),
+    new OptionHandler(
+        Flags.suppressHints, (_) => diagnosticHandler.showHints = false),
     new OptionHandler(
         '--output-type=dart|--output-type=dart-multi|--output-type=js',
         setOutputType),
     new OptionHandler(Flags.useCpsIr, passThrough),
     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.conditionalDirectives, passThrough),
     new OptionHandler('${Flags.minify}|-m', implyCompilation),
     new OptionHandler(Flags.preserveUris, passThrough),
     new OptionHandler('--force-strip=.*', setStrip),
     new OptionHandler(Flags.disableDiagnosticColors,
-                      (_) => diagnosticHandler.enableColors = false),
+        (_) => diagnosticHandler.enableColors = false),
     new OptionHandler(Flags.enableDiagnosticColors,
-                      (_) => diagnosticHandler.enableColors = true),
+        (_) => diagnosticHandler.enableColors = true),
     new OptionHandler('--enable[_-]checked[_-]mode|--checked',
-                      (_) => setCheckedMode(Flags.enableCheckedMode)),
+        (_) => setCheckedMode(Flags.enableCheckedMode)),
     new OptionHandler(Flags.trustTypeAnnotations,
-                      (_) => setTrustTypeAnnotations(
-                          Flags.trustTypeAnnotations)),
+        (_) => setTrustTypeAnnotations(Flags.trustTypeAnnotations)),
     new OptionHandler(Flags.trustPrimitives,
-                      (_) => setTrustPrimitives(
-                          Flags.trustPrimitives)),
-    new OptionHandler(Flags.trustJSInteropTypeAnnotations,
-                      (_) => setTrustJSInteropTypeAnnotations(
-                          Flags.trustJSInteropTypeAnnotations)),
+        (_) => 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(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, setDumpInfo),
-    new OptionHandler('--disallow-unsafe-eval',
-                      (_) => hasDisallowUnsafeEval = true),
+    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),
     new OptionHandler('--enable-async', (_) {
       diagnosticHandler.info(
           "Option '--enable-async' is no longer needed. "
           "Async-await is supported by default.",
           api.Diagnostic.HINT);
     }),
-    new OptionHandler('--enable-null-aware-operators',  (_) {
+    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);
     }),
     new OptionHandler('--enable-enum', (_) {
       diagnosticHandler.info(
           "Option '--enable-enum' is no longer needed. "
           "Enums are supported by default.",
           api.Diagnostic.HINT);
@@ skipping 11 matching lines @@
       arguments.add(nativeToUriPath(argument));
     })
   ];
 
   parseCommandLine(handlers, argv);
   if (wantHelp || wantVersion) {
     helpAndExit(wantHelp, wantVersion, diagnosticHandler.verbose);
   }
 
   if (hasDisallowUnsafeEval) {
-    String precompiledName =
-        relativize(currentDirectory,
-                   RandomAccessFileOutputProvider.computePrecompiledUri(out),
-                   Platform.isWindows);
+    String precompiledName = relativize(
+        currentDirectory,
+        RandomAccessFileOutputProvider.computePrecompiledUri(out),
+        Platform.isWindows);
     helpAndFail("Option '--disallow-unsafe-eval' has been removed."
-                " Instead, the compiler generates a file named"
-                " '$precompiledName'.");
+        " Instead, the compiler generates a file named"
+        " '$precompiledName'.");
   }
 
   if (outputLanguage != OUTPUT_LANGUAGE_DART && stripArgumentSet) {
     helpAndFail("Option '--force-strip' may only be used with "
-                "'--output-type=dart'.");
+        "'--output-type=dart'.");
   }
   if (arguments.isEmpty) {
     helpAndFail('No Dart file specified.');
   }
   if (arguments.length > 1) {
     var extra = arguments.sublist(1);
     helpAndFail('Extra arguments: ${extra.join(" ")}');
   }
 
   if (checkedMode && trustTypeAnnotations) {
     helpAndFail("Option '${Flags.trustTypeAnnotations}' may not be used in "
-                "checked mode.");
+        "checked mode.");
   }
 
   if (packageRoot != null && packageConfig != null) {
     helpAndFail("Cannot specify both '--package-root' and '--packages.");
   }
 
   if ((analyzeOnly || analyzeAll) && !optionsImplyCompilation.isEmpty) {
     if (!analyzeOnly) {
       diagnosticHandler.info(
           "Option '${Flags.analyzeAll}' implies '${Flags.analyzeOnly}'.",
           api.Diagnostic.INFO);
     }
     diagnosticHandler.info(
         "Options $optionsImplyCompilation indicate that output is expected, "
         "but compilation is turned off by the option '${Flags.analyzeOnly}'.",
         api.Diagnostic.INFO);
   }
   if (analyzeAll) analyzeOnly = true;
   if (!analyzeOnly) {
     if (allowNativeExtensions) {
       helpAndFail("Option '${Flags.allowNativeExtensions}' is only supported "
-                  "in combination with the '${Flags.analyzeOnly}' option.");
+          "in combination with the '${Flags.analyzeOnly}' option.");
     }
   }
   if (dumpInfo && outputLanguage == OUTPUT_LANGUAGE_DART) {
     helpAndFail("Option '${Flags.dumpInfo}' is not supported in "
-                "combination with the '--output-type=dart' option.");
+        "combination with the '--output-type=dart' option.");
   }
 
   options.add('--out=$out');
   options.add('--source-map=$sourceMapOut');
 
   RandomAccessFileOutputProvider outputProvider =
-      new RandomAccessFileOutputProvider(
-          out, sourceMapOut, onInfo: diagnosticHandler.info, onFailure: fail);
+      new RandomAccessFileOutputProvider(out, sourceMapOut,
+          onInfo: diagnosticHandler.info, onFailure: fail);
 
   api.CompilationResult compilationDone(api.CompilationResult result) {
     if (analyzeOnly) return result;
     if (!result.isSuccess) {
       fail('Compilation failed.');
     }
-    writeString(Uri.parse('$out.deps'),
-                getDepsOutput(inputProvider.sourceFiles));
-    diagnosticHandler.info(
-         'Compiled ${inputProvider.dartCharactersRead} characters Dart '
-         '-> ${outputProvider.totalCharactersWritten} characters '
-         '$outputLanguage in '
-         '${relativize(currentDirectory, out, Platform.isWindows)}');
+    writeString(
+        Uri.parse('$out.deps'), getDepsOutput(inputProvider.sourceFiles));
+    diagnosticHandler
+        .info('Compiled ${inputProvider.dartCharactersRead} characters Dart '
+            '-> ${outputProvider.totalCharactersWritten} characters '
+            '$outputLanguage in '
+            '${relativize(currentDirectory, out, Platform.isWindows)}');
     if (diagnosticHandler.verbose) {
       String input = uriPathToNative(arguments[0]);
       print('Dart file ($input) compiled to $outputLanguage.');
       print('Wrote the following files:');
       for (String filename in outputProvider.allOutputFiles) {
         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;
   }
 
   Uri uri = currentDirectory.resolve(arguments[0]);
-  return compileFunc(uri, libraryRoot, packageRoot, inputProvider,
-                     diagnosticHandler, options, outputProvider, environment,
-                     packageConfig, findPackages)
-            .then(compilationDone);
+  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) {
   if (uri.scheme != 'file') {
     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.report(
-        null, null, -1, -1, message, api.Diagnostic.ERROR);
+    diagnosticHandler.report(null, null, -1, -1, message, api.Diagnostic.ERROR);
   } else {
     print('Error: $message');
   }
   exitFunc(1);
 }
 
 Future<api.CompilationResult> compilerMain(List<String> arguments) {
   var root = uriPathToNative("/$LIBRARY_ROOT");
   arguments = <String>['--library-root=${Platform.script.toFilePath()}$root']
-      ..addAll(arguments);
+    ..addAll(arguments);
   return compile(arguments);
 }
 
 void help() {
   // This message should be no longer than 20 lines. The default
   // terminal size normally 80x24. Two lines are used for the prompts
   // before and after running the compiler. Another two lines may be
   // used to print an error message.
   print('''
 Usage: dart2js [options] dartfile
@@ skipping 124 matching lines @@
   --generate-code-with-compile-time-errors
     Generates output even if the program contains compile-time errors. Use the
     exit code to determine if compilation failed.
 
   --use-cps-ir
     Experimental.  Use the new CPS based backend for code generation.
 
   --no-frequency-based-minification
     Experimental.  Disabled the new frequency based minifying namer and use the
     old namer instead.
-'''.trim());
+'''
+      .trim());
 }
 
 void helpAndExit(bool wantHelp, bool wantVersion, bool verbose) {
   if (wantVersion) {
-    var version = (BUILD_ID == null)
-        ? '<non-SDK build>'
-        : BUILD_ID;
+    var version = (BUILD_ID == null) ? '<non-SDK build>' : BUILD_ID;
     print('Dart-to-JavaScript compiler (dart2js) version: $version');
   }
   if (wantHelp) {
     if (verbose) {
       verboseHelp();
     } else {
       help();
     }
   }
   exitFunc(0);
@@ skipping 74 matching lines @@
       args.addAll(batchArguments);
       args.addAll(splitLine(line, windows: Platform.isWindows));
       return internalMain(args);
     }).catchError((exception, trace) {
       if (!identical(exception, _EXIT_SIGNAL)) {
         exitCode = 253;
       }
     }).whenComplete(() {
       // The testing framework waits for a status line on stdout and
       // stderr before moving to the next test.
-      if (exitCode == 0){
+      if (exitCode == 0) {
         print(">>> TEST OK");
       } else if (exitCode == 253) {
         print(">>> TEST CRASH");
       } else {
         print(">>> TEST FAIL");
       }
       stderr.writeln(">>> EOF STDERR");
       subscription.resume();
     });
   });
 }