Formatting constructor initializers 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 316 matching lines @@
   final SourceWriter writer;
 
   /// Cached line info for calculating blank lines.
   LineInfo lineInfo;
 
   /// Cached previous token for calculating preceding whitespace.
   Token previousToken;
 
   /// A flag to indicate that a newline should be emitted before the next token.
   bool needsNewline = false;
+  
+  /// A counter for spaces that should be emitted preceding the next token.
+  int leadingSpaces = 0;
 
   /// Used for matching EOL comments
   final twoSlashes = new RegExp(r'//[^/]');
   
   /// Original pre-format selection information (may be null).
   final Selection preSelection;
   
   /// Post format selection information.
   Selection selection;
 
@@ skipping 186 matching lines @@
   }
 
   visitConstructorDeclaration(ConstructorDeclaration node) {
     modifier(node.externalKeyword);
     modifier(node.constKeyword);
     modifier(node.factoryKeyword);
     visit(node.returnType);
     token(node.period);
     visit(node.name);
     visit(node.parameters);
-    token(node.separator /* = or : */, precededBy: space, followedBy: space);
-    visitNodes(node.initializers, separatedBy: commaSeperator);
-    visit(node.redirectedConstructor);
+    
+    // Check for redirects or initializer lists
+    if (node.separator != null) {
+      if (node.redirectedConstructor != null) {
+        visitConstructorRedirects(node);
+      } else { 
+        visitConstructorInitializers(node);
+      }
+    }
 
     visitPrefixedBody(space, node.body);
   }
 
+  visitConstructorInitializers(ConstructorDeclaration node) {
+    newlines();
+    indent(2);
+    token(node.separator /* : */);
+    space();
+    for (var i = 0; i < node.initializers.length; i++) {
+      if (i > 0) {
+        comma();
+        newlines();
+        space(2);
+      }
+      node.initializers[i].accept(this);
+    } 
+    unindent(2);
+  }
+
+  visitConstructorRedirects(ConstructorDeclaration node) {
+    token(node.separator /* = */, precededBy: space, followedBy: space);
+    visitNodes(node.initializers, separatedBy: commaSeperator);
+    visit(node.redirectedConstructor);
+  }
+  
   visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     token(node.keyword);
     token(node.period);
     visit(node.fieldName);
     space();
     token(node.equals);
     space();
     visit(node.expression);
   }
 
@@ skipping 687 matching lines @@
       }
       checkForSelectionUpdate(token);
       append(token.lexeme);
       if (followedBy != null) {
         followedBy();
       }
       previousToken = token;
     }
   }
   
+  emitSpaces() {
+    while (leadingSpaces > 0) {
+      writer.print(' ');
+      leadingSpaces--;
+    }
+  }
+  
   checkForSelectionUpdate(Token token) {
     // Cache the first token on or AFTER the selection offset
     if (preSelection != null && selection == null) {
       // Check for overshots
       var overshot = token.offset - preSelection.offset;
       if (overshot >= 0) {
         //TODO(pquitslund): update length (may need truncating)
-        selection = new Selection(writer.toString().length - overshot, 
+        selection = new Selection(
+            writer.toString().length + leadingSpaces - overshot, 
             preSelection.length);
       }
     }
   }
 
   commaSeperator() {
     comma();
     space();
   }
 
   comma() {
-    append(',');
+    writer.print(',');
   }
 
+  
   /// Emit a non-breakable space.
-  space() {
+  space([n = 1]) {
     //TODO(pquitslund): replace with a proper space token
-    append(' ');
+    leadingSpaces+=n;
   }
-
+  
   /// Emit a breakable space
   breakableSpace() {
     //Implement
   }
 
   /// Append the given [string] to the source writer if it's non-null.
   append(String string) {
     if (string != null && !string.isEmpty) {
+      emitSpaces();
       writer.print(string);
     }
   }
 
   /// Indent.
-  indent() {
-    writer.indent();
+  indent([n = 1]) {
+    while (n-- > 0) {
+      writer.indent();
+    }
   }
-
+  
   /// Unindent
-  unindent() {
-    writer.unindent();
+  unindent([n = 1]) {
+    while (n-- > 0) {
+      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();
@@ skipping 26 matching lines @@
     while (comment != null) {
 
       emitComment(comment, previousToken);
 
       var nextToken = comment.next != null ? comment.next : token;
       var newlines = calculateNewlinesBetweenComments(comment, nextToken);
       if (newlines > 0) {
         writer.newlines(newlines);
         lines += newlines;
       } else if (!isEOF(token)) {
-        space();
+        append(' ');
       }
 
       previousToken = comment;
       comment = comment.next;
     }
 
     previousToken = token;
     return lines;
   }
 
 
   ensureTrailingNewline() {
     if (writer.lastToken is! NewlineToken) {
       writer.newline();
     }
   }
   
   
   /// Test if this [comment] is at the end of a line.
   bool isAtEOL(Token comment) =>
       comment != null && comment.toString().trim().startsWith(twoSlashes) &&
       sameLine(comment, previousToken);
 
   /// Emit this [comment], inserting leading whitespace if appropriate.
   emitComment(Token comment, Token previousToken) {
     if (!writer.currentLine.isWhitespace() && !isBlock(comment)) {
       var ws = countSpacesBetween(previousToken, comment);
       // Preserve one space but no more
       if (ws > 0) {
-        space();
+        append(' ');
       }
     }
 
     append(comment.toString().trim());
   }
 
   /// Count spaces between these tokens.  Tokens on different lines return 0.
   int countSpacesBetween(Token last, Token current) => isEOF(last) ||
       countNewlinesBetween(last, current) > 0 ? 0 : current.offset - last.end;
 
@@ skipping 57 matching lines @@
     var lastLine =
         lineInfo.getLocation(lastOffset).lineNumber;
     var currentLine =
         lineInfo.getLocation(currentOffset).lineNumber;
     return currentLine - lastLine;
   }
 
   String toString() => writer.toString();
 
 }