Remove js.Sequence and use binary comma operator instead.

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 13 matching lines @@
   T visitSwitch(Switch node);
   T visitCase(Case node);
   T visitDefault(Default node);
   T visitFunctionDeclaration(FunctionDeclaration node);
   T visitLabeledStatement(LabeledStatement node);
   T visitLiteralStatement(LiteralStatement node);
 
   T visitBlob(Blob node);
   T visitLiteralExpression(LiteralExpression node);
   T visitVariableDeclarationList(VariableDeclarationList node);
-  T visitSequence(Sequence node);
   T visitAssignment(Assignment node);
   T visitVariableInitialization(VariableInitialization node);
   T visitConditional(Conditional cond);
   T visitNew(New node);
   T visitCall(Call node);
   T visitBinary(Binary node);
   T visitPrefix(Prefix node);
   T visitPostfix(Postfix node);
 
   T visitVariableUse(VariableUse node);
@@ skipping 61 matching lines @@
   T visitCase(Case node) => visitNode(node);
   T visitDefault(Default node) => visitNode(node);
 
   T visitExpression(Expression node) => visitNode(node);
   T visitBlob(Blob node) => visitExpression(node);
   T visitVariableReference(VariableReference node) => visitExpression(node);
 
   T visitLiteralExpression(LiteralExpression node) => visitExpression(node);
   T visitVariableDeclarationList(VariableDeclarationList node)
       => visitExpression(node);
-  T visitSequence(Sequence node) => visitExpression(node);
   T visitAssignment(Assignment node) => visitExpression(node);
   T visitVariableInitialization(VariableInitialization node) {
     if (node.value != null) {
       return visitAssignment(node);
     } else {
       return visitExpression(node);
     }
   }
   T visitConditional(Conditional node) => visitExpression(node);
   T visitNew(New node) => visitExpression(node);
@@ skipping 71 matching lines @@
     return clone;
   }
 
   // Returns a node equivalent to [this], but with new [this.sourcePositions],
   // keeping the existing [endPosition]
   Node withLocation(var sourcePosition) =>
       withPosition(sourcePosition, this.endSourcePosition);
 
   VariableUse asVariableUse() => null;
 
+  bool get isCommaOperator => false;
+
   Statement toStatement() {
     throw new UnsupportedError('toStatement');
   }
 }
 
 class Program extends Node {
   final List<Statement> body;
   Program(this.body);
 
   accept(NodeVisitor visitor) => visitor.visitProgram(this);
@@ skipping 376 matching lines @@
     for (VariableInitialization declaration in declarations) {
       declaration.accept(visitor);
     }
   }
 
   VariableDeclarationList _clone() => new VariableDeclarationList(declarations);
 
   int get precedenceLevel => EXPRESSION;
 }
 
-class Sequence extends Expression {
-  final List<Expression> expressions;
-
-  Sequence(this.expressions);
-
-  accept(NodeVisitor visitor) => visitor.visitSequence(this);
-
-  void visitChildren(NodeVisitor visitor) {
-    for (Expression expr in expressions) expr.accept(visitor);
-  }
-
-  Sequence _clone() => new Sequence(expressions);
-
-  int get precedenceLevel => EXPRESSION;
-}
-
 class Assignment extends Expression {
   final Expression leftHandSide;
   final String op;         // Null, if the assignment is not compound.
   final Expression value;  // May be null, for [VariableInitialization]s.
 
   Assignment(leftHandSide, value)
       : this.compound(leftHandSide, null, value);
   Assignment.compound(this.leftHandSide, this.op, this.value);
 
   int get precedenceLevel => ASSIGNMENT;
@@ skipping 79 matching lines @@
 
   accept(NodeVisitor visitor) => visitor.visitBinary(this);
 
   Binary _clone() => new Binary(op, left, right);
 
   void visitChildren(NodeVisitor visitor) {
     left.accept(visitor);
     right.accept(visitor);
   }
 
+  bool get isCommaOperator => op == ',';
+
   int get precedenceLevel {
     // TODO(floitsch): switch to constant map.
     switch (op) {
       case "*":
       case "/":
       case "%":
         return MULTIPLICATIVE;
       case "+":
       case "-":
         return ADDITIVE;
@@ skipping 395 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) {}
 }