Remove js.Sequence and use binary comma operator instead.

sdk/lib/_internal/compiler/implementation/ssa/codegen.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 ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 446 matching lines @@
     HSubExpressionBlockInformation expressionSubGraph = expression;
     visitSubGraph(expressionSubGraph.subExpression);
     expressionStack = oldExpressionStack;
     isGeneratingExpression = oldIsGeneratingExpression;
     if (sequenceElements.isEmpty) {
       // Happens when the initializer, condition or update of a loop is empty.
       return null;
     } else if (sequenceElements.length == 1) {
       return sequenceElements[0];
     } else {
-      return new js.Sequence(sequenceElements);
+      js.Expression result = sequenceElements.removeLast();
+      while (sequenceElements.isNotEmpty) {
+        result = new js.Binary(',', sequenceElements.removeLast(), result);
+      }
+      return result;
     }
   }
 
   /**
     * Only visits the arguments starting at inputs[HInvoke.ARGUMENTS_OFFSET].
     */
   List<js.Expression> visitArguments(List<HInstruction> inputs,
                                      {int start: HInvoke.ARGUMENTS_OFFSET}) {
     assert(inputs.length >= start);
     List<js.Expression> result = <js.Expression>[];
@@ skipping 294 matching lines @@
         if (isConditionExpression &&
             info.updates != null && isJSExpression(info.updates)) {
           // If we have an updates graph, and it's expressible as an
           // expression, generate a for-loop.
           js.Expression jsInitialization = null;
           if (initialization != null) {
             int delayedVariablesCount = collectedVariableDeclarations.length;
             jsInitialization = generateExpression(initialization);
             if (!shouldGroupVarDeclarations &&
                 delayedVariablesCount < collectedVariableDeclarations.length) {
-              // We just added a new delayed variable-declaration. See if we
-              // can put in a 'var' in front of the initialization to make it
-              // go away.
-              List<js.Expression> expressions;
-              if (jsInitialization is js.Sequence) {
-                js.Sequence sequence = jsInitialization;
-                expressions = sequence.expressions;
-              } else {
-                expressions = <js.Expression>[jsInitialization];
-              }
-              bool canTransformToVariableDeclaration = true;
-              for (js.Expression expression in expressions) {
-                bool expressionIsVariableAssignment = false;
+              // We just added a new delayed variable-declaration. See if we can
+              // put in a 'var' in front of the initialization to make it go
+              // away. We walk the 'tree' of comma-operators to find the
+              // expressions and see if they are all assignments that can be
+              // converted into declarations.
+
+              List<js.Assignment> assignments;
+
+              bool allSimpleAssignments(js.Expression expression) {
                 if (expression is js.Assignment) {
                   js.Assignment assignment = expression;
                   if (assignment.leftHandSide is js.VariableUse &&
                       !assignment.isCompound) {
-                    expressionIsVariableAssignment = true;
+                    if (assignments == null) assignments = <js.Assignment>[];
+                    assignments.add(expression);
+                    return true;
                   }
+                } else if (expression.isCommaOperator) {
+                  js.Binary binary = expression;
+                  return allSimpleAssignments(binary.left)
+                      && allSimpleAssignments(binary.right);
                 }
-                if (!expressionIsVariableAssignment) {
-                  canTransformToVariableDeclaration = false;
-                  break;
-                }
+                return false;
               }
-              if (canTransformToVariableDeclaration) {
+
+              if (allSimpleAssignments(jsInitialization)) {
                 List<js.VariableInitialization> inits =
                     <js.VariableInitialization>[];
-                for (js.Assignment assignment in expressions) {
+                for (js.Assignment assignment in assignments) {
                   String id = (assignment.leftHandSide as js.VariableUse).name;
                   js.Node declaration = new js.VariableDeclaration(id);
                   inits.add(new js.VariableInitialization(declaration,
                                                           assignment.value));
                   collectedVariableDeclarations.remove(id);
                   declaredLocals.add(id);
                 }
                 jsInitialization = new js.VariableDeclarationList(inits);
               }
             }
@@ skipping 1854 matching lines @@
   js.PropertyAccess accessHelper(String name) {
     Element helper = compiler.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
     world.registerStaticUse(helper);
     return backend.namer.elementAccess(helper);
   }
 }