Fixes #1477. [Records] Type inference tests updated

LanguageFeatures/Records/type_inference_A01_t01.dart

@@ -2,9 +2,28 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-/// @assertion Type inference and promotion flows through records in much the 
-/// same way it does for instances of generic classes (which are covariant in 
-/// Dart just like record fields are) and collection literals.
+/// @assertion Given a type schema K and a record expression E of the general
+/// form (e1, ..., en, d1 : e{n+1}, ..., dm : e{n+m}) inference proceeds as
+/// follows.
+///
+/// If K is a record type schema of the form
+/// (K1, ..., Kn, {d1 : K{n+1}, ...., dm : K{n+m}}) then:
+///
+/// - Each ei is inferred with context type schema Ki to have type Si
+///   - Let Ri be the greatest closure of Ki
+///   - If Si is a subtype of Ri then let Ti be Si
+///   - Otherwise, if Si is dynamic, then we insert an implicit cast on ei to
+///     Ri, and let Ti be Ri
+///   - Otherwise, if Si is coercible to Ri (via some sequence of call method
+///     tearoff or implicit generic instantiation coercions), then we insert the
+///     appropriate implicit coercion(s) on ei. Let Ti be the type of the
+///     resulting coerced value (which must be a subtype of Ri, possibly proper).
+///   - Otherwise, it is a static error.
+///  - The type of E is (T1, ..., Tn, {d1 : T{n+1}, ...., dm : T{n+m}})
+/// If K is any other type schema:
+///
+/// - Each ei is inferred with context type schema _ to have type Ti
+/// - The type of E is (T1, ..., Tn, {d1 : T{n+1}, ...., dm : T{n+m}})
 ///
 /// @description Checks type inference for records.
 /// @author [email protected]

LanguageFeatures/Records/type_inference_A01_t02.dart

@@ -0,0 +1,41 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion Given a type schema K and a record expression E of the general
+/// form (e1, ..., en, d1 : e{n+1}, ..., dm : e{n+m}) inference proceeds as
+/// follows.
+///
+/// If K is a record type schema of the form
+/// (K1, ..., Kn, {d1 : K{n+1}, ...., dm : K{n+m}}) then:
+///
+/// - Each ei is inferred with context type schema Ki to have type Si
+///   - Let Ri be the greatest closure of Ki
+///   - If Si is a subtype of Ri then let Ti be Si
+///   - Otherwise, if Si is dynamic, then we insert an implicit cast on ei to
+///     Ri, and let Ti be Ri
+///   - Otherwise, if Si is coercible to Ri (via some sequence of call method
+///     tearoff or implicit generic instantiation coercions), then we insert the
+///     appropriate implicit coercion(s) on ei. Let Ti be the type of the
+///     resulting coerced value (which must be a subtype of Ri, possibly proper).
+///   - Otherwise, it is a static error.
+///  - The type of E is (T1, ..., Tn, {d1 : T{n+1}, ...., dm : T{n+m}})
+/// If K is any other type schema:
+///
+/// - Each ei is inferred with context type schema _ to have type Ti
+/// - The type of E is (T1, ..., Tn, {d1 : T{n+1}, ...., dm : T{n+m}})
+///
+/// @description Checks type inference for records.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+main() {
+  (num,) r1 = (42,) ..$0.isOdd;
+
+  ({num n}) r2 = (n: 42) ..n.isOdd;
+
+  (num, {Object s}) r3 = (42, s: "")
+    ..$0.isOdd
+    ..s.substring(0);
+}

LanguageFeatures/Records/type_inference_A01_t03.dart

@@ -0,0 +1,62 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion Given a type schema K and a record expression E of the general
+/// form (e1, ..., en, d1 : e{n+1}, ..., dm : e{n+m}) inference proceeds as
+/// follows.
+///
+/// If K is a record type schema of the form
+/// (K1, ..., Kn, {d1 : K{n+1}, ...., dm : K{n+m}}) then:
+///
+/// - Each ei is inferred with context type schema Ki to have type Si
+///   - Let Ri be the greatest closure of Ki
+///   - If Si is a subtype of Ri then let Ti be Si
+///   - Otherwise, if Si is dynamic, then we insert an implicit cast on ei to
+///     Ri, and let Ti be Ri
+///   - Otherwise, if Si is coercible to Ri (via some sequence of call method
+///     tearoff or implicit generic instantiation coercions), then we insert the
+///     appropriate implicit coercion(s) on ei. Let Ti be the type of the
+///     resulting coerced value (which must be a subtype of Ri, possibly proper).
+///   - Otherwise, it is a static error.
+///  - The type of E is (T1, ..., Tn, {d1 : T{n+1}, ...., dm : T{n+m}})
+/// If K is any other type schema:
+///
+/// - Each ei is inferred with context type schema _ to have type Ti
+/// - The type of E is (T1, ..., Tn, {d1 : T{n+1}, ...., dm : T{n+m}})
+///
+/// @description Checks an implicit downcast for records
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+import "../../Utils/expect.dart";
+import "../../Utils/static_type_helper.dart";
+
+class Callable {
+  void call(num x) {}
+}
+
+T id<T>(T x) => x;
+
+main() {
+  var c = Callable();
+  dynamic d = 3;
+  (num, double, int Function(int), void Function(num)) r1 = (d, 3, id, c)
+    ..expectStaticType<
+        Exactly<(num, double, int Function(int), void Function(num))>>();
+
+  Expect.throws(() {
+    dynamic d2 = 3.14;
+    (int, double, int Function(int), void Function(num)) r2 = (d2, 3, id, c);
+  });
+  Expect.throws(() {
+    (r1.$1 as dynamic).isEven;
+  });
+  Expect.throws(() {
+    (r1.$2 as dynamic)("42");
+  });
+  Expect.throws(() {
+    (r1.$3 as dynamic)("42");
+  });
+}

LanguageFeatures/Records/type_inference_A01_t04.dart

@@ -0,0 +1,63 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion Given a type schema K and a record expression E of the general
+/// form (e1, ..., en, d1 : e{n+1}, ..., dm : e{n+m}) inference proceeds as
+/// follows.
+///
+/// If K is a record type schema of the form
+/// (K1, ..., Kn, {d1 : K{n+1}, ...., dm : K{n+m}}) then:
+///
+/// - Each ei is inferred with context type schema Ki to have type Si
+///   - Let Ri be the greatest closure of Ki
+///   - If Si is a subtype of Ri then let Ti be Si
+///   - Otherwise, if Si is dynamic, then we insert an implicit cast on ei to
+///     Ri, and let Ti be Ri
+///   - Otherwise, if Si is coercible to Ri (via some sequence of call method
+///     tearoff or implicit generic instantiation coercions), then we insert the
+///     appropriate implicit coercion(s) on ei. Let Ti be the type of the
+///     resulting coerced value (which must be a subtype of Ri, possibly proper).
+///   - Otherwise, it is a static error.
+///  - The type of E is (T1, ..., Tn, {d1 : T{n+1}, ...., dm : T{n+m}})
+/// If K is any other type schema:
+///
+/// - Each ei is inferred with context type schema _ to have type Ti
+/// - The type of E is (T1, ..., Tn, {d1 : T{n+1}, ...., dm : T{n+m}})
+///
+/// @description Checks an implicit downcast for records
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+import "../../Utils/expect.dart";
+import "../../Utils/static_type_helper.dart";
+
+({List<int> list, Map<String, int> map, Set<String> set}) foo() =>
+    (list: [], map: {}, set: {}) ..expectStaticType<Exactly<
+        ({List<int> list, Map<String, int> map, Set<String> set})>>();
+
+void bar((List<int>, Map<String, int>, Set<String>) r) {
+  Expect.throws(() {(r.$0 as dynamic).add("");});
+  Expect.throws(() {(r.$1 as dynamic)[""] = "";});
+  Expect.throws(() {(r.$1 as dynamic)[42] = 42;});
+  Expect.throws(() {(r.$2 as dynamic).add(42);});
+}
+
+main() {
+  (List<int>, Map<String, int>, {Set<String> set}) r = ([], {}, set: {})
+      ..expectStaticType<Exactly<
+          (List<int>, Map<String, int>, {Set<String> set})>>();
+  Expect.throws(() {(r.$0 as dynamic).add("");});
+  Expect.throws(() {(r.$1 as dynamic)[""] = "";});
+  Expect.throws(() {(r.$1 as dynamic)[42] = 42;});
+  Expect.throws(() {(r.set as dynamic).add(42);});
+
+  Expect.throws(() {(foo().list as dynamic).add("");});
+  Expect.throws(() {(foo().map as dynamic)[""] = "";});
+  Expect.throws(() {(foo().map as dynamic)[42] = 42;});
+  Expect.throws(() {(foo().set as dynamic).add(42);});
+
+  bar(([], {}, {})
+     ..expectStaticType<Exactly<(List<int>, Map<String, int>, Set<String>)>>());
+}

LanguageFeatures/Records/type_inference_A01_t05.dart

@@ -0,0 +1,45 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion Given a type schema K and a record expression E of the general
+/// form (e1, ..., en, d1 : e{n+1}, ..., dm : e{n+m}) inference proceeds as
+/// follows.
+///
+/// If K is a record type schema of the form
+/// (K1, ..., Kn, {d1 : K{n+1}, ...., dm : K{n+m}}) then:
+///
+/// - Each ei is inferred with context type schema Ki to have type Si
+///   - Let Ri be the greatest closure of Ki
+///   - If Si is a subtype of Ri then let Ti be Si
+///   - Otherwise, if Si is dynamic, then we insert an implicit cast on ei to
+///     Ri, and let Ti be Ri
+///   - Otherwise, if Si is coercible to Ri (via some sequence of call method
+///     tearoff or implicit generic instantiation coercions), then we insert the
+///     appropriate implicit coercion(s) on ei. Let Ti be the type of the
+///     resulting coerced value (which must be a subtype of Ri, possibly proper).
+///   - Otherwise, it is a static error.
+///  - The type of E is (T1, ..., Tn, {d1 : T{n+1}, ...., dm : T{n+m}})
+/// If K is any other type schema:
+///
+/// - Each ei is inferred with context type schema _ to have type Ti
+/// - The type of E is (T1, ..., Tn, {d1 : T{n+1}, ...., dm : T{n+m}})
+///
+/// @description Checks type inference for records.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+import "../../Utils/expect.dart";
+
+class C<X> {
+  Type get typeArgument => X;
+}
+
+class D<X extends Y, Y> extends C<Y> {}
+
+main() {
+  (C<int>, {C<double> x}) r = (D(), x: D());
+  Expect.equals(int, r.$0.typeArgument);
+  Expect.equals(double, r.x.typeArgument);
+}

LanguageFeatures/Records/type_inference_A02_t01.dart

@@ -2,9 +2,28 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-/// @assertion Type inference and promotion flows through records in much the 
-/// same way it does for instances of generic classes (which are covariant in 
-/// Dart just like record fields are) and collection literals.
+/// @assertion Given a type schema K and a record expression E of the general
+/// form (e1, ..., en, d1 : e{n+1}, ..., dm : e{n+m}) inference proceeds as
+/// follows.
+///
+/// If K is a record type schema of the form
+/// (K1, ..., Kn, {d1 : K{n+1}, ...., dm : K{n+m}}) then:
+///
+/// - Each ei is inferred with context type schema Ki to have type Si
+///   - Let Ri be the greatest closure of Ki
+///   - If Si is a subtype of Ri then let Ti be Si
+///   - Otherwise, if Si is dynamic, then we insert an implicit cast on ei to
+///     Ri, and let Ti be Ri
+///   - Otherwise, if Si is coercible to Ri (via some sequence of call method
+///     tearoff or implicit generic instantiation coercions), then we insert the
+///     appropriate implicit coercion(s) on ei. Let Ti be the type of the
+///     resulting coerced value (which must be a subtype of Ri, possibly proper).
+///   - Otherwise, it is a static error.
+///  - The type of E is (T1, ..., Tn, {d1 : T{n+1}, ...., dm : T{n+m}})
+/// If K is any other type schema:
+///
+/// - Each ei is inferred with context type schema _ to have type Ti
+/// - The type of E is (T1, ..., Tn, {d1 : T{n+1}, ...., dm : T{n+m}})
 ///
 /// @description Checks horizontal inference for records.
 /// @author [email protected]