Improved comment handling (and misc. formatter fixes).

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 305 matching lines @@
     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);
+    visitNodes(directives, separatedBy: newlines, followedBy: newlines);
 
     preservePrecedingNewlines = true;
     visitNodes(node.declarations, separatedBy: newlines);
 
     // Handle trailing whitespace
     preservePrecedingNewlines = true;
     token(node.endToken /* EOF */);
   }
 
   visitConditionalExpression(ConditionalExpression node) {
@@ skipping 191 matching lines @@
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     visitNode(node.returnType, followedBy: space);
     token(node.propertyKeyword, followedBy: space);
     visit(node.name);
     visit(node.functionExpression);
   }
 
   visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     visit(node.functionDeclaration);
-    // TODO(pquitslund): fix and handle in function body
-    append(';');
   }
 
   visitFunctionExpression(FunctionExpression node) {
     visit(node.parameters);
     space();
     visit(node.body);
   }
 
   visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     visit(node.function);
@@ skipping 133 matching lines @@
   visitMapLiteral(MapLiteral node) {
     modifier(node.modifier);
     visitNode(node.typeArguments, followedBy: space);
     token(node.leftBracket);
     visitNodes(node.entries, separatedBy: commaSeperator);
     token(node.rightBracket);
   }
 
   visitMapLiteralEntry(MapLiteralEntry node) {
     visit(node.key);
-    space();
     token(node.separator);
     space();
     visit(node.value);
   }
 
   visitMethodDeclaration(MethodDeclaration node) {
     modifier(node.externalKeyword);
     modifier(node.modifierKeyword);
     visitNode(node.returnType, followedBy: space);
     modifier(node.propertyKeyword);
@@ skipping 344 matching lines @@
       if (preservePrecedingNewlines || minNewlines > 0) {
         var emitted = emitPrecedingNewlines(token, min: minNewlines);
         preservePrecedingNewlines = false;
         if (emitted > 0) {
           needsNewline = false;
         }
       }
       if (precededBy !=null) {
         precededBy();
       }
+      emitBlockComments(token);
       append(token.lexeme);
       if (followedBy != null) {
         followedBy();
       }
       previousToken = token;
     }
   }
 
   commaSeperator() {
     comma();
@@ skipping 25 matching lines @@
   /// Indent.
   indent() {
     writer.indent();
   }
 
   /// Unindent
   unindent() {
     writer.unindent();
   }
 
-  /// Emit any detected newlines or a minimum as specified by [minNewlines].
+  emitBlockComments(Token token) {
+    var comment = token.precedingComments;
+    while (comment != null) {
+      if (isBlock(comment)) {
+        append(comment.toString().trim());
+        if (linesBetween(comment.end, token.offset) >= 1) {
+          writer.newline();
+        } else {
+          space();
+        }
+      }
+      comment = comment.next;
+    }
+  }
+
+  /// Emit any detected newlines or a minimum as specified by [min].
   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();
+      if (!isBlock(comment)) {
+        append(comment.toString().trim());
+        var nextToken = comment.next != null ? comment.next : token;
+        var postCommentNewlines =
+            max(1, countNewlinesBetween(comment, nextToken));
+        writer.newlines(postCommentNewlines);
+        lines += postCommentNewlines;
+      }
       comment = comment.next;
     }
 
     previousToken = token;
     return lines;
   }
 
   /// 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;
     }
+
+    return linesBetween(last.end - 1, current.offset);
+  }
+
+  /// Test if this [comment] is a block comment.
+  bool isBlock(Token comment) =>
+      comment.type != TokenType.SINGLE_LINE_COMMENT &&
+        linesBetween(comment.offset, comment.end) <= 1;

[Brian Wilkerson, 2013/08/27 21:12:45]

Can this ever legitimately be 1, or should this test just be "< 1"?

[pquitslund, 2013/08/27 21:55:38]

I think not.  Fixed!

+
+  /// Count the lines between two offsets.
+  int linesBetween(int lastOffset, int currentOffset) {
     var lastLine =
-        lineInfo.getLocation(last.offset).lineNumber;
+        lineInfo.getLocation(lastOffset).lineNumber;
     var currentLine =
-        lineInfo.getLocation(current.offset).lineNumber;
-    return  currentLine - lastLine;
+        lineInfo.getLocation(currentOffset).lineNumber;
+    return currentLine - lastLine;
   }
 
   String toString() => writer.toString();
 
 }