dart2js: Use an abstract Name class for names in the generated JavaScript ast.

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 42 matching lines @@
   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 visitName(Name 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 80 matching lines @@
 
   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 visitName(Name node) => visitNode(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 393 matching lines @@
 abstract class Expression extends Node {
   int get precedenceLevel;
 
   Statement toStatement() => new ExpressionStatement(this);
 }
 
 abstract class Declaration implements VariableReference {
 
 }
 
+/// An implementation of [Name] represents a potentially late bound name in
+/// the generated ast.
+///
+/// While [Name] implements comparable, there is no requirement on the actual
+/// implementation of [compareTo] other than that it needs to be stable.
+/// In particular, there is no guarantee that implementations of [compareTo]
+/// will implement some form of lexicographic ordering like [String.compareTo].
+abstract class Name extends Literal
+    implements Declaration, Parameter, Comparable {
+  accept(NodeVisitor visitor) => visitor.visitName(this);
+
+  bool get allowRename => false;
+}
+
+class LiteralStringFromName extends LiteralString {
+  Name name;
+
+  LiteralStringFromName(this.name) : super(null);
+
+  String get value => '"${name.name}"';
+}
+
 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 661 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) {}
 }