[mini_types] Add a Type.gatherUsedIdentifiers 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, and those substitutions need to avoid name
collisions with identifier names that already appear in the type.

Change-Id: Ifd237a9842791f440e285d89e9d80b898e996411
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/395685
Reviewed-by: Samuel Rawlins <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/test/mini_types.dart

@@ -111,6 +111,25 @@ class FunctionType extends Type
         nullabilitySuffix: nullabilitySuffix);
   }
 
+  @override
+  void gatherUsedIdentifiers(Set<String> identifiers) {
+    returnType.gatherUsedIdentifiers(identifiers);
+    for (var positionalParameter in positionalParameters) {
+      positionalParameter.gatherUsedIdentifiers(identifiers);
+    }
+    for (var typeFormal in typeFormals) {
+      identifiers.add(typeFormal.name);
+    }
+    for (var namedParameter in namedParameters) {
+      // As explained in the documentation for `Type.gatherUsedIdentifiers`,
+      // to reduce the risk of confusion, this method is generous in which
+      // identifiers it reports. So report `namedParameter.name` even though
+      // it's not strictly necessary.
+      identifiers.add(namedParameter.name);
+      namedParameter.type.gatherUsedIdentifiers(identifiers);
+    }
+  }
+
   @override
   Type? recursivelyDemote({required bool covariant}) {
     Type? newReturnType = returnType.recursivelyDemote(covariant: covariant);
@@ -383,6 +402,14 @@ class PrimaryType extends Type {
         args: newArgs, nullabilitySuffix: nullabilitySuffix);
   }
 
+  @override
+  void gatherUsedIdentifiers(Set<String> identifiers) {
+    identifiers.add(name);
+    for (var arg in args) {
+      arg.gatherUsedIdentifiers(identifiers);
+    }
+  }
+
   @override
   Type? recursivelyDemote({required bool covariant}) {
     List<Type>? newArgs = args.recursivelyDemote(covariant: covariant);
@@ -467,6 +494,21 @@ class RecordType extends Type implements SharedRecordTypeStructure<Type> {
     );
   }
 
+  @override
+  void gatherUsedIdentifiers(Set<String> identifiers) {
+    for (var type in positionalTypes) {
+      type.gatherUsedIdentifiers(identifiers);
+    }
+    for (var namedType in namedTypes) {
+      // As explained in the documentation for `Type.gatherUsedIdentifiers`,
+      // to reduce the risk of confusion, this method is generous in which
+      // identifiers it reports. So report `namedType.name` even though it's
+      // not strictly necessary.
+      identifiers.add(namedType.name);
+      namedType.type.gatherUsedIdentifiers(identifiers);
+    }
+  }
+
   @override
   Type? recursivelyDemote({required bool covariant}) {
     List<Type>? newPositional;
@@ -581,6 +623,21 @@ abstract class Type implements SharedTypeStructure<Type>, _Substitutable<Type> {
   /// `Never`).
   Type? closureWithRespectToUnknown({required bool covariant});
 
+  /// Recursively visits `this`, gathering up all the identifiers that appear in
+  /// it, and adds them to the set [identifiers].
+  ///
+  /// This method is intended to aid in choosing safe names for substitutions.
+  /// For example, it can be used to determine that in a type like
+  /// `T Function<U>(U)`, it's not safe to rename the type variable `U` to `T`,
+  /// since that would conflict with an existing use of `T`.
+  ///
+  /// To lower the risk of confusion, it is generous in which identifiers it
+  /// reports. For example, in the type `void Function<T>({T X})`, it reports
+  /// `X` as a used identifier. This is because even though it would technically
+  /// be safe to rename the type variable `T` to `X`, to do so would be result
+  /// in a confusing type.
+  void gatherUsedIdentifiers(Set<String> identifiers);
+
   @override
   String getDisplayString() => type;
 
@@ -724,6 +781,12 @@ class TypeParameterType extends Type {
         promotion: newPromotion, nullabilitySuffix: nullabilitySuffix);
   }
 
+  @override
+  void gatherUsedIdentifiers(Set<String> identifiers) {
+    identifiers.add(typeParameter.name);
+    promotion?.gatherUsedIdentifiers(identifiers);
+  }
+
   @override
   Type? recursivelyDemote({required bool covariant}) {
     if (!covariant) {
@@ -1474,6 +1537,9 @@ class UnknownType extends Type implements SharedUnknownTypeStructure<Type> {
   Type? closureWithRespectToUnknown({required bool covariant}) =>
       covariant ? Type('Object?') : NeverType.instance;
 
+  @override
+  void gatherUsedIdentifiers(Set<String> identifiers) {}
+
   @override
   Type? recursivelyDemote({required bool covariant}) => null;
 

pkg/_fe_analyzer_shared/test/mini_types_test.dart

@@ -1021,6 +1021,47 @@ main() {
     });
   });
 
+  group('gatherUsedIdentifiers:', () {
+    Set<String> queryUsedIdentifiers(Type t) {
+      var identifiers = <String>{};
+      t.gatherUsedIdentifiers(identifiers);
+      return identifiers;
+    }
+
+    test('FunctionType', () {
+      expect(queryUsedIdentifiers(Type('int Function(String, {bool b})')),
+          unorderedEquals({'int', 'String', 'bool', 'b'}));
+    });
+
+    test('PrimaryType', () {
+      expect(queryUsedIdentifiers(Type('Map<String, int>')),
+          unorderedEquals({'Map', 'String', 'int'}));
+      expect(
+          queryUsedIdentifiers(Type('dynamic')), unorderedEquals({'dynamic'}));
+      expect(queryUsedIdentifiers(Type('error')), unorderedEquals({'error'}));
+      expect(queryUsedIdentifiers(Type('Never')), unorderedEquals({'Never'}));
+      expect(queryUsedIdentifiers(Type('Null')), unorderedEquals({'Null'}));
+      expect(queryUsedIdentifiers(Type('void')), unorderedEquals({'void'}));
+      expect(queryUsedIdentifiers(Type('FutureOr<int>')),
+          unorderedEquals({'FutureOr', 'int'}));
+    });
+
+    test('RecordType', () {
+      expect(queryUsedIdentifiers(Type('(int, {String s})')),
+          unorderedEquals({'int', 'String', 's'}));
+    });
+
+    test('TypeParameterType', () {
+      expect(queryUsedIdentifiers(Type('T')), unorderedEquals({'T'}));
+      expect(
+          queryUsedIdentifiers(Type('T&int')), unorderedEquals({'T', 'int'}));
+    });
+
+    test('UnknownType', () {
+      expect(queryUsedIdentifiers(Type('_')), isEmpty);
+    });
+  });
+
   group('substitute:', () {
     test('FunctionType', () {
       expect(Type('int Function(int, {int i})').substitute({t: Type('String')}),