Migrate more tests to the new style and reorganize some. (#1398)

No behavioral changes here, just migrating over more of the old tests
to the new style. Also, in the process of doing that, I noticed some
new tests weren't organized correctly. Yield, await, and throw were
under statement but those are all expressions. (Yes, even throw.)

Likewise, the generic function instantiation tests were under type/
even though they're expressions, not type annotations.

Author: munificent

test/declaration/constructor_parameter.unit

@@ -80,4 +80,14 @@ class Foo {
     required int super.e(),
     super.f() = x,
   });
+}
+>>> Covariant initializing formal.
+### This isn't semantically valid Dart code, but it's syntactically valid so
+### the formatter should handle it correctly.
+class A {
+  A(   covariant   this.foo);
+}
+<<<
+class A {
+  A(covariant this.foo);
 }

test/declaration/member_comment.unit

@@ -0,0 +1,24 @@
+40 columns                              |
+>>> Ensure blank line above doc comments on members.
+class Foo {
+var a = 1; /// Doc A.
+var b = 2;
+/// Doc c.
+void c() => body; /// Doc d.
+void d() {;}
+}
+<<<
+class Foo {
+  var a = 1;
+
+  /// Doc A.
+  var b = 2;
+
+  /// Doc c.
+  void c() => body;
+
+  /// Doc d.
+  void d() {
+    ;
+  }
+}

test/expression/function_reference.stmt

@@ -0,0 +1,63 @@
+40 columns                              |
+>>> Unsplit.
+void main() => id  < int   > ;
+<<<
+void main() => id<int>;
+>>> Unsplit with multiple type arguments.
+void main() => id  < int , String  , bool   > ;
+<<<
+void main() => id<int, String, bool>;
+>>> Unsplit generic constructor tear-off.
+var x = Class  < int  >;
+<<<
+var x = Class<int>;
+>>> Split type arguments.
+LongClassName<First, Second, Third, Fourth>;
+<<<
+LongClassName<
+  First,
+  Second,
+  Third,
+  Fourth
+>;
+>>> Split type arguments.
+LongClassName<First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>;
+<<<
+LongClassName<
+  First,
+  Second,
+  Third,
+  Fourth,
+  Fifth,
+  Sixth,
+  Seventh,
+  Eighth
+>;
+>>> Split nested type arguments.
+LongClassName<First, Inner<Second, Third, Fourth, Fifth, Sixth, Seventh>, Eighth>;
+<<<
+LongClassName<
+  First,
+  Inner<
+    Second,
+    Third,
+    Fourth,
+    Fifth,
+    Sixth,
+    Seventh
+  >,
+  Eighth
+>;
+>>> Split type arguments when nested inside expression.
+veryLongFunction(argument, ConstructorTearOff<First, Second, Third, Fourth>, argument);
+<<<
+veryLongFunction(
+  argument,
+  ConstructorTearOff<
+    First,
+    Second,
+    Third,
+    Fourth
+  >,
+  argument,
+);

test/expression/other.stmt

@@ -32,4 +32,43 @@ this;
 >>> Long qualified symbols do not split.
 #longComponent.anotherLongComponent.third;
 <<<
-#longComponent.anotherLongComponent.third;
+#longComponent.anotherLongComponent.third;
+>>> Yield.
+Stream<String> i(String n) async* {
+  yield   i   ;
+}
+<<<
+Stream<String> i(String n) async* {
+  yield i;
+}
+>>> Yield*.
+Stream<int> i(int n) async* {
+  yield * i (  n   - 1 )      ;
+}
+<<<
+Stream<int> i(int n) async* {
+  yield* i(n - 1);
+}
+>>> Await.
+foo() async {
+  await i (  1 + 2   )   ;
+}
+<<<
+foo() async {
+  await i(1 + 2);
+}
+>>> Throw.
+throw   'error'
+;
+<<<
+throw 'error';
+>>> Throw doesn't split after the 'throw' keyword.
+throw 'Some extremely long error message.';
+<<<
+throw 'Some extremely long error message.';
+>>> Throw with long string literal.
+throw new FormatException('This is a long exception message.');
+<<<
+throw new FormatException(
+  'This is a long exception message.',
+);

test/expression/set.stmt

@@ -19,4 +19,18 @@ const {first, second};
 >>> With type argument.
 <  int  >  {  1  ,  2  };
 <<<
-<int>{1, 2};
+<int>{1, 2};
+>>> Split in type argument.
+var set = <Inner<First, Second, Third, Fourth, Fifth, Sixth>>{};
+<<<
+var set =
+    <
+      Inner<
+        First,
+        Second,
+        Third,
+        Fourth,
+        Fifth,
+        Sixth
+      >
+    >{};

test/invocation/function.stmt

@@ -80,4 +80,4 @@ someFunctionOne(
   ),
   someArgument,
   someArgument,
-);
+);

test/invocation/invocation_expression.stmt

@@ -0,0 +1,35 @@
+40 columns                              |
+### An invocation expression is a function call where the function is itself
+### an expression like `(x + y)(arg)` and not a simple name like `foo(arg)`.
+>>> With type arguments, unsplit.
+(fn)<T, S>(1, 2);
+<<<
+(fn)<T, S>(1, 2);
+>>> Prefer to split value arguments instead of type arguments.
+(longFunction)<TypeArgument>(valueArgument);
+<<<
+(longFunction)<TypeArgument>(
+  valueArgument,
+);
+>>> 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,
+);

test/selection/selection.unit

@@ -14,4 +14,85 @@ class Bar {}
 <<<
 class Foo {}
 
-‹›class Bar {}
+‹›class Bar {}
+>>> Select entire file.
+‹main(  )  {
+  body(   )  ;}›
+<<<
+‹main() {
+  body();
+}›
+>>> With trailing comment.
+   ma‹in() {}
+// com›ment
+<<<
+ma‹in() {}
+// com›ment
+>>> In discarded whitespace.
+foo(  ‹  argument){  ›  }
+<<<
+foo(‹argument) {›}
+>>> In zero-length split whitespace.
+main(){veryLongMethodCall(‹veryLongArgumentName);
+veryLongMethodCall(›veryLongArgumentName);
+}
+<<<
+main() {
+  veryLongMethodCall(
+    ‹veryLongArgumentName,
+  );
+  veryLongMethodCall(›
+    veryLongArgumentName,
+  );
+}
+>>> In split-inserted space.
+main() {shortCall(argument, ‹  argument);
+shortCall(argument,  › argument);
+}
+<<<
+main() {
+  shortCall(argument, ‹argument);
+  shortCall(argument, ›argument);
+}
+>>> In inserted mandatory newline.
+foo() {body;  ‹  }
+bar() {body;  ›  }
+<<<
+foo() {
+  body;
+‹}
+
+bar() {
+  body;›
+}
+>>> In inserted mandatory space.
+main() async {
+await‹(1);
+throw›(2);
+}
+<<<
+main() async {
+  await ‹(1);
+  throw› (2);
+}
+>>> Across pieces that get solved separately.
+foo() {
+
+
+  fir‹st();
+}
+
+bar() {sec›ond();}
+<<<
+foo() {
+  fir‹st();
+}
+
+bar() {
+  sec›ond();
+}
+>>> Only whitespace in newline selected.
+foo() {} ‹  › bar() {}
+<<<
+foo() {}
+‹›bar() {}

test/statement/other.stmt

@@ -31,45 +31,6 @@ while (true) {
 while (true) {
   continue someLabel;
 }
->>> Yield.
-Stream<String> i(String n) async* {
-  yield   i   ;
-}
-<<<
-Stream<String> i(String n) async* {
-  yield i;
-}
->>> Yield*.
-Stream<int> i(int n) async* {
-  yield * i (  n   - 1 )      ;
-}
-<<<
-Stream<int> i(int n) async* {
-  yield* i(n - 1);
-}
->>> Await.
-foo() async {
-  await i (  1 + 2   )   ;
-}
-<<<
-foo() async {
-  await i(1 + 2);
-}
->>> Throw.
-throw   'error'
-;
-<<<
-throw 'error';
->>> Throw doesn't split after the 'throw' keyword.
-throw 'Some extremely long error message.';
-<<<
-throw 'Some extremely long error message.';
->>> Throw with long string literal.
-throw new FormatException('This is a long exception message.');
-<<<
-throw new FormatException(
-  'This is a long exception message.',
-);
 >>> Rethrow.
 try {
   throw 1   ;