[mini_types] Implement and test hashCode and equality logic.

Previously, the `hashCode` and `==` logic for the `Type` hierarchy
used a short-cut: convert the type to a string and then hash or
equality-check the result.

However, that trick won't work for generic function types (which I
intend to implement in a follow-up CL), because generic function types
that are alpha-equivalent (i.e. equivalent except for the names of
type formals) need to be considered equal. So, as preparation for
supporting generic function types, this change adds full
implementations of `hashCode` and `==` for all the classes in the
`Type` hierarchy.

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

Author: stereotype441

pkg/_fe_analyzer_shared/pubspec.yaml

@@ -15,6 +15,7 @@ dependencies:
 # See also https://dart.dev/tools/pub/dependencies.
 dev_dependencies:
   checks: any
+  collection: any
   macros: any
   test: any
 

pkg/_fe_analyzer_shared/test/mini_types.dart

@@ -11,6 +11,7 @@ import 'dart:core' hide Type;
 
 import 'package:_fe_analyzer_shared/src/type_inference/nullability_suffix.dart';
 import 'package:_fe_analyzer_shared/src/types/shared_type.dart';
+import 'package:collection/collection.dart';
 
 /// Surrounds [s] with parentheses if [condition] is `true`, otherwise returns
 /// [s] unchanged.
@@ -62,6 +63,14 @@ class FunctionType extends Type
     }
   }
 
+  @override
+  int get hashCode => Object.hash(
+      returnType,
+      const ListEquality().hash(positionalParameters),
+      requiredPositionalParameterCount,
+      const ListEquality().hash(namedParameters),
+      nullabilitySuffix);
+
   @override
   List<Type> get positionalParameterTypes => positionalParameters;
 
@@ -71,6 +80,17 @@ class FunctionType extends Type
   @override
   List<Never> get typeFormals => const [];
 
+  @override
+  bool operator ==(Object other) =>
+      other is FunctionType &&
+      returnType == other.returnType &&
+      const ListEquality()
+          .equals(positionalParameters, other.positionalParameters) &&
+      requiredPositionalParameterCount ==
+          other.requiredPositionalParameterCount &&
+      const ListEquality().equals(namedParameters, other.namedParameters) &&
+      nullabilitySuffix == other.nullabilitySuffix;
+
   @override
   Type? closureWithRespectToUnknown({required bool covariant}) {
     Type? newReturnType =
@@ -197,6 +217,16 @@ class NamedFunctionParameter
   NamedFunctionParameter(
       {required this.isRequired, required this.name, required this.type});
 
+  @override
+  int get hashCode => Object.hash(name, type, isRequired);
+
+  @override
+  bool operator ==(Object other) =>
+      other is NamedFunctionParameter &&
+      name == other.name &&
+      type == other.type &&
+      isRequired == other.isRequired;
+
   @override
   String toString() => [if (isRequired) 'required', type, name].join(' ');
 }
@@ -209,6 +239,13 @@ class NamedType implements SharedNamedTypeStructure<Type> {
   final Type type;
 
   NamedType({required this.name, required this.type});
+
+  @override
+  int get hashCode => Object.hash(name, type);
+
+  @override
+  bool operator ==(Object other) =>
+      other is NamedType && name == other.name && type == other.type;
 }
 
 /// Representation of the type `Never` suitable for unit testing of code in the
@@ -276,13 +313,24 @@ class PrimaryType extends Type {
       NullabilitySuffix nullabilitySuffix = NullabilitySuffix.none})
       : this._(nameInfo, args: args, nullabilitySuffix: nullabilitySuffix);
 
+  @override
+  int get hashCode => Object.hash(runtimeType, nameInfo,
+      const ListEquality().hash(args), nullabilitySuffix);
+
   bool get isInterfaceType {
     return nameInfo is InterfaceTypeName;
   }
 
   /// The name of the type.
   String get name => nameInfo.name;
 
+  @override
+  bool operator ==(Object other) =>
+      other is PrimaryType &&
+      nameInfo == other.nameInfo &&
+      const ListEquality().equals(args, other.args) &&
+      nullabilitySuffix == other.nullabilitySuffix;
+
   @override
   Type? closureWithRespectToUnknown({required bool covariant}) {
     List<Type>? newArgs =
@@ -315,9 +363,6 @@ class RecordType extends Type implements SharedRecordTypeStructure<Type> {
 
   final List<NamedType> namedTypes;
 
-  @override
-  List<NamedType> get sortedNamedTypes => namedTypes;
-
   RecordType({
     required this.positionalTypes,
     required this.namedTypes,
@@ -329,6 +374,23 @@ class RecordType extends Type implements SharedRecordTypeStructure<Type> {
     }
   }
 
+  @override
+  int get hashCode => Object.hash(
+      runtimeType,
+      const ListEquality().hash(positionalTypes),
+      const ListEquality().hash(namedTypes),
+      nullabilitySuffix);
+
+  @override
+  List<NamedType> get sortedNamedTypes => namedTypes;
+
+  @override
+  bool operator ==(Object other) =>
+      other is RecordType &&
+      const ListEquality().equals(positionalTypes, other.positionalTypes) &&
+      const ListEquality().equals(namedTypes, other.namedTypes) &&
+      nullabilitySuffix == other.nullabilitySuffix;
+
   @override
   Type? closureWithRespectToUnknown({required bool covariant}) {
     List<Type>? newPositional;
@@ -448,14 +510,8 @@ abstract class Type implements SharedTypeStructure<Type> {
 
   const Type._({this.nullabilitySuffix = NullabilitySuffix.none});
 
-  @override
-  int get hashCode => type.hashCode;
-
   String get type => toString();
 
-  @override
-  bool operator ==(Object other) => other is Type && this.type == other.type;
-
   /// Finds the nearest type that doesn't involve the unknown type (`_`).
   ///
   /// If [covariant] is `true`, a supertype will be returned (replacing `_` with
@@ -551,6 +607,17 @@ class TypeParameter extends TypeNameInfo
   @override
   String get displayName => name;
 
+  @override
+  int get hashCode {
+    // To ensure that generic function types with different type formal names
+    // have the same hash code, [FunctionType.hashCode] substitutes in a
+    // consistently-named set of synthetic type formals in place of the type
+    // formals. Since a fresh set of synthetic type formals will be created each
+    // time [FunctionType.hashCode] is called, it's important that two type
+    // formals with the same name (and bound) have the same hash code.
+    return Object.hash(name, bound);
+  }
+
   @override
   String toString() => name;
 }
@@ -575,6 +642,17 @@ class TypeParameterType extends Type {
   /// The type parameter's bound.
   Type get bound => typeParameter.bound;
 
+  @override
+  int get hashCode =>
+      Object.hash(runtimeType, typeParameter, promotion, nullabilitySuffix);
+
+  @override
+  bool operator ==(Object other) =>
+      other is TypeParameterType &&
+      typeParameter == other.typeParameter &&
+      promotion == other.promotion &&
+      nullabilitySuffix == other.nullabilitySuffix;
+
   @override
   Type? closureWithRespectToUnknown({required bool covariant}) {
     var newPromotion =
@@ -1318,6 +1396,14 @@ class UnknownType extends Type implements SharedUnknownTypeStructure<Type> {
   const UnknownType({super.nullabilitySuffix = NullabilitySuffix.none})
       : super._();
 
+  @override
+  int get hashCode =>
+      Object.hash(runtimeType, nullabilitySuffix, nullabilitySuffix);
+
+  @override
+  bool operator ==(Object other) =>
+      other is UnknownType && nullabilitySuffix == other.nullabilitySuffix;
+
   @override
   Type? closureWithRespectToUnknown({required bool covariant}) =>
       covariant ? Type('Object?') : NeverType.instance;

pkg/_fe_analyzer_shared/test/mini_types_test.dart

@@ -523,6 +523,85 @@ main() {
     });
   });
 
+  group('hashCode and equality:', () {
+    void checkEqual(Type t1, Type t2) {
+      expect(t1 == t2, isTrue);
+      expect(t1.hashCode == t2.hashCode, isTrue);
+    }
+
+    void checkNotEqual(Type t1, Type t2) {
+      expect(t1 == t2, isFalse);
+      // Note: don't compare `t1.hashCode` to `t2.hashCode` because it's not
+      // guaranteed whether they will be different or not. And besides, it
+      // really only matters for efficiency, and efficiency is not needed for
+      // the "mini_types" representation because it's only used in unit tests.
+    }
+
+    test('FunctionType', () {
+      checkEqual(Type('void Function()'), Type('void Function()'));
+      checkNotEqual(Type('void Function()?'), Type('void Function()'));
+      checkNotEqual(Type('T Function()'), Type('void Function()'));
+      checkNotEqual(Type('void Function(T)'), Type('void Function()'));
+      checkEqual(Type('void Function(T)'), Type('void Function(T)'));
+      checkNotEqual(Type('void Function(T)'), Type('void Function(U)'));
+      checkNotEqual(Type('void Function(T)'), Type('void Function([T])'));
+      checkNotEqual(Type('void Function({T t})'), Type('void Function()'));
+      checkEqual(Type('void Function({T t})'), Type('void Function({T t})'));
+      checkNotEqual(
+          Type('void Function({T t})'), Type('void Function({required T t})'));
+      checkNotEqual(Type('void Function({T t})'), Type('void Function({U t})'));
+      checkNotEqual(Type('void Function({T t})'), Type('void Function({T u})'));
+    });
+
+    test('PrimaryType', () {
+      checkEqual(Type('int'), Type('int'));
+      checkNotEqual(Type('int'), Type('String'));
+      checkNotEqual(Type('int'), Type('int?'));
+      checkEqual(Type('Map<int, String>'), Type('Map<int, String>'));
+      checkNotEqual(Type('Map<int, String>'), Type('Map<int, double>'));
+      checkNotEqual(Type('Map<int, String>'), Type('Map<num, String>'));
+      checkNotEqual(Type('List<int>'), Type('Iterable<int>'));
+      checkEqual(Type('dynamic'), Type('dynamic'));
+      checkEqual(Type('error'), Type('error'));
+      checkEqual(Type('Never'), Type('Never'));
+      checkEqual(Type('Null'), Type('Null'));
+      checkEqual(Type('void'), Type('void'));
+      checkEqual(Type('FutureOr<int>'), Type('FutureOr<int>'));
+      checkNotEqual(Type('dynamic'), Type('error'));
+      checkNotEqual(Type('error'), Type('Never'));
+      checkNotEqual(Type('Never'), Type('Null'));
+      checkNotEqual(Type('Null'), Type('void'));
+      checkNotEqual(Type('void'), Type('dynamic'));
+      checkNotEqual(Type('FutureOr<int>'), Type('FutureOr<String>'));
+      checkNotEqual(Type('FutureOr<int>'), Type('dynamic'));
+    });
+
+    test('RecordType', () {
+      checkEqual(Type('(int,)'), Type('(int,)'));
+      checkNotEqual(Type('(int,)?'), Type('(int,)'));
+      checkNotEqual(Type('(int, T)'), Type('(int,)'));
+      checkNotEqual(Type('(T,)'), Type('(U,)'));
+      checkNotEqual(Type('(int, {T t})'), Type('(int,)'));
+      checkEqual(Type('({T t})'), Type('({T t})'));
+      checkNotEqual(Type('({T t})'), Type('({U t})'));
+      checkNotEqual(Type('({T t})'), Type('({T u})'));
+    });
+
+    test('TypeParameterType', () {
+      checkEqual(Type('T'), Type('T'));
+      checkNotEqual(Type('T?'), Type('T'));
+      checkNotEqual(Type('T'), Type('U'));
+      checkNotEqual(Type('T&int'), Type('T'));
+      checkEqual(Type('T&int'), Type('T&int'));
+      checkNotEqual(Type('T&int'), Type('T&String'));
+    });
+
+    test('UnknownType', () {
+      checkEqual(Type('_'), Type('_'));
+      checkNotEqual(Type('_?'), Type('_'));
+    });
+  });
+
   group('recursivelyDemote:', () {
     group('FunctionType:', () {
       group('return type:', () {