[mini_types] Add a Type.substitute method.

This method will be used by a follow-up CL that adds support for
generic functions, since the implementation of `==` and `hashCode` for
generic functions needs to perform substitutions in order to recognize
that alpha-equivalent types (such as `T Function<T>()` and `U
Function<U>`) are equal.

Change-Id: If641c4d0ae48708abf3701853014dc52dfc559c5
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/395684
Reviewed-by: Chloe Stefantsova <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/test/mini_types.dart

@@ -130,6 +130,24 @@ class FunctionType extends Type
         nullabilitySuffix: nullabilitySuffix);
   }
 
+  @override
+  FunctionType? substitute(Map<TypeParameter, Type> substitution) {
+    var newReturnType = returnType.substitute(substitution);
+    var newPositionalParameters = positionalParameters.substitute(substitution);
+    var newNamedParameters = namedParameters.substitute(substitution);
+    if (newReturnType == null &&
+        newPositionalParameters == null &&
+        newNamedParameters == null) {
+      return null;
+    } else {
+      return FunctionType(newReturnType ?? returnType,
+          newPositionalParameters ?? positionalParameters,
+          requiredPositionalParameterCount: requiredPositionalParameterCount,
+          namedParameters: newNamedParameters ?? namedParameters,
+          nullabilitySuffix: nullabilitySuffix);
+    }
+  }
+
   @override
   Type withNullability(NullabilitySuffix suffix) =>
       FunctionType(returnType, positionalParameters,
@@ -179,6 +197,13 @@ class FutureOrType extends PrimaryType {
     return FutureOrType(newArg, nullabilitySuffix: nullabilitySuffix);
   }
 
+  @override
+  Type? substitute(Map<TypeParameter, Type> substitution) {
+    var newArg = typeArgument.substitute(substitution);
+    if (newArg == null) return null;
+    return FutureOrType(newArg, nullabilitySuffix: nullabilitySuffix);
+  }
+
   @override
   Type withNullability(NullabilitySuffix suffix) =>
       FutureOrType(typeArgument, nullabilitySuffix: suffix);
@@ -204,7 +229,9 @@ class InvalidType extends _SpecialSimpleType
 
 /// A named parameter of a function type.
 class NamedFunctionParameter
-    implements SharedNamedFunctionParameterStructure<Type> {
+    implements
+        SharedNamedFunctionParameterStructure<Type>,
+        _Substitutable<NamedFunctionParameter> {
   @override
   final String name;
 
@@ -227,11 +254,20 @@ class NamedFunctionParameter
       type == other.type &&
       isRequired == other.isRequired;
 
+  @override
+  NamedFunctionParameter? substitute(Map<TypeParameter, Type> substitution) {
+    var newType = type.substitute(substitution);
+    if (newType == null) return null;
+    return NamedFunctionParameter(
+        isRequired: isRequired, name: name, type: newType);
+  }
+
   @override
   String toString() => [if (isRequired) 'required', type, name].join(' ');
 }
 
-class NamedType implements SharedNamedTypeStructure<Type> {
+class NamedType
+    implements SharedNamedTypeStructure<Type>, _Substitutable<NamedType> {
   @override
   final String name;
 
@@ -246,6 +282,13 @@ class NamedType implements SharedNamedTypeStructure<Type> {
   @override
   bool operator ==(Object other) =>
       other is NamedType && name == other.name && type == other.type;
+
+  @override
+  NamedType? substitute(Map<TypeParameter, Type> substitution) {
+    var newType = type.substitute(substitution);
+    if (newType == null) return null;
+    return NamedType(name: name, type: newType);
+  }
 }
 
 /// Representation of the type `Never` suitable for unit testing of code in the
@@ -348,6 +391,14 @@ class PrimaryType extends Type {
         args: newArgs, nullabilitySuffix: nullabilitySuffix);
   }
 
+  @override
+  Type? substitute(Map<TypeParameter, Type> substitution) {
+    var newArgs = args.substitute(substitution);
+    if (newArgs == null) return null;
+    return PrimaryType._(nameInfo,
+        args: newArgs, nullabilitySuffix: nullabilitySuffix);
+  }
+
   @override
   Type withNullability(NullabilitySuffix suffix) =>
       PrimaryType._(nameInfo, args: args, nullabilitySuffix: suffix);
@@ -439,6 +490,17 @@ class RecordType extends Type implements SharedRecordTypeStructure<Type> {
     );
   }
 
+  @override
+  Type? substitute(Map<TypeParameter, Type> substitution) {
+    var newPositionalTypes = positionalTypes.substitute(substitution);
+    var newNamedTypes = namedTypes.substitute(substitution);
+    if (newPositionalTypes == null && newNamedTypes == null) return null;
+    return RecordType(
+        positionalTypes: newPositionalTypes ?? positionalTypes,
+        namedTypes: newNamedTypes ?? namedTypes,
+        nullabilitySuffix: nullabilitySuffix);
+  }
+
   @override
   Type withNullability(NullabilitySuffix suffix) => RecordType(
       positionalTypes: positionalTypes,
@@ -502,7 +564,7 @@ class SpecialTypeName extends TypeNameInfo {
 
 /// Representation of a type suitable for unit testing of code in the
 /// `_fe_analyzer_shared` package.
-abstract class Type implements SharedTypeStructure<Type> {
+abstract class Type implements SharedTypeStructure<Type>, _Substitutable<Type> {
   @override
   final NullabilitySuffix nullabilitySuffix;
 
@@ -582,11 +644,11 @@ sealed class TypeNameInfo {
   /// An assertion in the [PrimaryType] constructor verifies this.
   ///
   /// This ensures that the methods [Type.closureWithRespectToUnknown],
-  /// [Type.recursivelyDemote], and [Type.withNullability] (which create new
-  /// instances of [Type] based on old ones) create the appropriate subtype of
-  /// [Type]. It also ensures that when [Type] objects are directly constructed
-  /// (as they are in this file and in `mini_ast.dart`), the appropriate subtype
-  /// of [Type] is used.
+  /// [Type.recursivelyDemote], [Type.substitute], and [Type.withNullability]
+  /// (which create new instances of [Type] based on old ones) create the
+  /// appropriate subtype of [Type]. It also ensures that when [Type] objects
+  /// are directly constructed (as they are in this file and in
+  /// `mini_ast.dart`), the appropriate subtype of [Type] is used.
   final core.Type _expectedRuntimeType;
 
   TypeNameInfo(this.name, {required core.Type expectedRuntimeType})
@@ -674,6 +736,10 @@ class TypeParameterType extends Type {
     }
   }
 
+  @override
+  Type? substitute(Map<TypeParameter, Type> substitution) =>
+      substitution[typeParameter];
+
   @override
   Type withNullability(NullabilitySuffix suffix) =>
       TypeParameterType(typeParameter,
@@ -1411,6 +1477,9 @@ class UnknownType extends Type implements SharedUnknownTypeStructure<Type> {
   @override
   Type? recursivelyDemote({required bool covariant}) => null;
 
+  @override
+  Type? substitute(Map<TypeParameter, Type> substitution) => null;
+
   @override
   Type withNullability(NullabilitySuffix suffix) =>
       UnknownType(nullabilitySuffix: suffix);
@@ -1448,6 +1517,22 @@ abstract class _SpecialSimpleType extends PrimaryType {
 
   @override
   Type? recursivelyDemote({required bool covariant}) => null;
+
+  @override
+  Type? substitute(Map<TypeParameter, Type> substitution) => null;
+}
+
+/// Interface for [Type] and the data structures that comprise it, allowing
+/// type substitutions to be performed.
+abstract class _Substitutable<T extends _Substitutable<T>> {
+  /// If `this` contains any references to a [TypeParameter] matching one of the
+  /// keys in [substitution], returns a clone of `this` with those references
+  /// replaced by the corresponding value. Otherwise returns `null`.
+  ///
+  /// For example, if `t` is a reference to the [TypeParameter] object
+  /// representing `T`, then `Type('Map<T, U>`).substitute({t: Type('int')})`
+  /// returns a [Type] object representing `Map<int, U>`.
+  T? substitute(Map<TypeParameter, Type> substitution);
 }
 
 class _TypeParser {
@@ -1878,3 +1963,25 @@ extension on List<Type> {
     return newList;
   }
 }
+
+extension<T extends _Substitutable<T>> on List<T> {
+  /// Helper method for performing substitutions on the constituent parts of a
+  /// [Type] that are stored in lists.
+  ///
+  /// Calls [_Substitutable.substitute] on each element of the list; if all
+  /// those calls returned `null` (meaning no substitutions were done), returns
+  /// `null`. Otherwise returns a new [List] in which each element requiring
+  /// substitutions is replaced with the substitution result.
+  List<T>? substitute(Map<TypeParameter, Type> substitution) {
+    List<T>? result;
+    for (int i = 0; i < length; i++) {
+      var oldListElement = this[i];
+      var newType = oldListElement.substitute(substitution);
+      if (newType != null && result == null) {
+        result = sublist(0, i);
+      }
+      result?.add(newType ?? oldListElement);
+    }
+    return result;
+  }
+}

pkg/_fe_analyzer_shared/test/mini_types_test.dart

@@ -1020,4 +1020,61 @@ main() {
       });
     });
   });
+
+  group('substitute:', () {
+    test('FunctionType', () {
+      expect(Type('int Function(int, {int i})').substitute({t: Type('String')}),
+          isNull);
+      expect(Type('T Function(int, {int i})').substitute({t: Type('String')}),
+          Type('String Function(int, {int i})'));
+      expect(Type('int Function(T, {int i})?').substitute({t: Type('String')}),
+          Type('int Function(String, {int i})?'));
+      expect(Type('int Function(int, {T i})').substitute({t: Type('String')}),
+          Type('int Function(int, {String i})'));
+      expect(Type('int Function(T, T)').substitute({t: Type('String')}),
+          Type('int Function(String, String)'));
+      expect(Type('int Function({T t1, T t2})').substitute({t: Type('String')}),
+          Type('int Function({String t1, String t2})'));
+    });
+
+    test('PrimaryType', () {
+      expect(Type('Map<int, int>').substitute({t: Type('String')}), isNull);
+      expect(Type('Map<T, int>').substitute({t: Type('String')}),
+          Type('Map<String, int>'));
+      expect(Type('Map<int, T>').substitute({t: Type('String')}),
+          Type('Map<int, String>'));
+      expect(Type('Map<T, T>').substitute({t: Type('String')}),
+          Type('Map<String, String>'));
+      expect(Type('dynamic').substitute({t: Type('String')}), isNull);
+      expect(Type('error').substitute({t: Type('String')}), isNull);
+      expect(Type('Never').substitute({t: Type('String')}), isNull);
+      expect(Type('Null').substitute({t: Type('String')}), isNull);
+      expect(Type('void').substitute({t: Type('String')}), isNull);
+      expect(Type('FutureOr<int>').substitute({t: Type('String')}), isNull);
+      expect(Type('FutureOr<T>').substitute({t: Type('String')}),
+          Type('FutureOr<String>'));
+    });
+
+    test('RecordType', () {
+      expect(Type('(int, {int i})').substitute({t: Type('String')}), isNull);
+      expect(Type('(T, {int i})?').substitute({t: Type('String')}),
+          Type('(String, {int i})?'));
+      expect(Type('(int, {T i})').substitute({t: Type('String')}),
+          Type('(int, {String i})'));
+      expect(Type('(T, T)').substitute({t: Type('String')}),
+          Type('(String, String)'));
+      expect(Type('({T t1, T t2})').substitute({t: Type('String')}),
+          Type('({String t1, String t2})'));
+    });
+
+    test('TypeParameterType', () {
+      expect(Type('T').substitute({u: Type('String')}), isNull);
+      expect(Type('T').substitute({t: Type('String')}), Type('String'));
+      expect(Type('T&Object').substitute({t: Type('String')}), Type('String'));
+    });
+
+    test('UnknownType', () {
+      expect(Type('_').substitute({t: Type('String')}), isNull);
+    });
+  });
 }