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 visitDeferredExpression(DeferredExpression node);
+  T visitDeferredNumber(DeferredNumber node);
+  T visitDeferredString(DeferredString 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(DeferredToken node) => visitExpression(node);
+
+  T visitDeferredExpression(DeferredExpression node) => visitExpression(node);
+  T visitDeferredNumber(DeferredNumber node) => visitToken(node);
+  T visitDeferredString(DeferredString 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 509 matching lines @@
 
   Call(this.target, this.arguments,
        {JavaScriptNodeSourceInformation sourceInformation}) {
     this._sourceInformation = sourceInformation;
   }
 
   accept(NodeVisitor visitor) => visitor.visitCall(this);
 
   void visitChildren(NodeVisitor visitor) {
     target.accept(visitor);
-    for (Expression arg in arguments) arg.accept(visitor);
+    for (Expression arg in arguments) {
+      arg.accept(visitor);
+    }
   }
 
   Call _clone() => new Call(target, arguments);
 
   int get precedenceLevel => CALL;
 }
 
 class New extends Call {
   New(Expression cls, List<Expression> arguments) : super(cls, arguments);
 
@@ skipping 220 matching lines @@
   void visitChildren(NodeVisitor visitor) {
     receiver.accept(visitor);
     selector.accept(visitor);
   }
 
   PropertyAccess _clone() => new PropertyAccess(receiver, selector);
 
   int get precedenceLevel => CALL;
 }
 
+/// A [DeferredToken] is a placeholder for some [Expression] that is not known
+/// at construction time of an ast. Other than [InterpolatedExpression],

[sra1, 2015/06/10 19:30:00]

'Other than' -> 'Unlike' ?

[herhut, 2015/06/11 08:03:55]

Done.

+/// [DeferredToken] is not limited to templates but may also occur in
+/// fully instantiated asts.
+abstract class DeferredToken extends Expression {
+  void visitChildren(NodeVisitor visitor) {}
+
+  DeferredToken _clone() => this;
+}
+
+/// Interace for a deferred integer value. An implementation has to provide
+/// a value via the [value] getter the latest when the ast is printed.
+abstract class DeferredNumber extends DeferredToken implements Literal {
+  accept(NodeVisitor visitor) => visitor.visitDeferredNumber(this);
+
+  int get value;
+
+  int get precedenceLevel => PRIMARY;
+}
+
+/// Interace for a deferred string value. An implementation has to provide
+/// a value via the [value] getter the latest when the ast is printed.
+abstract class DeferredString extends DeferredToken implements Literal {
+  accept(NodeVisitor visitor) => visitor.visitDeferredString(this);
+
+  String get value;
+
+  int get precedenceLevel => PRIMARY;
+}
+
+/// Interace for a deferred [Expression] value. An implementation has to provide
+/// a value via the [value] getter the latest when the ast is printed.
+/// Also, [precedenceLevel] has to return the same value that
+/// [value.precedenceLevel] returns once [value] is bound to an [Expression].
+abstract class DeferredExpression extends DeferredToken {
+  accept(NodeVisitor visitor) => visitor.visitDeferredExpression(this);
+
+  Expression get value;
+}
+
 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) {}
 }