Accept test baselines

tests/baselines/reference/bindingPatternCannotBeOnlyInferenceSource.errors.txt

@@ -0,0 +1,44 @@
+tests/cases/compiler/bindingPatternCannotBeOnlyInferenceSource.ts(2,7): error TS2571: Object is of type 'unknown'.
+tests/cases/compiler/bindingPatternCannotBeOnlyInferenceSource.ts(3,9): error TS2339: Property 'p1' does not exist on type 'unknown'.
+tests/cases/compiler/bindingPatternCannotBeOnlyInferenceSource.ts(4,7): error TS2461: Type 'unknown' is not an array type.
+tests/cases/compiler/bindingPatternCannotBeOnlyInferenceSource.ts(4,7): error TS2571: Object is of type 'unknown'.
+tests/cases/compiler/bindingPatternCannotBeOnlyInferenceSource.ts(5,7): error TS2461: Type 'unknown' is not an array type.
+
+
+==== tests/cases/compiler/bindingPatternCannotBeOnlyInferenceSource.ts (5 errors) ====
+    declare function f<T>(): T;
+    const {} = f();       // error (only in strictNullChecks)
+          ~~
+!!! error TS2571: Object is of type 'unknown'.
+    const { p1 } = f();   // error
+            ~~
+!!! error TS2339: Property 'p1' does not exist on type 'unknown'.
+    const [] = f();       // error
+          ~~
+!!! error TS2461: Type 'unknown' is not an array type.
+          ~~
+!!! error TS2571: Object is of type 'unknown'.
+    const [e1, e2] = f(); // error
+          ~~~~~~~~
+!!! error TS2461: Type 'unknown' is not an array type.
+    
+    // Repro from #43605
+    type Dispatch<A = { type: any; [extraProps: string]: any }> = { <T extends A>(action: T): T };
+    type IFuncs = { readonly [key: string]: (...p: any) => void };
+    type IDestructuring<T extends IFuncs> = { readonly [key in keyof T]?: (...p: Parameters<T[key]>) => void };
+    type Destructuring<T extends IFuncs, U extends IDestructuring<T>> = (dispatch: Dispatch<any>, funcs: T) => U;
+    const funcs1 = {
+        funcA: (a: boolean): void => {},
+        funcB: (b: string, bb: string): void => {},
+        funcC: (c: number, cc: number, ccc: boolean): void => {},
+    };
+    type TFuncs1 = typeof funcs1;
+    declare function useReduxDispatch1<T extends IDestructuring<TFuncs1>>(destructuring: Destructuring<TFuncs1, T>): T;
+    const {} = useReduxDispatch1(
+        (d, f) => ({
+            funcA: (...p) => d(f.funcA(...p)), // p should be inferrable
+            funcB: (...p) => d(f.funcB(...p)),
+            funcC: (...p) => d(f.funcC(...p)),
+        })
+    );
+    

tests/baselines/reference/bindingPatternCannotBeOnlyInferenceSource.js

@@ -0,0 +1,61 @@
+//// [bindingPatternCannotBeOnlyInferenceSource.ts]
+declare function f<T>(): T;
+const {} = f();       // error (only in strictNullChecks)
+const { p1 } = f();   // error
+const [] = f();       // error
+const [e1, e2] = f(); // error
+
+// Repro from #43605
+type Dispatch<A = { type: any; [extraProps: string]: any }> = { <T extends A>(action: T): T };
+type IFuncs = { readonly [key: string]: (...p: any) => void };
+type IDestructuring<T extends IFuncs> = { readonly [key in keyof T]?: (...p: Parameters<T[key]>) => void };
+type Destructuring<T extends IFuncs, U extends IDestructuring<T>> = (dispatch: Dispatch<any>, funcs: T) => U;
+const funcs1 = {
+    funcA: (a: boolean): void => {},
+    funcB: (b: string, bb: string): void => {},
+    funcC: (c: number, cc: number, ccc: boolean): void => {},
+};
+type TFuncs1 = typeof funcs1;
+declare function useReduxDispatch1<T extends IDestructuring<TFuncs1>>(destructuring: Destructuring<TFuncs1, T>): T;
+const {} = useReduxDispatch1(
+    (d, f) => ({
+        funcA: (...p) => d(f.funcA(...p)), // p should be inferrable
+        funcB: (...p) => d(f.funcB(...p)),
+        funcC: (...p) => d(f.funcC(...p)),
+    })
+);
+
+
+//// [bindingPatternCannotBeOnlyInferenceSource.js]
+var _a = f(); // error (only in strictNullChecks)
+var p1 = f().p1; // error
+var _b = f(); // error
+var _c = f(), e1 = _c[0], e2 = _c[1]; // error
+var funcs1 = {
+    funcA: function (a) { },
+    funcB: function (b, bb) { },
+    funcC: function (c, cc, ccc) { }
+};
+var _d = useReduxDispatch1(function (d, f) { return ({
+    funcA: function () {
+        var p = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            p[_i] = arguments[_i];
+        }
+        return d(f.funcA.apply(f, p));
+    },
+    funcB: function () {
+        var p = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            p[_i] = arguments[_i];
+        }
+        return d(f.funcB.apply(f, p));
+    },
+    funcC: function () {
+        var p = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            p[_i] = arguments[_i];
+        }
+        return d(f.funcC.apply(f, p));
+    }
+}); });

tests/baselines/reference/bindingPatternCannotBeOnlyInferenceSource.symbols

@@ -0,0 +1,133 @@
+=== tests/cases/compiler/bindingPatternCannotBeOnlyInferenceSource.ts ===
+declare function f<T>(): T;
+>f : Symbol(f, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 0, 0))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 0, 19))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 0, 19))
+
+const {} = f();       // error (only in strictNullChecks)
+>f : Symbol(f, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 0, 0))
+
+const { p1 } = f();   // error
+>p1 : Symbol(p1, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 2, 7))
+>f : Symbol(f, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 0, 0))
+
+const [] = f();       // error
+>f : Symbol(f, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 0, 0))
+
+const [e1, e2] = f(); // error
+>e1 : Symbol(e1, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 4, 7))
+>e2 : Symbol(e2, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 4, 10))
+>f : Symbol(f, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 0, 0))
+
+// Repro from #43605
+type Dispatch<A = { type: any; [extraProps: string]: any }> = { <T extends A>(action: T): T };
+>Dispatch : Symbol(Dispatch, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 4, 21))
+>A : Symbol(A, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 7, 14))
+>type : Symbol(type, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 7, 19))
+>extraProps : Symbol(extraProps, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 7, 32))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 7, 65))
+>A : Symbol(A, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 7, 14))
+>action : Symbol(action, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 7, 78))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 7, 65))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 7, 65))
+
+type IFuncs = { readonly [key: string]: (...p: any) => void };
+>IFuncs : Symbol(IFuncs, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 7, 94))
+>key : Symbol(key, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 8, 26))
+>p : Symbol(p, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 8, 41))
+
+type IDestructuring<T extends IFuncs> = { readonly [key in keyof T]?: (...p: Parameters<T[key]>) => void };
+>IDestructuring : Symbol(IDestructuring, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 8, 62))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 9, 20))
+>IFuncs : Symbol(IFuncs, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 7, 94))
+>key : Symbol(key, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 9, 52))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 9, 20))
+>p : Symbol(p, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 9, 71))
+>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 9, 20))
+>key : Symbol(key, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 9, 52))
+
+type Destructuring<T extends IFuncs, U extends IDestructuring<T>> = (dispatch: Dispatch<any>, funcs: T) => U;
+>Destructuring : Symbol(Destructuring, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 9, 107))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 10, 19))
+>IFuncs : Symbol(IFuncs, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 7, 94))
+>U : Symbol(U, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 10, 36))
+>IDestructuring : Symbol(IDestructuring, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 8, 62))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 10, 19))
+>dispatch : Symbol(dispatch, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 10, 69))
+>Dispatch : Symbol(Dispatch, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 4, 21))
+>funcs : Symbol(funcs, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 10, 93))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 10, 19))
+>U : Symbol(U, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 10, 36))
+
+const funcs1 = {
+>funcs1 : Symbol(funcs1, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 11, 5))
+
+    funcA: (a: boolean): void => {},
+>funcA : Symbol(funcA, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 11, 16))
+>a : Symbol(a, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 12, 12))
+
+    funcB: (b: string, bb: string): void => {},
+>funcB : Symbol(funcB, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 12, 36))
+>b : Symbol(b, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 13, 12))
+>bb : Symbol(bb, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 13, 22))
+
+    funcC: (c: number, cc: number, ccc: boolean): void => {},
+>funcC : Symbol(funcC, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 13, 47))
+>c : Symbol(c, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 14, 12))
+>cc : Symbol(cc, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 14, 22))
+>ccc : Symbol(ccc, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 14, 34))
+
+};
+type TFuncs1 = typeof funcs1;
+>TFuncs1 : Symbol(TFuncs1, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 15, 2))
+>funcs1 : Symbol(funcs1, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 11, 5))
+
+declare function useReduxDispatch1<T extends IDestructuring<TFuncs1>>(destructuring: Destructuring<TFuncs1, T>): T;
+>useReduxDispatch1 : Symbol(useReduxDispatch1, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 16, 29))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 17, 35))
+>IDestructuring : Symbol(IDestructuring, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 8, 62))
+>TFuncs1 : Symbol(TFuncs1, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 15, 2))
+>destructuring : Symbol(destructuring, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 17, 70))
+>Destructuring : Symbol(Destructuring, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 9, 107))
+>TFuncs1 : Symbol(TFuncs1, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 15, 2))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 17, 35))
+>T : Symbol(T, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 17, 35))
+
+const {} = useReduxDispatch1(
+>useReduxDispatch1 : Symbol(useReduxDispatch1, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 16, 29))
+
+    (d, f) => ({
+>d : Symbol(d, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 19, 5))
+>f : Symbol(f, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 19, 7))
+
+        funcA: (...p) => d(f.funcA(...p)), // p should be inferrable
+>funcA : Symbol(funcA, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 19, 16))
+>p : Symbol(p, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 20, 16))
+>d : Symbol(d, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 19, 5))
+>f.funcA : Symbol(funcA, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 11, 16))
+>f : Symbol(f, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 19, 7))
+>funcA : Symbol(funcA, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 11, 16))
+>p : Symbol(p, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 20, 16))
+
+        funcB: (...p) => d(f.funcB(...p)),
+>funcB : Symbol(funcB, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 20, 42))
+>p : Symbol(p, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 21, 16))
+>d : Symbol(d, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 19, 5))
+>f.funcB : Symbol(funcB, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 12, 36))
+>f : Symbol(f, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 19, 7))
+>funcB : Symbol(funcB, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 12, 36))
+>p : Symbol(p, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 21, 16))
+
+        funcC: (...p) => d(f.funcC(...p)),
+>funcC : Symbol(funcC, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 21, 42))
+>p : Symbol(p, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 22, 16))
+>d : Symbol(d, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 19, 5))
+>f.funcC : Symbol(funcC, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 13, 47))
+>f : Symbol(f, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 19, 7))
+>funcC : Symbol(funcC, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 13, 47))
+>p : Symbol(p, Decl(bindingPatternCannotBeOnlyInferenceSource.ts, 22, 16))
+
+    })
+);
+

tests/baselines/reference/bindingPatternCannotBeOnlyInferenceSource.types

@@ -0,0 +1,128 @@
+=== tests/cases/compiler/bindingPatternCannotBeOnlyInferenceSource.ts ===
+declare function f<T>(): T;
+>f : <T>() => T
+
+const {} = f();       // error (only in strictNullChecks)
+>f() : unknown
+>f : <T>() => T
+
+const { p1 } = f();   // error
+>p1 : any
+>f() : unknown
+>f : <T>() => T
+
+const [] = f();       // error
+>f() : unknown
+>f : <T>() => T
+
+const [e1, e2] = f(); // error
+>e1 : any
+>e2 : any
+>f() : unknown
+>f : <T>() => T
+
+// Repro from #43605
+type Dispatch<A = { type: any; [extraProps: string]: any }> = { <T extends A>(action: T): T };
+>Dispatch : Dispatch<A>
+>type : any
+>extraProps : string
+>action : T
+
+type IFuncs = { readonly [key: string]: (...p: any) => void };
+>IFuncs : { readonly [key: string]: (...p: any) => void; }
+>key : string
+>p : any
+
+type IDestructuring<T extends IFuncs> = { readonly [key in keyof T]?: (...p: Parameters<T[key]>) => void };
+>IDestructuring : IDestructuring<T>
+>p : Parameters<T[key]>
+
+type Destructuring<T extends IFuncs, U extends IDestructuring<T>> = (dispatch: Dispatch<any>, funcs: T) => U;
+>Destructuring : Destructuring<T, U>
+>dispatch : Dispatch<any>
+>funcs : T
+
+const funcs1 = {
+>funcs1 : { funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }
+>{    funcA: (a: boolean): void => {},    funcB: (b: string, bb: string): void => {},    funcC: (c: number, cc: number, ccc: boolean): void => {},} : { funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }
+
+    funcA: (a: boolean): void => {},
+>funcA : (a: boolean) => void
+>(a: boolean): void => {} : (a: boolean) => void
+>a : boolean
+
+    funcB: (b: string, bb: string): void => {},
+>funcB : (b: string, bb: string) => void
+>(b: string, bb: string): void => {} : (b: string, bb: string) => void
+>b : string
+>bb : string
+
+    funcC: (c: number, cc: number, ccc: boolean): void => {},
+>funcC : (c: number, cc: number, ccc: boolean) => void
+>(c: number, cc: number, ccc: boolean): void => {} : (c: number, cc: number, ccc: boolean) => void
+>c : number
+>cc : number
+>ccc : boolean
+
+};
+type TFuncs1 = typeof funcs1;
+>TFuncs1 : { funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }
+>funcs1 : { funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }
+
+declare function useReduxDispatch1<T extends IDestructuring<TFuncs1>>(destructuring: Destructuring<TFuncs1, T>): T;
+>useReduxDispatch1 : <T extends IDestructuring<{ funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }>>(destructuring: Destructuring<TFuncs1, T>) => T
+>destructuring : Destructuring<{ funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }, T>
+
+const {} = useReduxDispatch1(
+>useReduxDispatch1(    (d, f) => ({        funcA: (...p) => d(f.funcA(...p)), // p should be inferrable        funcB: (...p) => d(f.funcB(...p)),        funcC: (...p) => d(f.funcC(...p)),    })) : { funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }
+>useReduxDispatch1 : <T extends IDestructuring<{ funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }>>(destructuring: Destructuring<{ funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }, T>) => T
+
+    (d, f) => ({
+>(d, f) => ({        funcA: (...p) => d(f.funcA(...p)), // p should be inferrable        funcB: (...p) => d(f.funcB(...p)),        funcC: (...p) => d(f.funcC(...p)),    }) : (d: Dispatch<any>, f: { funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }) => { funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }
+>d : Dispatch<any>
+>f : { funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }
+>({        funcA: (...p) => d(f.funcA(...p)), // p should be inferrable        funcB: (...p) => d(f.funcB(...p)),        funcC: (...p) => d(f.funcC(...p)),    }) : { funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }
+>{        funcA: (...p) => d(f.funcA(...p)), // p should be inferrable        funcB: (...p) => d(f.funcB(...p)),        funcC: (...p) => d(f.funcC(...p)),    } : { funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }
+
+        funcA: (...p) => d(f.funcA(...p)), // p should be inferrable
+>funcA : (a: boolean) => void
+>(...p) => d(f.funcA(...p)) : (a: boolean) => void
+>p : [a: boolean]
+>d(f.funcA(...p)) : void
+>d : Dispatch<any>
+>f.funcA(...p) : void
+>f.funcA : (a: boolean) => void
+>f : { funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }
+>funcA : (a: boolean) => void
+>...p : boolean
+>p : [a: boolean]
+
+        funcB: (...p) => d(f.funcB(...p)),
+>funcB : (b: string, bb: string) => void
+>(...p) => d(f.funcB(...p)) : (b: string, bb: string) => void
+>p : [b: string, bb: string]
+>d(f.funcB(...p)) : void
+>d : Dispatch<any>
+>f.funcB(...p) : void
+>f.funcB : (b: string, bb: string) => void
+>f : { funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }
+>funcB : (b: string, bb: string) => void
+>...p : string
+>p : [b: string, bb: string]
+
+        funcC: (...p) => d(f.funcC(...p)),
+>funcC : (c: number, cc: number, ccc: boolean) => void
+>(...p) => d(f.funcC(...p)) : (c: number, cc: number, ccc: boolean) => void
+>p : [c: number, cc: number, ccc: boolean]
+>d(f.funcC(...p)) : void
+>d : Dispatch<any>
+>f.funcC(...p) : void
+>f.funcC : (c: number, cc: number, ccc: boolean) => void
+>f : { funcA: (a: boolean) => void; funcB: (b: string, bb: string) => void; funcC: (c: number, cc: number, ccc: boolean) => void; }
+>funcC : (c: number, cc: number, ccc: boolean) => void
+>...p : number | boolean
+>p : [c: number, cc: number, ccc: boolean]
+
+    })
+);
+

tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening.js

@@ -0,0 +1,9 @@
+//// [bindingPatternContextualTypeDoesNotCauseWidening.ts]
+declare function pick<O, T extends keyof O>(keys: T[], obj?: O): Pick<O, T>;
+const _    = pick(['b'], { a: 'a', b: 'b' }); // T: "b"
+const {  } = pick(['b'], { a: 'a', b: 'b' }); // T: "b" | "a" ??? (before fix)
+
+
+//// [bindingPatternContextualTypeDoesNotCauseWidening.js]
+var _ = pick(['b'], { a: 'a', b: 'b' }); // T: "b"
+var _a = pick(['b'], { a: 'a', b: 'b' }); // T: "b" | "a" ??? (before fix)

tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening.symbols

@@ -0,0 +1,25 @@
+=== tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening.ts ===
+declare function pick<O, T extends keyof O>(keys: T[], obj?: O): Pick<O, T>;
+>pick : Symbol(pick, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 0))
+>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 22))
+>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 24))
+>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 22))
+>keys : Symbol(keys, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 44))
+>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 24))
+>obj : Symbol(obj, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 54))
+>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 22))
+>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --))
+>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 22))
+>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 24))
+
+const _    = pick(['b'], { a: 'a', b: 'b' }); // T: "b"
+>_ : Symbol(_, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 1, 5))
+>pick : Symbol(pick, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 0))
+>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 1, 26))
+>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 1, 34))
+
+const {  } = pick(['b'], { a: 'a', b: 'b' }); // T: "b" | "a" ??? (before fix)
+>pick : Symbol(pick, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 0))
+>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 2, 26))
+>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 2, 34))
+

tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening.types

@@ -0,0 +1,29 @@
+=== tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening.ts ===
+declare function pick<O, T extends keyof O>(keys: T[], obj?: O): Pick<O, T>;
+>pick : <O, T extends keyof O>(keys: T[], obj?: O) => Pick<O, T>
+>keys : T[]
+>obj : O
+
+const _    = pick(['b'], { a: 'a', b: 'b' }); // T: "b"
+>_ : Pick<{ a: string; b: string; }, "b">
+>pick(['b'], { a: 'a', b: 'b' }) : Pick<{ a: string; b: string; }, "b">
+>pick : <O, T extends keyof O>(keys: T[], obj?: O) => Pick<O, T>
+>['b'] : "b"[]
+>'b' : "b"
+>{ a: 'a', b: 'b' } : { a: string; b: string; }
+>a : string
+>'a' : "a"
+>b : string
+>'b' : "b"
+
+const {  } = pick(['b'], { a: 'a', b: 'b' }); // T: "b" | "a" ??? (before fix)
+>pick(['b'], { a: 'a', b: 'b' }) : Pick<{ a: string; b: string; }, "b">
+>pick : <O, T extends keyof O>(keys: T[], obj?: O) => Pick<O, T>
+>['b'] : "b"[]
+>'b' : "b"
+>{ a: 'a', b: 'b' } : { a: string; b: string; }
+>a : string
+>'a' : "a"
+>b : string
+>'b' : "b"
+

tests/baselines/reference/inferTupleFromBindingPattern.js

@@ -0,0 +1,7 @@
+//// [inferTupleFromBindingPattern.ts]
+declare function f<T>(cb: () => T): T;
+const [e1, e2, e3] = f(() => [1, "hi", true]);
+
+
+//// [inferTupleFromBindingPattern.js]
+var _a = f(function () { return [1, "hi", true]; }), e1 = _a[0], e2 = _a[1], e3 = _a[2];

tests/baselines/reference/inferTupleFromBindingPattern.symbols

@@ -0,0 +1,14 @@
+=== tests/cases/compiler/inferTupleFromBindingPattern.ts ===
+declare function f<T>(cb: () => T): T;
+>f : Symbol(f, Decl(inferTupleFromBindingPattern.ts, 0, 0))
+>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 0, 19))
+>cb : Symbol(cb, Decl(inferTupleFromBindingPattern.ts, 0, 22))
+>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 0, 19))
+>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 0, 19))
+
+const [e1, e2, e3] = f(() => [1, "hi", true]);
+>e1 : Symbol(e1, Decl(inferTupleFromBindingPattern.ts, 1, 7))
+>e2 : Symbol(e2, Decl(inferTupleFromBindingPattern.ts, 1, 10))
+>e3 : Symbol(e3, Decl(inferTupleFromBindingPattern.ts, 1, 14))
+>f : Symbol(f, Decl(inferTupleFromBindingPattern.ts, 0, 0))
+

tests/baselines/reference/inferTupleFromBindingPattern.types

@@ -0,0 +1,17 @@
+=== tests/cases/compiler/inferTupleFromBindingPattern.ts ===
+declare function f<T>(cb: () => T): T;
+>f : <T>(cb: () => T) => T
+>cb : () => T
+
+const [e1, e2, e3] = f(() => [1, "hi", true]);
+>e1 : number
+>e2 : string
+>e3 : boolean
+>f(() => [1, "hi", true]) : [number, string, boolean]
+>f : <T>(cb: () => T) => T
+>() => [1, "hi", true] : () => [number, string, boolean]
+>[1, "hi", true] : [number, string, true]
+>1 : 1
+>"hi" : "hi"
+>true : true
+