From e5872b48241628df2107cfcf4eae723bd8bfcb9e Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Sat, 18 Oct 2014 08:37:33 -0700 Subject: [PATCH] Addressing CR feedback --- .../contextualSignatureInstantiation.js | 31 ++++-- .../contextualSignatureInstantiation.types | 94 +++++++++++++++---- .../contextualSignatureInstantiation.ts | 18 ++-- 3 files changed, 108 insertions(+), 35 deletions(-) diff --git a/tests/baselines/reference/contextualSignatureInstantiation.js b/tests/baselines/reference/contextualSignatureInstantiation.js index fd3bd78dd0..11e19b3262 100644 --- a/tests/baselines/reference/contextualSignatureInstantiation.js +++ b/tests/baselines/reference/contextualSignatureInstantiation.js @@ -3,24 +3,30 @@ // If e is an expression of a function type that contains exactly one generic call signature and no other members, // and T is a function type with exactly one non - generic call signature and no other members, then any inferences // made for type parameters referenced by the parameters of T's call signature are fixed, and e's type is changed -// to a function type with e's call signature instantiated in the context of T�s call signature (section 3.8.5). +// to a function type with e's call signature instantiated in the context of T's call signature (section 3.8.5). declare function foo(cb: (x: number, y: string) => T): T; declare function bar(x: T, y: U, cb: (x: T, y: U) => V): V; +declare function baz(x: T, y: T, cb: (x: T, y: T) => U): U; -declare function f(x: number, y: string): boolean; declare function g(x: T, y: T): T; +declare function h(x: T, y: U): T[] | U[]; -var a: boolean; -var a = foo(f); // Should be boolean +var a: number; +var a = bar(1, 1, g); // Should be number +var a = baz(1, 1, g); // Should be number var b: number | string; var b = foo(g); // Should be number | string var b = bar(1, "one", g); // Should be number | string var b = bar("one", 1, g); // Should be number | string +var b = baz(b, b, g); // Should be number | string -var c: number; -var c = bar(1, 1, g); // Should be number +var d: number[] | string[]; +var d = foo(h); // Should be number[] | string[] +var d = bar(1, "one", h); // Should be number[] | string[] +var d = bar("one", 1, h); // Should be number[] | string[] +var d = baz(d, d, g); // Should be number[] | string[] //// [contextualSignatureInstantiation.js] @@ -28,12 +34,17 @@ var c = bar(1, 1, g); // Should be number // If e is an expression of a function type that contains exactly one generic call signature and no other members, // and T is a function type with exactly one non - generic call signature and no other members, then any inferences // made for type parameters referenced by the parameters of T's call signature are fixed, and e's type is changed -// to a function type with e's call signature instantiated in the context of T�s call signature (section 3.8.5). +// to a function type with e's call signature instantiated in the context of T's call signature (section 3.8.5). var a; -var a = foo(f); // Should be boolean +var a = bar(1, 1, g); // Should be number +var a = baz(1, 1, g); // Should be number var b; var b = foo(g); // Should be number | string var b = bar(1, "one", g); // Should be number | string var b = bar("one", 1, g); // Should be number | string -var c; -var c = bar(1, 1, g); // Should be number +var b = baz(b, b, g); // Should be number | string +var d; +var d = foo(h); // Should be number[] | string[] +var d = bar(1, "one", h); // Should be number[] | string[] +var d = bar("one", 1, h); // Should be number[] | string[] +var d = baz(d, d, g); // Should be number[] | string[] diff --git a/tests/baselines/reference/contextualSignatureInstantiation.types b/tests/baselines/reference/contextualSignatureInstantiation.types index 225761024b..4363272622 100644 --- a/tests/baselines/reference/contextualSignatureInstantiation.types +++ b/tests/baselines/reference/contextualSignatureInstantiation.types @@ -3,7 +3,7 @@ // If e is an expression of a function type that contains exactly one generic call signature and no other members, // and T is a function type with exactly one non - generic call signature and no other members, then any inferences // made for type parameters referenced by the parameters of T's call signature are fixed, and e's type is changed -// to a function type with e's call signature instantiated in the context of T�s call signature (section 3.8.5). +// to a function type with e's call signature instantiated in the context of T's call signature (section 3.8.5). declare function foo(cb: (x: number, y: string) => T): T; >foo : (cb: (x: number, y: string) => T) => T @@ -31,10 +31,21 @@ declare function bar(x: T, y: U, cb: (x: T, y: U) => V): V; >V : V >V : V -declare function f(x: number, y: string): boolean; ->f : (x: number, y: string) => boolean ->x : number ->y : string +declare function baz(x: T, y: T, cb: (x: T, y: T) => U): U; +>baz : (x: T, y: T, cb: (x: T, y: T) => U) => U +>T : T +>U : U +>x : T +>T : T +>y : T +>T : T +>cb : (x: T, y: T) => U +>x : T +>T : T +>y : T +>T : T +>U : U +>U : U declare function g(x: T, y: T): T; >g : (x: T, y: T) => T @@ -45,14 +56,31 @@ declare function g(x: T, y: T): T; >T : T >T : T -var a: boolean; ->a : boolean +declare function h(x: T, y: U): T[] | U[]; +>h : (x: T, y: U) => T[] | U[] +>T : T +>U : U +>x : T +>T : T +>y : U +>U : U +>T : T +>U : U -var a = foo(f); // Should be boolean ->a : boolean ->foo(f) : boolean ->foo : (cb: (x: number, y: string) => T) => T ->f : (x: number, y: string) => boolean +var a: number; +>a : number + +var a = bar(1, 1, g); // Should be number +>a : number +>bar(1, 1, g) : number +>bar : (x: T, y: U, cb: (x: T, y: U) => V) => V +>g : (x: T, y: T) => T + +var a = baz(1, 1, g); // Should be number +>a : number +>baz(1, 1, g) : number +>baz : (x: T, y: T, cb: (x: T, y: T) => U) => U +>g : (x: T, y: T) => T var b: number | string; >b : string | number @@ -75,12 +103,40 @@ var b = bar("one", 1, g); // Should be number | string >bar : (x: T, y: U, cb: (x: T, y: U) => V) => V >g : (x: T, y: T) => T -var c: number; ->c : number - -var c = bar(1, 1, g); // Should be number ->c : number ->bar(1, 1, g) : number ->bar : (x: T, y: U, cb: (x: T, y: U) => V) => V +var b = baz(b, b, g); // Should be number | string +>b : string | number +>baz(b, b, g) : string | number +>baz : (x: T, y: T, cb: (x: T, y: T) => U) => U +>b : string | number +>b : string | number +>g : (x: T, y: T) => T + +var d: number[] | string[]; +>d : string[] | number[] + +var d = foo(h); // Should be number[] | string[] +>d : string[] | number[] +>foo(h) : string[] | number[] +>foo : (cb: (x: number, y: string) => T) => T +>h : (x: T, y: U) => T[] | U[] + +var d = bar(1, "one", h); // Should be number[] | string[] +>d : string[] | number[] +>bar(1, "one", h) : string[] | number[] +>bar : (x: T, y: U, cb: (x: T, y: U) => V) => V +>h : (x: T, y: U) => T[] | U[] + +var d = bar("one", 1, h); // Should be number[] | string[] +>d : string[] | number[] +>bar("one", 1, h) : string[] | number[] +>bar : (x: T, y: U, cb: (x: T, y: U) => V) => V +>h : (x: T, y: U) => T[] | U[] + +var d = baz(d, d, g); // Should be number[] | string[] +>d : string[] | number[] +>baz(d, d, g) : string[] | number[] +>baz : (x: T, y: T, cb: (x: T, y: T) => U) => U +>d : string[] | number[] +>d : string[] | number[] >g : (x: T, y: T) => T diff --git a/tests/cases/conformance/types/typeRelationships/typeInference/contextualSignatureInstantiation.ts b/tests/cases/conformance/types/typeRelationships/typeInference/contextualSignatureInstantiation.ts index b5408da606..393d0e10d3 100644 --- a/tests/cases/conformance/types/typeRelationships/typeInference/contextualSignatureInstantiation.ts +++ b/tests/cases/conformance/types/typeRelationships/typeInference/contextualSignatureInstantiation.ts @@ -2,21 +2,27 @@ // If e is an expression of a function type that contains exactly one generic call signature and no other members, // and T is a function type with exactly one non - generic call signature and no other members, then any inferences // made for type parameters referenced by the parameters of T's call signature are fixed, and e's type is changed -// to a function type with e's call signature instantiated in the context of T’s call signature (section 3.8.5). +// to a function type with e's call signature instantiated in the context of T's call signature (section 3.8.5). declare function foo(cb: (x: number, y: string) => T): T; declare function bar(x: T, y: U, cb: (x: T, y: U) => V): V; +declare function baz(x: T, y: T, cb: (x: T, y: T) => U): U; -declare function f(x: number, y: string): boolean; declare function g(x: T, y: T): T; +declare function h(x: T, y: U): T[] | U[]; -var a: boolean; -var a = foo(f); // Should be boolean +var a: number; +var a = bar(1, 1, g); // Should be number +var a = baz(1, 1, g); // Should be number var b: number | string; var b = foo(g); // Should be number | string var b = bar(1, "one", g); // Should be number | string var b = bar("one", 1, g); // Should be number | string +var b = baz(b, b, g); // Should be number | string -var c: number; -var c = bar(1, 1, g); // Should be number +var d: number[] | string[]; +var d = foo(h); // Should be number[] | string[] +var d = bar(1, "one", h); // Should be number[] | string[] +var d = bar("one", 1, h); // Should be number[] | string[] +var d = baz(d, d, g); // Should be number[] | string[]