Roll dart_style 2.1.0 into the SDK.

This only adds support for the new constructor tear-offs. No existing
formatted code should be changed, so it should be safe to land this
without coordinating a roll of the pre-built SDK.

Change-Id: Ic3fd04f12ef5a1f67760d3edc78c5f419ba1c3c3
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/210285
Auto-Submit: Bob Nystrom <rnystrom@google.com>
Commit-Queue: Bob Nystrom <rnystrom@google.com>
Reviewed-by: Nate Bosch <nbosch@google.com>

Author: munificent

DEPS

@@ -103,7 +103,7 @@ vars = {
   #     and land the review.
   #
   # For more details, see https://github.com/dart-lang/sdk/issues/30164
-  "dart_style_rev": "06bfd19593ed84dd288f67e02c6a753e6516288a",
+  "dart_style_rev": "14d9b6fd58cc4744676c12be3cc5eee2a779db82",
 
   "dartdoc_rev" : "5f39ec674d81f5c199151d823fa4ecd01fc59eb2",
   "devtools_rev" : "64cffbed6366329ad05e44d48fa2298367643bb6",

pkg/front_end/testcases/constructor_tearoffs/call_instantiation.dart.textual_outline_modelled.expect

@@ -1,4 +1,6 @@
 T func<T>(T value) => value;
 int Function(int) f = funcValue.call;
+int Function(int) g = funcValue.call<int>;
 main() {}
+test(Function f) {}
 var funcValue = func;

pkg/front_end/testcases/constructor_tearoffs/const_tear_off.dart.textual_outline.expect

@@ -3,6 +3,7 @@ class A<T> {
   factory A.fact() => new A();
   factory A.redirect() = A;
 }
+
 typedef B<T> = A<T>;
 typedef C<T> = A<int>;
 const a = A.new;

pkg/front_end/testcases/constructor_tearoffs/const_tear_off.dart.textual_outline_modelled.expect

@@ -0,0 +1,27 @@
+class A<T> {
+  A();
+  factory A.fact() => new A();
+  factory A.redirect() = A;
+}
+
+const a = A.new;
+const b = A<int>.new;
+const c = A.fact;
+const d = A<int>.fact;
+const e = A.redirect;
+const f = A<int>.redirect;
+const g = B.new;
+const h = B<int>.new;
+const i = B.fact;
+const j = B<int>.fact;
+const k = B.redirect;
+const l = B<int>.redirect;
+const m = C.new;
+const n = C<int>.new;
+const o = C.fact;
+const p = C<int>.fact;
+const q = C.redirect;
+const r = C<int>.redirect;
+main() {}
+typedef B<T> = A<T>;
+typedef C<T> = A<int>;

pkg/front_end/testcases/constructor_tearoffs/dynamic_explicit_instantiation.dart.textual_outline_modelled.expect

@@ -0,0 +1,5 @@
+main() {}
+test1(dynamic x) => x.foo<int>;
+test2(Never x) => x.foo<int>;
+test3(dynamic x) => x.toString<int>;
+test4(Never x) => x.toString<int>;

pkg/front_end/testcases/constructor_tearoffs/explicit_instantiation_errors.dart.textual_outline_modelled.expect

@@ -0,0 +1,13 @@
+X boundedMethod<X extends num>(X x) => x;
+X id<X>(X x) => x;
+main() {}
+test() {}
+var a = id;
+var b = a<int>;
+var c = id<int>;
+var d = id<int, String>;
+var e = method<int>;
+var f = 0<int>;
+var g = main<int>;
+var h = boundedMethod<String>;
+void method<X, Y>() {}

pkg/front_end/testcases/constructor_tearoffs/explicit_new_as_unnamed.dart.textual_outline.expect

@@ -1,35 +1,43 @@
 class A {
   A.new();
 }
+
 class B {
   B();
 }
+
 class C {
   C();
   C.new();
 }
+
 class D {
   D.new();
   D();
 }
+
 class E1 {
   E1._();
   E1();
   factory E1.new() => E1._();
 }
+
 class E2 {
   E2._();
   factory E2.new() => E2._();
   E2();
 }
+
 class E3 {
   E3._();
   E3();
   factory E3.new() = E3._;
 }
+
 class E4 {
   E4._();
   factory E4.new() = E4._;
   E4();
 }
+
 main() {}

pkg/front_end/testcases/constructor_tearoffs/explicit_new_as_unnamed.dart.textual_outline_modelled.expect

@@ -0,0 +1,43 @@
+class A {
+  A.new();
+}
+
+class B {
+  B();
+}
+
+class C {
+  C();
+  C.new();
+}
+
+class D {
+  D();
+  D.new();
+}
+
+class E1 {
+  E1();
+  E1._();
+  factory E1.new() => E1._();
+}
+
+class E2 {
+  E2();
+  E2._();
+  factory E2.new() => E2._();
+}
+
+class E3 {
+  E3();
+  E3._();
+  factory E3.new() = E3._;
+}
+
+class E4 {
+  E4();
+  E4._();
+  factory E4.new() = E4._;
+}
+
+main() {}

pkg/front_end/testcases/constructor_tearoffs/generic_tearoff_with_context.dart.textual_outline.expect

@@ -4,6 +4,7 @@ class A<X> {
   A();
   factory A.bar1() => new A();
 }
+
 A<X> Function<X>(X) test1() => A.foo1;
 A<X> Function<X>(X) test2() => A.foo2;
 A<X> Function<X>(X) test3() => A.new;

pkg/front_end/testcases/constructor_tearoffs/generic_tearoff_with_context.dart.textual_outline_modelled.expect

@@ -1,9 +1,22 @@
-A<X> Function<X>(X) bar1() => A.foo1;
-A<X> Function<X>(X) bar2() => A.foo2;
+A<X> Function<X>() test10() => A.bar1;
+A<X> Function<X>(X) test1() => A.foo1;
+A<X> Function<X>(X) test11() => A.bar1;
+A<X> Function<X>(X) test2() => A.foo2;
+A<X> Function<X>(X) test3() => A.new;
+A<X> Function<X>(X) test4() => A<int>.new;
+A<X> Function<X>(X) test5() => A<int, String>.new;
+A<X> Function<X>(X) test6() => A<int>.foo1;
+A<X> Function<X>(X) test7() => A<int, String>.foo1;
+A<X> Function<X>(X) test8() => A<int>.foo2;
+A<X> Function<X>(X) test9() => A<int, String>.foo2;
+A<int> Function() test12() => A<int>.bar1;
+A<int> Function() test13() => A.bar1;
 
 class A<X> {
+  A();
   A.foo1(X x) {}
   A.foo2(X x, int y) {}
+  factory A.bar1() => new A();
 }
 
 main() {}