Revert "Redo "Steps towards making dart2js JS AST templates an indepentent library.""

pkg/compiler/lib/src/js/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;
+part of js;
 
 abstract class NodeVisitor<T> {
   T visitProgram(Program node);
 
   T visitBlock(Block node);
   T visitExpressionStatement(ExpressionStatement node);
   T visitEmptyStatement(EmptyStatement node);
   T visitIf(If node);
   T visitFor(For node);
   T visitForIn(ForIn node);
   T visitWhile(While node);
   T visitDo(Do node);
   T visitContinue(Continue node);
   T visitBreak(Break node);
   T visitReturn(Return node);
   T visitThrow(Throw node);
   T visitTry(Try node);
   T visitCatch(Catch node);
   T visitSwitch(Switch node);
   T visitCase(Case node);
   T visitDefault(Default node);
   T visitFunctionDeclaration(FunctionDeclaration node);
   T visitLabeledStatement(LabeledStatement node);
   T visitLiteralStatement(LiteralStatement node);
   T visitDartYield(DartYield node);
 
+  T visitBlob(Blob node);
   T visitLiteralExpression(LiteralExpression node);
   T visitVariableDeclarationList(VariableDeclarationList node);
   T visitAssignment(Assignment node);
   T visitVariableInitialization(VariableInitialization node);
   T visitConditional(Conditional cond);
   T visitNew(New node);
   T visitCall(Call node);
   T visitBinary(Binary node);
   T visitPrefix(Prefix node);
   T visitPostfix(Postfix node);
@@ skipping 59 matching lines @@
   T visitFunctionDeclaration(FunctionDeclaration node)
       => visitStatement(node);
   T visitLabeledStatement(LabeledStatement node) => visitStatement(node);
   T visitLiteralStatement(LiteralStatement node) => visitStatement(node);
 
   T visitCatch(Catch node) => visitNode(node);
   T visitCase(Case node) => visitNode(node);
   T visitDefault(Default node) => visitNode(node);
 
   T visitExpression(Expression node) => visitNode(node);
+  T visitBlob(Blob node) => visitExpression(node);
   T visitVariableReference(VariableReference node) => visitExpression(node);
 
   T visitLiteralExpression(LiteralExpression node) => visitExpression(node);
   T visitVariableDeclarationList(VariableDeclarationList node)
       => visitExpression(node);
   T visitAssignment(Assignment node) => visitExpression(node);
   T visitVariableInitialization(VariableInitialization node) {
     if (node.value != null) {
       return visitAssignment(node);
     } else {
@@ skipping 43 matching lines @@
   T visitInterpolatedStatement(InterpolatedStatement node)
       => visitInterpolatedNode(node);
 
   // Ignore comments by default.
   T visitComment(Comment node) => null;
 
   T visitAwait(Await node) => visitExpression(node);
   T visitDartYield(DartYield node) => visitStatement(node);
 }
 
-/// This tag interface has no behaviour but must be implemented by any class
-/// that is to be stored on a [Node] as source information.
-abstract class JavaScriptNodeSourceInformation {}
+abstract class Node {
+  SourceInformation get sourceInformation => _sourceInformation;
 
-abstract class Node {
-  JavaScriptNodeSourceInformation get sourceInformation => _sourceInformation;
-
-  JavaScriptNodeSourceInformation _sourceInformation;
+  SourceInformation _sourceInformation;
 
   accept(NodeVisitor visitor);
   void visitChildren(NodeVisitor visitor);
 
   // Shallow clone of node.  Does not clone positions since the only use of this
   // private method is create a copy with a new position.
   Node _clone();
 
   // Returns a node equivalent to [this], but with new source position and end
   // source position.
-  Node withSourceInformation(
-      JavaScriptNodeSourceInformation sourceInformation) {
+  Node withSourceInformation(SourceInformation sourceInformation) {
     if (sourceInformation == _sourceInformation) {
       return this;
     }
     Node clone = _clone();
     // TODO(sra): Should existing data be 'sticky' if we try to overwrite with
     // `null`?
     clone._sourceInformation = sourceInformation;
     return clone;
   }
 
@@ skipping 314 matching lines @@
   final String code;
 
   LiteralStatement(this.code);
 
   accept(NodeVisitor visitor) => visitor.visitLiteralStatement(this);
   void visitChildren(NodeVisitor visitor) { }
 
   LiteralStatement _clone() => new LiteralStatement(code);
 }
 
-// Not a real JavaScript node, but represents the yield statement from a dart
-// program translated to JavaScript.
+// Not a real javascript node, but represents the yield statement from a dart
+// program translated to javascript.
 class DartYield extends Statement {
   final Expression expression;
 
   final bool hasStar;
 
   DartYield(this.expression, this.hasStar);
 
   accept(NodeVisitor visitor) => visitor.visitDartYield(this);
 
   void visitChildren(NodeVisitor visitor) {
     expression.accept(visitor);
   }
 
   DartYield _clone() => new DartYield(expression, hasStar);
 }
 
 abstract class Expression extends Node {
   int get precedenceLevel;
 
   Statement toStatement() => new ExpressionStatement(this);
 }
 
+/// Wrap a CodeBuffer as an expression.
+class Blob extends Expression {
+  // TODO(ahe): This class is an aid to convert everything to ASTs, remove when
+  // not needed anymore.
+
+  final CodeBuffer buffer;
+
+  Blob(this.buffer);
+
+  accept(NodeVisitor visitor) => visitor.visitBlob(this);
+
+  void visitChildren(NodeVisitor visitor) {}
+
+  Blob _clone() => new Blob(buffer);
+
+  int get precedenceLevel => PRIMARY;
+
+}
+
 class LiteralExpression extends Expression {
   final String template;
   final List<Expression> inputs;
 
   LiteralExpression(this.template) : inputs = const [];
   LiteralExpression.withData(this.template, this.inputs);
 
   accept(NodeVisitor visitor) => visitor.visitLiteralExpression(this);
 
   void visitChildren(NodeVisitor visitor) {
@@ skipping 362 matching lines @@
   accept(NodeVisitor visitor) => visitor.visitLiteralNull(this);
   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
-   * as a JS value.
-   *
-   * TODO(sra): Introduce variants for known valid strings that don't allocate a
-   * new string just to add quotes.
+   * The constructor does not add the required quotes.  If [value] is
+   * not surrounded by quotes, the resulting object is invalid as a JS
+   * value.
    */
   LiteralString(this.value);
 
   accept(NodeVisitor visitor) => visitor.visitLiteralString(this);
   LiteralString _clone() => new LiteralString(value);
 }
 
 class LiteralNumber extends Literal {
-  final String value;  // Must be a valid JavaScript number literal.
+  final String value;
 
   LiteralNumber(this.value);
 
   accept(NodeVisitor visitor) => visitor.visitLiteralNumber(this);
   LiteralNumber _clone() => new LiteralNumber(value);
 }
 
 class ArrayInitializer extends Expression {
   final List<Expression> elements;
 
@@ skipping 148 matching lines @@
   accept(NodeVisitor visitor) => visitor.visitRegExpLiteral(this);
   void visitChildren(NodeVisitor visitor) {}
   RegExpLiteral _clone() => new RegExpLiteral(pattern);
 
   int get precedenceLevel => PRIMARY;
 }
 
 /**
  * An asynchronous await.
  *
- * Not part of JavaScript. We desugar this expression before outputting.
+ * Not part of javascript. We desugar this expression before outputting.
  * Should only occur in a [Fun] with `asyncModifier` async or asyncStar.
  */
 class Await extends Expression {
   /** The awaited expression. */
   final Expression expression;
 
   Await(this.expression);
 
   int get precedenceLevel => UNARY;
   accept(NodeVisitor visitor) => visitor.visitAwait(this);
@@ skipping 11 matching lines @@
 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) {}
 }