Add includeTypeAliasArguments flag to RecursiveTypeVisitor.

Change-Id: I4c5b3f79a1c630c27eda7a1739539d5312379c8e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/421401
Reviewed-by: Paul Berry <[email protected]>
Reviewed-by: Phil Quitslund <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/constant/has_invalid_type.dart

@@ -23,6 +23,8 @@ class _InvalidTypeVisitor extends RecursiveTypeVisitor {
   /// The result of whether any [InvalidType]s were found.
   bool result = false;
 
+  _InvalidTypeVisitor() : super(includeTypeAliasArguments: false);
+
   @override
   bool visitDartType(DartType dartType) {
     if (dartType is InvalidType) {

pkg/analyzer/lib/src/dart/constant/has_type_parameter_reference.dart

@@ -23,6 +23,8 @@ class _ReferencesTypeParameterVisitor extends RecursiveTypeVisitor {
   /// The result of whether any type parameters were found.
   bool result = false;
 
+  _ReferencesTypeParameterVisitor() : super(includeTypeAliasArguments: false);
+
   @override
   bool visitTypeParameterType(_) {
     result = true;

pkg/analyzer/lib/src/dart/element/type_visitor.dart

@@ -34,39 +34,68 @@ abstract class LinkingTypeVisitor<R> {
 
 /// Recursively visits a DartType tree until any visit method returns `false`.
 class RecursiveTypeVisitor extends UnifyingTypeVisitor<bool> {
+  final bool includeTypeAliasArguments;
+
+  /// If [includeTypeAliasArguments], also visits type arguments of
+  /// [InstantiatedTypeAliasElement]s associated with types.
+  RecursiveTypeVisitor({
+    required this.includeTypeAliasArguments,
+  });
+
   /// Visit each item in the list until one returns `false`, in which case, this
   /// will also return `false`.
   bool visitChildren(Iterable<DartType> types) =>
       types.every((type) => type.accept(this));
 
   @override
-  bool visitDartType(DartType type) => true;
+  bool visitDartType(DartType type) {
+    visitChildren(_maybeTypeAliasArguments(type));
+    return true;
+  }
 
   @override
-  bool visitFunctionType(FunctionType type) => visitChildren([
-        type.returnType,
-        ...type.typeParameters
-            .map((typeParameter) => typeParameter.bound)
-            .where((type) => type != null)
-            .map((type) => type!),
-        ...type.formalParameters.map((formalParameter) => formalParameter.type),
-      ]);
+  bool visitFunctionType(FunctionType type) {
+    return visitChildren([
+      ..._maybeTypeAliasArguments(type),
+      type.returnType,
+      ...type.typeParameters
+          .map((typeParameter) => typeParameter.bound)
+          .where((type) => type != null)
+          .map((type) => type!),
+      ...type.formalParameters.map((formalParameter) => formalParameter.type),
+    ]);
+  }
 
   @override
-  bool visitInterfaceType(InterfaceType type) =>
-      visitChildren(type.typeArguments);
+  bool visitInterfaceType(InterfaceType type) {
+    return visitChildren([
+      ..._maybeTypeAliasArguments(type),
+      ...type.typeArguments,
+    ]);
+  }
 
   @override
   bool visitRecordType(covariant RecordTypeImpl type) {
     return visitChildren([
+      ..._maybeTypeAliasArguments(type),
       ...type.positionalFields.map((field) => field.type),
       ...type.namedFields.map((field) => field.type),
     ]);
   }
 
   @override
   bool visitTypeParameterType(TypeParameterType type) {
+    visitChildren(_maybeTypeAliasArguments(type));
     // TODO(scheglov): Should we visit the bound here?
     return true;
   }
+
+  List<DartType> _maybeTypeAliasArguments(DartType type) {
+    if (includeTypeAliasArguments) {
+      if (type.alias case var alias?) {
+        return alias.typeArguments;
+      }
+    }
+    return const [];
+  }
 }

pkg/analyzer/lib/src/summary2/extension_type.dart

@@ -47,6 +47,8 @@ void _breakImplementsCycles(List<ExtensionTypeElementImpl2> elements) {
 class _DependenciesCollector extends RecursiveTypeVisitor {
   final List<ExtensionTypeElementImpl2> dependencies = [];
 
+  _DependenciesCollector() : super(includeTypeAliasArguments: false);
+
   @override
   bool visitInterfaceType(InterfaceType type) {
     var element = type.element3;

pkg/analyzer/test/src/dart/element/type_visitor_test.dart

@@ -198,6 +198,8 @@ class _MockRecursiveVisitor extends RecursiveTypeVisitor {
   final Set<DartType> visitedTypes = {};
   DartType? stopOnType;
 
+  _MockRecursiveVisitor() : super(includeTypeAliasArguments: false);
+
   void assertNotVisitedType(DartType type) {
     expect(visitedTypes, isNot(contains(type)));
   }

pkg/linter/lib/src/rules/analyzer_use_new_elements.dart

@@ -114,6 +114,8 @@ class AnalyzerUseNewElements extends LintRule {
 class _TypeVisitor extends RecursiveTypeVisitor {
   bool result = false;
 
+  _TypeVisitor() : super(includeTypeAliasArguments: false);
+
   @override
   bool visitInterfaceType(InterfaceType type) {
     result |= _isOldModelElement(type.element3);

pkg/linter/lib/src/rules/invalid_runtime_check_with_js_interop_types.dart

@@ -181,6 +181,8 @@ class InteropTypeChecker extends RecursiveTypeVisitor {
   bool _hasInteropType = false;
   final _visitedTypes = <DartType>{};
 
+  InteropTypeChecker() : super(includeTypeAliasArguments: false);
+
   bool hasInteropType(DartType type) {
     _hasInteropType = false;
     _visitedTypes.clear();