Support generic methods. Fix #556.

lib/src/source_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.source_visitor;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/src/generated/source.dart';
 
@@ skipping 115 matching lines @@
   ///
   /// This is a bit complex to handle the rules for formatting positional and
   /// named arguments. The goals, in rough order of descending priority are:
   ///
   /// 1. Keep everything on the first line.
   /// 2. Keep the named arguments together on the next line.
   /// 3. Keep everything together on the second line.
   /// 4. Split between one or more positional arguments, trying to keep as many
   ///    on earlier lines as possible.
   /// 5. Split the named arguments each onto their own line.
-  visitArgumentList(ArgumentList node) {
+  visitArgumentList(ArgumentList node, {bool nestExpression: true}) {
     // Corner case: handle empty argument lists.
     if (node.arguments.isEmpty) {
       token(node.leftParenthesis);
 
       // If there is a comment inside the parens, do allow splitting before it.
       if (node.rightParenthesis.precedingComments != null) soloZeroSplit();
 
       token(node.rightParenthesis);
       return;
     }
 
     // If the argument list has a trailing comma, format it like a collection
     // literal where each argument goes on its own line, they are indented +2,
     // and the ")" ends up on its own line.
     if (node.arguments.last.endToken.next.type == TokenType.COMMA) {
       _visitCollectionLiteral(
           null, node.leftParenthesis, node.arguments, node.rightParenthesis);
       return;
     }
 
+    if (nestExpression) builder.nestExpression();
     new ArgumentListVisitor(this, node).visit();
+    if (nestExpression) builder.unnest();
   }
 
   visitAsExpression(AsExpression node) {
     builder.startSpan();
     builder.nestExpression();
     visit(node.expression);
     soloSplit();
     token(node.asOperator);
     space();
     visit(node.type);
     builder.unnest();
     builder.endSpan();
   }
 
   // TODO(rnystrom): Type annotate once analyzer publishes a version with the
   // new AST type.
   // TODO(rnystrom): Test.
   visitAssertInitializer(node) {
     _simpleStatement(node, () {
       token(node.assertKeyword);
 
       var arguments = <Expression>[node.condition];
       if (node.message != null) arguments.add(node.message);
 
+      builder.nestExpression();
       var visitor = new ArgumentListVisitor.forArguments(
           this, node.leftParenthesis, node.rightParenthesis, arguments);
       visitor.visit();
+      builder.unnest();
     });
   }
 
   visitAssertStatement(AssertStatement node) {
     _simpleStatement(node, () {
       token(node.assertKeyword);
 
       var arguments = [node.condition];
       if (node.message != null) arguments.add(node.message);
 
@@ skipping 1018 matching lines @@
     visit(node.index);
     token(node.rightBracket);
     builder.endSpan();
   }
 
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     builder.startSpan();
     token(node.keyword);
     space();
     builder.startSpan(Cost.constructorName);
+
+    // Start the expression nesting for the argument list here, in case this
+    // is a generic constructor with type arguments. If it is, we need the type
+    // arguments to be nested too so they get indented past the arguments.
+    builder.nestExpression();
     visit(node.constructorName);
+
     builder.endSpan();
-    visit(node.argumentList);
+    visitArgumentList(node.argumentList, nestExpression: false);
     builder.endSpan();
+
+    builder.unnest();
   }
 
   visitIntegerLiteral(IntegerLiteral node) {
     token(node.literal);
   }
 
   visitInterpolationExpression(InterpolationExpression node) {
     token(node.leftBracket);
     visit(node.expression);
     token(node.rightBracket);
@@ skipping 71 matching lines @@
   visitMethodInvocation(MethodInvocation node) {
     // If there's no target, this is a "bare" function call like "foo(1, 2)",
     // or a section in a cascade. Handle this case specially.
     if (node.target == null) {
       // Try to keep the entire method invocation one line.
       builder.startSpan();
       builder.nestExpression();
 
       // This will be non-null for cascade sections.
       token(node.operator);
-      token(node.methodName.token);
-      visit(node.argumentList);
+      visit(node.methodName);
+
+      // TODO(rnystrom): Currently, there are no constraints between a generic
+      // method's type arguments and arguments. That can lead to some funny
+      // splitting like:
+      //
+      //     method<VeryLongType,
+      //             AnotherTypeArgument>(argument,
+      //         argument, argument, argument);
+      //
+      // The indentation is fine, but splitting in the middle of each argument
+      // list looks kind of strange. If this ends up happening in real world
+      // code, consider putting a constraint between them.
+
+      visit(node.typeArguments);
+      visitArgumentList(node.argumentList, nestExpression: false);
 
       builder.unnest();
       builder.endSpan();
       return;
     }
 
     new CallChainVisitor(this, node).visit();
   }
 
   visitNamedExpression(NamedExpression node) {
@@ skipping 1264 matching lines @@
   /// Gets the 1-based line number that the beginning of [token] lies on.
   int _startLine(Token token) => _lineInfo.getLocation(token.offset).lineNumber;
 
   /// Gets the 1-based line number that the end of [token] lies on.
   int _endLine(Token token) => _lineInfo.getLocation(token.end).lineNumber;
 
   /// Gets the 1-based column number that the beginning of [token] lies on.
   int _startColumn(Token token) =>
       _lineInfo.getLocation(token.offset).columnNumber;
 }