Preserve type arguments in generic invocation expressions. Fix #621. It already handled generic *method* invocations like "foo<int>(1)". This fixes cases where the receiver is itself an expression, like "(<T>(T t) => t)<int>(1)". R=kevmoo@google.com Review-Url: https://codereview.chromium.org//2844573002 .

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 58bbc3a..d71f499 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md

@@ -1,6 +1,9 @@
 # 1.0.4-dev
+
 * Ensure formatter throws an exception instead of introducing non-whitespace
-  changes.
+  changes. This sanity check ensures the formatter does not erase user code
+  when the formatter itself contains a bug.
+* Preserve type arguments in function expression invocations (#621).
 
 # 1.0.3
 

diff --git a/lib/src/source_visitor.dart b/lib/src/source_visitor.dart
index 213f7a4..f78627e 100644
--- a/lib/src/source_visitor.dart
+++ b/lib/src/source_visitor.dart

@@ -1151,8 +1151,16 @@
   }
 
   visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
+    // Try to keep the entire invocation one line.
+    builder.startSpan();
+    builder.nestExpression();
+
     visit(node.function);
-    visit(node.argumentList);
+    visit(node.typeArguments);
+    visitArgumentList(node.argumentList, nestExpression: false);
+
+    builder.unnest();
+    builder.endSpan();
   }
 
   visitFunctionTypeAlias(FunctionTypeAlias node) {

diff --git a/test/regression/0600/0621.stmt b/test/regression/0600/0621.stmt
new file mode 100644
index 0000000..08cb930
--- /dev/null
+++ b/test/regression/0600/0621.stmt

@@ -0,0 +1,8 @@
+>>>
+var x = (f as dynamic)<int>(40, 2);
+<<<
+var x = (f as dynamic)<int>(40, 2);
+>>>
+var y = (f as dynamic)<String>('hi', '!');
+<<<
+var y = (f as dynamic)<String>('hi', '!');
\ No newline at end of file

diff --git a/test/splitting/type_arguments.stmt b/test/splitting/type_arguments.stmt
index 2ba351a..9675153 100644
--- a/test/splitting/type_arguments.stmt
+++ b/test/splitting/type_arguments.stmt

@@ -65,4 +65,33 @@
 {
   <int>[];
   <int>[];
-}
\ No newline at end of file
+}
+>>> type arguments on invocation expressions, all on one line
+(fn)<T, S>(1, 2);
+<<<
+(fn)<T, S>(1, 2);
+>>> type arguments on invocation, prefer to not split at type args
+(longFunction)<TypeArgument>(valueArgument);
+<<<
+(longFunction)<TypeArgument>(
+    valueArgument);
+>>> type arguments on invocation expressions split both type and value arguments
+(longFunction)<First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(first, second, third, fourth, fifth, sixth, seventh, eighth);
+<<<
+(longFunction)<
+        First,
+        Second,
+        Third,
+        Fourth,
+        Fifth,
+        Sixth,
+        Seventh,
+        Eighth>(
+    first,
+    second,
+    third,
+    fourth,
+    fifth,
+    sixth,
+    seventh,
+    eighth);
\ No newline at end of file