Reformat code to minimize churn

pkg/analysis_server/lib/src/server/driver.dart

 // Copyright (c) 2014, 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 driver;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:math';
 
@@ skipping 54 matching lines @@
   /// Creates a new command line parser
   CommandLineParser({bool alwaysIgnoreUnrecognized: false})
       : _knownFlags = <String>[],
         _alwaysIgnoreUnrecognized = alwaysIgnoreUnrecognized,
         _parser = new ArgParser(allowTrailingOptions: true);
 
   ArgParser get parser => _parser;
 
   /// Defines a flag.
   /// See [ArgParser.addFlag()].
-  void addFlag(String name, {String abbr, String help, bool defaultsTo: false,
-      bool negatable: true, void callback(bool value), bool hide: false}) {
+  void addFlag(String name,
+      {String abbr,
+      String help,
+      bool defaultsTo: false,
+      bool negatable: true,
+      void callback(bool value),
+      bool hide: false}) {
     _knownFlags.add(name);
     _parser.addFlag(name,
         abbr: abbr,
         help: help,
         defaultsTo: defaultsTo,
         negatable: negatable,
         callback: callback,
         hide: hide);
   }
 
   /// Defines a value-taking option.
   /// See [ArgParser.addOption()].
-  void addOption(String name, {String abbr, String help, List<String> allowed,
-      Map<String, String> allowedHelp, String defaultsTo, void callback(value),
+  void addOption(String name,
+      {String abbr,
+      String help,
+      List<String> allowed,
+      Map<String, String> allowedHelp,
+      String defaultsTo,
+      void callback(value),
       bool allowMultiple: false}) {
     _knownFlags.add(name);
     _parser.addOption(name,
         abbr: abbr,
         help: help,
         allowed: allowed,
         allowedHelp: allowedHelp,
         defaultsTo: defaultsTo,
         callback: callback,
         allowMultiple: allowMultiple);
   }
 
   /// Generates a string displaying usage information for the defined options.
   /// See [ArgParser.usage].
   String getUsage() => _parser.usage;
 
   /// Parses [args], a list of command-line arguments, matches them against the
   /// flags and options defined by this parser, and returns the result. The
   /// values of any defined variables are captured in the given map.
   /// See [ArgParser].
-  ArgResults parse(
-      List<String> args, Map<String, String> definedVariables) => _parser
-      .parse(_filterUnknowns(parseDefinedVariables(args, definedVariables)));
+  ArgResults parse(List<String> args, Map<String, String> definedVariables) =>
+      _parser.parse(
+          _filterUnknowns(parseDefinedVariables(args, definedVariables)));
 
   List<String> parseDefinedVariables(
       List<String> args, Map<String, String> definedVariables) {
     int count = args.length;
     List<String> remainingArgs = <String>[];
     for (int i = 0; i < count; i++) {
       String arg = args[i];
       if (arg == '--') {
         while (i < count) {
           remainingArgs.add(args[i++]);
         }
       } else if (arg.startsWith("-D")) {
         definedVariables[arg.substring(2)] = args[++i];
       } else {
         remainingArgs.add(arg);
       }
     }
     return remainingArgs;
   }
 
   List<String> _filterUnknowns(List<String> args) {
-
     // Only filter args if the ignore flag is specified, or if
     // _alwaysIgnoreUnrecognized was set to true
     if (_alwaysIgnoreUnrecognized ||
         args.contains('--ignore-unrecognized-flags')) {
-
       // Filter all unrecognized flags and options.
       List<String> filtered = <String>[];
       for (int i = 0; i < args.length; ++i) {
         String arg = args[i];
         if (arg.startsWith('--') && arg.length > 2) {
           String option = arg.substring(2);
           // strip the last '=value'
           int equalsOffset = option.lastIndexOf('=');
           if (equalsOffset != -1) {
             option = option.substring(0, equalsOffset);
@@ skipping 272 matching lines @@
 
     _captureExceptions(service, () {
       stdioServer.serveStdio().then((_) {
         if (serve_http) {
           httpServer.close();
         }
         service.shutdown();
         exit(0);
       });
     },
-        print: results[INTERNAL_PRINT_TO_CONSOLE]
-            ? null
-            : httpServer.recordPrint);
+        print:
+            results[INTERNAL_PRINT_TO_CONSOLE] ? null : httpServer.recordPrint);
   }
 
   /**
    * Execute the given [callback] within a zone that will capture any unhandled
    * exceptions and both report them to the client and send them to the given
    * instrumentation [service]. If a [print] function is provided, then also
    * capture any data printed by the callback and redirect it to the function.
    */
   dynamic _captureExceptions(InstrumentationService service, dynamic callback(),
       {void print(String line)}) {
     Function errorFunction = (Zone self, ZoneDelegate parent, Zone zone,
         dynamic exception, StackTrace stackTrace) {
       service.logPriorityException(exception, stackTrace);
       AnalysisServer analysisServer = socketServer.analysisServer;
       analysisServer.sendServerErrorNotification(exception, stackTrace);
       throw exception;
     };
     Function printFunction = print == null
         ? null
         : (Zone self, ZoneDelegate parent, Zone zone, String line) {
-      // Note: we don't pass the line on to stdout, because that is reserved
-      // for communication to the client.
-      print(line);
-    };
+            // Note: we don't pass the line on to stdout, because that is reserved
+            // for communication to the client.
+            print(line);
+          };
     ZoneSpecification zoneSpecification = new ZoneSpecification(
         handleUncaughtError: errorFunction, print: printFunction);
     return runZoned(callback, zoneSpecification: zoneSpecification);
   }
 
   /**
    * Create and return the parser used to parse the command-line arguments.
    */
   CommandLineParser _createArgParser() {
     CommandLineParser parser =
@@ skipping 18 matching lines @@
         help: "print this help message without starting a server",
         defaultsTo: false,
         negatable: false);
     parser.addOption(INCREMENTAL_RESOLUTION_LOG,
         help: "the description of the incremental resolution log");
     parser.addFlag(INCREMENTAL_RESOLUTION_VALIDATION,
         help: "enable validation of incremental resolution results (slow)",
         defaultsTo: false,
         negatable: false);
     parser.addOption(INSTRUMENTATION_LOG_FILE,
-        help: "the path of the file to which instrumentation data will be written");
+        help:
+            "the path of the file to which instrumentation data will be written");
     parser.addFlag(INTERNAL_PRINT_TO_CONSOLE,
         help: "enable sending `print` output to the console",
         defaultsTo: false,
         negatable: false);
     parser.addOption(PORT_OPTION,
         help: "the http diagnostic port on which the server provides"
-        " status and performance information");
+            " status and performance information");
     parser.addOption(INTERNAL_DELAY_FREQUENCY);
     parser.addOption(SDK_OPTION, help: "[path] the path to the sdk");
     parser.addFlag(NO_ERROR_NOTIFICATION,
         help: "disable sending all analysis error notifications to the server",
         defaultsTo: false,
         negatable: false);
     parser.addFlag(NO_INDEX,
         help: "disable indexing sources", defaultsTo: false, negatable: false);
     parser.addFlag(USE_ANALISYS_HIGHLIGHT2,
         help: "enable version 2 of semantic highlight",
         defaultsTo: false,
         negatable: false);
     parser.addOption(FILE_READ_MODE,
         help: "an option of the ways files can be read from disk, " +
             "some clients normalize end of line characters which would make " +
             "the file offset and range information incorrect.",
         allowed: ["as-is", "normalize-eol-always"],
         allowedHelp: {
-      "as-is": "file contents are read as-is, no file changes occur",
-      "normalize-eol-always":
-          r'file contents normalize the end of line characters to the single character new line `\n`'
-    },
+          "as-is": "file contents are read as-is, no file changes occur",
+          "normalize-eol-always":
+              r'file contents normalize the end of line characters to the single character new line `\n`'
+        },
         defaultsTo: "as-is");
 
     return parser;
   }
 
   /**
    * Print information about how to use the server.
    */
   void _printUsage(ArgParser parser) {
     print('Usage: $BINARY_NAME [flags]');
     print('');
     print('Supported flags are:');
     print(parser.usage);
   }
 
   /**
    * Read the UUID from disk, generating and storing a new one if necessary.
    */
   String _readUuid(InstrumentationService service) {
     File uuidFile = new File(PhysicalResourceProvider.INSTANCE
         .getStateLocation('.instrumentation')
-        .getChild('uuid.txt').path);
+        .getChild('uuid.txt')
+        .path);
     try {
       if (uuidFile.existsSync()) {
         String uuid = uuidFile.readAsStringSync();
         if (uuid != null && uuid.length > 5) {
           return uuid;
         }
       }
     } catch (exception, stackTrace) {
       service.logPriorityException(exception, stackTrace);
     }
     int millisecondsSinceEpoch = new DateTime.now().millisecondsSinceEpoch;
     int random = new Random().nextInt(0x3fffffff);
     String uuid = '$millisecondsSinceEpoch$random';
     try {
       uuidFile.parent.createSync(recursive: true);
       uuidFile.writeAsStringSync(uuid);
     } catch (exception, stackTrace) {
       service.logPriorityException(exception, stackTrace);
       // Slightly alter the uuid to indicate it was not persisted
       uuid = 'temp-$uuid';
     }
     return uuid;
   }
 }