Flow control structure formatting (a la the Style Guide).

pkg/analyzer_experimental/lib/src/services/formatter_impl.dart

 // Copyright (c) 2013, 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.
 
 library formatter_impl;
 
 import 'dart:math';
 
 import 'package:analyzer_experimental/analyzer.dart';
 import 'package:analyzer_experimental/src/generated/parser.dart';
@@ skipping 177 matching lines @@
   /// Verify that these two token streams are equal.
   verifyEquals() {
     while (!isEOF(token1)) {
       checkPrecedingComments();
       if (!checkTokens()) {
         throwNotEqualException(token1, token2);
       }
       advance();
 
     }
-    if (!isEOF(token2)) {
+    // TODO(pquitslund): consider a better way to notice trailing synthetics
+    if (!isEOF(token2) && !isCLOSE_CURLY_BRACKET(token2)) {

[Brian Wilkerson, 2013/09/30 22:19:34]

Do you need to check that the token following the closing curly bracket is an
EOF token?

[pquitslund, 2013/09/30 22:41:56]

Done.

       throw new FormatterException(
           'Expected "EOF" but got "${token2}".');
     }
   }
 
   checkPrecedingComments() {
     var comment1 = token1.precedingComments;
     var comment2 = token2.precedingComments;
     while (comment1 != null) {
       if (comment2 == null) {
@@ skipping 45 matching lines @@
         return true;
       }
     }
     // '>' '>' => '>>'
     if (isGT(token1) && isGT(token1.next)) {
       if (isGT_GT(token2)) {
         token1 = token1.next;
         return true;
       }
     }
+    // Advance past synthetic { } tokens
+    if (isOPEN_CURLY_BRACKET(token2) || isCLOSE_CURLY_BRACKET(token2)) {
+      token2 = token2.next;
+      return checkTokens();
+    }
 
     return false;
   }
 
 }
 
 // Cached parser for testing token types.
 final tokenTester = new Parser(null,null);
 
 /// Test if this token is an EOF token.
 bool isEOF(Token token) => tokenIs(token, TokenType.EOF);
 
 /// Test for token type.
 bool tokenIs(Token token, TokenType type) => 
     token != null && tokenTester.matches4(token, type);
 
 /// Test if this token is a GT token.
 bool isGT(Token token) => tokenIs(token, TokenType.GT);
 
 /// Test if this token is a GT_GT token.
 bool isGT_GT(Token token) => tokenIs(token, TokenType.GT_GT);
 
 /// Test if this token is an INDEX token.
 bool isINDEX(Token token) => tokenIs(token, TokenType.INDEX);
 
+/// Test if this token is a OPEN_CURLY_BRACKET token.
+bool isOPEN_CURLY_BRACKET(Token token) =>
+    tokenIs(token, TokenType.OPEN_CURLY_BRACKET);
+
+/// Test if this token is a CLOSE_CURLY_BRACKET token.
+bool isCLOSE_CURLY_BRACKET(Token token) =>
+    tokenIs(token, TokenType.CLOSE_CURLY_BRACKET);
+
 /// Test if this token is a OPEN_SQUARE_BRACKET token.
 bool isOPEN_SQ_BRACKET(Token token) =>
     tokenIs(token, TokenType.OPEN_SQUARE_BRACKET);
 
 /// Test if this token is a CLOSE_SQUARE_BRACKET token.
 bool isCLOSE_SQUARE_BRACKET(Token token) =>
     tokenIs(token, TokenType.CLOSE_SQUARE_BRACKET);
 
 /// An AST visitor that drives formatting heuristics.
 class SourceVisitor implements ASTVisitor {
+  
+  static final OPEN_CURLY = syntheticToken(TokenType.OPEN_CURLY_BRACKET, '{');
+  static final CLOSE_CURLY = syntheticToken(TokenType.CLOSE_CURLY_BRACKET, '}');
+  
+  static const SYNTH_OFFSET = -13;
+  
+  static StringToken syntheticToken(TokenType type, String value) =>
+      new StringToken(type, value, SYNTH_OFFSET);
+  
+  static bool isSynthetic(Token token) => token.offset == SYNTH_OFFSET;

[Brian Wilkerson, 2013/09/30 22:19:34]

It's a little unfortunate that you have a helper method when Token already has
an "isSynthetic" method. Unfortunately, the only way you could use the method
defined on token is by defining a new class:

class SyntheticToken extends StringToken {
  SyntheticToken(TokenType type, String value) : super(type, value, 0);
  int get length => 0;
}

[pquitslund, 2013/09/30 22:41:56]

Totally.  As per our conversation, we'd have to add extra checks to make sure we
weren't matching other synthetic tokens such as EOFs...

 
   /// The writer to which the source is to be written.
   final SourceWriter writer;
 
   /// Cached line info for calculating blank lines.
   LineInfo lineInfo;
 
   /// Cached previous token for calculating preceding whitespace.
   Token previousToken;
 
@@ skipping 414 matching lines @@
     visitNode(node.returnType, followedBy: space);
     visit(node.identifier);
     visit(node.parameters);
   }
 
   visitHideCombinator(HideCombinator node) {
     token(node.keyword);
     space();
     visitNodes(node.hiddenNames, separatedBy: commaSeperator);
   }
-
+  
   visitIfStatement(IfStatement node) {
+    var hasElse = node.elseStatement != null;
     token(node.ifKeyword);
     space();
     token(node.leftParenthesis);
     visit(node.condition);
     token(node.rightParenthesis);
     space();
-    visit(node.thenStatement);
-    //visitPrefixed(' else ', node.elseStatement);
-    if (node.elseStatement != null) {
+    if (hasElse) {
+      printAsBlock(node.thenStatement);
       space();
       token(node.elseKeyword);
       space();
-      visit(node.elseStatement);
+      printAsBlock(node.elseStatement);
+    } else {
+      visit(node.thenStatement);
     }
   }
-
+  
   visitImplementsClause(ImplementsClause node) {
     token(node.keyword);
     space();
     visitNodes(node.interfaces, separatedBy: commaSeperator);
   }
 
   visitImportDirective(ImportDirective node) {
     token(node.keyword);
     space();
     visit(node.uri);
@@ skipping 507 matching lines @@
 
   /// Indent.
   indent() {
     writer.indent();
   }
 
   /// Unindent
   unindent() {
     writer.unindent();
   }
-
-
+  
+  /// Print this statement as if it were a block (e.g., surrounded by braces).
+  printAsBlock(Statement statement) {
+    if (statement is! Block) {
+      token(OPEN_CURLY);
+      indent();
+      newlines();
+      visit(statement);
+      newlines();
+      unindent();
+      token(CLOSE_CURLY);
+    } else {
+      visit(statement);
+    }
+  }
+  
   /// Emit any detected comments and newlines or a minimum as specified
   /// by [min].
   int emitPrecedingCommentsAndNewlines(Token token, {min: 0}) {
 
     var comment = token.precedingComments;
     var currentToken = comment != null ? comment : token;
 
     //Handle EOLs before newlines
     if (isAtEOL(comment)) {
       emitComment(comment, previousToken);
@@ skipping 64 matching lines @@
   /// Count newlines preceeding this [node].
   int countPrecedingNewlines(ASTNode node) =>
       countNewlinesBetween(node.beginToken.previous, node.beginToken);
 
   /// Count newlines succeeding this [node].
   int countSucceedingNewlines(ASTNode node) => node == null ? 0 :
       countNewlinesBetween(node.endToken, node.endToken.next);
 
   /// Count the blanks between these two tokens.
   int countNewlinesBetween(Token last, Token current) {
-    if (last == null || current == null) {
+    if (last == null || current == null || isSynthetic(last)) {
       return 0;
     }
 
     return linesBetween(last.end - 1, current.offset);
   }
 
   /// Calculate the newlines that should separate these comments.
   int calculateNewlinesBetweenComments(Token last, Token current) {
     // Insist on a newline after doc comments or single line comments
     // (NOTE that EOL comments have already been processed).
@@ skipping 32 matching lines @@
     var lastLine =
         lineInfo.getLocation(lastOffset).lineNumber;
     var currentLine =
         lineInfo.getLocation(currentOffset).lineNumber;
     return currentLine - lastLine;
   }
 
   String toString() => writer.toString();
 
 }