Minor formatter tweaks and a few more tests.

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 134 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 flag to indicate that user introduced newlines should be emitted before
   /// the next token.
   bool preservePrecedingNewlines = false;
-  
+
   /// Initialize a newly created visitor to write source code representing
   /// the visited nodes to the given [writer].
   SourceVisitor(FormatterOptions options, this.lineInfo) :
       writer = new SourceWriter(indentCount: options.initialIndentationLevel,
                                 lineSeparator: options.lineSeparator);
 
   visitAdjacentStrings(AdjacentStrings node) {
     visitNodes(node.strings, separatedBy: space);
   }
 
@@ skipping 45 matching lines @@
     visit(node.leftOperand);
     space();
     token(node.operator);
     space();
     visit(node.rightOperand);
   }
 
   visitBlock(Block node) {
     token(node.leftBracket);
     indent();
-
     visitNodes(node.statements, precededBy: newlines, separatedBy: newlines);
-    
     unindent();
     newlines();
     token(node.rightBracket);
   }
 
   visitBlockFunctionBody(BlockFunctionBody node) {
     visit(node.block);
   }
 
   visitBooleanLiteral(BooleanLiteral node) {
     token(node.literal);
   }
 
   visitBreakStatement(BreakStatement node) {
     token(node.keyword);
     visitNode(node.label, precededBy: space);
     token(node.semicolon);
   }
 
   visitCascadeExpression(CascadeExpression node) {
     visit(node.target);
     visitNodes(node.cascadeSections);
   }
 
   visitCatchClause(CatchClause node) {
-    
+
     token(node.onKeyword, precededBy: space, followedBy: space);
     visit(node.exceptionType);
 
     if (node.catchKeyword != null) {
       if (node.exceptionType != null) {
         space();
       }
       token(node.catchKeyword);
       space();
       token(node.leftParenthesis);
@@ skipping 12 matching lines @@
     modifier(node.abstractKeyword);
     token(node.classKeyword);
     space();
     visit(node.name);
     visit(node.typeParameters);
     visitNode(node.extendsClause, precededBy: space);
     visitNode(node.withClause, precededBy: space);
     visitNode(node.implementsClause, precededBy: space);
     space();
     token(node.leftBracket);
-    
     indent();
     visitNodes(node.members, precededBy: newlines, separatedBy: newlines);
     unindent();
     newlines();
-    
     token(node.rightBracket);
   }
 
   visitClassTypeAlias(ClassTypeAlias node) {
     token(node.keyword);
     space();
     visit(node.name);
     visit(node.typeParameters);
     space();
     token(node.equals);
     space();
     if (node.abstractKeyword != null) {
       token(node.abstractKeyword);
       space();
     }
     visit(node.superclass);
     visitNode(node.withClause, precededBy: space);
     visitNode(node.implementsClause, precededBy: space);
     token(node.semicolon);
   }
 
   visitComment(Comment node) => null;
 
   visitCommentReference(CommentReference node) => null;
 
   visitCompilationUnit(CompilationUnit node) {
-    
+
     // Cache EOF for leading whitespace calculation
     var start = node.beginToken.previous;
     if (start != null && start.type is TokenType_EOF) {
       previousToken = start;
     }
-    
+
     var scriptTag = node.scriptTag;
     var directives = node.directives;
     visit(scriptTag);
-    
+
     preservePrecedingNewlines = true;
     visitNodes(directives, separatedBy: newlines);
-    
+
     preservePrecedingNewlines = true;
     visitNodes(node.declarations, separatedBy: newlines);
 
     // Handle trailing whitespace
     preservePrecedingNewlines = true;
     token(node.endToken /* EOF */);
   }
 
   visitConditionalExpression(ConditionalExpression node) {
     visit(node.condition);
@@ skipping 11 matching lines @@
     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);
-    
+
     visitPrefixedBody(space, node.body);
   }
 
   visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     token(node.keyword);
     token(node.period);
     visit(node.fieldName);
     space();
     token(node.equals);
     space();
     visit(node.expression);
   }
 
   visitConstructorName(ConstructorName node) {
     visit(node.type);
     token(node.period);
     visit(node.name);
   }
 
   visitContinueStatement(ContinueStatement node) {
     token(node.keyword);
     visitNode(node.label, precededBy: space);
     token(node.semicolon);
   }
 
   visitDeclaredIdentifier(DeclaredIdentifier node) {
-    token(node.keyword);
-    space();
-    visit(node.type);
-    //TODO(pquitslund): avoiding visitSuffixed(..) but we can do better
-    if (node.type != null) {
-      space();
-    }
+    modifier(node.keyword);
+    visitNode(node.type, followedBy: space);
     visit(node.identifier);
   }
 
   visitDefaultFormalParameter(DefaultFormalParameter node) {
     visit(node.parameter);
     if (node.separator != null) {
       // The '=' separator is preceded by a space
       if (node.separator.type == TokenType.EQ) {
         space();
       }
@@ skipping 53 matching lines @@
     visit(node.superclass);
   }
 
   visitFieldDeclaration(FieldDeclaration node) {
     modifier(node.keyword);
     visit(node.fields);
     token(node.semicolon);
   }
 
   visitFieldFormalParameter(FieldFormalParameter node) {
-    token(node.keyword);
-    space();
-    visit(node.type);
-    space();
+    token(node.keyword, followedBy: space);
+    visitNode(node.type, followedBy: space);
     token(node.thisToken);
     token(node.period);
     visit(node.identifier);
     visit(node.parameters);
   }
 
   visitForEachStatement(ForEachStatement node) {
     token(node.forKeyword);
     space();
     token(node.leftParenthesis);
@@ skipping 108 matching lines @@
     space();
     visit(node.thenStatement);
     //visitPrefixed(' else ', node.elseStatement);
     if (node.elseStatement != null) {
       space();
       token(node.elseKeyword);
       space();
       visit(node.elseStatement);
     }
   }
-  
+
   visitImplementsClause(ImplementsClause node) {
     token(node.keyword);
     space();
     visitNodes(node.interfaces, separatedBy: commaSeperator);
   }
 
   visitImportDirective(ImportDirective node) {
     token(node.keyword);
     space();
     visit(node.uri);
@@ skipping 145 matching lines @@
   visitPartDirective(PartDirective node) {
     token(node.keyword);
     space();
     visit(node.uri);
     token(node.semicolon);
   }
 
   visitPartOfDirective(PartOfDirective node) {
     token(node.keyword);
     space();
+    token(node.ofToken);
+    space();
     visit(node.libraryName);
     token(node.semicolon);
   }
 
   visitPostfixExpression(PostfixExpression node) {
     visit(node.operand);
     token(node.operator);
   }
 
   visitPrefixedIdentifier(PrefixedIdentifier node) {
@@ skipping 212 matching lines @@
 
   /// Visit the given function [body], printing the [prefix] before if given
   /// body is not empty.
   visitPrefixedBody(prefix(), FunctionBody body) {
     if (body is! EmptyFunctionBody) {
       prefix();
     }
     visit(body);
   }
 
-  /// Visit a list of [nodes] if not null, optionally separated and/or preceded 
+  /// Visit a list of [nodes] if not null, optionally separated and/or preceded
   /// and followed by the given functions.
   visitNodes(NodeList<ASTNode> nodes, {precededBy(): null,
       separatedBy() : null, followedBy(): null}) {
     if (nodes != null) {
       var size = nodes.length;
       if (size > 0) {
         if (precededBy != null) {
           precededBy();
         }
         for (var i = 0; i < size; i++) {
           if (i > 0 && separatedBy != null) {
             separatedBy();
           }
           nodes[i].accept(this);
         }
         if (followedBy != null) {
           followedBy();
         }
       }
     }
   }
-  
-  /// Visit a [node], and if not null, optionally preceded or followed by the 
+
+  /// Visit a [node], and if not null, optionally preceded or followed by the
   /// specified functions.
   visitNode(ASTNode node, {precededBy(): null, followedBy(): null}) {
     if (node != null) {
       if (precededBy != null) {
         precededBy();
       }
       node.accept(this);
       if (followedBy != null) {
         followedBy();
       }
     }
   }
 
 
-  /// Emit the given [modifier] if it's non null, followed by non-breaking 
+  /// Emit the given [modifier] if it's non null, followed by non-breaking
   /// whitespace.
   modifier(Token modifier) {
     token(modifier, followedBy: space);
   }
-    
-  
+
+
   /// Indicate that at least one newline should be emitted and possibly more
   /// if the source has them.
   newlines() {
     preservePrecedingNewlines = true;
     needsNewline = true;
   }
-  
+
   token(Token token, {precededBy(), followedBy(), int minNewlines: 0}) {
     if (token != null) {
       if (needsNewline) {
         minNewlines = max(1, minNewlines);
       }
       if (preservePrecedingNewlines || minNewlines > 0) {
         var emitted = emitPrecedingNewlines(token, min: minNewlines);
         preservePrecedingNewlines = false;
         if (emitted > 0) {
           needsNewline = false;
         }
       }
       if (precededBy !=null) {
         precededBy();
       }
       append(token.lexeme);
-      if (followedBy != null) { 
+      if (followedBy != null) {
         followedBy();
       }
       previousToken = token;
-    }    
+    }
   }
-   
+
   commaSeperator() {
     comma();
     space();
   }
-  
+
   comma() {
     append(',');
   }
-  
+
   /// Emit a non-breakable space.
   space() {
     //TODO(pquitslund): replace with a proper space token
     append(' ');
   }
-  
+
   /// 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) {
       writer.print(string);
     }
   }
-    
+
   /// Indent.
   indent() {
     writer.indent();
   }
-  
+
   /// Unindent
   unindent() {
     writer.unindent();
   }
-  
+
   /// Emit any detected newlines or a minimum as specified by [minNewlines].
   int emitPrecedingNewlines(Token token, {min: 0}) {
     var comment = token.precedingComments;
     var currentToken = comment != null ? comment : token;
     var lines = max(min, countNewlinesBetween(previousToken, currentToken));
     writer.newlines(lines);
     while (comment != null) {
       append(comment.toString().trim());
       writer.newline();
       comment = comment.next;
@@ skipping 21 matching lines @@
       return 0;
     }
     var lastLine =
         lineInfo.getLocation(last.offset).lineNumber;
     var currentLine =
         lineInfo.getLocation(current.offset).lineNumber;
     return  currentLine - lastLine;
   }
 
   String toString() => writer.toString();
-  
+
 }