Support generic methods. Fix #556.

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';
@@ skipping 299 matching lines @@
 
     // Don't split right after a non-empty curly-bodied function.
     if (expression is FunctionExpression) {
       if (expression.body is! BlockFunctionBody) return false;
 
       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;
+    ArgumentList argumentList;
     if (expression is MethodInvocation) {
       argumentList = expression.argumentList;
     } else if (expression is InstanceCreationExpression) {
       argumentList = expression.argumentList;
     } else if (expression is FunctionExpressionInvocation) {
       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;
+    if (argument is NamedExpression) {
+      argument = (argument as NamedExpression).expression;
+    }
 
     // TODO(rnystrom): This logic is similar (but not identical) to
     // ArgumentListVisitor.hasBlockArguments. They overlap conceptually and
     // both have their own peculiar heuristics. It would be good to unify and
     // rationalize them.
 
     return _forcesSplit(argument);
   }
 
   /// Writes [call], which must be one of the supported expression types.
@@ skipping 47 matching lines @@
     // "." when calling a single method on a single name. This is especially
     // important because the identifier is often a library prefix, and splitting
     // there looks really odd.
     if (_properties.isEmpty &&
         _calls.length == 1 &&
         _blockCalls == null &&
         _target is SimpleIdentifier) {
       _endSpan();
     }
 
-    _visitor.visit(invocation.argumentList);
+    _visitor.builder.nestExpression();
+    _visitor.visit(invocation.typeArguments);
+    _visitor.visitArgumentList(invocation.argumentList, nestExpression: false);
+    _visitor.builder.unnest();
   }
 
   void _writeBlockCall(MethodInvocation invocation) {
     _visitor.token(invocation.operator);
     _visitor.token(invocation.methodName.token);
     _visitor.visit(invocation.argumentList);
   }
 
   /// If a [Rule] for the method chain is currently active, ends it.
   void _disableRule() {
@@ skipping 21 matching lines @@
   }
 
   /// Ends the span wrapping the call chain if it hasn't ended already.
   void _endSpan() {
     if (_spanEnded) return;
 
     _visitor.builder.endSpan();
     _spanEnded = true;
   }
 }