Indent functions in named argument lists with non-functions.

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 'dart:math' as math;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/scanner.dart';
@@ skipping 50 matching lines @@
         if (functionsEnd != null && functionsEnd != i) {
           functionsStart = null;
           functionsEnd = null;
           break;
         }
 
         functionsEnd = i + 1;
       }
     }
 
+    // Edge case: If all of the arguments are named, but they aren't all
+    // functions, then don't handle the functions specially. A function with a
+    // bunch of named arguments tends to look best when they are all lined up,
+    // even the function ones (unless they are all functions).
+    //
+    // Prefers:
+    //
+    //     function(
+    //         named: () {
+    //           something();
+    //         },
+    //         another: argument);
+    //
+    // Over:
+    //
+    //     function(named: () {
+    //       something();
+    //     }
+    //         another: argument);
+    if (functionsStart != null &&
+        node.arguments[0] is NamedExpression &&
+        (functionsStart > 0 || functionsEnd < node.arguments.length)) {
+      functionsStart = null;
+    }
+
     if (functionsStart == null) {
       // No functions, so there is just a single argument list.
       return new ArgumentListVisitor._(visitor, node,
           new ArgumentSublist(node.arguments, node.arguments), null, null);
     }
 
     // Split the arguments into two independent argument lists with the
     // functions in the middle.
     var argumentsBefore = node.arguments.take(functionsStart).toList();
     var functions = node.arguments.sublist(functionsStart, functionsEnd);
@@ skipping 331 matching lines @@
 
     // TODO(rnystrom): Should we step into parenthesized expressions?
 
     if (expression is ListLiteral) return expression.leftBracket;
     if (expression is MapLiteral) return expression.leftBracket;
 
     // Not a collection literal.
     return null;
   }
 }