Format all files under tools and utils directory.

tools/testing/dart/compiler_configuration.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 compiler_configuration;
 
 import 'dart:io' show Platform;
 
 import 'runtime_configuration.dart' show RuntimeConfiguration;
 import 'runtime_configuration.dart' show DartPrecompiledAdbRuntimeConfiguration;
@@ skipping 85 matching lines @@
             isDebug: isDebug, isChecked: isChecked);
       case 'precompiler':
         return new PrecompilerCompilerConfiguration(
             isDebug: isDebug,
             isChecked: isChecked,
             arch: configuration['arch'],
             useBlobs: useBlobs,
             isAndroid: configuration['system'] == 'android');
       case 'dartk':
         return new NoneCompilerConfiguration(
-              isDebug: isDebug,
-              isChecked: isChecked,
-              isHostChecked: isHostChecked,
-              useSdk: useSdk,
-              hotReload: hotReload,
-              hotReloadRollback: hotReloadRollback,
-              useDFE: true);
+            isDebug: isDebug,
+            isChecked: isChecked,
+            isHostChecked: isHostChecked,
+            useSdk: useSdk,
+            hotReload: hotReload,
+            hotReloadRollback: hotReloadRollback,
+            useDFE: true);
       case 'dartkp':
         return new PrecompilerCompilerConfiguration(
             isDebug: isDebug,
             isChecked: isChecked,
             arch: configuration['arch'],
             useBlobs: useBlobs,
             isAndroid: configuration['system'] == 'android',
             useDFE: true);
       case 'none':
         return new NoneCompilerConfiguration(
@@ skipping 61 matching lines @@
   }
 }
 
 /// The "none" compiler.
 class NoneCompilerConfiguration extends CompilerConfiguration {
   final bool hotReload;
   final bool hotReloadRollback;
   final bool useDFE;
 
   NoneCompilerConfiguration(
-      {bool isDebug, bool isChecked, bool isHostChecked, bool useSdk,
-       bool this.hotReload,
-       bool this.hotReloadRollback,
-       this.useDFE: false})
+      {bool isDebug,
+      bool isChecked,
+      bool isHostChecked,
+      bool useSdk,
+      bool this.hotReload,
+      bool this.hotReloadRollback,
+      this.useDFE: false})
       : super._subclass(
             isDebug: isDebug,
             isChecked: isChecked,
             isHostChecked: isHostChecked,
             useSdk: useSdk);
 
   bool get hasCompiler => false;
 
   List<String> computeRuntimeArguments(
       RuntimeConfiguration runtimeConfiguration,
@@ skipping 20 matching lines @@
       ..addAll(vmOptions)
       ..addAll(sharedOptions)
       ..addAll(originalArguments);
   }
 }
 
 /// The "dartk" compiler.
 class DartKCompilerConfiguration extends CompilerConfiguration {
   final bool verify, strong, treeShake;
 
-  DartKCompilerConfiguration({bool isChecked, bool isHostChecked, bool useSdk,
-        this.verify, this.strong, this.treeShake})
-      : super._subclass(isChecked: isChecked, isHostChecked: isHostChecked,
-                        useSdk: useSdk);
+  DartKCompilerConfiguration(
+      {bool isChecked,
+      bool isHostChecked,
+      bool useSdk,
+      this.verify,
+      this.strong,
+      this.treeShake})
+      : super._subclass(
+            isChecked: isChecked, isHostChecked: isHostChecked, useSdk: useSdk);
 
   @override
   String computeCompilerPath(String buildDir) {
     return 'tools/dartk_wrappers/dartk$executableScriptSuffix';
   }
 
   CompilationCommand computeCompilationCommand(
       String outputFileName,
       String buildDir,
       CommandBuilder commandBuilder,
@@ skipping 39 matching lines @@
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     List<String> args = [];
     if (isChecked) {
       args.add('--enable_asserts');
       args.add('--enable_type_checks');
     }
 
-    var newOriginalArguments = replaceDartFileWith(
-        originalArguments, artifact.filename);
+    var newOriginalArguments =
+        replaceDartFileWith(originalArguments, artifact.filename);
 
     return args
       ..addAll(vmOptions)
       ..addAll(sharedOptions)
       ..addAll(newOriginalArguments);
   }
 }
 
 typedef List<String> CompilerArgumentsFunction(
-    List<String> globalArguments,
-    String previousCompilerOutput);
+    List<String> globalArguments, String previousCompilerOutput);
 
 class PipelineCommand {
   final CompilerConfiguration compilerConfiguration;
   final CompilerArgumentsFunction _argumentsFunction;
 
   PipelineCommand._(this.compilerConfiguration, this._argumentsFunction);
 
   factory PipelineCommand.runWithGlobalArguments(CompilerConfiguration conf) {
-    return new PipelineCommand._(conf, (List<String> globalArguments,
-                                        String previousOutput) {
+    return new PipelineCommand._(conf,
+        (List<String> globalArguments, String previousOutput) {
       assert(previousOutput == null);
       return globalArguments;
     });
   }
 
   factory PipelineCommand.runWithDartOrKernelFile(CompilerConfiguration conf) {
-    return new PipelineCommand._(conf, (List<String> globalArguments,
-                                        String previousOutput) {
+    return new PipelineCommand._(conf,
+        (List<String> globalArguments, String previousOutput) {
       var filtered = globalArguments
-        .where((String name) => name.endsWith('.dart') ||
-                                name.endsWith('.dill'))
-        .toList();
+          .where(
+              (String name) => name.endsWith('.dart') || name.endsWith('.dill'))
+          .toList();
       assert(filtered.length == 1);
       return filtered;
     });
   }
 
   factory PipelineCommand.runWithPreviousKernelOutput(
       CompilerConfiguration conf) {
-    return new PipelineCommand._(conf, (List<String> globalArguments,
-                                        String previousOutput) {
+    return new PipelineCommand._(conf,
+        (List<String> globalArguments, String previousOutput) {
       assert(previousOutput.endsWith('.dill'));
       return replaceDartFileWith(globalArguments, previousOutput);
     });
   }
 
-  List<String> extractArguments(List<String> globalArguments,
-                                String previousOutput) {
+  List<String> extractArguments(
+      List<String> globalArguments, String previousOutput) {
     return _argumentsFunction(globalArguments, previousOutput);
   }
 }
 
 class ComposedCompilerConfiguration extends CompilerConfiguration {
   final List<PipelineCommand> pipelineCommands;
 
   ComposedCompilerConfiguration(this.pipelineCommands) : super._subclass();
 
   CommandArtifact computeCompilationArtifact(
       String buildDir,
       String tempDir,
       CommandBuilder commandBuilder,
       List globalArguments,
       Map<String, String> environmentOverrides) {
-
     List<Command> allCommands = [];
 
     // The first compilation command is as usual.
     var arguments = pipelineCommands[0].extractArguments(globalArguments, null);
-    CommandArtifact artifact =
-        pipelineCommands[0].compilerConfiguration.computeCompilationArtifact(
-          buildDir, tempDir, commandBuilder, arguments, environmentOverrides);
+    CommandArtifact artifact = pipelineCommands[0]
+        .compilerConfiguration
+        .computeCompilationArtifact(
+            buildDir, tempDir, commandBuilder, arguments, environmentOverrides);
     allCommands.addAll(artifact.commands);
 
     // The following compilation commands are based on the output of the
     // previous one.
     for (int i = 1; i < pipelineCommands.length; i++) {
       PipelineCommand pc = pipelineCommands[i];
 
       arguments = pc.extractArguments(globalArguments, artifact.filename);
       artifact = pc.compilerConfiguration.computeCompilationArtifact(
           buildDir, tempDir, commandBuilder, arguments, environmentOverrides);
@@ skipping 15 matching lines @@
       RuntimeConfiguration runtimeConfiguration,
       String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     CompilerConfiguration lastCompilerConfiguration =
         pipelineCommands.last.compilerConfiguration;
     return lastCompilerConfiguration.computeRuntimeArguments(
-        runtimeConfiguration, buildDir, info, vmOptions, sharedOptions,
-        originalArguments, artifact);
+        runtimeConfiguration,
+        buildDir,
+        info,
+        vmOptions,
+        sharedOptions,
+        originalArguments,
+        artifact);
   }
 
   static ComposedCompilerConfiguration createDartKPConfiguration(
-      {bool isChecked, bool isHostChecked, String arch, bool useBlobs,
-       bool isAndroid, bool useSdk, bool verify, bool strong, bool treeShake}) {
+      {bool isChecked,
+      bool isHostChecked,
+      String arch,
+      bool useBlobs,
+      bool isAndroid,
+      bool useSdk,
+      bool verify,
+      bool strong,
+      bool treeShake}) {
     var nested = [];
 
     // Compile with dartk.
     nested.add(new PipelineCommand.runWithGlobalArguments(
-        new DartKCompilerConfiguration(isChecked: isChecked,
-            isHostChecked: isHostChecked, useSdk: useSdk, verify: verify,
-            strong: strong, treeShake: treeShake)));
+        new DartKCompilerConfiguration(
+            isChecked: isChecked,
+            isHostChecked: isHostChecked,
+            useSdk: useSdk,
+            verify: verify,
+            strong: strong,
+            treeShake: treeShake)));
 
     // Run the normal precompiler.
     nested.add(new PipelineCommand.runWithPreviousKernelOutput(
         new PrecompilerCompilerConfiguration(
-          isChecked: isChecked, arch: arch, useBlobs: useBlobs,
-          isAndroid: isAndroid)));
+            isChecked: isChecked,
+            arch: arch,
+            useBlobs: useBlobs,
+            isAndroid: isAndroid)));
 
     return new ComposedCompilerConfiguration(nested);
   }
 
   static ComposedCompilerConfiguration createDartKConfiguration(
-      {bool isChecked, bool isHostChecked, bool useSdk, bool verify,
-       bool strong, bool treeShake}) {
+      {bool isChecked,
+      bool isHostChecked,
+      bool useSdk,
+      bool verify,
+      bool strong,
+      bool treeShake}) {
     var nested = [];
 
     // Compile with dartk.
     nested.add(new PipelineCommand.runWithGlobalArguments(
-        new DartKCompilerConfiguration(isChecked: isChecked,
-            isHostChecked: isHostChecked, useSdk: useSdk,
-            verify: verify, strong: strong, treeShake: treeShake)));
+        new DartKCompilerConfiguration(
+            isChecked: isChecked,
+            isHostChecked: isHostChecked,
+            useSdk: useSdk,
+            verify: verify,
+            strong: strong,
+            treeShake: treeShake)));
 
     return new ComposedCompilerConfiguration(nested);
   }
 }
 
 /// Common configuration for dart2js-based tools, such as, dart2js
 class Dart2xCompilerConfiguration extends CompilerConfiguration {
   final String moniker;
   static Map<String, List<Uri>> _bootstrapDependenciesCache =
       new Map<String, List<Uri>>();
@@ skipping 119 matching lines @@
       ..add(artifact.filename);
   }
 }
 
 class PrecompilerCompilerConfiguration extends CompilerConfiguration {
   final String arch;
   final bool useBlobs;
   final bool isAndroid;
   final bool useDFE;
 
-  PrecompilerCompilerConfiguration({bool isDebug, bool isChecked,
-    this.arch, this.useBlobs, this.isAndroid, this.useDFE: false})
+  PrecompilerCompilerConfiguration(
+      {bool isDebug,
+      bool isChecked,
+      this.arch,
+      this.useBlobs,
+      this.isAndroid,
+      this.useDFE: false})
       : super._subclass(isDebug: isDebug, isChecked: isChecked);
 
   int computeTimeoutMultiplier() {
     int multiplier = 2;
     if (isDebug) multiplier *= 4;
     if (isChecked) multiplier *= 2;
     return multiplier;
   }
 
   CommandArtifact computeCompilationArtifact(
       String buildDir,
       String tempDir,
       CommandBuilder commandBuilder,
       List arguments,
       Map<String, String> environmentOverrides) {
     var commands = new List<Command>();
-    commands.add(this.computeCompilationCommand(tempDir, buildDir, CommandBuilder.instance,
-          arguments, environmentOverrides));
+    commands.add(this.computeCompilationCommand(tempDir, buildDir,
+        CommandBuilder.instance, arguments, environmentOverrides));
     if (!useBlobs) {
-      commands.add(this.computeAssembleCommand(tempDir, buildDir, CommandBuilder.instance,
-          arguments, environmentOverrides));
+      commands.add(this.computeAssembleCommand(tempDir, buildDir,
+          CommandBuilder.instance, arguments, environmentOverrides));
       commands.add(this.computeRemoveAssemblyCommand(tempDir, buildDir,
           CommandBuilder.instance, arguments, environmentOverrides));
     }
-    return new CommandArtifact(commands, '$tempDir', 'application/dart-precompiled');
+    return new CommandArtifact(
+        commands, '$tempDir', 'application/dart-precompiled');
   }
 
   CompilationCommand computeCompilationCommand(
       String tempDir,
       String buildDir,
       CommandBuilder commandBuilder,
       List arguments,
       Map<String, String> environmentOverrides) {
     var exec;
     if (isAndroid) {
@@ skipping 24 matching lines @@
     return commandBuilder.getCompilationCommand('precompiler', tempDir, !useSdk,
         bootstrapDependencies(buildDir), exec, args, environmentOverrides);
   }
 
   CompilationCommand computeAssembleCommand(
       String tempDir,
       String buildDir,
       CommandBuilder commandBuilder,
       List arguments,
       Map<String, String> environmentOverrides) {
-
     var cc, shared, ld_flags;
     if (isAndroid) {
       var ndk = "third_party/android_tools/ndk";
       var triple;
       if (arch == "arm") {
         triple = "arm-linux-androideabi";
       } else if (arch == "arm64") {
         triple = "aarch64-linux-android";
       }
       var host;
@@ skipping 107 matching lines @@
       args.add('--enable_asserts');
       args.add('--enable_type_checks');
     }
 
     var dir = artifact.filename;
     if (runtimeConfiguration is DartPrecompiledAdbRuntimeConfiguration) {
       // On android the precompiled snapshot will be pushed to a different
       // directory on the device, use that one instead.
       dir = DartPrecompiledAdbRuntimeConfiguration.DeviceTestDir;
     }
-    originalArguments = replaceDartFileWith(
-        originalArguments, "$dir/out.aotsnapshot");
+    originalArguments =
+        replaceDartFileWith(originalArguments, "$dir/out.aotsnapshot");
 
     return args
       ..addAll(vmOptions)
       ..addAll(sharedOptions)
       ..addAll(originalArguments);
   }
 }
 
 class AppJitCompilerConfiguration extends CompilerConfiguration {
   AppJitCompilerConfiguration({bool isDebug, bool isChecked})
       : super._subclass(isDebug: isDebug, isChecked: isChecked);
 
   int computeTimeoutMultiplier() {
     int multiplier = 1;
     if (isDebug) multiplier *= 2;
     if (isChecked) multiplier *= 2;
     return multiplier;
   }
 
   CommandArtifact computeCompilationArtifact(
       String buildDir,
       String tempDir,
       CommandBuilder commandBuilder,
       List arguments,
       Map<String, String> environmentOverrides) {
     var snapshot = "$tempDir/out.jitsnapshot";
     return new CommandArtifact(<Command>[
-      this.computeCompilationCommand(tempDir, buildDir,
-          CommandBuilder.instance, arguments, environmentOverrides)
+      this.computeCompilationCommand(tempDir, buildDir, CommandBuilder.instance,
+          arguments, environmentOverrides)
     ], snapshot, 'application/dart-snapshot');
   }
 
   CompilationCommand computeCompilationCommand(
       String tempDir,
       String buildDir,
       CommandBuilder commandBuilder,
       List arguments,
       Map<String, String> environmentOverrides) {
     var exec = "$buildDir/dart";
     var args = new List();
     var snapshot = "$tempDir/out.jitsnapshot";
     args.add("--snapshot=$snapshot");
     args.add("--snapshot-kind=app-jit");
     args.addAll(arguments);
 
-    return commandBuilder.getCompilationCommand(
-        'app_jit',
-        tempDir,
-        !useSdk,
-        bootstrapDependencies(buildDir),
-        exec,
-        args,
-        environmentOverrides);
+    return commandBuilder.getCompilationCommand('app_jit', tempDir, !useSdk,
+        bootstrapDependencies(buildDir), exec, args, environmentOverrides);
   }
 
   List<String> computeCompilerArguments(
       vmOptions, sharedOptions, originalArguments) {
     List<String> args = [];
     if (isChecked) {
       args.add('--enable_asserts');
       args.add('--enable_type_checks');
     }
     return args
       ..addAll(vmOptions)
       ..addAll(sharedOptions)
       ..addAll(originalArguments);
   }
 
   List<String> computeRuntimeArguments(
       RuntimeConfiguration runtimeConfiguration,
       String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     List<String> args = [];
     if (isChecked) {
       args.add('--enable_asserts');
       args.add('--enable_type_checks');
     }
-    args
-      ..addAll(vmOptions)
-      ..addAll(sharedOptions)
-      ..addAll(originalArguments);
+    args..addAll(vmOptions)..addAll(sharedOptions)..addAll(originalArguments);
     for (var i = 0; i < args.length; i++) {
       if (args[i].endsWith(".dart")) {
         args[i] = artifact.filename;
       }
     }
     return args;
   }
 }
 
 class AnalyzerCompilerConfiguration extends CompilerConfiguration {
   AnalyzerCompilerConfiguration(
-      {bool isDebug, bool isChecked, bool isStrong, bool isHostChecked, bool
-      useSdk})
+      {bool isDebug,
+      bool isChecked,
+      bool isStrong,
+      bool isHostChecked,
+      bool useSdk})
       : super._subclass(
             isDebug: isDebug,
             isChecked: isChecked,
             isStrong: isStrong,
             isHostChecked: isHostChecked,
             useSdk: useSdk);
 
   int computeTimeoutMultiplier() {
     return 4;
   }
@@ skipping 19 matching lines @@
   CommandArtifact computeCompilationArtifact(
       String buildDir,
       String tempDir,
       CommandBuilder commandBuilder,
       List arguments,
       Map<String, String> environmentOverrides) {
     arguments = new List.from(arguments);
     if (isChecked || isStrong) {
       arguments.add('--enable_type_checks');
     }
-    if (isStrong){
+    if (isStrong) {
       arguments.add('--strong');
     }
     return new CommandArtifact(<Command>[
       commandBuilder.getAnalysisCommand('dart2analyzer',
           computeCompilerPath(buildDir), arguments, environmentOverrides,
           flavor: 'dart2analyzer')
     ], null, null); // Since this is not a real compilation, no artifacts are
     // produced.
   }
 
   List<String> computeRuntimeArguments(
       RuntimeConfiguration runtimeConfiguration,
       String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     return <String>[];
   }
 }