dart2js: Use frequency of occurence to sort metadata indices.

pkg/js_ast/lib/src/nodes.dart

 // Copyright (c) 2012, 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 js_ast;
 
 abstract class NodeVisitor<T> {
   T visitProgram(Program node);
 
   T visitBlock(Block node);
@@ skipping 31 matching lines @@
 
   T visitVariableUse(VariableUse node);
   T visitThis(This node);
   T visitVariableDeclaration(VariableDeclaration node);
   T visitParameter(Parameter node);
   T visitAccess(PropertyAccess node);
 
   T visitNamedFunction(NamedFunction node);
   T visitFun(Fun node);
 
+  T visitTokenExpression(TokenExpression node);
+  T visitTokenNumber(TokenNumber node);
+  T visitTokenString(TokenString node);
+
   T visitLiteralBool(LiteralBool node);
   T visitLiteralString(LiteralString node);
   T visitLiteralNumber(LiteralNumber node);
   T visitLiteralNull(LiteralNull node);
 
+  T visitStringConcatenation(StringConcatenation node);
+
   T visitArrayInitializer(ArrayInitializer node);
   T visitArrayHole(ArrayHole node);
   T visitObjectInitializer(ObjectInitializer node);
   T visitProperty(Property node);
   T visitRegExpLiteral(RegExpLiteral node);
 
   T visitAwait(Await node);
 
   T visitComment(Comment node);
 
@@ skipping 65 matching lines @@
 
   T visitVariableUse(VariableUse node) => visitVariableReference(node);
   T visitVariableDeclaration(VariableDeclaration node)
       => visitVariableReference(node);
   T visitParameter(Parameter node) => visitVariableDeclaration(node);
   T visitThis(This node) => visitParameter(node);
 
   T visitNamedFunction(NamedFunction node) => visitExpression(node);
   T visitFun(Fun node) => visitExpression(node);
 
+  T visitToken(Token node) => visitExpression(node);
+
+  T visitTokenExpression(TokenExpression node) => visitExpression(node);
+  T visitTokenNumber(TokenNumber node) => visitToken(node);
+  T visitTokenString(TokenString node) => visitToken(node);
+
   T visitLiteral(Literal node) => visitExpression(node);
 
   T visitLiteralBool(LiteralBool node) => visitLiteral(node);
   T visitLiteralString(LiteralString node) => visitLiteral(node);
   T visitLiteralNumber(LiteralNumber node) => visitLiteral(node);
   T visitLiteralNull(LiteralNull node) => visitLiteral(node);
 
+  T visitStringConcatenation(StringConcatenation node) => visitLiteral(node);
+
   T visitArrayInitializer(ArrayInitializer node) => visitExpression(node);
   T visitArrayHole(ArrayHole node) => visitExpression(node);
   T visitObjectInitializer(ObjectInitializer node) => visitExpression(node);
   T visitProperty(Property node) => visitNode(node);
   T visitRegExpLiteral(RegExpLiteral node) => visitExpression(node);
 
   T visitInterpolatedNode(InterpolatedNode node) => visitNode(node);
 
   T visitInterpolatedExpression(InterpolatedExpression node)
       => visitInterpolatedNode(node);
@@ skipping 750 matching lines @@
   void visitChildren(NodeVisitor visitor) {
     receiver.accept(visitor);
     selector.accept(visitor);
   }
 
   PropertyAccess _clone() => new PropertyAccess(receiver, selector);
 
   int get precedenceLevel => CALL;
 }
 
+abstract class Token extends Literal {

[sra1, 2015/05/27 19:38:51]

These are abstract classes that are overridden.
Describe how they should be used.

I think 'DeferredToken' and 'DeferredNumberToken' etc would be a better names. 
'Late' would be an acceptable synonym for 'Deferred'

[herhut, 2015/06/09 11:10:00]

Well, this is only one use (the current use) of the Token interface. Once could
also use it to insert a blob into the AST without telling what it really is.
Just as an example. But I am fine with the renaming if you want to narrow the
scope.

+  void visitChildren(NodeVisitor visitor) {}
+
+  Token _clone() => this;
+}
+
+abstract class TokenNumber extends Token {
+  accept(NodeVisitor visitor) => visitor.visitTokenNumber(this);
+
+  int get value;
+}
+
+abstract class TokenString extends Token {
+  accept(NodeVisitor visitor) => visitor.visitTokenString(this);
+
+  String get value;
+}
+
+abstract class TokenExpression extends Token {

[sra1, 2015/05/27 19:38:51]

What is a TokenExpression?
DeferredExpression?

[herhut, 2015/06/09 11:10:00]

Done.

+  accept(NodeVisitor visitor) => visitor.visitTokenExpression(this);
+
+  Expression get value;

[sra1, 2015/05/27 19:38:51]

What is the precedence?
PRIMARY is almost certainly wrong.

[herhut, 2015/06/09 11:10:00]

It actually was correct for the current usage but I have changed Token to extend
Expression, so now any class that implements TokenExpression will have to supply
a precedence.

+}
+
 abstract class Literal extends Expression {
   void visitChildren(NodeVisitor visitor) {}
 
   int get precedenceLevel => PRIMARY;
 }
 
 class LiteralBool extends Literal {
   final bool value;
 
   LiteralBool(this.value);
@@ skipping 10 matching lines @@
   LiteralNull _clone() => new LiteralNull();
 }
 
 class LiteralString extends Literal {
   final String value;
 
   /**
    * Constructs a LiteralString from a string value.
    *
    * The constructor does not add the required quotes.  If [value] is not
-   * surrounded by quotes and property escaped, the resulting object is invalid
+   * surrounded by quotes and properly escaped, the resulting object is invalid
    * as a JS value.
    *
    * TODO(sra): Introduce variants for known valid strings that don't allocate a
    * new string just to add quotes.
    */
   LiteralString(this.value);
 
   accept(NodeVisitor visitor) => visitor.visitLiteralString(this);
   LiteralString _clone() => new LiteralString(value);
 }
 
+class StringConcatenation extends Literal {
+  final List<Literal> parts;
+
+  /**
+   * Constructs a StringConcatenation from a list of Literal elements.
+   * The constructor does not add surrounding quotes to the resulting
+   * concatenated string.
+   */
+  StringConcatenation(this.parts);
+
+  accept(NodeVisitor visitor) => visitor.visitStringConcatenation(this);
+
+  void visitChildren(NodeVisitor visitor) {
+    for (Literal part in parts) part.accept(visitor);
+  }
+
+  StringConcatenation _clone() => new StringConcatenation(this.parts);
+}
+
 class LiteralNumber extends Literal {
   final String value;  // Must be a valid JavaScript number literal.
 
   LiteralNumber(this.value);
 
   accept(NodeVisitor visitor) => visitor.visitLiteralNumber(this);
   LiteralNumber _clone() => new LiteralNumber(value);
 }
 
 class ArrayInitializer extends Expression {
@@ skipping 183 matching lines @@
 class Await extends Expression {
   /** The awaited expression. */
   final Expression expression;
 
   Await(this.expression);
 
   int get precedenceLevel => UNARY;
   accept(NodeVisitor visitor) => visitor.visitAwait(this);
   void visitChildren(NodeVisitor visitor) => expression.accept(visitor);
   Await _clone() => new Await(expression);
-
 }
 
 /**
  * A comment.
  *
  * Extends [Statement] so we can add comments before statements in
  * [Block] and [Program].
  */
 class Comment extends Statement {
   final String comment;
 
   Comment(this.comment);
 
   accept(NodeVisitor visitor) => visitor.visitComment(this);
   Comment _clone() => new Comment(comment);
 
   void visitChildren(NodeVisitor visitor) {}
 }