mirror of
https://github.com/microsoft/TypeScript.git
synced 2025-12-12 20:25:48 -06:00
Merge pull request #2761 from Microsoft/conformanceContextuallyTypedFuncExp
Conformance test for update spec section 4.9.3 contextual typing in function expression
This commit is contained in:
Yui
commit
3da13152f0
120
tests/baselines/reference/functionExpressionContextualTyping1.js
Normal file
120
tests/baselines/reference/functionExpressionContextualTyping1.js
Normal file
@ -0,0 +1,120 @@
|
||||
//// [functionExpressionContextualTyping1.ts]
|
||||
// When a function expression with no type parameters and no parameter type annotations
|
||||
// is contextually typed (section 4.19) by a type T and a contextual signature S can be extracted from T
|
||||
|
||||
enum E { red, blue }
|
||||
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a function type with exactly one call signature, and if that call signature is non- generic, S is that signature.
|
||||
|
||||
var a0: (n: number, s: string) => number = (num, str) => {
|
||||
num.toExponential();
|
||||
return 0;
|
||||
}
|
||||
|
||||
class Class<T> {
|
||||
foo() { }
|
||||
}
|
||||
|
||||
var a1: (c: Class<Number>) => number = (a1) => {
|
||||
a1.foo();
|
||||
return 1;
|
||||
}
|
||||
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a union type, let U be the set of element types in T that have call signatures.
|
||||
// If each type in U has exactly one call signature and that call signature is non- generic,
|
||||
// and if all of the signatures are identical ignoring return types,
|
||||
// then S is a signature with the same parameters and a union of the return types.
|
||||
var b1: ((s: string, w: boolean) => void) | ((s: string, w: boolean) => string);
|
||||
b1 = (k, h) => { };
|
||||
var b2: typeof a0 | ((n: number, s: string) => string);
|
||||
b2 = (foo, bar) => { return foo + 1; }
|
||||
b2 = (foo, bar) => { return "hello"; }
|
||||
var b3: (name: string, num: number, boo: boolean) => void;
|
||||
b3 = (name, number) => { };
|
||||
|
||||
var b4: (n: E) => string = (number = 1) => { return "hello"; };
|
||||
var b5: (n: {}) => string = (number = "string") => { return "hello"; };
|
||||
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// Otherwise, no contextual signature can be extracted from T and S is undefined.
|
||||
var b6: ((s: string, w: boolean) => void) | ((n: number) => number);
|
||||
var b7: ((s: string, w: boolean) => void) | ((s: string, w: number) => string);
|
||||
b6 = (k) => { k.toLowerCase() };
|
||||
b6 = (i) => {
|
||||
i.toExponential();
|
||||
return i;
|
||||
}; // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
|
||||
b7 = (j, m) => { }; // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
|
||||
|
||||
class C<T, U> {
|
||||
constructor() {
|
||||
var k: ((j: T, k: U) => (T|U)[]) | ((j: number,k :U) => number[]) = (j, k) => {
|
||||
return [j, k];
|
||||
} // Per spec, no contextual signature can be extracted in this case.
|
||||
}
|
||||
}
|
||||
|
||||
//// [functionExpressionContextualTyping1.js]
|
||||
// When a function expression with no type parameters and no parameter type annotations
|
||||
// is contextually typed (section 4.19) by a type T and a contextual signature S can be extracted from T
|
||||
var E;
|
||||
(function (E) {
|
||||
E[E["red"] = 0] = "red";
|
||||
E[E["blue"] = 1] = "blue";
|
||||
})(E || (E = {}));
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a function type with exactly one call signature, and if that call signature is non- generic, S is that signature.
|
||||
var a0 = function (num, str) {
|
||||
num.toExponential();
|
||||
return 0;
|
||||
};
|
||||
var Class = (function () {
|
||||
function Class() {
|
||||
}
|
||||
Class.prototype.foo = function () { };
|
||||
return Class;
|
||||
})();
|
||||
var a1 = function (a1) {
|
||||
a1.foo();
|
||||
return 1;
|
||||
};
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a union type, let U be the set of element types in T that have call signatures.
|
||||
// If each type in U has exactly one call signature and that call signature is non- generic,
|
||||
// and if all of the signatures are identical ignoring return types,
|
||||
// then S is a signature with the same parameters and a union of the return types.
|
||||
var b1;
|
||||
b1 = function (k, h) { };
|
||||
var b2;
|
||||
b2 = function (foo, bar) { return foo + 1; };
|
||||
b2 = function (foo, bar) { return "hello"; };
|
||||
var b3;
|
||||
b3 = function (name, number) { };
|
||||
var b4 = function (number) {
|
||||
if (number === void 0) { number = 1; }
|
||||
return "hello";
|
||||
};
|
||||
var b5 = function (number) {
|
||||
if (number === void 0) { number = "string"; }
|
||||
return "hello";
|
||||
};
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// Otherwise, no contextual signature can be extracted from T and S is undefined.
|
||||
var b6;
|
||||
var b7;
|
||||
b6 = function (k) { k.toLowerCase(); };
|
||||
b6 = function (i) {
|
||||
i.toExponential();
|
||||
return i;
|
||||
}; // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
|
||||
b7 = function (j, m) { }; // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
|
||||
var C = (function () {
|
||||
function C() {
|
||||
var k = function (j, k) {
|
||||
return [j, k];
|
||||
}; // Per spec, no contextual signature can be extracted in this case.
|
||||
}
|
||||
return C;
|
||||
})();
|
||||
@ -0,0 +1,169 @@
|
||||
=== tests/cases/conformance/expressions/contextualTyping/functionExpressionContextualTyping1.ts ===
|
||||
// When a function expression with no type parameters and no parameter type annotations
|
||||
// is contextually typed (section 4.19) by a type T and a contextual signature S can be extracted from T
|
||||
|
||||
enum E { red, blue }
|
||||
>E : Symbol(E, Decl(functionExpressionContextualTyping1.ts, 0, 0))
|
||||
>red : Symbol(E.red, Decl(functionExpressionContextualTyping1.ts, 3, 8))
|
||||
>blue : Symbol(E.blue, Decl(functionExpressionContextualTyping1.ts, 3, 13))
|
||||
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a function type with exactly one call signature, and if that call signature is non- generic, S is that signature.
|
||||
|
||||
var a0: (n: number, s: string) => number = (num, str) => {
|
||||
>a0 : Symbol(a0, Decl(functionExpressionContextualTyping1.ts, 8, 3))
|
||||
>n : Symbol(n, Decl(functionExpressionContextualTyping1.ts, 8, 9))
|
||||
>s : Symbol(s, Decl(functionExpressionContextualTyping1.ts, 8, 19))
|
||||
>num : Symbol(num, Decl(functionExpressionContextualTyping1.ts, 8, 44))
|
||||
>str : Symbol(str, Decl(functionExpressionContextualTyping1.ts, 8, 48))
|
||||
|
||||
num.toExponential();
|
||||
>num.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
|
||||
>num : Symbol(num, Decl(functionExpressionContextualTyping1.ts, 8, 44))
|
||||
>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
class Class<T> {
|
||||
>Class : Symbol(Class, Decl(functionExpressionContextualTyping1.ts, 11, 1))
|
||||
>T : Symbol(T, Decl(functionExpressionContextualTyping1.ts, 13, 12))
|
||||
|
||||
foo() { }
|
||||
>foo : Symbol(foo, Decl(functionExpressionContextualTyping1.ts, 13, 16))
|
||||
}
|
||||
|
||||
var a1: (c: Class<Number>) => number = (a1) => {
|
||||
>a1 : Symbol(a1, Decl(functionExpressionContextualTyping1.ts, 17, 3))
|
||||
>c : Symbol(c, Decl(functionExpressionContextualTyping1.ts, 17, 9))
|
||||
>Class : Symbol(Class, Decl(functionExpressionContextualTyping1.ts, 11, 1))
|
||||
>Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
|
||||
>a1 : Symbol(a1, Decl(functionExpressionContextualTyping1.ts, 17, 40))
|
||||
|
||||
a1.foo();
|
||||
>a1.foo : Symbol(Class.foo, Decl(functionExpressionContextualTyping1.ts, 13, 16))
|
||||
>a1 : Symbol(a1, Decl(functionExpressionContextualTyping1.ts, 17, 40))
|
||||
>foo : Symbol(Class.foo, Decl(functionExpressionContextualTyping1.ts, 13, 16))
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a union type, let U be the set of element types in T that have call signatures.
|
||||
// If each type in U has exactly one call signature and that call signature is non- generic,
|
||||
// and if all of the signatures are identical ignoring return types,
|
||||
// then S is a signature with the same parameters and a union of the return types.
|
||||
var b1: ((s: string, w: boolean) => void) | ((s: string, w: boolean) => string);
|
||||
>b1 : Symbol(b1, Decl(functionExpressionContextualTyping1.ts, 27, 3))
|
||||
>s : Symbol(s, Decl(functionExpressionContextualTyping1.ts, 27, 10))
|
||||
>w : Symbol(w, Decl(functionExpressionContextualTyping1.ts, 27, 20))
|
||||
>s : Symbol(s, Decl(functionExpressionContextualTyping1.ts, 27, 46))
|
||||
>w : Symbol(w, Decl(functionExpressionContextualTyping1.ts, 27, 56))
|
||||
|
||||
b1 = (k, h) => { };
|
||||
>b1 : Symbol(b1, Decl(functionExpressionContextualTyping1.ts, 27, 3))
|
||||
>k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 28, 6))
|
||||
>h : Symbol(h, Decl(functionExpressionContextualTyping1.ts, 28, 8))
|
||||
|
||||
var b2: typeof a0 | ((n: number, s: string) => string);
|
||||
>b2 : Symbol(b2, Decl(functionExpressionContextualTyping1.ts, 29, 3))
|
||||
>a0 : Symbol(a0, Decl(functionExpressionContextualTyping1.ts, 8, 3))
|
||||
>n : Symbol(n, Decl(functionExpressionContextualTyping1.ts, 29, 22))
|
||||
>s : Symbol(s, Decl(functionExpressionContextualTyping1.ts, 29, 32))
|
||||
|
||||
b2 = (foo, bar) => { return foo + 1; }
|
||||
>b2 : Symbol(b2, Decl(functionExpressionContextualTyping1.ts, 29, 3))
|
||||
>foo : Symbol(foo, Decl(functionExpressionContextualTyping1.ts, 30, 6))
|
||||
>bar : Symbol(bar, Decl(functionExpressionContextualTyping1.ts, 30, 10))
|
||||
>foo : Symbol(foo, Decl(functionExpressionContextualTyping1.ts, 30, 6))
|
||||
|
||||
b2 = (foo, bar) => { return "hello"; }
|
||||
>b2 : Symbol(b2, Decl(functionExpressionContextualTyping1.ts, 29, 3))
|
||||
>foo : Symbol(foo, Decl(functionExpressionContextualTyping1.ts, 31, 6))
|
||||
>bar : Symbol(bar, Decl(functionExpressionContextualTyping1.ts, 31, 10))
|
||||
|
||||
var b3: (name: string, num: number, boo: boolean) => void;
|
||||
>b3 : Symbol(b3, Decl(functionExpressionContextualTyping1.ts, 32, 3))
|
||||
>name : Symbol(name, Decl(functionExpressionContextualTyping1.ts, 32, 9))
|
||||
>num : Symbol(num, Decl(functionExpressionContextualTyping1.ts, 32, 22))
|
||||
>boo : Symbol(boo, Decl(functionExpressionContextualTyping1.ts, 32, 35))
|
||||
|
||||
b3 = (name, number) => { };
|
||||
>b3 : Symbol(b3, Decl(functionExpressionContextualTyping1.ts, 32, 3))
|
||||
>name : Symbol(name, Decl(functionExpressionContextualTyping1.ts, 33, 6))
|
||||
>number : Symbol(number, Decl(functionExpressionContextualTyping1.ts, 33, 11))
|
||||
|
||||
var b4: (n: E) => string = (number = 1) => { return "hello"; };
|
||||
>b4 : Symbol(b4, Decl(functionExpressionContextualTyping1.ts, 35, 3))
|
||||
>n : Symbol(n, Decl(functionExpressionContextualTyping1.ts, 35, 9))
|
||||
>E : Symbol(E, Decl(functionExpressionContextualTyping1.ts, 0, 0))
|
||||
>number : Symbol(number, Decl(functionExpressionContextualTyping1.ts, 35, 28))
|
||||
|
||||
var b5: (n: {}) => string = (number = "string") => { return "hello"; };
|
||||
>b5 : Symbol(b5, Decl(functionExpressionContextualTyping1.ts, 36, 3))
|
||||
>n : Symbol(n, Decl(functionExpressionContextualTyping1.ts, 36, 9))
|
||||
>number : Symbol(number, Decl(functionExpressionContextualTyping1.ts, 36, 29))
|
||||
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// Otherwise, no contextual signature can be extracted from T and S is undefined.
|
||||
var b6: ((s: string, w: boolean) => void) | ((n: number) => number);
|
||||
>b6 : Symbol(b6, Decl(functionExpressionContextualTyping1.ts, 40, 3))
|
||||
>s : Symbol(s, Decl(functionExpressionContextualTyping1.ts, 40, 10))
|
||||
>w : Symbol(w, Decl(functionExpressionContextualTyping1.ts, 40, 20))
|
||||
>n : Symbol(n, Decl(functionExpressionContextualTyping1.ts, 40, 46))
|
||||
|
||||
var b7: ((s: string, w: boolean) => void) | ((s: string, w: number) => string);
|
||||
>b7 : Symbol(b7, Decl(functionExpressionContextualTyping1.ts, 41, 3))
|
||||
>s : Symbol(s, Decl(functionExpressionContextualTyping1.ts, 41, 10))
|
||||
>w : Symbol(w, Decl(functionExpressionContextualTyping1.ts, 41, 20))
|
||||
>s : Symbol(s, Decl(functionExpressionContextualTyping1.ts, 41, 46))
|
||||
>w : Symbol(w, Decl(functionExpressionContextualTyping1.ts, 41, 56))
|
||||
|
||||
b6 = (k) => { k.toLowerCase() };
|
||||
>b6 : Symbol(b6, Decl(functionExpressionContextualTyping1.ts, 40, 3))
|
||||
>k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 42, 6))
|
||||
>k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 42, 6))
|
||||
|
||||
b6 = (i) => {
|
||||
>b6 : Symbol(b6, Decl(functionExpressionContextualTyping1.ts, 40, 3))
|
||||
>i : Symbol(i, Decl(functionExpressionContextualTyping1.ts, 43, 6))
|
||||
|
||||
i.toExponential();
|
||||
>i : Symbol(i, Decl(functionExpressionContextualTyping1.ts, 43, 6))
|
||||
|
||||
return i;
|
||||
>i : Symbol(i, Decl(functionExpressionContextualTyping1.ts, 43, 6))
|
||||
|
||||
}; // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
|
||||
b7 = (j, m) => { }; // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
|
||||
>b7 : Symbol(b7, Decl(functionExpressionContextualTyping1.ts, 41, 3))
|
||||
>j : Symbol(j, Decl(functionExpressionContextualTyping1.ts, 47, 6))
|
||||
>m : Symbol(m, Decl(functionExpressionContextualTyping1.ts, 47, 8))
|
||||
|
||||
class C<T, U> {
|
||||
>C : Symbol(C, Decl(functionExpressionContextualTyping1.ts, 47, 19))
|
||||
>T : Symbol(T, Decl(functionExpressionContextualTyping1.ts, 49, 8))
|
||||
>U : Symbol(U, Decl(functionExpressionContextualTyping1.ts, 49, 10))
|
||||
|
||||
constructor() {
|
||||
var k: ((j: T, k: U) => (T|U)[]) | ((j: number,k :U) => number[]) = (j, k) => {
|
||||
>k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 51, 11))
|
||||
>j : Symbol(j, Decl(functionExpressionContextualTyping1.ts, 51, 17))
|
||||
>T : Symbol(T, Decl(functionExpressionContextualTyping1.ts, 49, 8))
|
||||
>k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 51, 22))
|
||||
>U : Symbol(U, Decl(functionExpressionContextualTyping1.ts, 49, 10))
|
||||
>T : Symbol(T, Decl(functionExpressionContextualTyping1.ts, 49, 8))
|
||||
>U : Symbol(U, Decl(functionExpressionContextualTyping1.ts, 49, 10))
|
||||
>j : Symbol(j, Decl(functionExpressionContextualTyping1.ts, 51, 45))
|
||||
>k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 51, 55))
|
||||
>U : Symbol(U, Decl(functionExpressionContextualTyping1.ts, 49, 10))
|
||||
>j : Symbol(j, Decl(functionExpressionContextualTyping1.ts, 51, 77))
|
||||
>k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 51, 79))
|
||||
|
||||
return [j, k];
|
||||
>j : Symbol(j, Decl(functionExpressionContextualTyping1.ts, 51, 77))
|
||||
>k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 51, 79))
|
||||
|
||||
} // Per spec, no contextual signature can be extracted in this case.
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,206 @@
|
||||
=== tests/cases/conformance/expressions/contextualTyping/functionExpressionContextualTyping1.ts ===
|
||||
// When a function expression with no type parameters and no parameter type annotations
|
||||
// is contextually typed (section 4.19) by a type T and a contextual signature S can be extracted from T
|
||||
|
||||
enum E { red, blue }
|
||||
>E : E
|
||||
>red : E
|
||||
>blue : E
|
||||
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a function type with exactly one call signature, and if that call signature is non- generic, S is that signature.
|
||||
|
||||
var a0: (n: number, s: string) => number = (num, str) => {
|
||||
>a0 : (n: number, s: string) => number
|
||||
>n : number
|
||||
>s : string
|
||||
>(num, str) => { num.toExponential(); return 0;} : (num: number, str: string) => number
|
||||
>num : number
|
||||
>str : string
|
||||
|
||||
num.toExponential();
|
||||
>num.toExponential() : string
|
||||
>num.toExponential : (fractionDigits?: number) => string
|
||||
>num : number
|
||||
>toExponential : (fractionDigits?: number) => string
|
||||
|
||||
return 0;
|
||||
>0 : number
|
||||
}
|
||||
|
||||
class Class<T> {
|
||||
>Class : Class<T>
|
||||
>T : T
|
||||
|
||||
foo() { }
|
||||
>foo : () => void
|
||||
}
|
||||
|
||||
var a1: (c: Class<Number>) => number = (a1) => {
|
||||
>a1 : (c: Class<Number>) => number
|
||||
>c : Class<Number>
|
||||
>Class : Class<T>
|
||||
>Number : Number
|
||||
>(a1) => { a1.foo(); return 1;} : (a1: Class<Number>) => number
|
||||
>a1 : Class<Number>
|
||||
|
||||
a1.foo();
|
||||
>a1.foo() : void
|
||||
>a1.foo : () => void
|
||||
>a1 : Class<Number>
|
||||
>foo : () => void
|
||||
|
||||
return 1;
|
||||
>1 : number
|
||||
}
|
||||
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a union type, let U be the set of element types in T that have call signatures.
|
||||
// If each type in U has exactly one call signature and that call signature is non- generic,
|
||||
// and if all of the signatures are identical ignoring return types,
|
||||
// then S is a signature with the same parameters and a union of the return types.
|
||||
var b1: ((s: string, w: boolean) => void) | ((s: string, w: boolean) => string);
|
||||
>b1 : ((s: string, w: boolean) => void) | ((s: string, w: boolean) => string)
|
||||
>s : string
|
||||
>w : boolean
|
||||
>s : string
|
||||
>w : boolean
|
||||
|
||||
b1 = (k, h) => { };
|
||||
>b1 = (k, h) => { } : (k: string, h: boolean) => void
|
||||
>b1 : ((s: string, w: boolean) => void) | ((s: string, w: boolean) => string)
|
||||
>(k, h) => { } : (k: string, h: boolean) => void
|
||||
>k : string
|
||||
>h : boolean
|
||||
|
||||
var b2: typeof a0 | ((n: number, s: string) => string);
|
||||
>b2 : ((n: number, s: string) => number) | ((n: number, s: string) => string)
|
||||
>a0 : (n: number, s: string) => number
|
||||
>n : number
|
||||
>s : string
|
||||
|
||||
b2 = (foo, bar) => { return foo + 1; }
|
||||
>b2 = (foo, bar) => { return foo + 1; } : (foo: number, bar: string) => number
|
||||
>b2 : ((n: number, s: string) => number) | ((n: number, s: string) => string)
|
||||
>(foo, bar) => { return foo + 1; } : (foo: number, bar: string) => number
|
||||
>foo : number
|
||||
>bar : string
|
||||
>foo + 1 : number
|
||||
>foo : number
|
||||
>1 : number
|
||||
|
||||
b2 = (foo, bar) => { return "hello"; }
|
||||
>b2 = (foo, bar) => { return "hello"; } : (foo: number, bar: string) => string
|
||||
>b2 : ((n: number, s: string) => number) | ((n: number, s: string) => string)
|
||||
>(foo, bar) => { return "hello"; } : (foo: number, bar: string) => string
|
||||
>foo : number
|
||||
>bar : string
|
||||
>"hello" : string
|
||||
|
||||
var b3: (name: string, num: number, boo: boolean) => void;
|
||||
>b3 : (name: string, num: number, boo: boolean) => void
|
||||
>name : string
|
||||
>num : number
|
||||
>boo : boolean
|
||||
|
||||
b3 = (name, number) => { };
|
||||
>b3 = (name, number) => { } : (name: string, number: number) => void
|
||||
>b3 : (name: string, num: number, boo: boolean) => void
|
||||
>(name, number) => { } : (name: string, number: number) => void
|
||||
>name : string
|
||||
>number : number
|
||||
|
||||
var b4: (n: E) => string = (number = 1) => { return "hello"; };
|
||||
>b4 : (n: E) => string
|
||||
>n : E
|
||||
>E : E
|
||||
>(number = 1) => { return "hello"; } : (number?: E) => string
|
||||
>number : E
|
||||
>1 : number
|
||||
>"hello" : string
|
||||
|
||||
var b5: (n: {}) => string = (number = "string") => { return "hello"; };
|
||||
>b5 : (n: {}) => string
|
||||
>n : {}
|
||||
>(number = "string") => { return "hello"; } : (number?: {}) => string
|
||||
>number : {}
|
||||
>"string" : string
|
||||
>"hello" : string
|
||||
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// Otherwise, no contextual signature can be extracted from T and S is undefined.
|
||||
var b6: ((s: string, w: boolean) => void) | ((n: number) => number);
|
||||
>b6 : ((s: string, w: boolean) => void) | ((n: number) => number)
|
||||
>s : string
|
||||
>w : boolean
|
||||
>n : number
|
||||
|
||||
var b7: ((s: string, w: boolean) => void) | ((s: string, w: number) => string);
|
||||
>b7 : ((s: string, w: boolean) => void) | ((s: string, w: number) => string)
|
||||
>s : string
|
||||
>w : boolean
|
||||
>s : string
|
||||
>w : number
|
||||
|
||||
b6 = (k) => { k.toLowerCase() };
|
||||
>b6 = (k) => { k.toLowerCase() } : (k: any) => void
|
||||
>b6 : ((s: string, w: boolean) => void) | ((n: number) => number)
|
||||
>(k) => { k.toLowerCase() } : (k: any) => void
|
||||
>k : any
|
||||
>k.toLowerCase() : any
|
||||
>k.toLowerCase : any
|
||||
>k : any
|
||||
>toLowerCase : any
|
||||
|
||||
b6 = (i) => {
|
||||
>b6 = (i) => { i.toExponential(); return i;} : (i: any) => any
|
||||
>b6 : ((s: string, w: boolean) => void) | ((n: number) => number)
|
||||
>(i) => { i.toExponential(); return i;} : (i: any) => any
|
||||
>i : any
|
||||
|
||||
i.toExponential();
|
||||
>i.toExponential() : any
|
||||
>i.toExponential : any
|
||||
>i : any
|
||||
>toExponential : any
|
||||
|
||||
return i;
|
||||
>i : any
|
||||
|
||||
}; // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
|
||||
b7 = (j, m) => { }; // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
|
||||
>b7 = (j, m) => { } : (j: any, m: any) => void
|
||||
>b7 : ((s: string, w: boolean) => void) | ((s: string, w: number) => string)
|
||||
>(j, m) => { } : (j: any, m: any) => void
|
||||
>j : any
|
||||
>m : any
|
||||
|
||||
class C<T, U> {
|
||||
>C : C<T, U>
|
||||
>T : T
|
||||
>U : U
|
||||
|
||||
constructor() {
|
||||
var k: ((j: T, k: U) => (T|U)[]) | ((j: number,k :U) => number[]) = (j, k) => {
|
||||
>k : ((j: T, k: U) => (T | U)[]) | ((j: number, k: U) => number[])
|
||||
>j : T
|
||||
>T : T
|
||||
>k : U
|
||||
>U : U
|
||||
>T : T
|
||||
>U : U
|
||||
>j : number
|
||||
>k : U
|
||||
>U : U
|
||||
>(j, k) => { return [j, k]; } : (j: any, k: any) => any[]
|
||||
>j : any
|
||||
>k : any
|
||||
|
||||
return [j, k];
|
||||
>[j, k] : any[]
|
||||
>j : any
|
||||
>k : any
|
||||
|
||||
} // Per spec, no contextual signature can be extracted in this case.
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,21 @@
|
||||
tests/cases/conformance/expressions/contextualTyping/functionExpressionContextualTyping2.ts(11,1): error TS2322: Type '(foo: number, bar: string) => boolean' is not assignable to type '((n: number, s: string) => number) | ((n: number, s: string) => string)'.
|
||||
Type '(foo: number, bar: string) => boolean' is not assignable to type '(n: number, s: string) => string'.
|
||||
Type 'boolean' is not assignable to type 'string'.
|
||||
|
||||
|
||||
==== tests/cases/conformance/expressions/contextualTyping/functionExpressionContextualTyping2.ts (1 errors) ====
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a function type with exactly one call signature, and if that call signature is non- generic, S is that signature.
|
||||
// If T is a union type, let U be the set of element types in T that have call signatures.
|
||||
// If each type in U has exactly one call signature and that call signature is non- generic,
|
||||
// and if all of the signatures are identical ignoring return types, then S is a signature
|
||||
// with the same parameters and a union of the return types.
|
||||
// Otherwise, no contextual signature can be extracted from T and S is undefined.
|
||||
|
||||
var a0: (n: number, s: string) => number
|
||||
var a1: typeof a0 | ((n: number, s: string) => string);
|
||||
a1 = (foo, bar) => { return true; } // Error
|
||||
~~
|
||||
!!! error TS2322: Type '(foo: number, bar: string) => boolean' is not assignable to type '((n: number, s: string) => number) | ((n: number, s: string) => string)'.
|
||||
!!! error TS2322: Type '(foo: number, bar: string) => boolean' is not assignable to type '(n: number, s: string) => string'.
|
||||
!!! error TS2322: Type 'boolean' is not assignable to type 'string'.
|
||||
@ -0,0 +1,24 @@
|
||||
//// [functionExpressionContextualTyping2.ts]
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a function type with exactly one call signature, and if that call signature is non- generic, S is that signature.
|
||||
// If T is a union type, let U be the set of element types in T that have call signatures.
|
||||
// If each type in U has exactly one call signature and that call signature is non- generic,
|
||||
// and if all of the signatures are identical ignoring return types, then S is a signature
|
||||
// with the same parameters and a union of the return types.
|
||||
// Otherwise, no contextual signature can be extracted from T and S is undefined.
|
||||
|
||||
var a0: (n: number, s: string) => number
|
||||
var a1: typeof a0 | ((n: number, s: string) => string);
|
||||
a1 = (foo, bar) => { return true; } // Error
|
||||
|
||||
//// [functionExpressionContextualTyping2.js]
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a function type with exactly one call signature, and if that call signature is non- generic, S is that signature.
|
||||
// If T is a union type, let U be the set of element types in T that have call signatures.
|
||||
// If each type in U has exactly one call signature and that call signature is non- generic,
|
||||
// and if all of the signatures are identical ignoring return types, then S is a signature
|
||||
// with the same parameters and a union of the return types.
|
||||
// Otherwise, no contextual signature can be extracted from T and S is undefined.
|
||||
var a0;
|
||||
var a1;
|
||||
a1 = function (foo, bar) { return true; }; // Error
|
||||
@ -0,0 +1,56 @@
|
||||
// When a function expression with no type parameters and no parameter type annotations
|
||||
// is contextually typed (section 4.19) by a type T and a contextual signature S can be extracted from T
|
||||
|
||||
enum E { red, blue }
|
||||
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a function type with exactly one call signature, and if that call signature is non- generic, S is that signature.
|
||||
|
||||
var a0: (n: number, s: string) => number = (num, str) => {
|
||||
num.toExponential();
|
||||
return 0;
|
||||
}
|
||||
|
||||
class Class<T> {
|
||||
foo() { }
|
||||
}
|
||||
|
||||
var a1: (c: Class<Number>) => number = (a1) => {
|
||||
a1.foo();
|
||||
return 1;
|
||||
}
|
||||
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a union type, let U be the set of element types in T that have call signatures.
|
||||
// If each type in U has exactly one call signature and that call signature is non- generic,
|
||||
// and if all of the signatures are identical ignoring return types,
|
||||
// then S is a signature with the same parameters and a union of the return types.
|
||||
var b1: ((s: string, w: boolean) => void) | ((s: string, w: boolean) => string);
|
||||
b1 = (k, h) => { };
|
||||
var b2: typeof a0 | ((n: number, s: string) => string);
|
||||
b2 = (foo, bar) => { return foo + 1; }
|
||||
b2 = (foo, bar) => { return "hello"; }
|
||||
var b3: (name: string, num: number, boo: boolean) => void;
|
||||
b3 = (name, number) => { };
|
||||
|
||||
var b4: (n: E) => string = (number = 1) => { return "hello"; };
|
||||
var b5: (n: {}) => string = (number = "string") => { return "hello"; };
|
||||
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// Otherwise, no contextual signature can be extracted from T and S is undefined.
|
||||
var b6: ((s: string, w: boolean) => void) | ((n: number) => number);
|
||||
var b7: ((s: string, w: boolean) => void) | ((s: string, w: number) => string);
|
||||
b6 = (k) => { k.toLowerCase() };
|
||||
b6 = (i) => {
|
||||
i.toExponential();
|
||||
return i;
|
||||
}; // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
|
||||
b7 = (j, m) => { }; // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
|
||||
|
||||
class C<T, U> {
|
||||
constructor() {
|
||||
var k: ((j: T, k: U) => (T|U)[]) | ((j: number,k :U) => number[]) = (j, k) => {
|
||||
return [j, k];
|
||||
} // Per spec, no contextual signature can be extracted in this case.
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
// A contextual signature S is extracted from a function type T as follows:
|
||||
// If T is a function type with exactly one call signature, and if that call signature is non- generic, S is that signature.
|
||||
// If T is a union type, let U be the set of element types in T that have call signatures.
|
||||
// If each type in U has exactly one call signature and that call signature is non- generic,
|
||||
// and if all of the signatures are identical ignoring return types, then S is a signature
|
||||
// with the same parameters and a union of the return types.
|
||||
// Otherwise, no contextual signature can be extracted from T and S is undefined.
|
||||
|
||||
var a0: (n: number, s: string) => number
|
||||
var a1: typeof a0 | ((n: number, s: string) => string);
|
||||
a1 = (foo, bar) => { return true; } // Error
|
||||
Loading…
x
Reference in New Issue
Block a user