Smarter splitting around named collection arguments.

lib/src/call_chain_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.call_chain_visitor;
 
 import 'package:analyzer/analyzer.dart';
 
 import 'argument_list_visitor.dart';
 import 'rule/argument.dart';
+import 'rule/rule.dart';
 import 'source_visitor.dart';
 
 /// Helper class for [SourceVisitor] that handles visiting and writing a
 /// chained series of method invocations, property accesses, and/or prefix
 /// expressions. In other words, anything using the "." operator.
 class CallChainVisitor {
   final SourceVisitor _visitor;
 
   /// The initial target of the call chain.
   ///
@@ skipping 279 matching lines @@
     // * ParenthesizedExpression.
     // * The right operand in an infix operator call.
     // * The body of a `=>` function.
 
     // Don't split right after a collection literal.
     if (expression is ListLiteral) return false;
     if (expression is MapLiteral) return false;
 
     // Don't split right after a non-empty curly-bodied function.
     if (expression is FunctionExpression) {
-      var function = expression as FunctionExpression;
+      if (expression.body is! BlockFunctionBody) return false;
 
-      if (function.body is! BlockFunctionBody) return false;
-
-      return (function.body as BlockFunctionBody).block.statements.isEmpty;
+      return (expression.body as BlockFunctionBody).block.statements.isEmpty;
     }
 
     // If the expression ends in an argument list, base the splitting on the
     // last argument.
     var argumentList;
     if (expression is MethodInvocation) {
-      argumentList = (expression as MethodInvocation).argumentList;
+      argumentList = expression.argumentList;
     } else if (expression is InstanceCreationExpression) {
-      argumentList = (expression as InstanceCreationExpression).argumentList;
+      argumentList = expression.argumentList;
     } else if (expression is FunctionExpressionInvocation) {
-      argumentList = (expression as FunctionExpressionInvocation).argumentList;
+      argumentList = expression.argumentList;
     }
 
     // Any other kind of expression always splits.
     if (argumentList == null) return true;
     if (argumentList.arguments.isEmpty) return true;
 
     var argument = argumentList.arguments.last;
     if (argument is NamedExpression) argument = argument.expression;
 
     // TODO(rnystrom): This logic is similar (but not identical) to
@@ skipping 77 matching lines @@
 
     _visitor.builder.endRule();
     _ruleEnabled = false;
   }
 
   /// Creates a new method chain [Rule] if one is not already active.
   void _enableRule({bool lazy: false}) {
     if (_ruleEnabled) return;
 
     // If the properties split, force the calls to split too.
-    var rule = new NamedRule();
+    var rule = new Rule();
     if (_propertyRule != null) _propertyRule.setNamedArgsRule(rule);
 
     if (lazy) {
       _visitor.builder.startLazyRule(rule);
     } else {
       _visitor.builder.startRule(rule);
     }
 
     _ruleEnabled = true;
   }
 
   /// Ends the span wrapping the call chain if it hasn't ended already.
   void _endSpan() {
     if (_spanEnded) return;
 
     _visitor.builder.endSpan();
     _spanEnded = true;
   }
 }