dart2js: Use frequency of occurence to sort metadata indices.

pkg/js_ast/lib/src/builder.dart

 // Copyright (c) 2013, 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.
 
 // Utilities for building JS ASTs at runtime.  Contains a builder class
 // and a parser that parses part of the language.
 
 part of js_ast;
 
 
@@ skipping 311 matching lines @@
   }
 
   /// Creates a literal js string from [value].
   ///
   /// Note that this function only puts quotes around [value]. It does not do
   /// any escaping, so use only when you can guarantee that [value] does not
   /// contain newlines or backslashes. For escaping the string use
   /// [escapedString].
   LiteralString string(String value) => new LiteralString('"$value"');
 
+  /// Creates an instance of [LiteralString] from [value].
+  ///
+  /// Does not add quotes or do any escaping.
+  LiteralString stringPart(String value) => new LiteralString(value);
+
+  StringConcatenation concatenateStrings(Iterable<Literal> parts,
+                                         {addQuotes: false}) {
+    List<Literal> _parts;
+    if (addQuotes) {
+      _parts = <Literal>[stringPart('"')]

[sra1, 2015/05/27 20:30:15]

This stringPart can be shared between begining and end, or over all
concatenateStrings.

[herhut, 2015/06/01 12:09:43]

I share them locally for now.

+          ..addAll(parts)
+          ..add(stringPart('"'));
+    } else {
+      _parts = new List.from(parts, growable: false);
+    }
+    return new StringConcatenation(_parts);
+  }
+
+  Iterable<Literal> joinLiterals(Iterable<Literal> list, Literal separator) {
+    return new _InterleaveIterable(list, separator);
+  }
+
   LiteralNumber number(num value) => new LiteralNumber('$value');
 
   LiteralBool boolean(bool value) => new LiteralBool(value);
 
   ArrayInitializer numArray(Iterable<int> list) =>
       new ArrayInitializer(list.map(number).toList());
 
   ArrayInitializer stringArray(Iterable<String> list) =>
       new ArrayInitializer(list.map(string).toList());
 
   Comment comment(String text) => new Comment(text);
 
   Call propertyCall(Expression receiver,
                       String fieldName,
                       List<Expression> arguments) {
     return new Call(new PropertyAccess.field(receiver, fieldName), arguments);
   }
 }
 
 LiteralString string(String value) => js.string(value);
+LiteralString stringPart(String value) => js.stringPart(value);
+Iterable<Literal> joinLiterals(Iterable<Literal> list, Literal separator) {
+  return js.joinLiterals(list, separator);
+}
 LiteralNumber number(num value) => js.number(value);
 ArrayInitializer numArray(Iterable<int> list) => js.numArray(list);
 ArrayInitializer stringArray(Iterable<String> list) => js.stringArray(list);
 Call propertyCall(Expression receiver,
                   String fieldName,
                   List<Expression> arguments) {
   return js.propertyCall(receiver, fieldName, arguments);
 }
 
 class MiniJsParserError {
@@ skipping 403 matching lines @@
           new InterpolatedExpression(nameOrPosition);
       interpolatedValues.add(expression);
       return expression;
     } else {
       error("Expected primary expression");
       return null;
     }
   }
 
   Expression parseFunctionExpression() {
-    String last = lastToken;
     if (lastCategory == ALPHA || lastCategory == HASH) {
       Declaration name = parseVariableDeclaration();
       return new NamedFunction(name, parseFun());
     }
     return parseFun();
   }
 
   Expression parseFun() {
     List<Parameter> params = <Parameter>[];
 
@@ skipping 479 matching lines @@
 
   Statement parseFunctionDeclaration() {
     Declaration name = parseVariableDeclaration();
     Expression fun = parseFun();
     return new FunctionDeclaration(name, fun);
   }
 
   Statement parseTry() {
     expectCategory(LBRACE);
     Block body = parseBlock();
-    String token = lastToken;
     Catch catchPart = null;
     if (acceptString('catch')) catchPart = parseCatch();
     Block finallyPart = null;
     if (acceptString('finally')) {
       expectCategory(LBRACE);
       finallyPart = parseBlock();
     } else {
       if (catchPart == null) error("expected 'finally'");
     }
     return new Try(body, catchPart, finallyPart);
@@ skipping 55 matching lines @@
 
   Catch parseCatch() {
     expectCategory(LPAREN);
     Declaration errorName = parseVariableDeclaration();
     expectCategory(RPAREN);
     expectCategory(LBRACE);
     Block body = parseBlock();
     return new Catch(errorName, body);
   }
 }
+
+class _InterleaveIterator implements Iterator<Node> {
+  Iterator<Node> source;
+  Node separator;
+  bool isNextSeparator = false;
+  bool isInitialized = false;
+
+  _InterleaveIterator(this.source, this.separator);
+
+  bool moveNext() {
+    if (!isInitialized) {
+      isInitialized = true;
+      return source.moveNext();
+    } else if (isNextSeparator) {
+      isNextSeparator = false;
+      return true;
+    } else {
+      return isNextSeparator = source.moveNext();
+    }
+  }
+
+  Node get current {
+    if (isNextSeparator) return separator._clone();
+    return source.current;
+  }
+}
+
+class _InterleaveIterable extends IterableBase {
+  Iterable<Node> source;
+  Node separator;
+
+  _InterleaveIterable(this.source, this.separator);
+
+  Iterator<Node> get iterator {
+    return new _InterleaveIterator(source.iterator, separator);
+  }
+}