dartfmt gets opinionated about 'gratuitous' linebreaks.

pkg/analyzer/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/analyzer.dart';
 import 'package:analyzer/src/generated/java_core.dart' show CharSequence;
@@ skipping 334 matching lines @@
 
   /// 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 preserveNewlines = false;
+
   /// A counter for spaces that should be emitted preceding the next token.
   int leadingSpaces = 0;
 
   /// A flag to specify whether line-leading spaces should be preserved (and
   /// addded to the indent level).
   bool allowLineLeadingSpaces;
 
   /// Used for matching EOL comments
   final twoSlashes = new RegExp(r'//[^/]');
 
@@ skipping 90 matching lines @@
 
   visitBreakStatement(BreakStatement node) {
     token(node.keyword);
     visitNode(node.label, precededBy: space);
     token(node.semicolon);
   }
 
   visitCascadeExpression(CascadeExpression node) {
     visit(node.target);
     indent(2);
-    visitNodes(node.cascadeSections);
+    newlines();
+    visitNodes(node.cascadeSections, separatedBy: newlines);
     unindent(2);
   }
 
   visitCatchClause(CatchClause node) {
 
     token(node.onKeyword, followedBy: space);
     visit(node.exceptionType);
 
     if (node.catchKeyword != null) {
       if (node.exceptionType != null) {
         space();
       }
       token(node.catchKeyword);
       space();
       token(node.leftParenthesis);
       visit(node.exceptionParameter);
       token(node.comma, followedBy: space);
       visit(node.stackTraceParameter);
       token(node.rightParenthesis);
       space();
     } else {
       space();
     }
     visit(node.body);
   }
 
   visitClassDeclaration(ClassDeclaration node) {
+    preserveLeadingNewlines();
     modifier(node.abstractKeyword);
     token(node.classKeyword);
     space();
     visit(node.name);
     allowContinuedLines((){
       visit(node.typeParameters);
       visitNode(node.extendsClause, precededBy: space);
       visitNode(node.withClause, precededBy: space);
       visitNode(node.implementsClause, precededBy: space);
       space();
@@ skipping 37 matching lines @@
     }
 
     var scriptTag = node.scriptTag;
     var directives = node.directives;
     visit(scriptTag);
 
     visitNodes(directives, separatedBy: newlines, followedBy: newlines);
 
     visitNodes(node.declarations, separatedBy: newlines);
 
+    preserveLeadingNewlines();
+
     // Handle trailing whitespace
     token(node.endToken /* EOF */);
 
     // Be a good citizen, end with a NL
     ensureTrailingNewline();
   }
 
   visitConditionalExpression(ConditionalExpression node) {
     visit(node.condition);
     space();
@@ skipping 234 matching lines @@
       visitCommaSeparatedNodes(node.updaters);
     }
     token(node.rightParenthesis);
     if (node.body is! EmptyStatement) {
       space();
     }
     visit(node.body);
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
+    preserveLeadingNewlines();
     visitNode(node.returnType, followedBy: space);
     token(node.propertyKeyword, followedBy: space);
     visit(node.name);
     visit(node.functionExpression);
   }
 
   visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     visit(node.functionDeclaration);
   }
 
@@ skipping 144 matching lines @@
     visitCommaSeparatedNodes(node.elements);
     optionalTrailingComma(node.rightBracket);
     unindent();
     token(node.rightBracket);
   }
 
   visitMapLiteral(MapLiteral node) {
     modifier(node.constKeyword);
     visitNode(node.typeArguments, followedBy: space);
     token(node.leftBracket);
+    newlines();
     indent();
-    visitCommaSeparatedNodes(node.entries);
+    visitCommaSeparatedNodes(node.entries, followedBy: newlines);
     optionalTrailingComma(node.rightBracket);
     unindent();
+    newlines();
     token(node.rightBracket);
   }
 
   visitMapLiteralEntry(MapLiteralEntry node) {
     visit(node.key);
     token(node.separator);
     space();
     visit(node.value);
   }
 
@@ skipping 320 matching lines @@
           nodes[i].accept(this);
         }
         if (followedBy != null) {
           followedBy();
         }
       }
     }
   }
 
   /// Visit a comma-separated list of [nodes] if not null.
-  visitCommaSeparatedNodes(NodeList<ASTNode> nodes) {
+  visitCommaSeparatedNodes(NodeList<ASTNode> nodes, {followedBy(): null}) {
+    //TODO(pquitslund): handle this more neatly

[pquitslund, 2013/12/18 17:16:47]

EG: by introducing a const pointer to the space function.

[Brian Wilkerson, 2013/12/18 17:53:07]

In order to do that, the space function will have to be a static function. But
if it's a static function, then it's already a constant, so you don't need an
additional const variable to point to it and should be able to write
"{followedBy(): space}".

+    if (followedBy == null) {
+      followedBy = space;
+    }
     if (nodes != null) {
       var size = nodes.length;
       if (size > 0) {
         var node;
         for (var i = 0; i < size; i++) {
           node = nodes[i];
           if (i > 0) {
             var comma = node.beginToken.previous;
             token(comma);
-            space();
+            followedBy();
           }
           node.accept(this);
         }
       }
     }
   }
 
 
   /// Visit a [node], and if not null, optionally preceded or followed by the
   /// specified functions.
@@ skipping 28 matching lines @@
     needsNewline = true;
   }
 
   /// Optionally emit a trailing comma.
   optionalTrailingComma(Token rightBracket) {
     if (rightBracket.previous.lexeme == ',') {
       token(rightBracket.previous);
     }
   }
 
+  /// Indicate that user introduced newlines should be emitted before the next
+  /// token.
+  preserveLeadingNewlines() {
+    preserveNewlines = true;
+  }
+
   token(Token token, {precededBy(), followedBy(), int minNewlines: 0}) {
     if (token != null) {
       if (needsNewline) {
         minNewlines = max(1, minNewlines);
       }
       var emitted = emitPrecedingCommentsAndNewlines(token, min: minNewlines);
       if (emitted > 0) {
         needsNewline = false;
       }
       if (precededBy != null) {
@@ skipping 90 matching lines @@
     var comment = token.precedingComments;
     var currentToken = comment != null ? comment : token;
 
     //Handle EOLs before newlines
     if (isAtEOL(comment)) {
       emitComment(comment, previousToken);
       comment = comment.next;
       currentToken = comment != null ? comment : token;
     }
 
-    var lines = max(min, countNewlinesBetween(previousToken, currentToken));
+    var lines = 0;
+    if (needsNewline || preserveNewlines) {
+      lines = max(min, countNewlinesBetween(previousToken, currentToken));
+      preserveNewlines = false;
+    }
     emitNewlines(lines);
 
     previousToken =
         currentToken.previous != null ? currentToken.previous : token.previous;
 
     while (comment != null) {
 
       emitComment(comment, previousToken);
 
       var nextToken = comment.next != null ? comment.next : token;
@@ skipping 109 matching lines @@
     var lastLine =
         lineInfo.getLocation(lastOffset).lineNumber;
     var currentLine =
         lineInfo.getLocation(currentOffset).lineNumber;
     return currentLine - lastLine;
   }
 
   String toString() => writer.toString();
 
 }