Add many more tests showing current behaviors

Author: weswigham

tests/baselines/reference/indexAccessCombinedInference.js

@@ -1,29 +1,148 @@
 //// [indexAccessCombinedInference.ts]
+// Simple case
 interface Args {
     TA: object,
     TY: object
 }
 
-function foo<T extends Args>(
+declare function foo<T extends Args>(
     a: T["TA"],
-    b: T["TY"]): T["TA"] & T["TY"] {
-    return undefined!;
-}
+    b: T["TY"]): T["TA"] & T["TY"];
 
 const x = foo({
     x: {
         j: 12,
         i: 11
     }
-}, { y: 42 });
+}, { y: 42 });
+
+// Union result type
+interface A {
+    foo: number;
+}
+interface B {
+    bar: string;
+}
+declare const something: A | B;
+
+const y = foo(something, { bat: 42 });
+
+// Union key type
+interface Args2 {
+    TA?: object, // Optional since only one of TA or TB needs to be infered in the below argument list
+    TB?: object,
+    TY: object
+}
+declare function foo2<T extends Args2>(
+    a: T["TA"] | T["TB"],
+    b: T["TY"]): {a: T["TA"], b: T["TB"]} & T["TY"];
+declare function foo3<T extends Args2>( // Morally equivalent to foo2
+    a: T["TA" | "TB"],
+    b: T["TY"]): {a: T["TA"], b: T["TB"]} & T["TY"];
+let z = foo2({
+    x: {
+        j: 12,
+        i: 11
+    }
+}, { y: 42 });
+let zz = foo3({
+    x: {
+        j: 12,
+        i: 11
+    }
+}, { y: 42 });
+z = zz;
+zz = z;
+
+// Higher-order
+interface Args3 {
+    Key: "A" | "B",
+    A: object,
+    B: object,
+    Merge: object,
+}
+declare const either: "A" | "B";
+declare function pickOne<T extends Args3>(key: T["Key"], left: T["A"], right: T["B"], into: T["Merge"]): T[T["Key"]] & T["Merge"];
+
+const opt1 = pickOne("A", {x: 12}, {y: ""}, {z: /./});
+const opt2 = pickOne("B", {x: 12}, {y: ""}, {z: /./});
+const opt3 = pickOne(either, {x: 12}, {y: ""}, {z: /./});
+
+const pickDelayed = <TKey extends Args3["Key"]>(x: TKey) => pickOne(x, {j: x}, {i: x}, {chosen: x});
+const opt4 = pickDelayed("A");
+const opt5 = pickDelayed("B");
+const opt6 = pickDelayed(either);
+
+// Reopenable
+interface Args3 {
+    /**
+     * One must make patched parameters optional, otherwise signatures expecting the unpatched
+     * interface (ie, pickOne above) will not be able to produce a type satisfying the interface
+     * (as there are no inference sites for the new members) and will fall back to the constraints on each member
+     */
+    Extra?: object,
+}
+declare function pickOne<T extends Args3>(key: T["Key"], left: T["A"], right: T["B"], into: T["Merge"], extra: T["Extra"]): T[T["Key"]] & {into: T["Merge"], extra: T["Extra"]};
+const opt7 = pickOne("A", {x: 12}, {y: ""}, {z: /./}, {z: /./});
+const opt8 = pickOne("B", {x: 12}, {y: ""}, {z: /./}, {z: /./});
+const opt9 = pickOne(either, {x: 12}, {y: ""}, {z: /./}, {z: /./});
+
+// Interactions with `this` types
+interface TPicker {
+    Key: keyof this,
+    X: number,
+    Y: string
+}
+declare function chooseLiteral<T extends TPicker>(choice: T["Key"], x: T["X"], y:T["Y"]): T[T["Key"]];
+const cx = chooseLiteral("X", 1, "no");
+const cy = chooseLiteral("Y", 0, "yes");
+const ceither = chooseLiteral("X" as "X" | "Y", 1, "yes");
+const cneither = chooseLiteral("Key", 0, "no");
+
+// Multiple inference sites
+interface Args4 {
+    0: object,
+    1: Record<keyof this["0"], Function>,
+}
+declare function dualInputs<T extends Args4>(x: T["0"], y: T["0"], toDelay: T["1"]): T["0"] & {transformers: T["1"]};
+
+const result = dualInputs({x: 0}, {x: 1}, {x: () => ""});
+
 
 //// [indexAccessCombinedInference.js]
-function foo(a, b) {
-    return undefined;
-}
 var x = foo({
     x: {
         j: 12,
         i: 11
     }
 }, { y: 42 });
+var y = foo(something, { bat: 42 });
+var z = foo2({
+    x: {
+        j: 12,
+        i: 11
+    }
+}, { y: 42 });
+var zz = foo3({
+    x: {
+        j: 12,
+        i: 11
+    }
+}, { y: 42 });
+z = zz;
+zz = z;
+var opt1 = pickOne("A", { x: 12 }, { y: "" }, { z: /./ });
+var opt2 = pickOne("B", { x: 12 }, { y: "" }, { z: /./ });
+var opt3 = pickOne(either, { x: 12 }, { y: "" }, { z: /./ });
+var pickDelayed = function (x) { return pickOne(x, { j: x }, { i: x }, { chosen: x }); };
+var opt4 = pickDelayed("A");
+var opt5 = pickDelayed("B");
+var opt6 = pickDelayed(either);
+var opt7 = pickOne("A", { x: 12 }, { y: "" }, { z: /./ }, { z: /./ });
+var opt8 = pickOne("B", { x: 12 }, { y: "" }, { z: /./ }, { z: /./ });
+var opt9 = pickOne(either, { x: 12 }, { y: "" }, { z: /./ }, { z: /./ });
+var cx = chooseLiteral("X", 1, "no");
+var cy = chooseLiteral("Y", 0, "yes");
+var ceither = chooseLiteral("X", 1, "yes");
+var cneither = chooseLiteral("Key", 0, "no");
+var result = dualInputs({ x: 0 }, { x: 1 }, { x: function () { return ""; } });