Split after "=>" if the parameters split.

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 700 matching lines @@
       space();
 
       // The "async" or "sync" keyword.
       token(node.keyword, after: space);
 
       // Try to keep the "(...) => " with the start of the body for anonymous
       // functions.
       if (_isInLambda(node)) builder.startSpan();
 
       token(node.functionDefinition); // "=>".
-      soloSplit(Cost.arrow);
+
+      // Split after the "=>", using the rule created before the parameters
+      // by _visitBody().
+      split();
+      builder.endRule();
 
       if (_isInLambda(node)) builder.endSpan();
 
       builder.startBlockArgumentNesting();
       builder.startSpan();
       visit(node.expression);
       builder.endSpan();
       builder.endBlockArgumentNesting();
     });
   }
@@ skipping 828 matching lines @@
   }
 
   /// Visit the given function [parameters] followed by its [body], printing a
   /// space before it if it's not empty.
   ///
   /// If [afterParameters] is provided, it is invoked between the parameters
   /// and body. (It's used for constructor initialization lists.)
   void _visitBody(FormalParameterList parameters, FunctionBody body,
       [afterParameters()]) {
     // If the body is "=>", add an extra level of indentation around the
-    // parameters and the body. This ensures that if the parameters wrap, they
-    // wrap more deeply than the "=>" does, as in:
+    // parameters and a rule that spans the parameters and the "=>". This
+    // ensures that if the parameters wrap, they wrap more deeply than the "=>"
+    // does, as in:
     //
     //     someFunction(parameter,
     //             parameter, parameter) =>
     //         "the body";
-    if (body is ExpressionFunctionBody) builder.nestExpression();
+    //
+    // Also, it ensures that if the parameters wrap, we split at the "=>" too
+    // to avoid:
+    //
+    //     someFunction(parameter,
+    //         parameter) => function(
+    //         argument);
+    //
+    // This is confusing because it looks like those two lines are at the same
+    // level when they are actually unrelated. Splitting at "=>" forces:
+    //
+    //     someFunction(parameter,
+    //             parameter) =>
+    //         function(
+    //             argument);
+    if (body is ExpressionFunctionBody) {
+      builder.nestExpression();
+
+      // This rule is ended by visitExpressionFunctionBody().
+      builder.startRule(new SimpleRule(cost: Cost.arrow));
+    }
 
     if (parameters != null) {
       builder.nestExpression();
 
       visit(parameters);
       if (afterParameters != null) afterParameters();
 
       builder.unnest();
     }
 
@@ skipping 469 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;
 }