dart-lang#1354. Horizontal inference tests added

Author: sgrekhov

LanguageFeatures/Horizontal-inference/argument_partitioning_t01.dart

@@ -0,0 +1,80 @@
+// 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 First, we form a dependency graph among the invocation arguments
+/// based on the following rule: there is a dependency edge from argument A to
+/// argument B if and only if the type of the invocation target is generic, and
+/// the following relationship exists among A, B, and at least one of the
+/// invocation target’s type parameters T:
+///
+/// A is a function literal expression,
+/// AND the parameter in the invocation target corresponding to A is function
+/// typed,
+/// AND T is a free variable in the type of at least one of the parameters of
+/// that function type,
+/// AND the corresponding parameter in A does not have a type annotation,
+/// AND EITHER:
+/// The parameter in the invocation target corresponding to B is function typed,
+/// and T is a free variable in its return type
+/// OR the parameter in the invocation target corresponding to B is not function
+/// typed, and T is a free variable in its type.
+///
+/// The idea here is that we're trying to draw a dependency edge from A to B in
+/// precisely those circumstances in which there is likely to be a benefit to
+/// performing a round of horizontal inference after type inferring B and before
+/// type inferring A.
+///
+/// Stage selection
+/// After building the dependency graph, we condense it into its strongly
+/// connected components (a.k.a. "dependency cycles"). The resulting
+/// condensation is guaranteed to be acyclic (that is, considering the nodes of
+/// the condensed graph, the arguments in each node depend transitively on each
+/// other, and possibly on the arguments in other nodes, but no dependency cycle
+/// exists between one node and another).
+///
+/// @description Checks that type inferred from non-function types and return
+/// types of the functions to function types
+/// @author [email protected]
+
+import "../../Utils/expect.dart";
+
+var aType;
+var bType;
+var cType;
+var dType;
+
+void f<T, U, V>(void Function(T, U) a, T b, U Function(V) c, V Function(U) d) {
+  aType = a.runtimeType;
+  bType = b.runtimeType;
+  cType = c.runtimeType;
+  dType = d.runtimeType;
+}
+
+typedef expectedA = void Function(String s, int i);
+typedef expectedB = String;
+typedef expectedC = int Function(Object? o);
+typedef expectedD = bool Function(Object? o);
+
+typedef Str = String;
+typedef Int = int;
+typedef Boolean = bool;
+
+main() {
+  // T = String, U = int, V = bool
+  f((t, u) {}, "x", (v) => 42, (u) => true);
+  Expect.equals(expectedA, aType);
+  Expect.equals(expectedB, bType);
+  Expect.equals(expectedC, cType);
+  Expect.equals(expectedD, dType);
+
+  Str s = "Lily was here";
+  Int i = 0;
+  Boolean b = true;
+
+  f((t, u) {}, s, (v) => i, (u) => b);
+  Expect.equals(expectedA, aType);
+  Expect.equals(expectedB, bType);
+  Expect.equals(expectedC, cType);
+  Expect.equals(expectedD, dType);
+}

LanguageFeatures/Horizontal-inference/argument_partitioning_t02.dart

@@ -0,0 +1,53 @@
+// 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 First, we form a dependency graph among the invocation arguments
+/// based on the following rule: there is a dependency edge from argument A to
+/// argument B if and only if the type of the invocation target is generic, and
+/// the following relationship exists among A, B, and at least one of the
+/// invocation target’s type parameters T:
+///
+/// A is a function literal expression,
+/// AND the parameter in the invocation target corresponding to A is function
+/// typed,
+/// AND T is a free variable in the type of at least one of the parameters of
+/// that function type,
+/// AND the corresponding parameter in A does not have a type annotation,
+/// AND EITHER:
+/// The parameter in the invocation target corresponding to B is function typed,
+/// and T is a free variable in its return type
+/// OR the parameter in the invocation target corresponding to B is not function
+/// typed, and T is a free variable in its type.
+///
+/// The idea here is that we're trying to draw a dependency edge from A to B in
+/// precisely those circumstances in which there is likely to be a benefit to
+/// performing a round of horizontal inference after type inferring B and before
+/// type inferring A.
+///
+/// Stage selection
+/// After building the dependency graph, we condense it into its strongly
+/// connected components (a.k.a. "dependency cycles"). The resulting
+/// condensation is guaranteed to be acyclic (that is, considering the nodes of
+/// the condensed graph, the arguments in each node depend transitively on each
+/// other, and possibly on the arguments in other nodes, but no dependency cycle
+/// exists between one node and another).
+///
+/// @description Checks that type is not inferred from function arguments to
+/// non-function types and return types of the functions
+/// @author [email protected]
+
+void f<T, U, V>(void Function(T, U) a, T b, U Function(V) c) {}
+
+main() {
+  dynamic s = "Lily was here";
+  f((String t, u) {}, s, (v) => 42);
+//  ^^^^^^^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  f((t, String u) {}, "s", (v) => v);
+//  ^^^^^^^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

LanguageFeatures/Horizontal-inference/argument_partitioning_t03.dart

@@ -0,0 +1,47 @@
+// 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 First, we form a dependency graph among the invocation arguments
+/// based on the following rule: there is a dependency edge from argument A to
+/// argument B if and only if the type of the invocation target is generic, and
+/// the following relationship exists among A, B, and at least one of the
+/// invocation target’s type parameters T:
+///
+/// A is a function literal expression,
+/// AND the parameter in the invocation target corresponding to A is function
+/// typed,
+/// AND T is a free variable in the type of at least one of the parameters of
+/// that function type,
+/// AND the corresponding parameter in A does not have a type annotation,
+/// AND EITHER:
+/// The parameter in the invocation target corresponding to B is function typed,
+/// and T is a free variable in its return type
+/// OR the parameter in the invocation target corresponding to B is not function
+/// typed, and T is a free variable in its type.
+///
+/// The idea here is that we're trying to draw a dependency edge from A to B in
+/// precisely those circumstances in which there is likely to be a benefit to
+/// performing a round of horizontal inference after type inferring B and before
+/// type inferring A.
+///
+/// Stage selection
+/// After building the dependency graph, we condense it into its strongly
+/// connected components (a.k.a. "dependency cycles"). The resulting
+/// condensation is guaranteed to be acyclic (that is, considering the nodes of
+/// the condensed graph, the arguments in each node depend transitively on each
+/// other, and possibly on the arguments in other nodes, but no dependency cycle
+/// exists between one node and another).
+///
+/// @description Checks that type is not inferred from function arguments to
+/// non-function types and return types of the functions. Test dependency loop
+/// @author [email protected]
+
+void f<U, V>(U Function(V) c, V Function(U) d) {}
+
+main() {
+  f((v) => 42, (String u) => true);
+//         ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

LanguageFeatures/Horizontal-inference/argument_partitioning_t04.dart

@@ -0,0 +1,67 @@
+// 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 First, we form a dependency graph among the invocation arguments
+/// based on the following rule: there is a dependency edge from argument A to
+/// argument B if and only if the type of the invocation target is generic, and
+/// the following relationship exists among A, B, and at least one of the
+/// invocation target’s type parameters T:
+///
+/// A is a function literal expression,
+/// AND the parameter in the invocation target corresponding to A is function
+/// typed,
+/// AND T is a free variable in the type of at least one of the parameters of
+/// that function type,
+/// AND the corresponding parameter in A does not have a type annotation,
+/// AND EITHER:
+/// The parameter in the invocation target corresponding to B is function typed,
+/// and T is a free variable in its return type
+/// OR the parameter in the invocation target corresponding to B is not function
+/// typed, and T is a free variable in its type.
+///
+/// The idea here is that we're trying to draw a dependency edge from A to B in
+/// precisely those circumstances in which there is likely to be a benefit to
+/// performing a round of horizontal inference after type inferring B and before
+/// type inferring A.
+///
+/// Stage selection
+/// After building the dependency graph, we condense it into its strongly
+/// connected components (a.k.a. "dependency cycles"). The resulting
+/// condensation is guaranteed to be acyclic (that is, considering the nodes of
+/// the condensed graph, the arguments in each node depend transitively on each
+/// other, and possibly on the arguments in other nodes, but no dependency cycle
+/// exists between one node and another).
+///
+/// @description Checks that type inferred from non-function types and return
+/// types of the functions to function types
+/// @author [email protected]
+
+import "../../Utils/expect.dart";
+
+var aType;
+var bType;
+var cType;
+var dType;
+
+void f<T, U, V>(void Function(T, U) a, List<T> b, List<U> Function(V) c,
+    List<V> Function(U) d) {
+  aType = a.runtimeType;
+  bType = b.runtimeType;
+  cType = c.runtimeType;
+  dType = d.runtimeType;
+}
+
+typedef expectedA = void Function(String s, int i);
+typedef expectedB = List<String>;
+typedef expectedC = List<int> Function(Object? o);
+typedef expectedD = List<bool> Function(Object? o);
+
+main() {
+  // T = String, U = int, V = bool
+  f((t, u) {}, ["x"], (v) => [42], (u) => [true]);
+  Expect.equals(expectedA, aType);
+  Expect.equals(expectedB, bType);
+  Expect.equals(expectedC, cType);
+  Expect.equals(expectedD, dType);
+}

LanguageFeatures/Horizontal-inference/argument_partitioning_t05.dart

@@ -0,0 +1,64 @@
+// 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 First, we form a dependency graph among the invocation arguments
+/// based on the following rule: there is a dependency edge from argument A to
+/// argument B if and only if the type of the invocation target is generic, and
+/// the following relationship exists among A, B, and at least one of the
+/// invocation target’s type parameters T:
+///
+/// A is a function literal expression,
+/// AND the parameter in the invocation target corresponding to A is function
+/// typed,
+/// AND T is a free variable in the type of at least one of the parameters of
+/// that function type,
+/// AND the corresponding parameter in A does not have a type annotation,
+/// AND EITHER:
+/// The parameter in the invocation target corresponding to B is function typed,
+/// and T is a free variable in its return type
+/// OR the parameter in the invocation target corresponding to B is not function
+/// typed, and T is a free variable in its type.
+///
+/// The idea here is that we're trying to draw a dependency edge from A to B in
+/// precisely those circumstances in which there is likely to be a benefit to
+/// performing a round of horizontal inference after type inferring B and before
+/// type inferring A.
+///
+/// Stage selection
+/// After building the dependency graph, we condense it into its strongly
+/// connected components (a.k.a. "dependency cycles"). The resulting
+/// condensation is guaranteed to be acyclic (that is, considering the nodes of
+/// the condensed graph, the arguments in each node depend transitively on each
+/// other, and possibly on the arguments in other nodes, but no dependency cycle
+/// exists between one node and another).
+///
+/// @description Checks that type inferred from non-function types and return
+/// types of the functions to function types
+/// @author [email protected]
+
+import "../../Utils/expect.dart";
+
+var aType;
+var bType;
+var cType;
+var dType;
+
+void f<T, U, V>(void Function(T, U) a, Map<T, U> b, Map<U, V> c, V Function(U) d) {
+  aType = a.runtimeType;
+  bType = b.runtimeType;
+  cType = c.runtimeType;
+  dType = d.runtimeType;
+}
+
+typedef expectedA = void Function(String s, int i);
+typedef expectedB = Map<String, int>;
+typedef expectedC = Map<int, List<String>>;
+typedef expectedD = List<String> Function(int i);
+
+main() {
+  // T = String, U = int, V = List<String>
+  f((t, u) {}, {"x": 42}, {42: ["x", "y"]}, (u) => ["Lily", "was", "here"]);
+  Expect.equals(expectedA, aType);
+  Expect.equals(expectedD, dType);
+}

LanguageFeatures/Horizontal-inference/argument_partitioning_t06.dart

@@ -0,0 +1,59 @@
+// 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 First, we form a dependency graph among the invocation arguments
+/// based on the following rule: there is a dependency edge from argument A to
+/// argument B if and only if the type of the invocation target is generic, and
+/// the following relationship exists among A, B, and at least one of the
+/// invocation target’s type parameters T:
+///
+/// A is a function literal expression,
+/// AND the parameter in the invocation target corresponding to A is function
+/// typed,
+/// AND T is a free variable in the type of at least one of the parameters of
+/// that function type,
+/// AND the corresponding parameter in A does not have a type annotation,
+/// AND EITHER:
+/// The parameter in the invocation target corresponding to B is function typed,
+/// and T is a free variable in its return type
+/// OR the parameter in the invocation target corresponding to B is not function
+/// typed, and T is a free variable in its type.
+///
+/// The idea here is that we're trying to draw a dependency edge from A to B in
+/// precisely those circumstances in which there is likely to be a benefit to
+/// performing a round of horizontal inference after type inferring B and before
+/// type inferring A.
+///
+/// Stage selection
+/// After building the dependency graph, we condense it into its strongly
+/// connected components (a.k.a. "dependency cycles"). The resulting
+/// condensation is guaranteed to be acyclic (that is, considering the nodes of
+/// the condensed graph, the arguments in each node depend transitively on each
+/// other, and possibly on the arguments in other nodes, but no dependency cycle
+/// exists between one node and another).
+///
+/// @description Checks that type is not inferred from function arguments to
+/// non-function types and return types of the functions
+/// @author [email protected]
+
+void f1<X, Y>(X Function(Y) a, void Function(X) b) {}
+void f2<X, Y>(void Function(Y) a, Y Function(X) b) {}
+void f3<T, U>(Map<T, U> a, void Function(T, U) b) {}
+
+main() {
+  f1((v) => 42, (String u) {});
+//              ^^^^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  f2((int v) {}, (u) => "Lily was here");
+//   ^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  f3({"x": "42"}, (String t, int u) {});
+//                ^^^^^^^^^^^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}