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)
-      => visitExpression(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)
-      => visitStatement(node);
-  T visitJSExpression(JSExpression node) => visitExpression(node);
+      => visitInterpolatedNode(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 {}
+abstract class InterpolatedNode implements Node {
+  get name; // 'int' for positional interpolated nodes, 'String' for named.
+}
 
 class InterpolatedExpression extends Expression implements InterpolatedNode {
-  Expression value;
+  final name;
 
-  InterpolatedExpression(this.value);
-
-  void assign(Expression newValue) {
-    value = newValue;
-  }
+  InterpolatedExpression(this.name);
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedExpression(this);
+  void visitChildren(NodeVisitor visitor) {}
 
-  void visitChildren(NodeVisitor visitor) {
-    if (value != null) value.accept(visitor);
-  }
+  int get precedenceLevel => PRIMARY;
+}
 
-  int get precedenceLevel => value.precedenceLevel;
+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;
 }
 
 class InterpolatedStatement extends Statement implements InterpolatedNode {
-  Statement value;
+  final name;
 
-  InterpolatedStatement(this.value);
-
-  void assign(Node newValue) {
-    if (newValue is Expression)
-      value = new ExpressionStatement(newValue);
-    else
-      value = newValue;
-  }
+  InterpolatedStatement(this.name);
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedStatement(this);
-
-  void visitChildren(NodeVisitor visitor) {
-    if (value != null) value.accept(visitor);
-  }
+  void visitChildren(NodeVisitor 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) {}
 }