Indent the parameter list more if the body is a wrapped "=>". Fix #144.

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 438 matching lines @@
     visit(node.elseExpression);
 
     _writer.endMultisplit();
     _writer.endSpan();
     _writer.unnest();
   }
 
   visitConstructorDeclaration(ConstructorDeclaration node) {
     visitMemberMetadata(node.metadata);
 
-    _writer.nestExpression();
     modifier(node.externalKeyword);
     modifier(node.constKeyword);
     modifier(node.factoryKeyword);
     visit(node.returnType);
     token(node.period);
     visit(node.name);
 
     // Start a multisplit that spans the parameter list. We'll use this for the
     // split before ":" to ensure that if the parameter list doesn't fit on one
     // line that the initialization list gets pushed to its own line too.
     if (node.initializers.length == 1) _writer.startMultisplit();
 
-    visit(node.parameters);
-
-    // Check for redirects or initializer lists.
-    if (node.redirectedConstructor != null) {
-      _visitConstructorRedirects(node);
-    } else if (node.initializers.isNotEmpty) {
-      _visitConstructorInitializers(node);
-    }
-
-    _writer.unnest();
-
-    visitBody(node.body);
+    _visitBody(node.parameters, node.body, () {
+      // Check for redirects or initializer lists.
+      if (node.redirectedConstructor != null) {
+        _visitConstructorRedirects(node);
+      } else if (node.initializers.isNotEmpty) {
+        _visitConstructorInitializers(node);
+      }
+    });
   }
 
   void _visitConstructorInitializers(ConstructorDeclaration node) {
     _writer.indent(2);
 
     if (node.initializers.length == 1) {
       // If there is only a single initializer, allow it on the first line, but
       // only if the parameter list also fit all one line.
       _writer.multisplit(space: true);
       _writer.endMultisplit();
@@ skipping 209 matching lines @@
     token(node.inKeyword);
     space();
     visit(node.iterator);
     token(node.rightParenthesis);
     space();
     visit(node.body);
     _writer.unnest();
   }
 
   visitFormalParameterList(FormalParameterList node) {
+    _writer.nestExpression();
     token(node.leftParenthesis);
 
     // Allow splitting after the "(" in non-empty parameter lists, but not for
     // lambdas.
     if ((node.parameters.isNotEmpty ||
             node.rightParenthesis.precedingComments != null) &&
         !_isLambda(node)) {
       zeroSplit();
     }
 
@@ skipping 24 matching lines @@
         inOptionalParams = true;
       }
 
       visit(parameter);
     }
 
     // "]" or "}" for optional parameters.
     token(node.rightDelimiter);
 
     token(node.rightParenthesis);
+    _writer.unnest();
     _writer.endSpan();
   }
 
   visitForStatement(ForStatement node) {
     _writer.nestExpression();
     token(node.forKeyword);
     space();
     token(node.leftParenthesis);
 
     _writer.startMultisplit();
@@ skipping 51 matching lines @@
     visit(node.name);
     visit(node.functionExpression);
     _writer.unnest();
   }
 
   visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     visit(node.functionDeclaration);
   }
 
   visitFunctionExpression(FunctionExpression node) {
-    visit(node.parameters);
-    visitBody(node.body);
+    _visitBody(node.parameters, node.body);
   }
 
   visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     visit(node.function);
     visit(node.argumentList);
   }
 
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     visitDeclarationMetadata(node.metadata);
 
@@ skipping 158 matching lines @@
   visitMapLiteralEntry(MapLiteralEntry node) {
     visit(node.key);
     token(node.separator);
     split();
     visit(node.value);
   }
 
   visitMethodDeclaration(MethodDeclaration node) {
     visitMemberMetadata(node.metadata);
 
-    _writer.nestExpression();
     modifier(node.externalKeyword);
     modifier(node.modifierKeyword);
     visit(node.returnType, after: space);
     modifier(node.propertyKeyword);
     modifier(node.operatorKeyword);
     visit(node.name);
-    if (!node.isGetter) visit(node.parameters);
 
-    _writer.unnest();
-
-    visitBody(node.body);
+    _visitBody(node.parameters, node.body);
   }
 
   visitMethodInvocation(MethodInvocation node) {
     // With a chain of method calls like `foo.bar.baz.bang`, they either all
     // split or none of them do.
     var startedMultisplit = false;
 
     // Try to keep the entire method chain one line.
     _writer.startSpan();
     _writer.nestExpression();
@@ skipping 444 matching lines @@
   }
 
   /// Visit metadata annotations on parameters and type parameters.
   ///
   /// These are always on the same line as the parameter.
   void visitParameterMetadata(NodeList<Annotation> metadata) {
     // TODO(rnystrom): Allow splitting after annotations?
     visitNodes(metadata, between: space, after: space);
   }
 
-  /// Visit the given function [body], printing a space before it if it's not
-  /// empty.
-  void visitBody(FunctionBody body) {
+  /// 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 (parameters != null) {
+      // If the body is "=>", add an extra level of indentation around the
+      // parameters. This ensures that if they wrap, they wrap more deeply than
+      // the "=>" does, as in:
+      //
+      //     someFunction(parameter,
+      //             parameter, parameter) =>
+      //         "the body";
+      if (body is ExpressionFunctionBody) _writer.nestExpression();
+
+      visit(parameters);
+      if (afterParameters != null) afterParameters();
+
+      if (body is ExpressionFunctionBody) _writer.unnest();
+    }
+
     if (body is! EmptyFunctionBody) space();
     visit(body);
   }
 
   /// Visit a list of [nodes] if not null, optionally separated and/or preceded
   /// and followed by the given functions.
   void visitNodes(Iterable<AstNode> nodes, {before(), between(), after()}) {
     if (nodes == null || nodes.isEmpty) return;
 
     if (before != null) before();
@@ skipping 408 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;
 }