Migrate language_2/nonfunction_type_aliases to NNBD.

Change-Id: I2cf8ebe11b86549488fa04f18d5e92c1bf9c3a15
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/152585
Auto-Submit: Bob Nystrom <rnystrom@google.com>
Reviewed-by: Nicholas Shahan <nshahan@google.com>
Commit-Queue: Bob Nystrom <rnystrom@google.com>

Author: munificent

tests/language/nonfunction_type_aliases/aliased_cyclic_superclass_error_test.dart

@@ -0,0 +1,14 @@
+// Copyright (c) 2019, 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.
+
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+typedef T = C;
+
+class C extends T {}
+//    ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+main() => C();

tests/language/nonfunction_type_aliases/generic_aliased_supertype_test.dart

@@ -0,0 +1,19 @@
+// Copyright (c) 2019, 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.
+
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+class A<X> {}
+
+typedef A1<Y> = A<Y>;
+typedef A2<U, Z> = A1<A<Z>>;
+typedef A3<W> = A2<int, A<W>>;
+
+class B extends A3<B> {}
+
+void f(A<A<A<B>>> a) {}
+
+void main() {
+  f(B());
+}

tests/language/nonfunction_type_aliases/generic_usage_class_error_test.dart

@@ -0,0 +1,38 @@
+// Copyright (c) 2019, 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.
+
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import 'dart:async';
+
+// Introduce an aliased type.
+
+class A<X> {
+  A();
+  A.named();
+  static void staticMethod<Y>() {}
+}
+
+typedef T<X> = A<X>;
+
+// Use the aliased type.
+
+abstract class C {}
+
+abstract class D2 extends C with T<int> {}
+//             ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+abstract class D4 = C with T<void>;
+//             ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+main() {
+  T<List<List<List<List>>>>.staticMethod<T<int>>();
+  //                        ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+}

tests/language/nonfunction_type_aliases/generic_usage_class_test.dart

@@ -0,0 +1,71 @@
+// Copyright (c) 2019, 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.
+
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import 'dart:async';
+
+// Introduce an aliased type.
+
+class A<X> {
+  A();
+  A.named();
+  static void staticMethod<Y>() {}
+}
+
+typedef T<X> = A<X>;
+
+// Use the aliased type.
+
+T<int>? v1;
+List<T<void>> v2 = [];
+final T<String> v3 = throw "Anything";
+const List<T<C>> v4 = [];
+const v5 = <Type, Type>{T: T};
+
+abstract class C {
+  static T<C>? v1;
+  static List<T<T>> v2 = [];
+  static final T<Null> v3 = throw "Anything";
+  static const List<T<List>> v4 = [];
+
+  T<C>? v5;
+  List<T<T>> v6 = [];
+  final T<Null> v7;
+
+  C(): v7 = T<Null>();
+  C.name1(this.v5, this.v7);
+  factory C.name2(T<C> arg1, T<Null> arg2) = C.name1;
+
+  T<double> operator +(T<double> other);
+  T<FutureOr<FutureOr<void>>> get g;
+  set g(T<FutureOr<FutureOr<void>>> value);
+  Map<T<C>, T<C>> m1(covariant T<C> arg1, [Set<Set<T<C>>> arg2]);
+  void m2({T arg1, Map<T, T> arg2(T Function(T) arg21, T arg22)});
+}
+
+class D1<X> extends T<X> {}
+abstract class D3<X, Y> implements T<T> {}
+
+extension E on T<dynamic> {
+  T<dynamic> foo(T<dynamic> t) => t;
+}
+
+X foo<X>(X x) => x;
+
+T<Object> Function(T<Object>) id = (x) => x;
+
+main() {
+  var v8 = <T<C>>[];
+  var v9 = <Set<T<T>>, Set<T<T>>>{{}: {}};
+  var v10 = {v8};
+  v9[{}] = {T<T>()};
+  Set<List<T<C>>> v11 = v10;
+  v10 = v11;
+  T<Null>();
+  T<Null>.named();
+  T<Object> v12 = foo<T<bool>>(T<bool>());
+  id(v12);
+  T.staticMethod<T<int>>();
+}

tests/language/nonfunction_type_aliases/generic_usage_dynamic_error_test.dart

@@ -0,0 +1,72 @@
+// Copyright (c) 2019, 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.
+
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import 'dart:async';
+
+// Introduce an aliased type.
+
+typedef T<X> = dynamic;
+
+// Use the aliased type.
+
+abstract class C {
+  final T<Null> v7;
+
+  C(): v7 = T();
+  //        ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+}
+
+class D1<X> extends T<X> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+abstract class D2 extends C with T<int> {}
+//             ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+abstract class D3<X, Y> implements T<T> {}
+//             ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+abstract class D4 = C with T<void>;
+//             ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+X foo<X>(X x) => x;
+
+main() {
+  var v9 = <Set<T<T>>, Set<T<T>>>{{}: {}};
+  v9[{}] = {T<T>()};
+  //        ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+
+  T<Null>();
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  T<Null>.named();
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  T<Object> v12 = foo<T<bool>>(T<bool>());
+  //                           ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+
+  T<List<List<List<List>>>>.staticMethod<T<int>>();
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

tests/language/nonfunction_type_aliases/generic_usage_dynamic_test.dart

@@ -0,0 +1,56 @@
+// Copyright (c) 2019, 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.
+
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import 'dart:async';
+
+// Introduce an aliased type.
+
+typedef T<X> = dynamic;
+
+// Use the aliased type.
+
+T<int>? v1;
+List<T<void>> v2 = [];
+final T<String> v3 = throw "Anything";
+const List<T<C>> v4 = [];
+const v5 = <Type, Type>{T: T};
+
+abstract class C {
+  static T<C>? v1;
+  static List<T<T>> v2 = [];
+  static final T<Null> v3 = throw "Anything";
+  static const List<T<List>> v4 = [];
+
+  T<C>? v5;
+  List<T<T>> v6 = [];
+  final T<Null> v7;
+
+  C.name1(this.v5, this.v7);
+  factory C.name2(T<C> arg1, T<Null> arg2) = C.name1;
+
+  T<double> operator +(T<double> other);
+  T<FutureOr<FutureOr<void>>> get g;
+  set g(T<FutureOr<FutureOr<void>>> value);
+  Map<T<C>, T<C>> m1(covariant T<C> arg1, [Set<Set<T<C>>> arg2]);
+  void m2({T arg1, Map<T, T> arg2(T Function(T) arg21, T arg22)});
+}
+
+extension E on T<dynamic> {
+  T<dynamic> foo(T<dynamic> t) => t;
+}
+
+X foo<X>(X x) => x;
+
+T<Type> Function(T<Type>)? id;
+
+main() {
+  var v8 = <T<C>>[];
+  var v9 = <Set<T<T>>, Set<T<T>>>{{}: {}};
+  var v10 = {v8};
+  v9[{}] = {};
+  Set<List<T<C>>> v11 = v10;
+  v10 = v11;
+}

tests/language/nonfunction_type_aliases/generic_usage_function_error_test.dart

@@ -0,0 +1,52 @@
+// Copyright (c) 2019, 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.
+
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import 'dart:async';
+
+// Introduce an aliased type.
+
+typedef T<X> = Function;
+
+// Use the aliased type.
+
+abstract class C {
+  final T<Null> v7;
+
+  C(): v7 = T();
+  //        ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+}
+
+X foo<X>(X x) => x;
+
+main() {
+  var v9 = <Set<T<T>>, Set<T<T>>>{{}: {}};
+  v9[{}] = {T<T>()};
+  //        ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+
+  T<Null>();
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  T<Null>.named();
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  T<Object> v12 = foo<T<bool>>(T<bool>());
+  //                           ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+
+  T<List<List<List<List>>>>.staticMethod<T<int>>();
+  //                        ^^^^^^^^^^^^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+}

tests/language/nonfunction_type_aliases/generic_usage_function_test.dart

@@ -0,0 +1,62 @@
+// Copyright (c) 2019, 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.
+
+// SharedOptions=--enable-experiment=nonfunction-type-aliases
+
+import 'dart:async';
+
+// Introduce an aliased type.
+
+typedef T<X> = Function;
+
+// Use the aliased type.
+
+T<int>? v1;
+List<T<void>> v2 = [];
+final T<String> v3 = throw "Anything";
+const List<T<C>> v4 = [];
+const v5 = <Type, Type>{T: T};
+
+abstract class C {
+  static T<C>? v1;
+  static List<T<T>> v2 = [];
+  static final T<Null> v3 = throw "Anything";
+  static const List<T<List>> v4 = [];
+
+  T<C>? v5;
+  List<T<T>> v6 = [];
+  final T<Null> v7;
+
+  C(): v7 = print;
+  C.name1(this.v5, this.v7);
+  factory C.name2(T<C> arg1, T<Null> arg2) = C.name1;
+
+  T<double> operator +(T<double> other);
+  T<FutureOr<FutureOr<void>>> get g;
+  set g(T<FutureOr<FutureOr<void>>> value);
+  Map<T<C>, T<C>> m1(covariant T<C> arg1, [Set<Set<T<C>>> arg2]);
+  void m2({T arg1, Map<T, T> arg2(T Function(T) arg21, T arg22)});
+}
+
+class D1<X> extends T<X> {}
+abstract class D2 extends C with T<int> {}
+abstract class D3<X, Y> implements T<T> {}
+abstract class D4 = C with T<void>;
+
+extension E on T<dynamic> {
+  T<dynamic> foo(T<dynamic> t) => t;
+}
+
+X foo<X>(X x) => x;
+
+T<Type> Function(T<Type>)? id;
+
+main() {
+  var v8 = <T<C>>[];
+  var v9 = <Set<T<T>>, Set<T<T>>>{{}: {}};
+  var v10 = {v8};
+  v9[{}] = {};
+  Set<List<T<C>>> v11 = v10;
+  v10 = v11;
+}