Avoid printing braces for one-statement blocks in js-printer.

pkg/compiler/lib/src/js/printer.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;
 
 
 class JavaScriptPrintingOptions {
   final bool shouldCompressOutput;
   final bool minifyLocalVariables;
@@ skipping 186 matching lines @@
   }
 
   visitAll(List<Node> nodes) {
     nodes.forEach(visit);
   }
 
   visitProgram(Program program) {
     visitAll(program.body);
   }
 
-  bool blockBody(Node body, {bool needsSeparation, bool needsNewline}) {
+  Statement unwrapIfSingleStatement(Statement body) {

[floitsch, 2015/02/23 14:26:05]

unwrapBlockIfSingleStatement ?

[sigurdm, 2015/02/23 14:34:21]

Done.

+    Statement result = body;
+    while (result is Block) {
+      Block block = result;
+      if (block.statements.length != 1) break;
+      result = block.statements.single;
+    }
+    return result;
+  }
+
+  bool blockBody(Statement body, {bool needsSeparation, bool needsNewline}) {
     if (body is Block) {
       spaceOut();
-      blockOut(body, false, needsNewline);
+      blockOut(body, shouldIndent: false, needsNewline: needsNewline);
       return true;
     }
     if (shouldCompressOutput && needsSeparation) {
       // If [shouldCompressOutput] is false, then the 'lineOut' will insert
       // the separation.
       out(" ");
     } else {
       lineOut();
     }
     indentMore();
     visit(body);
     indentLess();
     return false;
   }
 
   void blockOutWithoutBraces(Node node) {
     if (node is Block) {
       context.enterNode(node);
       Block block = node;
       block.statements.forEach(blockOutWithoutBraces);
       context.exitNode(node);
     } else {
       visit(node);
     }
   }
 
-  void blockOut(Block node, bool shouldIndent, bool needsNewline) {
+  void blockOut(Block node, {bool shouldIndent, bool needsNewline}) {
     if (shouldIndent) indent();
     context.enterNode(node);
     out("{");
     lineOut();
     indentMore();
     node.statements.forEach(blockOutWithoutBraces);
     indentLess();
     indent();
     out("}");
     context.exitNode(node);
     if (needsNewline) lineOut();
   }
 
   visitBlock(Block block) {
-    blockOut(block, true, true);
+    blockOut(block, shouldIndent: true, needsNewline: true);
   }
 
   visitExpressionStatement(ExpressionStatement expressionStatement) {
     indent();
     visitNestedExpression(expressionStatement.expression, EXPRESSION,
                           newInForInit: false, newAtStatementBegin: true);
     outSemicolonLn();
   }
 
   visitEmptyStatement(EmptyStatement nop) {
     outIndentLn(";");
   }
 
   void ifOut(If node, bool shouldIndent) {
-    Node then = node.then;
-    Node elsePart = node.otherwise;
+    Statement then = unwrapIfSingleStatement(node.then);
+    Statement elsePart = node.otherwise;
     bool hasElse = node.hasElse;
 
     // Handle dangling elses and a work-around for Android 4.0 stock browser.
     // Android 4.0 requires braces for a single do-while in the `then` branch.
     // See issue 10923.
     if (hasElse) {
-      bool needsBraces = node.then.accept(danglingElseVisitor) || then is Do;
+      bool needsBraces = then.accept(danglingElseVisitor) || then is Do;
       if (needsBraces) {
         then = new Block(<Statement>[then]);
       }
     }
     if (shouldIndent) indent();
     out("if");
     spaceOut();
     out("(");
     visitNestedExpression(node.condition, EXPRESSION,
                           newInForInit: false, newAtStatementBegin: false);
     out(")");
     bool thenWasBlock =
         blockBody(then, needsSeparation: false, needsNewline: !hasElse);
     if (hasElse) {
       if (thenWasBlock) {
         spaceOut();
       } else {
         indent();
       }
       out("else");
       if (elsePart is If) {
         pendingSpace = true;
         ifOut(elsePart, false);
       } else {
-        blockBody(elsePart, needsSeparation: true, needsNewline: true);
+        blockBody(unwrapIfSingleStatement(elsePart),
+                  needsSeparation: true, needsNewline: true);
       }
     }
   }
 
   visitIf(If node) {
     ifOut(node, true);
   }
 
   visitFor(For loop) {
     outIndent("for");
     spaceOut();
     out("(");
     if (loop.init != null) {
       visitNestedExpression(loop.init, EXPRESSION,
                             newInForInit: true, newAtStatementBegin: false);
     }
     out(";");
     if (loop.condition != null) {
       spaceOut();
       visitNestedExpression(loop.condition, EXPRESSION,
                             newInForInit: false, newAtStatementBegin: false);
     }
     out(";");
     if (loop.update != null) {
       spaceOut();
       visitNestedExpression(loop.update, EXPRESSION,
                             newInForInit: false, newAtStatementBegin: false);
     }
     out(")");
-    blockBody(loop.body, needsSeparation: false, needsNewline: true);
+    blockBody(unwrapIfSingleStatement(loop.body),
+              needsSeparation: false, needsNewline: true);
   }
 
   visitForIn(ForIn loop) {
     outIndent("for");
     spaceOut();
     out("(");
     visitNestedExpression(loop.leftHandSide, EXPRESSION,
                           newInForInit: true, newAtStatementBegin: false);
     out(" in");
     pendingSpace = true;
     visitNestedExpression(loop.object, EXPRESSION,
                           newInForInit: false, newAtStatementBegin: false);
     out(")");
-    blockBody(loop.body, needsSeparation: false, needsNewline: true);
+    blockBody(unwrapIfSingleStatement(loop.body),
+              needsSeparation: false, needsNewline: true);
   }
 
   visitWhile(While loop) {
     outIndent("while");
     spaceOut();
     out("(");
     visitNestedExpression(loop.condition, EXPRESSION,
                           newInForInit: false, newAtStatementBegin: false);
     out(")");
-    blockBody(loop.body, needsSeparation: false, needsNewline: true);
+    blockBody(unwrapIfSingleStatement(loop.body),
+              needsSeparation: false, needsNewline: true);
   }
 
   visitDo(Do loop) {
     outIndent("do");
-    if (blockBody(loop.body, needsSeparation: true, needsNewline: false)) {
+    if (blockBody(unwrapIfSingleStatement(loop.body),
+                  needsSeparation: true, needsNewline: false)) {
       spaceOut();
     } else {
       indent();
     }
     out("while");
     spaceOut();
     out("(");
     visitNestedExpression(loop.condition, EXPRESSION,
                           newInForInit: false, newAtStatementBegin: false);
     out(")");
@@ skipping 67 matching lines @@
   }
 
   visitCatch(Catch node) {
     spaceOut();
     out("catch");
     spaceOut();
     out("(");
     visitNestedExpression(node.declaration, EXPRESSION,
                           newInForInit: false, newAtStatementBegin: false);
     out(")");
-    blockBody(node.body, needsSeparation: false, needsNewline: true);
+    blockBody(node.body, needsSeparation: false, needsNewline: false);
   }
 
   visitSwitch(Switch node) {
     outIndent("switch");
     spaceOut();
     out("(");
     visitNestedExpression(node.key, EXPRESSION,
                           newInForInit: false, newAtStatementBegin: false);
     out(")");
     spaceOut();
@@ skipping 21 matching lines @@
     outIndentLn("default:");
     if (!node.body.statements.isEmpty) {
       indentMore();
       blockOutWithoutBraces(node.body);
       indentLess();
     }
   }
 
   visitLabeledStatement(LabeledStatement node) {
     outIndent("${node.label}:");
-    blockBody(node.body, needsSeparation: false, needsNewline: true);
+    blockBody(unwrapIfSingleStatement(node.body),
+              needsSeparation: false, needsNewline: true);
   }
 
   void functionOut(Fun fun, Node name, VarCollector vars) {
     out("function");
     if (name != null) {
       out(" ");
       // Name must be a [Decl]. Therefore only test for primary expressions.
       visitNestedExpression(name, PRIMARY,
                             newInForInit: false, newAtStatementBegin: false);
     }
@@ skipping 742 matching lines @@
         codes.add(nthLetter((n ~/ nameSpaceSize) % LETTERS));
       }
       codes.add(charCodes.$0 + digit);
       newName = new String.fromCharCodes(codes);
     }
     assert(new RegExp(r'[a-zA-Z][a-zA-Z0-9]*').hasMatch(newName));
     maps.last[oldName] = newName;
     return newName;
   }
 }