dart2js: Use frequency of occurence to sort metadata indices.

pkg/compiler/lib/src/js_emitter/old_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.
 
 part of dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 663 matching lines @@
            js.string(namer.globalPropertyName(element)),
            js.string(namer.lazyInitializerName(element)),
            code,
            js.string(element.name)]);
     }
   }
 
   jsAst.Statement buildMetadata(Program program, OutputUnit outputUnit) {
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
-    jsAst.Expression constructList(List<jsAst.Expression> list) {
-      return new jsAst.ArrayInitializer(list == null ? [] : list);
-    }
-
-    List<jsAst.Expression> types = program.metadataTypes[outputUnit];
+    jsAst.Expression types = program.metadataTypesForOutputUnit(outputUnit);
 
     if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) {
       jsAst.Expression metadataAccess =
           generateEmbeddedGlobalAccess(embeddedNames.METADATA);
       jsAst.Expression typesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.TYPES);
 
-      parts..add(js.statement('# = #;', [metadataAccess,
-                                         constructList(program.metadata)]))
-           ..add(js.statement('# = #;', [typesAccess, constructList(types)]));
+      parts..add(js.statement('# = #;', [metadataAccess, program.metadata]))
+           ..add(js.statement('# = #;', [typesAccess, types]));
     } else if (types != null) {
       parts.add(js.statement('var ${namer.deferredTypesName} = #;',
-                             constructList(types)));
+                             types));
     }
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildCompileTimeConstants(List<Constant> constants,
                                            {bool isMainFragment}) {
     assert(isMainFragment != null);
 
     if (constants.isEmpty) return js.comment("No constants in program.");
     List<jsAst.Statement> parts = <jsAst.Statement>[];
@@ skipping 356 matching lines @@
 
     // Emit all required typedef declarations into the main output unit.
     // TODO(karlklose): unify required classes and typedefs to declarations
     // and have builders for each kind.
     for (TypedefElement typedef in typedefsNeededForReflection) {
       LibraryElement library = typedef.library;
       // TODO(karlklose): add a TypedefBuilder and move this code there.
       DartType type = typedef.alias;
       // TODO(zarah): reify type variables once reflection on type arguments of
       // typedefs is supported.
-      int typeIndex =
+      jsAst.Expression typeIndex =
           task.metadataCollector.reifyType(type, ignoreTypeVariables: true);
       ClassBuilder builder = new ClassBuilder(typedef, namer);
-      builder.addProperty(embeddedNames.TYPEDEF_TYPE_PROPERTY_NAME,
-                          js.number(typeIndex));
+      builder.addProperty(embeddedNames.TYPEDEF_TYPE_PROPERTY_NAME, typeIndex);
       builder.addProperty(embeddedNames.TYPEDEF_PREDICATE_PROPERTY_NAME,
                           js.boolean(true));
 
       // We can be pretty sure that the objectClass is initialized, since
       // typedefs are only emitted with reflection, which requires lots of
       // classes.
       assert(compiler.objectClass != null);
       builder.superName = namer.className(compiler.objectClass);
       jsAst.Node declaration = builder.toObjectInitializer();
       String mangledName = namer.globalPropertyName(typedef);
@@ skipping 166 matching lines @@
 
   void assembleProgram(Program program) {
     for (Fragment fragment in program.fragments) {
       for (Library library in fragment.libraries) {
         assembleLibrary(library, fragment);
       }
     }
     assembleTypedefs(program);
   }
 
-  void emitMainOutputUnit(Program program,
-                          Map<OutputUnit, String> deferredLoadHashes) {
-    MainFragment mainFragment = program.fragments.first;
+  jsAst.Program buildOutputAstForMain(Program program,
+      Map<OutputUnit, _DeferredOutputUnitHash> deferredLoadHashes) {
+    MainFragment mainFragment = program.mainFragment;
     OutputUnit mainOutputUnit = mainFragment.outputUnit;
-
-    LineColumnCollector lineColumnCollector;
-    List<CodeOutputListener> codeOutputListeners;
-    if (generateSourceMap) {
-      lineColumnCollector = new LineColumnCollector();
-      codeOutputListeners = <CodeOutputListener>[lineColumnCollector];
-    }
-
-    CodeOutput mainOutput =
-        new StreamCodeOutput(compiler.outputProvider('', 'js'),
-                             codeOutputListeners);
-    outputBuffers[mainOutputUnit] = mainOutput;
-
     bool isProgramSplit = program.isSplit;
 
     List<jsAst.Statement> statements = <jsAst.Statement>[];
 
     statements..add(buildGeneratedBy())
               ..add(js.comment(HOOKS_API_USAGE));
 
     if (isProgramSplit) {
       /// For deferred loading we communicate the initializers via this global
       /// variable. The deferred hunks will add their initialization to this.
@@ skipping 184 matching lines @@
       "metadata": buildMetadata(program, mainOutputUnit),
       "convertToFastObject": buildConvertToFastObjectFunction(),
       "convertToSlowObject": buildConvertToSlowObjectFunction(),
       "convertGlobalObjectsToFastObjects":
           buildConvertGlobalObjectToFastObjects(),
       "debugFastObjects": buildDebugFastObjectCode(),
       "init": buildInitFunction(),
       "main": buildMain(mainFragment.invokeMain)
     }));
 
-    mainOutput.addBuffer(jsAst.prettyPrint(new jsAst.Program(statements),
+    return new jsAst.Program(statements);
+  }
+
+  void emitMainOutputUnit(OutputUnit mainOutputUnit, jsAst.Program program) {
+    LineColumnCollector lineColumnCollector;
+    List<CodeOutputListener> codeOutputListeners;
+    if (generateSourceMap) {
+      lineColumnCollector = new LineColumnCollector();
+      codeOutputListeners = <CodeOutputListener>[lineColumnCollector];
+    }
+
+    CodeOutput mainOutput =
+        new StreamCodeOutput(compiler.outputProvider('', 'js'),
+                             codeOutputListeners);
+    outputBuffers[mainOutputUnit] = mainOutput;
+
+
+    mainOutput.addBuffer(jsAst.prettyPrint(program,
                                            compiler,
                                            monitor: compiler.dumpInfoTask));
 
     if (compiler.deferredMapUri != null) {
       outputDeferredMap();
     }
 
     if (generateSourceMap) {
       mainOutput.add(
           generateSourceMapTag(compiler.sourceMapUri, compiler.outputUri));
@@ skipping 146 matching lines @@
           descriptors.remove(library);
         }
 
         outputs[outputUnit] = new jsAst.ArrayInitializer(parts);
       }
     }
 
     return outputs;
   }
 
+  void finalizeTokensInAst(jsAst.Program main,
+                           Iterable<jsAst.Program> deferredParts) {
+    task.metadataCollector.countTokensInProgram(main);
+    deferredParts.forEach(task.metadataCollector.countTokensInProgram);
+    task.metadataCollector.finalizeTokens();
+  }
+
   int emitProgram(ProgramBuilder programBuilder) {
     Program program = programBuilder.buildProgram(
         storeFunctionTypesInMetadata: true);
 
     assembleProgram(program);
 
     // Construct the ASTs for all deferred output units.
     Map<OutputUnit, jsAst.Program> deferredParts =
         buildOutputAstForDeferredCode(program);
 
+    Map<OutputUnit, _DeferredOutputUnitHash> deferredHashTokens =
+        new Map<OutputUnit, _DeferredOutputUnitHash>.fromIterables(
+          deferredParts.keys,
+          deferredParts.keys.map((OutputUnit unit) {
+            return new _DeferredOutputUnitHash(unit);
+          })
+        );
+
+    jsAst.Program mainOutput =
+        buildOutputAstForMain(program, deferredHashTokens);
+
+    finalizeTokensInAst(mainOutput, deferredParts.values);
+
     // Emit deferred units first, so we have their hashes.
     // Map from OutputUnit to a hash of its content. The hash uniquely
     // identifies the code of the output-unit. It does not include
     // boilerplate JS code, like the sourcemap directives or the hash
     // itself.
     Map<OutputUnit, String> deferredLoadHashes =
         emitDeferredOutputUnits(deferredParts);
-    emitMainOutputUnit(program, deferredLoadHashes);
+
+    deferredHashTokens.forEach((OutputUnit key, _DeferredOutputUnitHash token) {
+      token.setHash(deferredLoadHashes[key]);
+    });
+    emitMainOutputUnit(program.mainFragment.outputUnit, mainOutput);
 
     if (backend.requiresPreamble &&
         !backend.htmlLibraryIsLoaded) {
       compiler.reportHint(NO_LOCATION_SPANNABLE, MessageKind.PREAMBLE);
     }
     // Return the total program size.
     return outputBuffers.values.fold(0, (a, b) => a + b.length);
   }
 
   String generateSourceMapTag(Uri sourceMapUri, Uri fileUri) {
@@ skipping 25 matching lines @@
     if (owner == null) {
       compiler.internalError(element, 'Owner is null.');
     }
     return elementDescriptors
         .putIfAbsent(fragment, () => new Map<Element, ClassBuilder>())
         .putIfAbsent(owner, () => new ClassBuilder(owner, namer));
   }
 
   /// Emits support-code for deferred loading into [output].
   jsAst.Statement buildDeferredBoilerPlate(
-      Map<OutputUnit, String> deferredLoadHashes) {
+      Map<OutputUnit, _DeferredOutputUnitHash> deferredLoadHashes) {
     List<jsAst.Statement> parts = <jsAst.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.
@@ skipping 13 matching lines @@
                   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<String>> deferredLibraryUris =
-        new Map<String, List<String>>();
-    Map<String, List<String>> deferredLibraryHashes =
-        new Map<String, List<String>>();
+    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.forEach(
                   (String loadId, List<OutputUnit>outputUnits) {
-      List<String> uris = new List<String>();
-      List<String> hashes = new List<String>();
-      deferredLibraryHashes[loadId] = new List<String>();
+      List<jsAst.LiteralString> uris = new List<jsAst.LiteralString>();
+      List<_DeferredOutputUnitHash> hashes =
+          new List<_DeferredOutputUnitHash>();
+      deferredLibraryHashes[loadId] = new List<_DeferredOutputUnitHash>();
       for (OutputUnit outputUnit in outputUnits) {
-        uris.add(backend.deferredPartFileName(outputUnit.name));
+        uris.add(js.escapedString(
+            backend.deferredPartFileName(outputUnit.name)));
         hashes.add(deferredLoadHashes[outputUnit]);
       }
 
       deferredLibraryUris[loadId] = uris;
       deferredLibraryHashes[loadId] = hashes;
     });
 
-    void emitMapping(String name, Map<String, List<String>> mapping) {
+    void emitMapping(String name, Map<String, List<jsAst.Expression>> mapping) {
       List<jsAst.Property> properties = new List<jsAst.Property>();
-      mapping.forEach((String key, List<String> values) {
+      mapping.forEach((String key, List<jsAst.Expression> values) {
         properties.add(new jsAst.Property(js.escapedString(key),
-            new jsAst.ArrayInitializer(
-                values.map(js.escapedString).toList())));
+            new jsAst.ArrayInitializer(values)));
       });
       jsAst.Node initializer =
           new jsAst.ObjectInitializer(properties, isOneLiner: true);
 
       jsAst.Node globalName = generateEmbeddedGlobalAccess(name);
       parts.add(js.statement("# = #", [globalName, initializer]));
     }
 
     emitMapping(embeddedNames.DEFERRED_LIBRARY_URIS, deferredLibraryUris);
     emitMapping(embeddedNames.DEFERRED_LIBRARY_HASHES,
@@ skipping 38 matching lines @@
         // in stack traces and profile entries.
         body.add(js.statement('var dart = #', libraryDescriptor));
 
         if (compiler.useContentSecurityPolicy) {
           body.add(buildCspPrecompiledFunctionFor(outputUnit));
         }
         body.add(
             js.statement('$setupProgramName(dart, ${typesAccess}.length);'));
       }
 
-      if (task.metadataCollector.types[outputUnit] != null) {
-        body..add(buildMetadata(program, outputUnit))
-            ..add(js.statement('${typesAccess}.push.apply(${typesAccess}, '
-                               '${namer.deferredTypesName});'));
-      }
+      body..add(buildMetadata(program, outputUnit))
+          ..add(js.statement('${typesAccess}.push.apply(${typesAccess}, '
+                             '${namer.deferredTypesName});'));
 
       // Set the currentIsolate variable to the current isolate (which is
       // provided as second argument).
       body.add(js.statement("${namer.currentIsolate} = arguments[1];"));
 
       body.add(buildCompileTimeConstants(fragment.constants,
                                          isMainFragment: false));
       body.add(buildStaticNonFinalFieldInitializations(outputUnit));
 
       List<jsAst.Statement> statements = <jsAst.Statement>[];
@@ skipping 129 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }