[cfe] Extend UP and DOWN onto record types

Closes #49914

Part of #49713

Change-Id: I49b1ca4ca9b68c8a8dfcdd9d0fc855f173088efe
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/258005
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Chloe Stefantsova <[email protected]>

Author: chloestefantsova

pkg/front_end/test/fasta/type_inference/type_schema_environment_nnbd_test.dart

@@ -460,6 +460,36 @@ class TypeSchemaEnvironmentTest extends TypeSchemaEnvironmentTestBase {
         lowerBound: "<Z extends FutureOr<dynamic>?>() -> void");
   }
 
+  void test_lower_bound_record() {
+    parseTestLibrary("""
+      class A;
+      class B extends A;
+    """);
+
+    checkLowerBound(type1: "(A, B)", type2: "(B, A)", lowerBound: "(B, B)");
+    checkLowerBound(
+        type1: "(A, {B b})", type2: "(B, {A b})", lowerBound: "(B, {B b})");
+    checkLowerBound(
+        type1: "(A, {(B, {A a}) b})",
+        type2: "(B, {(A, {B a}) b})",
+        lowerBound: "(B, {(B, {B a}) b})");
+    checkLowerBound(type1: "(A?, B)", type2: "(B, A?)", lowerBound: "(B, B)");
+    checkLowerBound(type1: "(A, B?)", type2: "(B?, A)", lowerBound: "(B, B)");
+
+    checkLowerBound(type1: "(A, A)", type2: "(A, A, A)", lowerBound: "Never");
+    checkLowerBound(type1: "(A, A)", type2: "(A, {A a})", lowerBound: "Never");
+    checkLowerBound(type1: "({A a})", type2: "(A, A)", lowerBound: "Never");
+    checkLowerBound(
+        type1: "({A a, B b})", type2: "({A a})", lowerBound: "Never");
+
+    checkLowerBound(type1: "(A, B)", type2: "Record", lowerBound: "(A, B)");
+    checkLowerBound(type2: "Record", type1: "(A, B)", lowerBound: "(A, B)");
+
+    checkLowerBound(
+        type1: "(A, B)", type2: "(A, B) -> void", lowerBound: "Never");
+    checkLowerBound(type1: "Record", type2: "A", lowerBound: "Never");
+  }
+
   void test_lower_bound_identical() {
     parseTestLibrary("class A;");
 
@@ -911,6 +941,36 @@ class TypeSchemaEnvironmentTest extends TypeSchemaEnvironmentTestBase {
         upperBound: "([dynamic]) -> dynamic");
   }
 
+  void test_upper_bound_record() {
+    parseTestLibrary("""
+      class A;
+      class B extends A;
+    """);
+
+    checkUpperBound(type1: "(A, B)", type2: "(B, A)", upperBound: "(A, A)");
+    checkUpperBound(
+        type1: "(A, {B b})", type2: "(B, {A b})", upperBound: "(A, {A b})");
+    checkUpperBound(
+        type1: "(A, {(B, {A a}) b})",
+        type2: "(B, {(A, {B a}) b})",
+        upperBound: "(A, {(A, {A a}) b})");
+    checkUpperBound(type1: "(A?, B)", type2: "(B, A?)", upperBound: "(A?, A?)");
+    checkUpperBound(type1: "(A, B?)", type2: "(B?, A)", upperBound: "(A?, A?)");
+
+    checkUpperBound(type1: "(A, A)", type2: "(A, A, A)", upperBound: "Record");
+    checkUpperBound(type1: "(A, A)", type2: "(A, {A a})", upperBound: "Record");
+    checkUpperBound(type1: "({A a})", type2: "(A, A)", upperBound: "Record");
+    checkUpperBound(
+        type1: "({A a, B b})", type2: "({A a})", upperBound: "Record");
+
+    checkUpperBound(type1: "(A, B)", type2: "Record", upperBound: "Record");
+    checkUpperBound(type2: "Record", type1: "(A, B)", upperBound: "Record");
+
+    checkUpperBound(
+        type1: "(A, B)", type2: "(A, B) -> void", upperBound: "Object");
+    checkUpperBound(type1: "Record", type2: "A", upperBound: "Object");
+  }
+
   void test_upper_bound_identical() {
     parseTestLibrary("class A;");
 

pkg/kernel/lib/core_types.dart

@@ -86,6 +86,9 @@ class CoreTypes {
   InterfaceType? _functionLegacyRawType;
   InterfaceType? _functionNullableRawType;
   InterfaceType? _functionNonNullableRawType;
+  InterfaceType? _recordLegacyRawType;
+  InterfaceType? _recordNullableRawType;
+  InterfaceType? _recordNonNullableRawType;
   InterfaceType? _invocationLegacyRawType;
   InterfaceType? _invocationNullableRawType;
   InterfaceType? _invocationNonNullableRawType;
@@ -795,6 +798,38 @@ class CoreTypes {
     }
   }
 
+  InterfaceType get recordLegacyRawType {
+    return _recordLegacyRawType ??= _legacyRawTypes[recordClass] ??=
+        new InterfaceType(recordClass, Nullability.legacy, const <DartType>[]);
+  }
+
+  InterfaceType get recordNullableRawType {
+    return _recordNullableRawType ??= _nullableRawTypes[recordClass] ??=
+        new InterfaceType(
+            recordClass, Nullability.nullable, const <DartType>[]);
+  }
+
+  InterfaceType get recordNonNullableRawType {
+    return _recordNonNullableRawType ??= _nonNullableRawTypes[recordClass] ??=
+        new InterfaceType(
+            recordClass, Nullability.nonNullable, const <DartType>[]);
+  }
+
+  InterfaceType recordRawType(Nullability nullability) {
+    switch (nullability) {
+      case Nullability.legacy:
+        return recordLegacyRawType;
+      case Nullability.nullable:
+        return recordNullableRawType;
+      case Nullability.nonNullable:
+        return recordNonNullableRawType;
+      case Nullability.undetermined:
+      default:
+        throw new StateError(
+            "Unsupported nullability $nullability on an InterfaceType.");
+    }
+  }
+
   InterfaceType get invocationLegacyRawType {
     return _invocationLegacyRawType ??= _legacyRawTypes[invocationClass] ??=
         new InterfaceType(

pkg/kernel/lib/src/standard_bounds.dart

@@ -411,6 +411,11 @@ mixin StandardBounds {
           type1, type2, clientLibrary);
     }
 
+    if (type1 is RecordType && type2 is RecordType) {
+      return _getNullabilityAwareRecordStandardLowerBound(
+          type1, type2, clientLibrary);
+    }
+
     // DOWN(T1, T2) = T1 if T1 <: T2.
     // DOWN(T1, T2) = T2 if T2 <: T1.
 
@@ -780,6 +785,33 @@ mixin StandardBounds {
           type1, coreTypes.objectNonNullableRawType, clientLibrary);
     }
 
+    if (type1 is RecordType) {
+      if (type2 is RecordType) {
+        return _getNullabilityAwareRecordStandardUpperBound(
+            type1, type2, clientLibrary);
+      }
+
+      if (type2 is InterfaceType && type2.classNode == coreTypes.recordClass) {
+        // UP(Record(...), Record) = Record
+        return coreTypes.recordRawType(uniteNullabilities(
+            type1.declaredNullability, type2.declaredNullability));
+      }
+
+      // UP(Record(...), T2) = UP(Object, T2)
+      return _getNullabilityAwareStandardUpperBound(
+          coreTypes.objectNonNullableRawType, type2, clientLibrary);
+    } else if (type2 is RecordType) {
+      if (type1 is InterfaceType && type1.classNode == coreTypes.recordClass) {
+        // UP(Record, Record(...)) = Record
+        return coreTypes.recordRawType(uniteNullabilities(
+            type1.declaredNullability, type2.declaredNullability));
+      }
+
+      // UP(T1, Record(...)) = UP(T1, Object)
+      return _getNullabilityAwareStandardUpperBound(
+          type1, coreTypes.objectNonNullableRawType, clientLibrary);
+    }
+
     // UP(FutureOr<T1>, FutureOr<T2>) = FutureOr<T3> where T3 = UP(T1, T2)
     // UP(Future<T1>, FutureOr<T2>) = FutureOr<T3> where T3 = UP(T1, T2)
     // UP(FutureOr<T1>, Future<T2>) = FutureOr<T3> where T3 = UP(T1, T2)
@@ -1051,6 +1083,60 @@ mixin StandardBounds {
             math.min(f.requiredParameterCount, g.requiredParameterCount));
   }
 
+  /// Computes the nullability-aware lower bound of two record types.
+  ///
+  /// The algorithm is defined as follows:
+  /// DOWN((P00, ..., P0k, Named0), (P10, ..., P1k, Named1)) =
+  ///   (P20, ..., P2k, Named2)
+  /// if:
+  ///   P2i is DOWN(P0i, P1i),
+  ///   Named0 contains R0i xi
+  ///       if Named1 contains R1i xi
+  ///   Named1 contains R1i xi
+  ///       if Named0 contains R0i xi
+  ///   Named2 contains exactly R2i xi
+  ///       for each xi in both Named0 and Named1
+  ///     where R0i xi is in Named0
+  ///     where R1i xi is in Named1
+  ///     and R2i is UP(R0i, R1i)
+  /// DOWN(Record(...), Record(...)) = Never otherwise.
+  DartType _getNullabilityAwareRecordStandardLowerBound(
+      RecordType r1, RecordType r2, Library clientLibrary) {
+    // The fallback result for whenever the following rule applies:
+    //     DOWN(Record(...), Record(...)) = Never otherwise.
+    late final DartType fallbackResult = NeverType.fromNullability(
+        intersectNullabilities(r1.declaredNullability, r2.declaredNullability));
+
+    if (r1.positional.length != r2.positional.length ||
+        r1.named.length != r2.named.length) {
+      return fallbackResult;
+    }
+
+    int positionalLength = r1.positional.length;
+    int namedLength = r1.named.length;
+
+    for (int i = 0; i < namedLength; i++) {
+      if (r1.named[i].name != r2.named[i].name) {
+        return fallbackResult;
+      }
+    }
+
+    List<DartType> positional = new List<DartType>.generate(
+        positionalLength,
+        (i) => _getNullabilityAwareStandardLowerBound(
+            r1.positional[i], r2.positional[i], clientLibrary));
+
+    List<NamedType> named = new List<NamedType>.generate(
+        namedLength,
+        (i) => new NamedType(
+            r1.named[i].name,
+            _getNullabilityAwareStandardLowerBound(
+                r1.named[i].type, r2.named[i].type, clientLibrary)));
+
+    return new RecordType(positional, named,
+        intersectNullabilities(r1.declaredNullability, r2.declaredNullability));
+  }
+
   /// Computes the nullability-aware lower bound of two function types.
   ///
   /// UP(
@@ -1219,6 +1305,63 @@ mixin StandardBounds {
         requiredParameterCount: f.requiredParameterCount);
   }
 
+  /// Computes the nullability-aware lower bound of two record types.
+  ///
+  /// UP((P00, ... P0k, Named0), (P10, ... P1k, Named1)) =
+  ///   (P20, ..., P2k, Named2)
+  /// if:
+  ///   P2i is UP(P0i, P1i)
+  ///   Named0 contains R0i xi
+  ///       if Named1 contains R1i xi
+  ///   Named1 contains R1i xi
+  ///       if Named0 contains R0i xi
+  ///   Named2 contains exactly R2i xi
+  ///       for each xi in both Named0 and Named1
+  ///     where R0i xi is in Named0
+  ///     where R1i xi is in Named1
+  ///     and R2i is UP(R0i, R1i)
+  /// UP(Record(...), Record(...)) = Record otherwise
+  DartType _getNullabilityAwareRecordStandardUpperBound(
+      RecordType r1, RecordType r2, Library clientLibrary) {
+    // The return value for whenever the following applies:
+    //     UP(Record(...), Record(...)) = Record otherwise
+    late final DartType fallbackResult = coreTypes.recordRawType(
+        uniteNullabilities(r1.declaredNullability, r2.declaredNullability));
+
+    // Here we perform a quick check on the function types to figure out if we
+    // can compute a non-trivial upper bound for them.
+    if (r1.positional.length != r2.positional.length ||
+        r1.named.length != r2.named.length) {
+      return fallbackResult;
+    }
+
+    int positionalLength = r1.positional.length;
+    int namedLength = r1.named.length;
+
+    for (int i = 0; i < namedLength; i++) {
+      // The named parameters of record types are assumed to be sorted
+      // lexicographically.
+      if (r1.named[i].name != r2.named[i].name) {
+        return fallbackResult;
+      }
+    }
+
+    List<DartType> positional = new List<DartType>.generate(
+        positionalLength,
+        (i) => _getNullabilityAwareStandardUpperBound(
+            r1.positional[i], r2.positional[i], clientLibrary));
+
+    List<NamedType> named = new List<NamedType>.generate(
+        namedLength,
+        (i) => new NamedType(
+            r1.named[i].name,
+            _getNullabilityAwareStandardUpperBound(
+                r1.named[i].type, r2.named[i].type, clientLibrary)));
+
+    return new RecordType(positional, named,
+        uniteNullabilities(r1.declaredNullability, r2.declaredNullability));
+  }
+
   DartType _getNullabilityAwareTypeParameterStandardUpperBound(
       TypeParameterType type1, DartType type2, Library clientLibrary) {
     // UP(X1 extends B1, T2) =