Format all files under tools and utils directory.

tools/dart2js/class_generator/class_generator.dart

 // Copyright (c) 2015, 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.
 
 // Script that generates different approaches to initialize classes in
 // JavaScript.
 // Also benchmarks the approaches.
 
 import 'dart:io';
 import 'dart:async';
@@ skipping 49 matching lines @@
   final bool shouldEmitInstantiatePreviousMethod;
 
   /// Makes sure that the dart2js tree-shaker doesn't remove classes.
   ///
   /// When set to `-1`, all classes are kept alive.
   final int fakeInstantiateClass;
 
   /// Defines the percent of classes that are dynamically instantiated.
   final int instantiateClassesPercent;
 
-  Config({this.nbClasses, this.nbMethodsPerClass,
-          this.shareCommonSuperclass, this.sameMethodNames,
-          this.shouldPrintInMethod, this.nbWhileLoopsInBody,
-          this.shouldWrapProgram, this.shouldEmitCallAllMethods,
-          this.shouldEmitInstantiatePreviousMethod,
-          this.fakeInstantiateClass, this.instantiateClassesPercent});
+  Config(
+      {this.nbClasses,
+      this.nbMethodsPerClass,
+      this.shareCommonSuperclass,
+      this.sameMethodNames,
+      this.shouldPrintInMethod,
+      this.nbWhileLoopsInBody,
+      this.shouldWrapProgram,
+      this.shouldEmitCallAllMethods,
+      this.shouldEmitInstantiatePreviousMethod,
+      this.fakeInstantiateClass,
+      this.instantiateClassesPercent});
 }
 
 String get d8Path {
   Uri scriptPath = Platform.script;
   String d8Executable = "../../../third_party/d8/";
   if (Platform.isWindows) {
     d8Executable += "windows/d8.exe";
   } else if (Platform.isMacOS) {
     d8Executable += "macos/d8";
   } else if (Platform.isLinux) {
@@ skipping 87 matching lines @@
     } finally {
       dir.deleteSync(recursive: true);
     }
   }
 
   Future<String> generateRawJs(String filePrefix);
 
   String buildFileName(String filePrefix, String extension) {
     // TODO(floitsch): store other config info in the file name.
     return "$filePrefix.$nbClasses.$nbMethodsPerClass."
-           "$instantiateClassesPercent.$description.$extension";
+        "$instantiateClassesPercent.$description.$extension";
   }
 
   String writeFile(String filePrefix) {
     buffer.clear();
-    emitClasses();  // Output is stored in `buffer`.
+    emitClasses(); // Output is stored in `buffer`.
 
     String fileName = buildFileName(filePrefix, fileExtension);
     new File(fileName).writeAsStringSync(buffer.toString());
     print("wrote: $fileName");
     return fileName;
   }
 
   void writeln(x) => buffer.writeln(x);
 
   String classIdToName(int id) {
@@ skipping 97 matching lines @@
           o = o.$instantiatePreviousMethodName();
         } while(o != null);
       """);
     }
     if (wrapProgram) writeln("})();");
   }
 
   String get fileExtension => "js";
 }
 
-enum PrototypeApproach {
-  tmpFunction,
-  internalProto,
-  objectCreate
-}
+enum PrototypeApproach { tmpFunction, internalProto, objectCreate }
+
 class PlainJavaScriptClassGenerator extends JavaScriptClassGenerator {
   final PrototypeApproach prototypeApproach;
   final bool shouldInlineInherit;
   final bool useMethodsObject;
 
   PlainJavaScriptClassGenerator(Config config,
-                                {this.prototypeApproach,
-                                 this.shouldInlineInherit,
-                                 this.useMethodsObject})
+      {this.prototypeApproach, this.shouldInlineInherit, this.useMethodsObject})
       : super(config) {
     if (prototypeApproach == null) {
       throw "Must provide prototype approach";
     }
     if (shouldInlineInherit == null) {
       throw "Must provide inlining approach";
     }
     if (useMethodsObject == null) {
       throw "Must provide object-proto approach";
     }
@@ skipping 46 matching lines @@
       case PrototypeApproach.internalProto:
         if (useMethodsObject) {
           writeln('''
             function inherit(cls, sup, methods) {
               cls.prototype = methods;
               if (sup != null) {
                 cls.prototype.__proto__ = sup.prototype;
               }
             }
             ''');
-
         } else {
           writeln('''
             function inherit(cls, sup) {
               cls.prototype.__proto__ = sup.prototype;
             }
             ''');
         }
         break;
       case PrototypeApproach.tmpFunction:
         if (useMethodsObject) {
@@ skipping 44 matching lines @@
     function copyProperties(from, to) {
       var props = Object.keys(from);
       for (var i = 0; i < props.length; i++) {
         var p = props[i];
         to[p] = from[p];
       }
     }""");
   }
 
   void emitMethod(int classId, String methodName, Function bodyEmitter,
-                  {bool emitArgument: true}) {
+      {bool emitArgument: true}) {
     String argumentString = emitArgument ? argumentName : "";
     if (useMethodsObject) {
       writeln("$methodName: function($argumentString)");
       bodyEmitter();
       writeln(",");
     } else {
       String className = classIdToName(classId);
       String proto = "$className.prototype";
       writeln("$proto.$methodName = function($argumentString)");
       bodyEmitter();
     }
   }
 
   /// Returns the methods object, if we use an object.
   void emitMethods(int classId) {
     List<int> methodIds = [];
     int nbGenericMethods = nbMethodsPerClass;
     if (useMethodsObject) {
       writeln("$methodsObjectName = {");
     }
     if (shouldEmitCallAllMethods) nbGenericMethods--;
     for (int j = 0; j < nbGenericMethods; j++) {
       String methodName = methodIdToName(j, classId);
       emitMethod(classId, methodName, () => emitMethodBody(j, classId));
       methodIds.add(j);
     }
     if (shouldEmitCallAllMethods) {
-      emitMethod(classId,
-      callOtherMethodsName,
+      emitMethod(classId, callOtherMethodsName,
           () => emitCallOtherMethodsBody(methodIds, classId));
     }
     if (shouldEmitInstantiatePreviousMethod) {
-      emitMethod(classId,
-      instantiatePreviousMethodName,
+      emitMethod(classId, instantiatePreviousMethodName,
           () => emitInstantiatePrevious(classId),
-      emitArgument: false);
+          emitArgument: false);
     }
     if (useMethodsObject) {
       writeln("};");
     }
   }
 
   void emitClass(int classId, int superclassId) {
     String className = classIdToName(classId);
     writeln("function $className() {}");
     switch (prototypeApproach) {
@@ skipping 134 matching lines @@
 
   Future<String> generateRawJs(String filePrefix) async {
     String dartFile = writeFile(filePrefix);
     String outFile = buildFileName(filePrefix, "js");
     Map<String, String> env = {};
     if (shouldUseNewEmitter) {
       env["DART_VM_OPTIONS"] = '-Ddart2js.use.new.emitter=true';
     }
     print("compiling");
     print("dart2jsPath: $dart2jsPath");
-    ProcessResult result =
-        await Process.run(dart2jsPath, [dartFile, "--out=$outFile"],
-                          environment: env);
+    ProcessResult result = await Process
+        .run(dart2jsPath, [dartFile, "--out=$outFile"], environment: env);
     if (result.exitCode != 0) {
       print("compilation failed");
       print(result.stdout);
       print(result.stderr);
       return null;
     }
     print("compilation done");
     return outFile;
   }
 
-  Future measureDart(String filePrefix, { bool useSnapshot: false }) async {
+  Future measureDart(String filePrefix, {bool useSnapshot: false}) async {
     String dartFile = writeFile(filePrefix);
     String command = Platform.executable;
     Stopwatch watch = new Stopwatch();
     Directory dir = Directory.systemTemp.createTempSync('snapshot');
     try {
       String measuring = dartFile;
       if (useSnapshot) {
         print("creating snapshot");
         measuring = new File("${dir.path}/measuring.snapshot").path;
         ProcessResult result =
-        await Process.run(command, ["--snapshot=$measuring", dartFile]);
+            await Process.run(command, ["--snapshot=$measuring", dartFile]);
         if (result.exitCode != 0) {
           print("snapshot creation failed");
           print(result.stdout);
           print(result.stderr);
           return;
         }
       }
       List<String> args = [measuring];
       print("Running: $command ${args.join(' ')}");
       int nbRuns = 10;
@@ skipping 36 matching lines @@
       nbClasses: 2000,
       nbMethodsPerClass: 20,
       fakeInstantiateClass: -1,
       instantiateClassesPercent: 20,
       shareCommonSuperclass: true,
       sameMethodNames: true,
       shouldPrintInMethod: true,
       nbWhileLoopsInBody: 1,
       shouldWrapProgram: true,
       shouldEmitCallAllMethods: true,
-      shouldEmitInstantiatePreviousMethod: true
-  );
+      shouldEmitInstantiatePreviousMethod: true);
 
   var plain = new PlainJavaScriptClassGenerator(config,
       prototypeApproach: PrototypeApproach.tmpFunction,
       useMethodsObject: false,
       shouldInlineInherit: false);
   var plainProto = new PlainJavaScriptClassGenerator(config,
       prototypeApproach: PrototypeApproach.internalProto,
       useMethodsObject: false,
       shouldInlineInherit: false);
   var plainObjectCreate = new PlainJavaScriptClassGenerator(config,
@@ skipping 41 matching lines @@
   await plainProtoObj.measure(filePrefix);
   await plainObjectCreateObj.measure(filePrefix);
   await plainProtoInlineObj.measure(filePrefix);
   await plainObjectCreateInlineObj.measure(filePrefix);
   await es6.measure(filePrefix);
   await dartNew.measure(filePrefix);
   await dart.measure(filePrefix);
   await dart.measureDart(filePrefix);
   await dart.measureDart(filePrefix, useSnapshot: true);
 }