Revert "JS templates"

sdk/lib/_internal/compiler/implementation/js/nodes.dart

Index: sdk/lib/_internal/compiler/implementation/js/nodes.dart
diff --git a/sdk/lib/_internal/compiler/implementation/js/nodes.dart b/sdk/lib/_internal/compiler/implementation/js/nodes.dart
index 93d1f5ecb735a5b3e47353ce0c14eb03b132bb11..b48c4aeb4ebebc023b14aa3a59a0d2041ab7d0d8 100644
--- a/sdk/lib/_internal/compiler/implementation/js/nodes.dart
+++ b/sdk/lib/_internal/compiler/implementation/js/nodes.dart
@@ -64,10 +64,8 @@ abstract class NodeVisitor<T> {
   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> {
@@ -152,18 +150,11 @@ class BaseVisitor<T> implements NodeVisitor<T> {
   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;
@@ -463,7 +454,59 @@ class LiteralStatement extends Statement {
 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.
@@ -910,62 +953,65 @@ class Property extends Node {
 }
 
 /// 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);
 
-  accept(NodeVisitor visitor) => visitor.visitInterpolatedExpression(this);
-  void visitChildren(NodeVisitor visitor) {}
-
-  int get precedenceLevel => PRIMARY;
-}
+  void assign(Expression newValue) {
+    value = newValue;
+  }
 
-class InterpolatedLiteral extends Literal implements InterpolatedNode {
-  final name;
+  accept(NodeVisitor visitor) => visitor.visitInterpolatedExpression(this);
 
-  InterpolatedLiteral(this.name);
+  void visitChildren(NodeVisitor visitor) {
+    if (value != null) value.accept(visitor);
+  }
 
-  accept(NodeVisitor visitor) => visitor.visitInterpolatedLiteral(this);
-  void visitChildren(NodeVisitor visitor) {}
+  int get precedenceLevel => value.precedenceLevel;
 }
 
-class InterpolatedParameter extends Expression
-    implements Parameter, InterpolatedNode {
-  final name;
-
-  InterpolatedParameter(this.name);
+class InterpolatedStatement extends Statement implements InterpolatedNode {
+  Statement value;
 
-  accept(NodeVisitor visitor) => visitor.visitInterpolatedParameter(this);
-  void visitChildren(NodeVisitor visitor) {}
+  InterpolatedStatement(this.value);
 
-  int get precedenceLevel => PRIMARY;
-}
+  void assign(Node newValue) {
+    if (newValue is Expression)
+      value = new ExpressionStatement(newValue);
+    else
+      value = newValue;
+  }
 
-class InterpolatedSelector extends Expression implements InterpolatedNode {
-  final name;
+  accept(NodeVisitor visitor) => visitor.visitInterpolatedStatement(this);
 
-  InterpolatedSelector(this.name);
+  void visitChildren(NodeVisitor visitor) {
+    if (value != null) value.accept(visitor);
+  }
+}
 
-  accept(NodeVisitor visitor) => visitor.visitInterpolatedSelector(this);
-  void visitChildren(NodeVisitor visitor) {}
+class JSExpression extends Expression {
+  Expression value;
+  List<InterpolatedNode> interpolatedNodes;
 
-  int get precedenceLevel => PRIMARY;
-}
+  JSExpression(this.value, this.interpolatedNodes);
 
-class InterpolatedStatement extends Statement implements InterpolatedNode {
-  final name;
+  accept(NodeVisitor visitor) => visitor.visitJSExpression(this);
 
-  InterpolatedStatement(this.name);
+  void visitChildren(NodeVisitor visitor) {
+    value.accept(visitor);
+    for (InterpolatedNode node in interpolatedNodes) {
+      node.accept(visitor);
+    }
+  }
 
-  accept(NodeVisitor visitor) => visitor.visitInterpolatedStatement(this);
-  void visitChildren(NodeVisitor 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