Formatter checkpoint.

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';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
 import 'package:analyzer_experimental/src/generated/source.dart';
 import 'package:analyzer_experimental/src/services/writer.dart';
 
 /// OS line separator. --- TODO(pquitslund): may not be necessary
 const NEW_LINE = '\n' ; //Platform.pathSeparator;
 
@@ skipping 51 matching lines @@
 
 /// Dart source code formatter.
 abstract class CodeFormatter {
 
   factory CodeFormatter([FormatterOptions options = const FormatterOptions()])
                         => new CodeFormatterImpl(options);
 
   /// Format the specified portion (from [offset] with [length]) of the given
   /// [source] string, optionally providing an [indentationLevel].
   String format(CodeKind kind, String source, {int offset, int end,
-    int indentationLevel:0});
+    int indentationLevel: 0});
 
 }
 
 class CodeFormatterImpl implements CodeFormatter, AnalysisErrorListener {
 
   final FormatterOptions options;
   final errors = <AnalysisError>[];
 
   LineInfo lineInfo;
 
   CodeFormatterImpl(this.options);
 
   String format(CodeKind kind, String source, {int offset, int end,
-      int indentationLevel:0}) {
+      int indentationLevel: 0}) {
 
     var start = tokenize(source);
     checkForErrors();
 
     var node = parse(kind, start);
     checkForErrors();
 
     var formatter = new SourceVisitor(options, lineInfo);
     node.accept(formatter);
 
@@ skipping 27 matching lines @@
   Token tokenize(String source) {
     var scanner = new StringScanner(null, source, this);
     var token = scanner.tokenize();
     lineInfo = new LineInfo(scanner.lineStarts);
     return token;
   }
 
 }
 
 
-
 /// An AST visitor that drives formatting heuristics.
 class SourceVisitor implements ASTVisitor {
 
   /// The writer to which the source is to be written.
   SourceWriter writer;
 
+  /// Cached line info for calculating blank lines.
   LineInfo lineInfo;
 
+  /// Cached previous token for calculating preceding whitespace.
+  Token previousToken;
+
   /// 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) {
     visitList(node.strings, ' ');
   }
 
@@ skipping 48 matching lines @@
     writer.indent();
 
     for (var stmt in node.statements) {
       writer.newline();
       visit(stmt);
     }
 
     writer.unindent();
     writer.newline();
     writer.print('}');
+    previousToken = node.rightBracket;
   }
 
   visitBlockFunctionBody(BlockFunctionBody node) {
     visit(node.block);
   }
 
   visitBooleanLiteral(BooleanLiteral node) {
     writer.print(node.literal.lexeme);
   }
 
@@ skipping 18 matching lines @@
       visit(node.exceptionParameter);
       visitPrefixed(', ', node.stackTraceParameter);
       writer.print(') ');
     } else {
       writer.print(' ');
     }
     visit(node.body);
   }
 
   visitClassDeclaration(ClassDeclaration node) {
-    visitToken(node.abstractKeyword, ' ');
-    writer.print('class ');
+    emitToken(node.abstractKeyword, ' ');
+    emitToken(node.classKeyword, ' ');
     visit(node.name);
     visit(node.typeParameters);
     visitPrefixed(' ', node.extendsClause);
     visitPrefixed(' ', node.withClause);
     visitPrefixed(' ', node.implementsClause);
-    writer.print(' {');
+//    writer.print(' {');
+//    writer.print(' ');
+//    emit(node.leftBracket);
+    emitPrefixedToken(' ', node.leftBracket);
     writer.indent();
-    for (var member in node.members) {
-      writer.newline();
-      visit(member);
+
+    for (var i = 0; i < node.members.length; i++) {
+      visit(node.members[i]);
     }
 
     writer.unindent();
-    writer.newline();
-    writer.print('}');
+
+    emit(node.rightBracket, min: 1);
   }
 
   visitClassTypeAlias(ClassTypeAlias node) {
     writer.print('typedef ');
     visit(node.name);
     visit(node.typeParameters);
     writer.print(' = ');
     if (node.abstractKeyword != null) {
       writer.print('abstract ');
     }
     visit(node.superclass);
     visitPrefixed(' ', node.withClause);
     visitPrefixed(' ', node.implementsClause);
     writer.print(';');
   }
 
   visitComment(Comment node) => null;
 
   visitCommentReference(CommentReference node) => null;
 
   visitCompilationUnit(CompilationUnit node) {
     var scriptTag = node.scriptTag;
     var directives = node.directives;
     visit(scriptTag);
     var prefix = scriptTag == null ? '' : ' ';
     visitPrefixedList(prefix, directives, ' ');
-    prefix = scriptTag == null && directives.isEmpty ? '' : ' ';
-    visitPrefixedListWithBlanks(prefix, node.declarations);
+    //prefix = scriptTag == null && directives.isEmpty ? '' : ' ';
+    prefix = '';
+    visitPrefixedList(prefix, node.declarations);
 
     //TODO(pquitslund): move this?
     writer.newline();
   }
 
   visitConditionalExpression(ConditionalExpression node) {
     visit(node.condition);
     writer.print(' ? ');
     visit(node.thenExpression);
     writer.print(' : ');
     visit(node.elseExpression);
   }
 
   visitConstructorDeclaration(ConstructorDeclaration node) {
-    visitToken(node.externalKeyword, ' ');
-    visitToken(node.constKeyword, ' ');
-    visitToken(node.factoryKeyword, ' ');
+    emitToken(node.externalKeyword, ' ');
+    emitToken(node.constKeyword, ' ');
+    emitToken(node.factoryKeyword, ' ');
     visit(node.returnType);
     visitPrefixed('.', node.name);
     visit(node.parameters);
     visitPrefixedList(' : ', node.initializers, ', ');
     visitPrefixed(' = ', node.redirectedConstructor);
     visitPrefixedBody(' ', node.body);
   }
 
   visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
-    visitToken(node.keyword, '.');
+    emitToken(node.keyword, '.');
     visit(node.fieldName);
     writer.print(' = ');
     visit(node.expression);
   }
 
   visitConstructorName(ConstructorName node) {
     visit(node.type);
     visitPrefixed('.', node.name);
   }
 
   visitContinueStatement(ContinueStatement node) {
     writer.print('continue');
     visitPrefixed(' ', node.label);
     writer.print(';');
   }
 
   visitDeclaredIdentifier(DeclaredIdentifier node) {
-    visitToken(node.keyword, ' ');
+    emitToken(node.keyword, ' ');
     visitSuffixed(node.type, ' ');
     visit(node.identifier);
   }
 
   visitDefaultFormalParameter(DefaultFormalParameter node) {
     visit(node.parameter);
     if (node.separator != null) {
       writer.print(' ');
       writer.print(node.separator.lexeme);
       visitPrefixed(' ', node.defaultValue);
@@ skipping 39 matching lines @@
     visit(node.expression);
     writer.print(';');
   }
 
   visitExtendsClause(ExtendsClause node) {
     writer.print('extends ');
     visit(node.superclass);
   }
 
   visitFieldDeclaration(FieldDeclaration node) {
-    visitToken(node.keyword, ' ');
+    emitToken(node.keyword, ' ');
     visit(node.fields);
     writer.print(';');
   }
 
   visitFieldFormalParameter(FieldFormalParameter node) {
-    visitToken(node.keyword, ' ');
+    emitToken(node.keyword, ' ');
     visitSuffixed(node.type, ' ');
     writer.print('this.');
     visit(node.identifier);
     visit(node.parameters);
   }
 
   visitForEachStatement(ForEachStatement node) {
     writer.print('for (');
     visit(node.loopVariable);
     writer.print(' in ');
@@ skipping 40 matching lines @@
     writer.print(';');
     visitPrefixed(' ', node.condition);
     writer.print(';');
     visitPrefixedList(' ', node.updaters, ', ');
     writer.print(') ');
     visit(node.body);
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     visitSuffixed(node.returnType, ' ');
-    visitToken(node.propertyKeyword, ' ');
+    emitToken(node.propertyKeyword, ' ');
     visit(node.name);
     visit(node.functionExpression);
   }
 
   visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     visit(node.functionDeclaration);
     writer.print(';');
   }
 
   visitFunctionExpression(FunctionExpression node) {
@@ skipping 38 matching lines @@
   visitImplementsClause(ImplementsClause node) {
     writer.print('implements ');
     visitList(node.interfaces, ', ');
   }
 
   visitImportDirective(ImportDirective node) {
     writer.print('import ');
     visit(node.uri);
     visitPrefixed(' as ', node.prefix);
     visitPrefixedList(' ', node.combinators, ' ');
-    writer.print(';');
+//    writer.print(';');
+    emit(node.semicolon);
+//    writer.newline();
   }
 
   visitIndexExpression(IndexExpression node) {
     if (node.isCascaded) {
       writer.print('..');
     } else {
       visit(node.target);
     }
     writer.print('[');
     visit(node.index);
     writer.print(']');
   }
 
   visitInstanceCreationExpression(InstanceCreationExpression node) {
-    visitToken(node.keyword, ' ');
+    emitToken(node.keyword, ' ');
     visit(node.constructorName);
     visit(node.argumentList);
   }
 
   visitIntegerLiteral(IntegerLiteral node) {
     writer.print(node.literal.lexeme);
   }
 
   visitInterpolationExpression(InterpolationExpression node) {
     if (node.rightBracket != null) {
@@ skipping 62 matching lines @@
     writer.print('}');
   }
 
   visitMapLiteralEntry(MapLiteralEntry node) {
     visit(node.key);
     writer.print(' : ');
     visit(node.value);
   }
 
   visitMethodDeclaration(MethodDeclaration node) {
-    visitToken(node.externalKeyword, ' ');
-    visitToken(node.modifierKeyword, ' ');
+    emitToken(node.externalKeyword, ' ');
+    emitToken(node.modifierKeyword, ' ');
     visitSuffixed(node.returnType, ' ');
-    visitToken(node.propertyKeyword, ' ');
-    visitToken(node.operatorKeyword, ' ');
+    emitToken(node.propertyKeyword, ' ');
+    emitToken(node.operatorKeyword, ' ');
     visit(node.name);
     if (!node.isGetter) {
       visit(node.parameters);
     }
     visitPrefixedBody(' ', node.body);
   }
 
   visitMethodInvocation(MethodInvocation node) {
     if (node.isCascaded) {
       writer.print('..');
@@ skipping 92 matching lines @@
   visitScriptTag(ScriptTag node) {
     writer.print(node.scriptTag.lexeme);
   }
 
   visitShowCombinator(ShowCombinator node) {
     writer.print('show ');
     visitList(node.shownNames, ', ');
   }
 
   visitSimpleFormalParameter(SimpleFormalParameter node) {
-    visitToken(node.keyword, ' ');
+    emitToken(node.keyword, ' ');
     visitSuffixed(node.type, ' ');
     visit(node.identifier);
   }
 
   visitSimpleIdentifier(SimpleIdentifier node) {
-    writer.print(node.token.lexeme);
+    emit(node.token);
+//    writer.print(node.token.lexeme);
   }
 
   visitSimpleStringLiteral(SimpleStringLiteral node) {
     writer.print(node.literal.lexeme);
   }
 
   visitStringInterpolation(StringInterpolation node) {
     visitList(node.elements);
   }
 
@@ skipping 74 matching lines @@
     visitList(node.typeParameters, ', ');
     writer.print('>');
   }
 
   visitVariableDeclaration(VariableDeclaration node) {
     visit(node.name);
     visitPrefixed(' = ', node.initializer);
   }
 
   visitVariableDeclarationList(VariableDeclarationList node) {
-    visitToken(node.keyword, ' ');
+    emitToken(node.keyword, ' ');
     visitSuffixed(node.type, ' ');
     visitList(node.variables, ', ');
   }
 
   visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     visit(node.variables);
     writer.print(';');
   }
 
   visitWhileStatement(WhileStatement node) {
@@ skipping 35 matching lines @@
 
   /// Visit the given function [body], printing the [prefix] before if given
   /// body is not empty.
   visitPrefixedBody(String prefix, FunctionBody body) {
     if (body is! EmptyFunctionBody) {
       writer.print(prefix);
     }
     visit(body);
   }
 
-  /// Safely visit the given [token], printing the suffix after the [token]
+  /// Emit the given [token], printing the prefix before the [token]
+  /// if it is non-null.
+  emitPrefixedToken(String prefix, Token token) {
+    if (token != null) {
+      writer.print(prefix);
+      emit(token);
+    }
+  }
+
+  /// Emit the given [token], printing the suffix after the [token]
   /// node if it is non-null.
-  visitToken(Token token, String suffix) {
+  emitToken(Token token, String suffix) {
     if (token != null) {
-      writer.print(token.lexeme);
+      emit(token);
       writer.print(suffix);
     }
   }
 
   /// Print a list of [nodes], separated by the given [separator].
   visitList(NodeList<ASTNode> nodes, [String separator = '']) {
     if (nodes != null) {
       var size = nodes.length;
       for (var i = 0; i < size; i++) {
         if (i > 0) {
@@ skipping 14 matching lines @@
             writer.print(separator);
           }
           nodes[i].accept(this);
         }
         writer.print(suffix);
       }
     }
   }
 
   /// Print a list of [nodes], separated by the given [separator].
-  visitPrefixedList(String prefix, NodeList<ASTNode> nodes, String separator) {
+  visitPrefixedList(String prefix, NodeList<ASTNode> nodes,
+      [String separator = null]) {
     if (nodes != null) {
       var size = nodes.length;
       if (size > 0) {
         writer.print(prefix);
         for (var i = 0; i < size; i++) {
-          if (i > 0) {
+          if (i > 0 && separator != null) {
             writer.print(separator);
           }
           nodes[i].accept(this);
         }
       }
     }
   }
 
-  /// Print a list of [nodes], preserving blank lines between nodes.
-  visitPrefixedListWithBlanks(String prefix,
-      NodeList<ASTNode> nodes) {
-    if (nodes != null) {
-      var size = nodes.length;
-      if (size > 0) {
-        writer.print(prefix);
-        for (var i = 0; i < size; i++) {
-          if (i > 0) {
-            // Emit blanks lines
-            var lastLine =
-                lineInfo.getLocation(nodes[i-1].endToken.offset).lineNumber;
-            var currentLine =
-                lineInfo.getLocation(nodes[i].beginToken.offset).lineNumber;
-            var blanks = currentLine - lastLine;
-            for (var i = 0; i < blanks; i++) {
-              writer.newline();
-            }
-          }
-          nodes[i].accept(this);
-        }
-      }
+  /// Emit the given [token], preceeded by any detected newlines or a minimum
+  /// as specified by [min].
+  emit(Token token, {min: 0}) {
+    var comment = token.precedingComments;
+    var currentToken = comment != null ? comment : token;
+    var newlines = max(min, countNewlinesBetween(previousToken, currentToken));
+    writer.newlines(newlines);
+    while (comment != null) {
+      writer.print(comment.toString().trim());
+      writer.newline();
+      comment = comment.next;
     }
+
+    previousToken = token;
+    writer.print(token.lexeme);
+  }
+
+  /// Count the blanks between these two nodes.
+  int countBlankLinesBetween(ASTNode lastNode, ASTNode currentNode) =>
+      countNewlinesBetween(lastNode.endToken, currentNode.beginToken);
+
+  /// 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 nodes.
+  int countNewlinesBetween(Token last, Token current) {
+    if (last == null || current == null) {
+      return 0;
+    }
+    var lastLine =
+        lineInfo.getLocation(last.offset).lineNumber;
+    var currentLine =
+        lineInfo.getLocation(current.offset).lineNumber;
+    return  currentLine - lastLine;
   }
 
 }