Analyzer: introduce more non-function typedef test cases

Bug: #44078
Change-Id: I9b4f299c61034301b5a9c403f128a614384236ff
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/184680
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Samuel Rawlins <[email protected]>

Author: srawlins

pkg/analyzer/test/src/diagnostics/implements_deferred_class_test.dart

@@ -29,6 +29,21 @@ class B implements a.A {}
     ]);
   }
 
+  test_implements_interfaceTypeTypedef() async {
+    newFile('$testPackageLibPath/lib1.dart', content: '''
+library lib1;
+class A {}
+typedef B = A;
+''');
+    await assertErrorsInCode('''
+library root;
+import 'lib1.dart' deferred as a;
+class C implements a.B {}
+''', [
+      error(CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS, 67, 3),
+    ]);
+  }
+
   test_mixinApplication() async {
     newFile('$testPackageLibPath/lib1.dart', content: '''
 library lib1;

pkg/analyzer/test/src/diagnostics/inference_failure_on_instance_creation_test.dart

@@ -2,6 +2,7 @@
 // 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.
 
+import 'package:analyzer/src/dart/analysis/experiments.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ -21,6 +22,7 @@ class InferenceFailureOnInstanceCreationTest extends PubPackageResolutionTest {
     super.setUp();
     writeTestPackageAnalysisOptionsFile(
       AnalysisOptionsFileConfig(
+        experiments: [EnableString.nonfunction_type_aliases],
         strictInference: true,
       ),
     );
@@ -68,6 +70,18 @@ HashMap<int, int> f() {
 ''');
   }
 
+  test_missingTypeArgument_interfaceTypeTypedef_noInference() async {
+    await assertErrorsInCode(r'''
+import 'dart:collection';
+typedef A = HashMap;
+void f() {
+  A();
+}
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_INSTANCE_CREATION, 60, 1),
+    ]);
+  }
+
   test_missingTypeArgument_noInference() async {
     await assertErrorsInCode(r'''
 import 'dart:collection';

pkg/analyzer/test/src/diagnostics/instantiate_abstract_class_test.dart

@@ -56,6 +56,18 @@ void f() {
     assertType(findNode.instanceCreation('new A<int>'), 'A<int>');
   }
 
+  test_new_interfaceTypeTypedef() async {
+    await assertErrorsInCode('''
+abstract class A {}
+typedef B = A;
+void f() {
+  new B();
+}
+''', [
+      error(CompileTimeErrorCode.INSTANTIATE_ABSTRACT_CLASS, 52, 1),
+    ]);
+  }
+
   test_new_nonGeneric() async {
     await assertErrorsInCode('''
 abstract class A {}
@@ -80,6 +92,18 @@ void f() {
     assertType(findNode.instanceCreation('A<int>'), 'A<int>');
   }
 
+  test_noKeyword_interfaceTypeTypedef() async {
+    await assertErrorsInCode('''
+abstract class A {}
+typedef B = A;
+void f() {
+  B();
+}
+''', [
+      error(CompileTimeErrorCode.INSTANTIATE_ABSTRACT_CLASS, 48, 1),
+    ]);
+  }
+
   test_noKeyword_nonGeneric() async {
     await assertErrorsInCode('''
 abstract class A {}

pkg/analyzer/test/src/diagnostics/non_type_in_catch_clause_test.dart

@@ -16,56 +16,77 @@ main() {
 @reflectiveTest
 class NonTypeInCatchClauseTest extends PubPackageResolutionTest {
   test_isClass() async {
-    await assertErrorsInCode(r'''
+    await assertNoErrorsInCode(r'''
 f() {
   try {
   } on String catch (e) {
+    e;
   }
 }
-''', [
-      error(HintCode.UNUSED_CATCH_CLAUSE, 35, 1),
-    ]);
+''');
   }
 
   test_isFunctionTypeAlias() async {
-    await assertErrorsInCode(r'''
+    await assertNoErrorsInCode(r'''
 typedef F();
 f() {
   try {
   } on F catch (e) {
+    e;
   }
 }
-''', [
-      error(HintCode.UNUSED_CATCH_CLAUSE, 43, 1),
-    ]);
+''');
+  }
+
+  test_isGenericFunctionTypeAlias() async {
+    await assertNoErrorsInCode(r'''
+typedef F<T> = void Function(T);
+f() {
+  try {
+  } on F catch (e) {
+    e;
+  }
+}
+''');
+  }
+
+  test_isInterfaceTypeTypeAlias() async {
+    await assertNoErrorsInCode(r'''
+typedef F = String;
+f() {
+  try {
+  } on F catch (e) {
+    e;
+  }
+}
+''');
   }
 
   test_isTypeParameter() async {
-    await assertErrorsInCode(r'''
+    await assertNoErrorsInCode(r'''
 class A<T extends Object> {
   f() {
     try {
     } on T catch (e) {
+      e;
     }
   }
 }
-''', [
-      error(HintCode.UNUSED_CATCH_CLAUSE, 64, 1),
-    ]);
+''');
   }
 
   test_notDefined() async {
     await assertErrorsInCode('''
 f() {
   try {
   } on T catch (e) {
+    e;
   }
 }
 ''', [
       // TODO(srawlins): Ideally the first error should not be reported.
       error(HintCode.NULLABLE_TYPE_IN_CATCH_CLAUSE, 21, 1),
       error(CompileTimeErrorCode.NON_TYPE_IN_CATCH_CLAUSE, 21, 1),
-      error(HintCode.UNUSED_CATCH_CLAUSE, 30, 1),
     ]);
   }
 
@@ -75,13 +96,13 @@ var T = 0;
 f() {
   try {
   } on T catch (e) {
+    e;
   }
 }
 ''', [
       // TODO(srawlins): Ideally the first error should not be reported.
       error(HintCode.NULLABLE_TYPE_IN_CATCH_CLAUSE, 32, 1),
       error(CompileTimeErrorCode.NON_TYPE_IN_CATCH_CLAUSE, 32, 1),
-      error(HintCode.UNUSED_CATCH_CLAUSE, 41, 1),
     ]);
   }
 

pkg/analyzer/test/src/diagnostics/not_iterable_spread_test.dart

@@ -10,13 +10,23 @@ import '../dart/resolution/context_collection_resolution.dart';
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(NotIterableSpreadTest);
-    defineReflectiveTests(NotIterableSpreadNullSafetyTest);
+    defineReflectiveTests(NotIterableSpreadWithoutNullSafetyTest);
   });
 }
 
 @reflectiveTest
-class NotIterableSpreadNullSafetyTest extends NotIterableSpreadTest
-    with WithNullSafetyMixin {
+class NotIterableSpreadTest extends PubPackageResolutionTest
+    with NotIterableSpreadTestCases {
+  test_iterable_interfaceTypeTypedef() async {
+    await assertNoErrorsInCode('''
+typedef A = List<int>;
+f(A a) {
+  var v = [...a];
+  v;
+}
+''');
+  }
+
   test_iterable_typeParameter_bound_listQuestion() async {
     await assertNoErrorsInCode('''
 void f<T extends List<int>?>(T a) {
@@ -27,9 +37,7 @@ void f<T extends List<int>?>(T a) {
   }
 }
 
-@reflectiveTest
-class NotIterableSpreadTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+mixin NotIterableSpreadTestCases on PubPackageResolutionTest {
   test_iterable_list() async {
     await assertNoErrorsInCode('''
 var a = [0];
@@ -100,3 +108,7 @@ void f<T extends num>(T a) {
     ]);
   }
 }
+
+@reflectiveTest
+class NotIterableSpreadWithoutNullSafetyTest extends PubPackageResolutionTest
+    with WithoutNullSafetyMixin, NotIterableSpreadTestCases {}

pkg/analyzer/test/src/diagnostics/redirect_to_abstract_class_constructor_test.dart

@@ -47,6 +47,18 @@ class A {
 }
 
 class B extends A {}
+''');
+  }
+
+  test_redirectsToSubclass_asTypedef() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  factory A.named() = C;
+  A();
+}
+
+class B extends A {}
+typedef C = B;
 ''');
   }
 }

pkg/analyzer/test/src/diagnostics/unnecessary_cast_test.dart

@@ -16,7 +16,9 @@ main() {
 
 @reflectiveTest
 class UnnecessaryCastTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+    with UnnecessaryCastTestCases, WithoutNullSafetyMixin {}
+
+mixin UnnecessaryCastTestCases on PubPackageResolutionTest {
   test_conditionalExpression_changesResultType_left() async {
     await assertNoErrorsInCode(r'''
 class A {}
@@ -216,8 +218,8 @@ void f<T>(T a) {
 }
 
 @reflectiveTest
-class UnnecessaryCastTestWithNullSafety extends UnnecessaryCastTest
-    with WithNullSafetyMixin {
+class UnnecessaryCastTestWithNullSafety extends PubPackageResolutionTest
+    with UnnecessaryCastTestCases {
   test_interfaceType_star_toNone() async {
     newFile('$testPackageLibPath/a.dart', content: r'''
 // @dart = 2.7
@@ -254,4 +256,15 @@ void f() {
       error(HintCode.IMPORT_OF_LEGACY_LIBRARY_INTO_NULL_SAFE, 7, 8),
     ]);
   }
+
+  test_type_type_asInterfaceTypeTypedef() async {
+    await assertErrorsInCode(r'''
+typedef N = num;
+void f(num a) {
+  a as N;
+}
+''', [
+      error(HintCode.UNNECESSARY_CAST, 35, 6),
+    ]);
+  }
 }