Handle function arguments inside function calls.

lib/src/argument_list_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.argument_list_visitor;
 
 import 'package:analyzer/analyzer.dart';
 
 import 'chunk.dart';
 import 'rule/argument.dart';
@@ skipping 79 matching lines @@
     var argumentsAfter = node.arguments.skip(functionsEnd).toList();
 
     return new ArgumentListVisitor._(
         visitor,
         node,
         new ArgumentSublist(node.arguments, argumentsBefore),
         functions,
         new ArgumentSublist(node.arguments, argumentsAfter));
   }
 
-  ArgumentListVisitor._(
-      this._visitor,
-      this._node,
-      this._arguments,
-      this._functions,
-      this._argumentsAfterFunctions);
+  ArgumentListVisitor._(this._visitor, this._node, this._arguments,
+      this._functions, this._argumentsAfterFunctions);
 
   /// Builds chunks for the call chain.
   void visit() {
     // If there is just one positional argument, it tends to look weird to
     // split before it, so try not to.
     if (_isSingle) _visitor.builder.startSpan();
 
     // Nest around the parentheses in case there are comments before or after
     // them.
     _visitor.builder.nestExpression();
@@ skipping 39 matching lines @@
     if (_isSingle) _visitor.builder.endSpan();
   }
 
   /// Returns `true` if [expression] is a [FunctionExpression] with a block
   /// body.
   static bool _isBlockFunction(Expression expression) {
     if (expression is NamedExpression) {
       expression = (expression as NamedExpression).expression;
     }
 
+    // Allow functions wrapped in dotted method calls like "a.b.c(() { ... })".
+    if (expression is MethodInvocation) {
+      if (!_isValidWrappingTarget(expression.target)) return false;
+      if (expression.argumentList.arguments.length != 1) return false;
+
+      return _isBlockFunction(expression.argumentList.arguments.single);
+    }
+
     // Curly body functions are.
     if (expression is! FunctionExpression) return false;
     var function = expression as FunctionExpression;
     return function.body is BlockFunctionBody;
   }
+
+  /// Returns `true` if [expression] is a valid method invocation target for
+  /// an invocation that wraps a function literal argument.
+  static bool _isValidWrappingTarget(Expression expression) {
+    // Allow bare function calls.
+    if (expression == null) return true;
+
+    // Allow property accesses.
+    while (expression is PropertyAccess) {
+      expression = (expression as PropertyAccess).target;
+    }
+
+    if (expression is PrefixedIdentifier) return true;
+    if (expression is SimpleIdentifier) return true;
+
+    return false;
+  }
 }
 
 /// A range of arguments from a complete argument list.
 ///
 /// One of these typically covers all of the arguments in an invocation. But,
 /// when an argument list has block functions in the middle, the arguments
 /// before and after the functions are treated as separate independent lists.
 /// In that case, there will be two of these.
 class ArgumentSublist {
   /// The full argument list from the AST.
@@ skipping 146 matching lines @@
     var positionalRule = rule;
     var namedRule = new NamedRule(_collectionRule);
     visitor.builder.startRule(namedRule);
 
     // Let the positional args force the named ones to split.
     if (positionalRule != null) {
       positionalRule.setNamedArgsRule(namedRule);
     }
 
     // Split before the first named argument.
-    namedRule.beforeArguments(visitor.builder.split(
-        space: !_isFirstArgument(_named.first)));
+    namedRule.beforeArguments(
+        visitor.builder.split(space: !_isFirstArgument(_named.first)));
 
     for (var argument in _named) {
       _visitArgument(visitor, namedRule, argument);
 
       // Write the split.
       if (argument != _named.last) visitor.split();
     }
 
     visitor.builder.endRule();
   }
 
-  void _visitArgument(SourceVisitor visitor, ArgumentRule rule, Expression argument) {
+  void _visitArgument(
+      SourceVisitor visitor, ArgumentRule rule, Expression argument) {
     // If we're about to write a collection argument, handle it specially.
     if (_collections.contains(argument)) {
       if (rule != null) rule.beforeCollection();
 
       // Tell it to use the rule we've already created.
       visitor.setNextLiteralBodyRule(_collectionRule);
     } else if (_hasMultipleArguments) {
       // Corner case: If there is just a single argument, don't bump the
       // nesting. This lets us avoid spurious indentation in cases like:
       //
@@ skipping 27 matching lines @@
   /// indentation to make them look more statement-like.
   static bool _isCollectionArgument(Expression expression) {
     if (expression is NamedExpression) {
       expression = (expression as NamedExpression).expression;
     }
 
     // TODO(rnystrom): Should we step into parenthesized expressions?
 
     return expression is ListLiteral || expression is MapLiteral;
   }
-}
+}