Reformat untouched files.

pkg/compiler/lib/src/js_emitter/full_emitter/emitter.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 dart2js.js_emitter.full_emitter;
 
 import 'dart:collection' show HashMap;
 import 'dart:convert';
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
@@ skipping 559 matching lines @@
     return ':$names';
   }
 
   jsAst.Statement buildCspPrecompiledFunctionFor(OutputUnit outputUnit) {
     if (compiler.options.useContentSecurityPolicy) {
       // TODO(ahe): Compute a hash code.
       // TODO(sigurdm): Avoid this precompiled function. Generated
       // constructor-functions and getter/setter functions can be stored in the
       // library-description table. Setting properties on these can be moved to
       // finishClasses.
-      return js.statement(
-          r"""
+      return js.statement(r"""
         #precompiled = function ($collectedClasses$) {
           #norename;
           var $desc;
           #functions;
           return #result;
-        };""",
-          {
-            'norename': new jsAst.Comment("// ::norenaming:: "),
-            'precompiled':
-                generateEmbeddedGlobalAccess(embeddedNames.PRECOMPILED),
-            'functions': cspPrecompiledFunctionFor(outputUnit),
-            'result': new jsAst.ArrayInitializer(
-                cspPrecompiledConstructorNamesFor(outputUnit))
-          });
+        };""", {
+        'norename': new jsAst.Comment("// ::norenaming:: "),
+        'precompiled': generateEmbeddedGlobalAccess(embeddedNames.PRECOMPILED),
+        'functions': cspPrecompiledFunctionFor(outputUnit),
+        'result': new jsAst.ArrayInitializer(
+            cspPrecompiledConstructorNamesFor(outputUnit))
+      });
     } else {
       return js.comment("Constructors are generated at runtime.");
     }
   }
 
   void assembleClass(
       Class cls, ClassBuilder enclosingBuilder, Fragment fragment) {
     ClassEntity classElement = cls.element;
     reporter.withCurrentElement(classElement, () {
       classEmitter.emitClass(cls, enclosingBuilder, fragment);
@@ skipping 58 matching lines @@
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildLazilyInitializedStaticFields(
       Iterable<StaticField> lazyFields,
       {bool isMainFragment: true}) {
     if (lazyFields.isNotEmpty) {
       needsLazyInitializer = true;
       List<jsAst.Expression> laziesInfo =
           buildLaziesInfo(lazyFields, isMainFragment);
-      return js.statement(
-          '''
+      return js.statement('''
       (function(lazies) {
         for (var i = 0; i < lazies.length; ) {
           var fieldName = lazies[i++];
           var getterName = lazies[i++];
           var lazyValue = lazies[i++];
           if (#notMinified) {
             var staticName = lazies[i++];
           }
           if (#isDeferredFragment) {
             var fieldHolder = lazies[i++];
@@ skipping 10 matching lines @@
             }
           } else {
             if (#notMinified) {
               #lazy(fieldName, getterName, lazyValue, staticName, fieldHolder);
             } else {
               #lazy(fieldName, getterName, lazyValue, null, fieldHolder);
             }
           }
         }
       })(#laziesInfo)
-      ''',
-          {
-            'notMinified': !compiler.options.enableMinification,
-            'laziesInfo': new jsAst.ArrayInitializer(laziesInfo),
-            'lazy': js(lazyInitializerName),
-            'isMainFragment': isMainFragment,
-            'isDeferredFragment': !isMainFragment
-          });
+      ''', {
+        'notMinified': !compiler.options.enableMinification,
+        'laziesInfo': new jsAst.ArrayInitializer(laziesInfo),
+        'lazy': js(lazyInitializerName),
+        'isMainFragment': isMainFragment,
+        'isDeferredFragment': !isMainFragment
+      });
     } else {
       return js.comment("No lazy statics.");
     }
   }
 
   List<jsAst.Expression> buildLaziesInfo(
       Iterable<StaticField> lazies, bool isMainFragment) {
     List<jsAst.Expression> laziesInfo = <jsAst.Expression>[];
     for (StaticField field in lazies) {
       laziesInfo.add(js.quoteName(field.name));
@@ skipping 54 matching lines @@
     return initializer;
   }
 
   jsAst.Expression constantListGenerator(jsAst.Expression array) {
     // TODO(floitsch): there is no harm in caching the template.
     return js('${namer.isolateName}.#(#)', [makeConstListProperty, array]);
   }
 
   jsAst.Statement buildMakeConstantList(bool outputContainsConstantList) {
     if (outputContainsConstantList) {
-      return js.statement(
-          r'''
+      return js.statement(r'''
           // Functions are stored in the hidden class and not as properties in
           // the object. We never actually look at the value, but only want
           // to know if the property exists.
           #.# = function (list) {
             list.immutable$list = Array;
             list.fixed$length = Array;
             return list;
-          }''',
-          [namer.isolateName, makeConstListProperty]);
+          }''', [namer.isolateName, makeConstListProperty]);
     } else {
       return js.comment("Output contains no constant list.");
     }
   }
 
   jsAst.Statement buildFunctionThatReturnsNull() {
     return js.statement('#.# = function() {}',
         [namer.isolateName, backend.rtiEncoder.getFunctionThatReturnsNullName]);
   }
 
   jsAst.Expression generateFunctionThatReturnsNull() {
     return js("#.#",
         [namer.isolateName, backend.rtiEncoder.getFunctionThatReturnsNullName]);
   }
 
   buildMain(jsAst.Statement invokeMain) {
     if (compiler.isMockCompilation) return js.comment("Mock compilation");
 
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     if (NativeGenerator
         .needsIsolateAffinityTagInitialization(_closedWorld.backendUsage)) {
       parts.add(NativeGenerator.generateIsolateAffinityTagInitialization(
-          _closedWorld.backendUsage,
-          generateEmbeddedGlobalAccess,
-          js(
-              """
+          _closedWorld.backendUsage, generateEmbeddedGlobalAccess, js("""
         // On V8, the 'intern' function converts a string to a symbol, which
         // makes property access much faster.
         function (s) {
           var o = {};
           o[s] = 1;
           return Object.keys(convertToFastObject(o))[0];
-        }""",
-              [])));
+        }""", [])));
     }
 
     parts
       ..add(js.comment('BEGIN invoke [main].'))
       ..add(invokeMain)
       ..add(js.comment('END invoke [main].'));
 
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildInitFunction(bool outputContainsConstantList) {
     jsAst.Expression allClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.ALL_CLASSES);
     jsAst.Expression getTypeFromNameAccess =
         generateEmbeddedGlobalAccess(embeddedNames.GET_TYPE_FROM_NAME);
     jsAst.Expression interceptorsByTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
     jsAst.Expression leafTagsAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
     jsAst.Expression finishedClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
     jsAst.Expression cyclicThrow =
         staticFunctionAccess(commonElements.cyclicThrowHelper);
     jsAst.Expression laziesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LAZIES);
 
-    return js.statement(
-        '''
+    return js.statement('''
       function init() {
         $isolatePropertiesName = Object.create(null);
         #allClasses = map();
         #getTypeFromName = function(name) {return #allClasses[name];};
         #interceptorsByTag = map();
         #leafTags = map();
         #finishedClasses = map();
 
         if (#needsLazyInitializer) {
           // [staticName] is only provided in non-minified mode. If missing, we
@@ skipping 83 matching lines @@
           Isolate.prototype.constructor = Isolate;
           Isolate.#isolatePropertiesName = isolateProperties;
           if (#outputContainsConstantList) {
             Isolate.#makeConstListProperty = oldIsolate.#makeConstListProperty;
           }
           Isolate.#functionThatReturnsNullProperty =
               oldIsolate.#functionThatReturnsNullProperty;
           return Isolate;
       }
 
-      }''',
-        {
-          'allClasses': allClassesAccess,
-          'getTypeFromName': getTypeFromNameAccess,
-          'interceptorsByTag': interceptorsByTagAccess,
-          'leafTags': leafTagsAccess,
-          'finishedClasses': finishedClassesAccess,
-          'needsLazyInitializer': needsLazyInitializer,
-          'lazies': laziesAccess,
-          'cyclicThrow': cyclicThrow,
-          'isolatePropertiesName': namer.isolatePropertiesName,
-          'outputContainsConstantList': outputContainsConstantList,
-          'makeConstListProperty': makeConstListProperty,
-          'functionThatReturnsNullProperty':
-              backend.rtiEncoder.getFunctionThatReturnsNullName,
-        });
+      }''', {
+      'allClasses': allClassesAccess,
+      'getTypeFromName': getTypeFromNameAccess,
+      'interceptorsByTag': interceptorsByTagAccess,
+      'leafTags': leafTagsAccess,
+      'finishedClasses': finishedClassesAccess,
+      'needsLazyInitializer': needsLazyInitializer,
+      'lazies': laziesAccess,
+      'cyclicThrow': cyclicThrow,
+      'isolatePropertiesName': namer.isolatePropertiesName,
+      'outputContainsConstantList': outputContainsConstantList,
+      'makeConstListProperty': makeConstListProperty,
+      'functionThatReturnsNullProperty':
+          backend.rtiEncoder.getFunctionThatReturnsNullName,
+    });
   }
 
   jsAst.Statement buildConvertToFastObjectFunction() {
     List<jsAst.Statement> debugCode = <jsAst.Statement>[];
     if (DEBUG_FAST_OBJECTS) {
       debugCode.add(js.statement(r'''
         // The following only works on V8 when run with option
         // "--allow-natives-syntax".  We use'new Function' because the
          // miniparser does not understand V8 native syntax.
         if (typeof print === "function") {
           var HasFastProperties =
             new Function("a", "return %HasFastProperties(a)");
           print("Size of global object: "
                    + String(Object.getOwnPropertyNames(properties).length)
                    + ", fast properties " + HasFastProperties(properties));
         }'''));
     }
 
-    return js.statement(
-        r'''
+    return js.statement(r'''
       function convertToFastObject(properties) {
         // Create an instance that uses 'properties' as prototype. This should
         // make 'properties' a fast object.
         function MyClass() {};
         MyClass.prototype = properties;
         new MyClass();
         #;
         return properties;
-      }''',
-        [debugCode]);
+      }''', [debugCode]);
   }
 
   jsAst.Statement buildConvertToSlowObjectFunction() {
     return js.statement(r'''
     function convertToSlowObject(properties) {
       // Add and remove a property to make the object transition into hashmap
       // mode.
       properties.__MAGIC_SLOW_PROPERTY = 1;
       delete properties.__MAGIC_SLOW_PROPERTY;
       return properties;
@@ skipping 234 matching lines @@
                    + String(Object.getOwnPropertyNames(C).length)
                    + ", fast properties " + HasFastProperties(C));
             var names = Object.getOwnPropertyNames($);
             for (var i = 0; i < names.length; i++) {
               print("$." + names[i]);
             }
           }
        '''));
 
       for (String object in Namer.userGlobalObjects) {
-        parts.add(js.statement(
-            '''
+        parts.add(js.statement('''
           if (typeof print === "function") {
             print("Size of " + #objectString + ": "
                   + String(Object.getOwnPropertyNames(#object).length)
                   + ", fast properties " + HasFastProperties(#object));
           }
-        ''',
-            {"object": object, "objectString": js.string(object)}));
+        ''', {"object": object, "objectString": js.string(object)}));
       }
     }
 
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildMangledNames() {
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     if (!mangledFieldNames.isEmpty) {
@@ skipping 112 matching lines @@
       // contain typedefs that are used for reflection.
       for (LibraryEntity element in remainingLibraries) {
         parts.add(generateLibraryDescriptor(element, mainFragment));
         descriptors.remove(element);
       }
     }
     jsAst.ArrayInitializer descriptorsAst = new jsAst.ArrayInitializer(parts);
 
     // Using a named function here produces easier to read stack traces in
     // Chrome/V8.
-    statements.add(js.statement(
-        """
+    statements.add(js.statement("""
     (function() {
        // No renaming in the top-level function to save the locals for the
        // nested context where they will be used more. We have to put the
        // comment into a hole as the parser strips out comments right away.
        #disableVariableRenaming;
        #supportsDirectProtoAccess;
 
        if (#isProgramSplit) {
          /// We collect all the global state, so it can be passed to the
          /// initializer of deferred files.
@@ skipping 76 matching lines @@
        #convertToFastObject;
        #convertToSlowObject;
 
        #convertGlobalObjectsToFastObjects;
        #debugFastObjects;
 
        #init;
 
        #main;
     })();
-    """,
-        {
-          "disableVariableRenaming": js.comment("/* ::norenaming:: */"),
-          "isProgramSplit": isProgramSplit,
-          "supportsDirectProtoAccess": buildSupportsDirectProtoAccess(),
-          "globalsHolder": globalsHolder,
-          "globalObjectSetup": buildGlobalObjectSetup(isProgramSplit),
-          "isolateName": namer.isolateName,
-          "isolatePropertiesName": js(isolatePropertiesName),
-          "initName": initName,
-          "functionThatReturnsNull": buildFunctionThatReturnsNull(),
-          "mangledNames": buildMangledNames(),
-          "setupProgram": buildSetupProgram(
-              program, compiler, backend, namer, this, _closedWorld),
-          "setupProgramName": setupProgramName,
-          "descriptors": descriptorsAst,
-          "cspPrecompiledFunctions":
-              buildCspPrecompiledFunctionFor(mainOutputUnit),
-          "getInterceptorMethods":
-              interceptorEmitter.buildGetInterceptorMethods(),
-          "oneShotInterceptors": interceptorEmitter.buildOneShotInterceptors(),
-          "makeConstantList":
-              buildMakeConstantList(program.outputContainsConstantList),
-          "compileTimeConstants": buildCompileTimeConstants(
-              mainFragment.constants,
-              isMainFragment: true),
-          "deferredBoilerPlate": buildDeferredBoilerPlate(deferredLoadHashes),
-          "staticNonFinalInitializers":
-              buildStaticNonFinalFieldInitializations(mainOutputUnit),
-          "typeToInterceptorMap":
-              interceptorEmitter.buildTypeToInterceptorMap(program),
-          "lazyStaticFields": buildLazilyInitializedStaticFields(
-              mainFragment.staticLazilyInitializedFields),
-          "metadata": buildMetadata(program, mainOutputUnit),
-          "convertToFastObject": buildConvertToFastObjectFunction(),
-          "convertToSlowObject": buildConvertToSlowObjectFunction(),
-          "convertGlobalObjectsToFastObjects":
-              buildConvertGlobalObjectToFastObjects(),
-          "debugFastObjects": buildDebugFastObjectCode(),
-          "init": buildInitFunction(program.outputContainsConstantList),
-          "main": buildMain(mainFragment.invokeMain)
-        }));
+    """, {
+      "disableVariableRenaming": js.comment("/* ::norenaming:: */"),
+      "isProgramSplit": isProgramSplit,
+      "supportsDirectProtoAccess": buildSupportsDirectProtoAccess(),
+      "globalsHolder": globalsHolder,
+      "globalObjectSetup": buildGlobalObjectSetup(isProgramSplit),
+      "isolateName": namer.isolateName,
+      "isolatePropertiesName": js(isolatePropertiesName),
+      "initName": initName,
+      "functionThatReturnsNull": buildFunctionThatReturnsNull(),
+      "mangledNames": buildMangledNames(),
+      "setupProgram": buildSetupProgram(
+          program, compiler, backend, namer, this, _closedWorld),
+      "setupProgramName": setupProgramName,
+      "descriptors": descriptorsAst,
+      "cspPrecompiledFunctions": buildCspPrecompiledFunctionFor(mainOutputUnit),
+      "getInterceptorMethods": interceptorEmitter.buildGetInterceptorMethods(),
+      "oneShotInterceptors": interceptorEmitter.buildOneShotInterceptors(),
+      "makeConstantList":
+          buildMakeConstantList(program.outputContainsConstantList),
+      "compileTimeConstants": buildCompileTimeConstants(mainFragment.constants,
+          isMainFragment: true),
+      "deferredBoilerPlate": buildDeferredBoilerPlate(deferredLoadHashes),
+      "staticNonFinalInitializers":
+          buildStaticNonFinalFieldInitializations(mainOutputUnit),
+      "typeToInterceptorMap":
+          interceptorEmitter.buildTypeToInterceptorMap(program),
+      "lazyStaticFields": buildLazilyInitializedStaticFields(
+          mainFragment.staticLazilyInitializedFields),
+      "metadata": buildMetadata(program, mainOutputUnit),
+      "convertToFastObject": buildConvertToFastObjectFunction(),
+      "convertToSlowObject": buildConvertToSlowObjectFunction(),
+      "convertGlobalObjectsToFastObjects":
+          buildConvertGlobalObjectToFastObjects(),
+      "debugFastObjects": buildDebugFastObjectCode(),
+      "init": buildInitFunction(program.outputContainsConstantList),
+      "main": buildMain(mainFragment.invokeMain)
+    }));
 
     return new jsAst.Program(statements);
   }
 
   void emitMainOutputUnit(OutputUnit mainOutputUnit, jsAst.Program program) {
     LocationCollector locationCollector;
     List<CodeOutputListener> codeOutputListeners;
     if (generateSourceMap) {
       locationCollector = new LocationCollector();
       codeOutputListeners = <CodeOutputListener>[locationCollector];
@@ skipping 154 matching lines @@
         .putIfAbsent(owner, () {
       return new ClassBuilder.forLibrary(owner, namer);
     });
   }
 
   /// Emits support-code for deferred loading into [output].
   jsAst.Statement buildDeferredBoilerPlate(
       Map<OutputUnit, _DeferredOutputUnitHash> deferredLoadHashes) {
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
-    parts.add(js.statement(
-        '''
+    parts.add(js.statement('''
         {
           // Function for checking if a hunk is loaded given its hash.
           #isHunkLoaded = function(hunkHash) {
             return !!$deferredInitializers[hunkHash];
           };
           #deferredInitialized = new Object(null);
           // Function for checking if a hunk is initialized given its hash.
           #isHunkInitialized = function(hunkHash) {
             return #deferredInitialized[hunkHash];
           };
           // Function for initializing a loaded hunk, given its hash.
           #initializeLoadedHunk = function(hunkHash) {
             $deferredInitializers[hunkHash](
             #globalsHolder, ${namer.staticStateHolder});
             #deferredInitialized[hunkHash] = true;
           };
         }
-        ''',
-        {
-          "globalsHolder": globalsHolder,
-          "isHunkLoaded":
-              generateEmbeddedGlobalAccess(embeddedNames.IS_HUNK_LOADED),
-          "isHunkInitialized":
-              generateEmbeddedGlobalAccess(embeddedNames.IS_HUNK_INITIALIZED),
-          "initializeLoadedHunk": generateEmbeddedGlobalAccess(
-              embeddedNames.INITIALIZE_LOADED_HUNK),
-          "deferredInitialized":
-              generateEmbeddedGlobalAccess(embeddedNames.DEFERRED_INITIALIZED)
-        }));
+        ''', {
+      "globalsHolder": globalsHolder,
+      "isHunkLoaded":
+          generateEmbeddedGlobalAccess(embeddedNames.IS_HUNK_LOADED),
+      "isHunkInitialized":
+          generateEmbeddedGlobalAccess(embeddedNames.IS_HUNK_INITIALIZED),
+      "initializeLoadedHunk":
+          generateEmbeddedGlobalAccess(embeddedNames.INITIALIZE_LOADED_HUNK),
+      "deferredInitialized":
+          generateEmbeddedGlobalAccess(embeddedNames.DEFERRED_INITIALIZED)
+    }));
 
     // Write a javascript mapping from Deferred import load ids (derrived
     // from the import prefix.) to a list of lists of uris of hunks to load,
     // and a corresponding mapping to a list of hashes used by
     // INITIALIZE_LOADED_HUNK and IS_HUNK_LOADED.
     Map<String, List<jsAst.LiteralString>> deferredLibraryUris =
         new Map<String, List<jsAst.LiteralString>>();
     Map<String, List<_DeferredOutputUnitHash>> deferredLibraryHashes =
         new Map<String, List<_DeferredOutputUnitHash>>();
     compiler.deferredLoadTask.hunksToLoad
@@ skipping 201 matching lines @@
     // data.
     mapping["_comment"] = "This mapping shows which compiled `.js` files are "
         "needed for a given deferred library import.";
     mapping.addAll(compiler.deferredLoadTask.computeDeferredMap());
     compiler.outputProvider(
         compiler.options.deferredMapUri.path, '', OutputType.info)
       ..add(const JsonEncoder.withIndent("  ").convert(mapping))
       ..close();
   }
 }