Tweak formatting rules. Fix #211.

lib/src/source_visitor.dart

 // Copyright (c) 2014, 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 dart_style.src.source_visitor;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 
@@ skipping 87 matching lines @@
 
     // If there is just one positional argument, it tends to look weird to
     // split before it, so try not to.
     var singleArgument = node.arguments.length == 1 &&
         node.arguments.single is ! NamedExpression;
     if (singleArgument) _writer.startSpan();
 
     // Nest around the parentheses in case there are comments before or after
     // them.
     _writer.nestExpression();
+
     token(node.leftParenthesis);
 
+    // Corner case: If the first argument to a method is a block-bodied
+    // function, it looks bad if its parameter list gets wrapped to the next
+    // line. Bump the cost to try to avoid that. This prefers:
+    //
+    //     receiver
+    //         .method()
+    //         .chain((parameter, list) {
+    //       ...
+    //     });
+    //
+    // over:
+    //
+    //     receiver.method().chain(
+    //         (parameter, list) {
+    //       ...
+    //     });
+    // TODO(rnystrom): This causes a function expression's long parameter list
+    // to get split instead, like:
+    //
+    //     receiver.method((longParameter,
+    //         anotherParameter) {
+    //       ...
+    //     });
+    //
+    // Instead of bumping the cost, this should wrap a span around the "("
+    // before the argument list and the function's parameter list. That requires
+    // spans to not strictly be a stack, though, so would be a larger change
+    // than I want to do right now.
+    var cost = Cost.normal;
+    if (node.arguments.isNotEmpty) {
+      var firstArg = node.arguments.first;
+      if (firstArg is FunctionExpression &&
+          firstArg.body is BlockFunctionBody) {
+        cost = Cost.firstBlockArgument;
+      }
+    }
+
     // Allow splitting after "(".
-    var lastParam = zeroSplit();
+    var lastParam = zeroSplit(cost);
 
     // Try to keep the positional arguments together.
-    _writer.startSpan();
+    _writer.startSpan(Cost.positionalArguments);
 
     var i = 0;
     for (; i < node.arguments.length; i++) {
       var argument = node.arguments[i];
 
       if (argument is NamedExpression) break;
 
       visit(argument);
 
       // Write the trailing comma and split.
@@ skipping 847 matching lines @@
 
   visitLibraryIdentifier(LibraryIdentifier node) {
     visit(node.components.first);
     for (var component in node.components.skip(1)) {
       token(component.beginToken.previous); // "."
       visit(component);
     }
   }
 
   visitListLiteral(ListLiteral node) {
+    // Corner case: Splitting inside a list looks bad if there's only one
+    // element, so make those more costly.
+    var cost = node.elements.length <= 1 ? Cost.singleElementList : Cost.normal;
     _visitCollectionLiteral(
-        node, node.leftBracket, node.elements, node.rightBracket);
+        node, node.leftBracket, node.elements, node.rightBracket, cost);
   }
 
   visitMapLiteral(MapLiteral node) {
     _visitCollectionLiteral(
         node, node.leftBracket, node.entries, node.rightBracket);
   }
 
   visitMapLiteralEntry(MapLiteralEntry node) {
     visit(node.key);
     token(node.separator);
@@ skipping 541 matching lines @@
       visit(node);
 
       // The comma after the node.
       if (node.endToken.next.lexeme == ",") token(node.endToken.next);
     }
   }
 
   /// Visits the collection literal [node] whose body starts with [leftBracket],
   /// ends with [rightBracket] and contains [elements].
   void _visitCollectionLiteral(TypedLiteral node, Token leftBracket,
-      Iterable<AstNode> elements, Token rightBracket) {
+      Iterable<AstNode> elements, Token rightBracket, [int cost]) {
     modifier(node.constKeyword);
     visit(node.typeArguments);
 
-    _startBody(leftBracket);
+    _startBody(leftBracket, cost: cost);
 
     // Each list element takes at least 3 characters (one character for the
     // element, one for the comma, one for the space), so force it to split if
     // we know that won't fit.
     if (elements.length > _writer.pageWidth ~/ 3) _writer.preemptMultisplits();
 
     for (var element in elements) {
       if (element != elements.first) _writer.multisplit(space: true);
 
       _writer.nestExpression();
@@ skipping 82 matching lines @@
     // TODO(rnystrom): Can the analyzer move "semicolon" to some shared base
     // type?
     token((node as dynamic).semicolon);
     _writer.unnest();
   }
   /// Writes an opening bracket token ("(", "{", "[") and handles indenting and
   /// starting the multisplit it contains.
   ///
   /// If [space] is `true`, then the initial multisplit will use a space if not
   /// split.
-  void _startBody(Token leftBracket, {bool space: false}) {
+  void _startBody(Token leftBracket, {int cost, bool space: false}) {
     token(leftBracket);
 
     // Indent the body.
-    _writer.startMultisplit();
+    _writer.startMultisplit(cost: cost);
     _writer.indent();
 
     // Split after the bracket.
     _writer.multisplit(space: space);
   }
 
   /// Writes a closing bracket token (")", "}", "]") and handles unindenting
   /// and ending the multisplit it contains.
   ///
   /// Used for blocks, other curly bodies, and collection literals.
@@ skipping 72 matching lines @@
 
   /// Writes a single-space split with the given [cost].
   ///
   /// If [cost] is omitted, defaults to [Cost.normal]. Returns the newly created
   /// [SplitParam].
   SplitParam split([int cost]) => _writer.writeSplit(cost: cost, space: true);
 
   /// Writes a split that is the empty string when unsplit.
   ///
   /// Returns the newly created [SplitParam].
-  SplitParam zeroSplit() => _writer.writeSplit();
+  SplitParam zeroSplit([int cost]) => _writer.writeSplit(cost: cost);
 
   /// Emit [token], along with any comments and formatted whitespace that comes
   /// before it.
   ///
   /// Does nothing if [token] is `null`. If [before] is given, it will be
   /// executed before the token is outout. Likewise, [after] will be called
   /// after the token is output.
   void token(Token token, {before(), after()}) {
     if (token == null) return;
 
@@ skipping 171 matching lines @@
   /// Gets the 1-based line number that the beginning of [token] lies on.
   int _startLine(Token token) => _lineInfo.getLocation(token.offset).lineNumber;
 
   /// Gets the 1-based line number that the end of [token] lies on.
   int _endLine(Token token) => _lineInfo.getLocation(token.end).lineNumber;
 
   /// Gets the 1-based column number that the beginning of [token] lies on.
   int _startColumn(Token token) =>
       _lineInfo.getLocation(token.offset).columnNumber;
 }