Revert "JS templates"

sdk/lib/_internal/compiler/implementation/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;
 
 abstract class NodeVisitor<T> {
   T visitProgram(Program node);
 
   T visitBlock(Block node);
@@ skipping 46 matching lines @@
 
   T visitArrayInitializer(ArrayInitializer node);
   T visitArrayElement(ArrayElement node);
   T visitObjectInitializer(ObjectInitializer node);
   T visitProperty(Property node);
   T visitRegExpLiteral(RegExpLiteral 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 visitJSExpression(JSExpression node);
 }
 
 class BaseVisitor<T> implements NodeVisitor<T> {
   T visitNode(Node node) {
     node.visitChildren(this);
     return null;
   }
 
   T visitProgram(Program node) => visitNode(node);
 
@@ skipping 64 matching lines @@
   T visitLiteralString(LiteralString node) => visitLiteral(node);
   T visitLiteralNumber(LiteralNumber node) => visitLiteral(node);
   T visitLiteralNull(LiteralNull node) => visitLiteral(node);
 
   T visitArrayInitializer(ArrayInitializer node) => visitExpression(node);
   T visitArrayElement(ArrayElement node) => visitNode(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);
-  T visitInterpolatedLiteral(InterpolatedLiteral node)
-      => visitInterpolatedNode(node);
-  T visitInterpolatedParameter(InterpolatedParameter node)
-      => visitInterpolatedNode(node);
-  T visitInterpolatedSelector(InterpolatedSelector node)
-      => visitInterpolatedNode(node);
+      => visitExpression(node);
   T visitInterpolatedStatement(InterpolatedStatement node)
-      => visitInterpolatedNode(node);
+      => visitStatement(node);
+  T visitJSExpression(JSExpression node) => visitExpression(node);
 
   // Ignore comments by default.
   T visitComment(Comment node) => null;
 }
 
 abstract class Node {
   var sourcePosition;
   var endSourcePosition;
 
   accept(NodeVisitor visitor);
@@ skipping 279 matching lines @@
 
   LiteralStatement(this.code);
 
   accept(NodeVisitor visitor) => visitor.visitLiteralStatement(this);
   void visitChildren(NodeVisitor visitor) { }
 }
 
 abstract class Expression extends Node {
   int get precedenceLevel;
 
+  Call callWith(List<Expression> arguments) => new Call(this, arguments);
+
+  PropertyAccess operator [](expression) {
+    if (expression is Expression) {
+      return new PropertyAccess(this, expression);
+    } else if (expression is int) {
+      return new PropertyAccess.indexed(this, expression);
+    } else if (expression is String) {
+      return new PropertyAccess.field(this, expression);
+    } else {
+      throw new ArgumentError('Expected an int, String, or Expression');
+    }
+  }
+
   Statement toStatement() => new ExpressionStatement(this);
+
+  Call call([expression]) {
+    List<Expression> arguments;
+    if (expression == null) {
+      arguments = <Expression>[];
+    } else if (expression is List) {
+      arguments = expression.map(js.toExpression).toList();
+    } else {
+      arguments = <Expression>[js.toExpression(expression)];
+    }
+    return callWith(arguments);
+  }
+
+  Expression operator +(expression) => binary('+', expression);
+
+  Expression operator -(expression) => binary('-', expression);
+
+  Expression operator &(expression) => binary('&', expression);
+
+  Expression operator <(expression) => binary('<', expression);
+
+  Expression operator >(expression) => binary('>', expression);
+
+  Expression operator >=(expression) => binary('>=', expression);
+
+  Expression binary(String operator, expression) {
+    return new Binary(operator, this, js.toExpression(expression));
+  }
+
+  Expression update(String operator, expression) {
+    return new Assignment.compound(this, operator, js.toExpression(expression));
+  }
+
+  Expression get plusPlus => new Postfix('++', this);
+
+  Prefix get typeof => new Prefix('typeof', this);
+
+  Prefix get not => new Prefix('!', 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 leg.CodeBuffer buffer;
 
   Blob(this.buffer);
@@ skipping 426 matching lines @@
 
   accept(NodeVisitor visitor) => visitor.visitProperty(this);
 
   void visitChildren(NodeVisitor visitor) {
     name.accept(visitor);
     value.accept(visitor);
   }
 }
 
 /// Tag class for all interpolated positions.
-abstract class InterpolatedNode implements Node {
-  get name; // 'int' for positional interpolated nodes, 'String' for named.
-}
+abstract class InterpolatedNode implements Node {}
 
 class InterpolatedExpression extends Expression implements InterpolatedNode {
-  final name;
+  Expression value;
 
-  InterpolatedExpression(this.name);
+  InterpolatedExpression(this.value);
+
+  void assign(Expression newValue) {
+    value = newValue;
+  }
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedExpression(this);
-  void visitChildren(NodeVisitor visitor) {}
 
-  int get precedenceLevel => PRIMARY;
-}
+  void visitChildren(NodeVisitor visitor) {
+    if (value != null) value.accept(visitor);
+  }
 
-class InterpolatedLiteral extends Literal implements InterpolatedNode {
-  final name;
-
-  InterpolatedLiteral(this.name);
-
-  accept(NodeVisitor visitor) => visitor.visitInterpolatedLiteral(this);
-  void visitChildren(NodeVisitor visitor) {}
-}
-
-class InterpolatedParameter extends Expression
-    implements Parameter, InterpolatedNode {
-  final name;
-
-  InterpolatedParameter(this.name);
-
-  accept(NodeVisitor visitor) => visitor.visitInterpolatedParameter(this);
-  void visitChildren(NodeVisitor visitor) {}
-
-  int get precedenceLevel => PRIMARY;
-}
-
-class InterpolatedSelector extends Expression implements InterpolatedNode {
-  final name;
-
-  InterpolatedSelector(this.name);
-
-  accept(NodeVisitor visitor) => visitor.visitInterpolatedSelector(this);
-  void visitChildren(NodeVisitor visitor) {}
-
-  int get precedenceLevel => PRIMARY;
+  int get precedenceLevel => value.precedenceLevel;
 }
 
 class InterpolatedStatement extends Statement implements InterpolatedNode {
-  final name;
+  Statement value;
 
-  InterpolatedStatement(this.name);
+  InterpolatedStatement(this.value);
+
+  void assign(Node newValue) {
+    if (newValue is Expression)
+      value = new ExpressionStatement(newValue);
+    else
+      value = newValue;
+  }
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedStatement(this);
-  void visitChildren(NodeVisitor visitor) {}
+
+  void visitChildren(NodeVisitor visitor) {
+    if (value != null) value.accept(visitor);
+  }
 }
 
+class JSExpression extends Expression {
+  Expression value;
+  List<InterpolatedNode> interpolatedNodes;
+
+  JSExpression(this.value, this.interpolatedNodes);
+
+  accept(NodeVisitor visitor) => visitor.visitJSExpression(this);
+
+  void visitChildren(NodeVisitor visitor) {
+    value.accept(visitor);
+    for (InterpolatedNode node in interpolatedNodes) {
+      node.accept(visitor);
+    }
+  }
+
+  int get precedenceLevel => value.precedenceLevel;
+}
+
+// TODO(sra): JSStatement like JSExpression.
+
 /**
  * [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.*/
   String pattern;
 
   RegExpLiteral(this.pattern);
@@ skipping 12 matching lines @@
  */
 class Comment extends Statement {
   final String comment;
 
   Comment(this.comment);
 
   accept(NodeVisitor visitor) => visitor.visitComment(this);
 
   void visitChildren(NodeVisitor visitor) {}
 }