Eat some dogfood!

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 29 matching lines @@
 
   /// The rule used to split the bodies of all of the block arguments.
   Rule get _blockArgumentRule {
     // Lazy initialize.
     if (_blockRule == null && _blockArguments.isNotEmpty) {
       _blockRule = new SimpleRule(cost: Cost.splitBlocks);
     }
 
     return _blockRule;
   }
+
   Rule _blockRule;
 
   /// Returns `true` if there is only a single positional argument.
   bool get _isSingle => _positional.length == 1 && _named.isEmpty;
 
   /// Whether this argument list has any block arguments that are functions.
   bool get hasFunctionBlockArguments => _blockArguments.any(_isBlockFunction);
 
   bool get hasBlockArguments => _blockArguments.isNotEmpty;
 
   /// Whether this argument list should force the containing method chain to
   /// add a level of block nesting.
   bool get nestMethodArguments {
     // If there are block arguments, we don't want the method to force them to
     // the right.
     if (_blockArguments.isNotEmpty) return false;
 
     // Corner case: If there is just a single argument, don't bump the nesting.
     // This lets us avoid spurious indentation in cases like:
     //
     //     object.method(function(() {
     //       body;
     //     }));
     return _node.arguments.length > 1;
   }
 
   factory ArgumentListVisitor(SourceVisitor visitor, ArgumentList node) {
     // Assumes named arguments follow all positional ones.
-    var positional = node.arguments
-        .takeWhile((arg) => arg is! NamedExpression).toList();
+    var positional =
+        node.arguments.takeWhile((arg) => arg is! NamedExpression).toList();
     var named = node.arguments.skip(positional.length).toList();
 
     var blocks = node.arguments.where(_isBlockArgument).toSet();
 
     // Count the leading arguments that are block literals.
     var leadingBlocks = 0;
     for (var argument in node.arguments) {
       if (!blocks.contains(argument)) break;
       leadingBlocks++;
     }
@@ skipping 111 matching lines @@
     var positionalRule = rule;
     var namedRule = new NamedRule(_blockArgumentRule);
     _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: _positional.isNotEmpty));
+    namedRule
+        .beforeArguments(_visitor.builder.split(space: _positional.isNotEmpty));
 
     for (var argument in _named) {
       _writeArgument(namedRule, argument);
 
       // Write the split.
       if (argument != _named.last) _visitor.split();
     }
 
     _visitor.builder.endRule();
   }
@@ skipping 57 matching lines @@
     if (expression is NamedExpression) {
       expression = (expression as NamedExpression).expression;
     }
 
     // Curly body functions are.
     if (expression is! FunctionExpression) return false;
     var function = expression as FunctionExpression;
     return function.body is BlockFunctionBody;
   }
 }