Support for interpolated declarations in the js parser.

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;
 
 abstract class NodeVisitor<T> {
   T visitProgram(Program node);
 
   T visitBlock(Block node);
@@ skipping 51 matching lines @@
 
   T visitAwait(Await node);
 
   T visitComment(Comment node);
 
   T visitInterpolatedExpression(InterpolatedExpression node);
   T visitInterpolatedLiteral(InterpolatedLiteral node);
   T visitInterpolatedParameter(InterpolatedParameter node);
   T visitInterpolatedSelector(InterpolatedSelector node);
   T visitInterpolatedStatement(InterpolatedStatement node);
+  T visitInterpolatedDeclaration(InterpolatedDeclaration node);
 }
 
 class BaseVisitor<T> implements NodeVisitor<T> {
   T visitNode(Node node) {
     node.visitChildren(this);
     return null;
   }
 
   T visitProgram(Program node) => visitNode(node);
 
@@ skipping 74 matching lines @@
   T visitInterpolatedExpression(InterpolatedExpression node)
       => visitInterpolatedNode(node);
   T visitInterpolatedLiteral(InterpolatedLiteral node)
       => visitInterpolatedNode(node);
   T visitInterpolatedParameter(InterpolatedParameter node)
       => visitInterpolatedNode(node);
   T visitInterpolatedSelector(InterpolatedSelector node)
       => visitInterpolatedNode(node);
   T visitInterpolatedStatement(InterpolatedStatement node)
       => visitInterpolatedNode(node);
+  T visitInterpolatedDeclaration(InterpolatedDeclaration node) {
+    return 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.
@@ skipping 236 matching lines @@
   void visitChildren(NodeVisitor visitor) {
     body.accept(visitor);
     if (catchPart != null) catchPart.accept(visitor);
     if (finallyPart != null) finallyPart.accept(visitor);
   }
 
   Try _clone() => new Try(body, catchPart, finallyPart);
 }
 
 class Catch extends Node {
-  final VariableDeclaration declaration;
+  final Declaration declaration;
   final Block body;
 
   Catch(this.declaration, this.body);
 
   accept(NodeVisitor visitor) => visitor.visitCatch(this);
 
   void visitChildren(NodeVisitor visitor) {
     declaration.accept(visitor);
     body.accept(visitor);
   }
@@ skipping 44 matching lines @@
   accept(NodeVisitor visitor) => visitor.visitDefault(this);
 
   void visitChildren(NodeVisitor visitor) {
     body.accept(visitor);
   }
 
   Default _clone() => new Default(body);
 }
 
 class FunctionDeclaration extends Statement {
-  final VariableDeclaration name;
+  final Declaration name;
   final Fun function;
 
   FunctionDeclaration(this.name, this.function);
 
   accept(NodeVisitor visitor) => visitor.visitFunctionDeclaration(this);
 
   void visitChildren(NodeVisitor visitor) {
     name.accept(visitor);
     function.accept(visitor);
   }
@@ skipping 44 matching lines @@
 
   DartYield _clone() => new DartYield(expression, hasStar);
 }
 
 abstract class Expression extends Node {
   int get precedenceLevel;
 
   Statement toStatement() => new ExpressionStatement(this);
 }
 
+abstract class Declaration implements VariableReference {
+
+}
+
 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 51 matching lines @@
     leftHandSide.accept(visitor);
     if (value != null) value.accept(visitor);
   }
 
   Assignment _clone() =>
       new Assignment.compound(leftHandSide, op, value);
 }
 
 class VariableInitialization extends Assignment {
   /** [value] may be null. */
-  VariableInitialization(VariableDeclaration declaration, Expression value)
+  VariableInitialization(Declaration declaration, Expression value)
       : super(declaration, value);
 
-  VariableDeclaration get declaration => leftHandSide;
+  Declaration get declaration => leftHandSide;
 
   accept(NodeVisitor visitor) => visitor.visitVariableInitialization(this);
 
   VariableInitialization _clone() =>
       new VariableInitialization(declaration, value);
 }
 
 class Conditional extends Expression {
   final Expression condition;
   final Expression then;
@@ skipping 154 matching lines @@
   VariableUse(String name) : super(name);
 
   accept(NodeVisitor visitor) => visitor.visitVariableUse(this);
   VariableUse _clone() => new VariableUse(name);
 
   VariableUse asVariableUse() => this;
 
   toString() => 'VariableUse($name)';
 }
 
-class VariableDeclaration extends VariableReference {
+class VariableDeclaration extends VariableReference implements Declaration {
   final bool allowRename;
   VariableDeclaration(String name, {this.allowRename: true}) : super(name);
 
   accept(NodeVisitor visitor) => visitor.visitVariableDeclaration(this);
   VariableDeclaration _clone() => new VariableDeclaration(name);
 }
 
 class Parameter extends VariableDeclaration {
   Parameter(String name) : super(name);
 
   accept(NodeVisitor visitor) => visitor.visitParameter(this);
   Parameter _clone() => new Parameter(name);
 }
 
 class This extends Parameter {
   This() : super("this");
 
   accept(NodeVisitor visitor) => visitor.visitThis(this);
   This _clone() => new This();
 }
 
 class NamedFunction extends Expression {
-  final VariableDeclaration name;
+  final Declaration name;
   final Fun function;
 
   NamedFunction(this.name, this.function);
 
   accept(NodeVisitor visitor) => visitor.visitNamedFunction(this);
 
   void visitChildren(NodeVisitor visitor) {
     name.accept(visitor);
     function.accept(visitor);
   }
@@ skipping 251 matching lines @@
 class InterpolatedStatement extends Statement with InterpolatedNode {
   final nameOrPosition;
 
   InterpolatedStatement(this.nameOrPosition);
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedStatement(this);
   void visitChildren(NodeVisitor visitor) {}
   InterpolatedStatement _clone() => new InterpolatedStatement(nameOrPosition);
 }
 
+class InterpolatedDeclaration extends Expression
+                              with InterpolatedNode
+                              implements Declaration {
+  final nameOrPosition;
+
+  InterpolatedDeclaration(this.nameOrPosition);
+
+  accept(NodeVisitor visitor) => visitor.visitInterpolatedDeclaration(this);
+  void visitChildren(NodeVisitor visitor) {}
+  InterpolatedDeclaration _clone() {
+    return new InterpolatedDeclaration(nameOrPosition);
+  }
+
+  @override
+  String get name => throw "No name for the interpolated node";
+
+  @override
+  int get precedenceLevel => PRIMARY;
+}
+
 /**
  * [RegExpLiteral]s, despite being called "Literal", do not inherit from
  * [Literal]. Indeed, regular expressions in JavaScript have a side-effect and
  * are thus not in the same category as numbers or strings.
  */
 class RegExpLiteral extends Expression {
   /** Contains the pattern and the flags.*/
   final String pattern;
 
   RegExpLiteral(this.pattern);
@@ skipping 33 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) {}
 }