implement opassign, fix bugs in pre/postfix, introduce a let* helper

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 204 matching lines @@
     // `null`?
     clone.sourceInformation = sourceInformation;
     return clone;
   }
 
   bool get isCommaOperator => false;
 
   Statement toStatement() {
     throw new UnsupportedError('toStatement');
   }
+  Statement toReturn() {
+    throw new UnsupportedError('toReturn');
+  }
+
+  // For debugging

[Jennifer Messerly, 2015/04/07 22:00:29]

it was hard to read js_ast nodes in debugger, compared to analyzer nodes which
were really easy

+  String toString() {
+    var context = new SimpleJavaScriptPrintingContext();
+    var opts = new JavaScriptPrintingOptions(allowKeywordsInProperties: true);
+    context.buffer.write('js_ast `');
+    accept(new Printer(opts, context));
+    context.buffer.write('`');
+    return context.getText();
+  }
 }
 
 class Program extends Node {
   final List<Statement> body;
   Program(this.body);
 
   accept(NodeVisitor visitor) => visitor.visitProgram(this);
   void visitChildren(NodeVisitor visitor) {
     for (Statement statement in body) statement.accept(visitor);
   }
   Program _clone() => new Program(body);
 }
 
 abstract class Statement extends Node {
   Statement toStatement() => this;
+  Statement toReturn() => new Block([this, new Return()]);
 }
 
 class Block extends Statement {
   final List<Statement> statements;
   Block(this.statements) {
     assert(!statements.any((s) => s is! Statement));
   }
   Block.empty() : this.statements = <Statement>[];
 
   accept(NodeVisitor visitor) => visitor.visitBlock(this);
@@ skipping 153 matching lines @@
   void visitChildren(NodeVisitor visitor) {}
 
   Break _clone() => new Break(targetLabel);
 }
 
 class Return extends Statement {
   final Expression value;  // Can be null.
 
   Return([this.value = null]);
 
+  Statement toReturn() => this;
+
   accept(NodeVisitor visitor) => visitor.visitReturn(this);
 
   void visitChildren(NodeVisitor visitor) {
     if (value != null) value.accept(visitor);
   }
 
   Return _clone() => new Return(value);
 }
 
 class Throw extends Statement {
@@ skipping 149 matching lines @@
   accept(NodeVisitor visitor) => visitor.visitDartYield(this);
 
   void visitChildren(NodeVisitor visitor) {
     expression.accept(visitor);
   }
 
   DartYield _clone() => new DartYield(expression, hasStar);
 }
 
 abstract class Expression extends Node {
+  Expression();
+
+  factory Expression.binary(List<Expression> exprs, String op) {
+    Expression comma = null;
+    for (var node in exprs) {
+      comma = (comma == null) ? node : new Binary(op, comma, node);
+    }
+    return comma;
+  }
+
   int get precedenceLevel;
 
-  Statement toStatement() => new ExpressionStatement(this);
+  Statement toStatement() => new ExpressionStatement(toVoidExpression());
+  Statement toReturn() => new Return(this);
+
+  Expression toVoidExpression() => this;
+  Expression toAssignExpression(Expression left) => new Assignment(left, this);
+  Statement toVariableDeclaration(Identifier name) =>
+      new VariableDeclarationList('let',
+          [new VariableInitialization(name, this)]).toStatement();
 }
 
 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);
@@ skipping 133 matching lines @@
 
   Binary _clone() => new Binary(op, left, right);
 
   void visitChildren(NodeVisitor visitor) {
     left.accept(visitor);
     right.accept(visitor);
   }
 
   bool get isCommaOperator => op == ',';
 
+  Expression toVoidExpression() {
+    if (!isCommaOperator) return super.toVoidExpression();

[Leaf, 2015/04/08 04:08:34]

It almost feels like it would be worth having a CommaOperator subclass of
Binary.  WDYT?

[Jennifer Messerly, 2015/04/08 16:35:46]

Yeah, I agree. So far I was trying to maintain compatibility-ish with js_ast in
dart2js, but maybe not worth it. It definitely constrains the design. Hmmm,
maybe I could make the Binary constructor be a factory, that creates Comma
subclass when op == ','

+    var l = left.toVoidExpression();
+    var r = right.toVoidExpression();
+    if (l == left && r == right) return this;
+    return new Binary(',', l, r);
+  }
+
+  Statement toStatement() {
+    if (!isCommaOperator) return super.toStatement();
+    return new Block([left.toStatement(), right.toStatement()]);
+  }
+
+  Statement toReturn() {
+    if (!isCommaOperator) return super.toReturn();
+    return new Block([left.toStatement(), right.toReturn()]);
+  }
+
+  List<Expression> commaToExpressionList() {
+    if (!isCommaOperator) throw new StateError('not a comma expression');
+    var exprs = [];
+    _flattenComma(exprs, left);
+    _flattenComma(exprs, right);
+    return exprs;
+  }
+
+  static void _flattenComma(List<Expression> exprs, Expression node) {
+    if (node is Binary && node.isCommaOperator) {
+      _flattenComma(exprs, node.left);
+      _flattenComma(exprs, node.right);
+    } else {
+      exprs.add(node);
+    }
+  }
+
   int get precedenceLevel {
     // TODO(floitsch): switch to constant map.
     switch (op) {
       case "*":
       case "/":
       case "%":
         return MULTIPLICATIVE;
       case "+":
       case "-":
         return ADDITIVE;
@@ skipping 615 matching lines @@
   final Expression expression;
 
   CommentExpression(this.comment, this.expression);
 
   int get precedenceLevel => PRIMARY;
   accept(NodeVisitor visitor) => visitor.visitCommentExpression(this);
   CommentExpression _clone() => new CommentExpression(comment, expression);
 
   void visitChildren(NodeVisitor visitor) => expression.accept(visitor);
 }