From 5ac12cfbc0c8464dfa8487a521afe4af9720fbe3 Mon Sep 17 00:00:00 2001 From: Yui T Date: Tue, 14 Apr 2015 13:05:29 -0700 Subject: [PATCH] Update test filenames --- .../functionExpressionContextualTyping1.js | 74 ++++++-- .../functionExpressionContextualTyping1.types | 167 ++++++++++++++++++ ...tionExpressionContextualTyping2.errors.txt | 36 ++++ .../functionExpressionContextualTyping2.js | 36 ++++ 4 files changed, 296 insertions(+), 17 deletions(-) create mode 100644 tests/baselines/reference/functionExpressionContextualTyping1.types create mode 100644 tests/baselines/reference/functionExpressionContextualTyping2.errors.txt create mode 100644 tests/baselines/reference/functionExpressionContextualTyping2.js diff --git a/tests/baselines/reference/functionExpressionContextualTyping1.js b/tests/baselines/reference/functionExpressionContextualTyping1.js index f0331c84070..6e528a5aedc 100644 --- a/tests/baselines/reference/functionExpressionContextualTyping1.js +++ b/tests/baselines/reference/functionExpressionContextualTyping1.js @@ -1,36 +1,76 @@ //// [functionExpressionContextualTyping1.ts] -var g0: (n: number, s: string) => number +enum E { red, blue } + +var g0: (n: number, s:string) => number; +var g: ((s: string, w: boolean) => void) | ((n: number) => number); +var g1: ((s: string, w: boolean) => void) | ((s: string, w: number) => string); + +g1 = (j, m) => { } // Per spec, no contextual signature can be extracted in this case. +g = (k, h=true) => { k.toLowerCase() }; +g = (k) => { k.toLowerCase() }; +g = (i) => { + i.toExponential(); + return i; +}; // Per spec, no contextual signature can be extracted in this case. + +var h: ((s: string, w: boolean) => void) | ((s: string, w: boolean) => string); +h = (k, h) => { }; + var i: typeof g0 | ((n: number, s: string) => string); -i = (foo, bar) => { return true; } +i = (foo, bar) => { return foo + 1; } +i = (foo, bar) => { return "hello"; } +var j: (name: string, num: number, boo: boolean) => void; +j = (name, number) => { }; -class C { } - -var j: (c: C) => number = (j) => { return 1; } +var k: (n: E) => string = (number = 1) => { return "hello"; }; +var k1: (n: {}) => string = (number = 1) => { return "hello"; }; class C { constructor() { - var k: (j: T, k: U) => (T|U)[] = (j = 1, k = 0) => { + 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] +var E; +(function (E) { + E[E["red"] = 0] = "red"; + E[E["blue"] = 1] = "blue"; +})(E || (E = {})); var g0; +var g; +var g1; +g1 = function (j, m) { }; // Per spec, no contextual signature can be extracted in this case. +g = function (k, h) { + if (h === void 0) { h = true; } + k.toLowerCase(); +}; +g = function (k) { k.toLowerCase(); }; +g = function (i) { + i.toExponential(); + return i; +}; // Per spec, no contextual signature can be extracted in this case. +var h; +h = function (k, h) { }; var i; -i = function (foo, bar) { return true; }; -var C = (function () { - function C() { - } - return C; -})(); -var j = function (j) { return 1; }; +i = function (foo, bar) { return foo + 1; }; +i = function (foo, bar) { return "hello"; }; +var j; +j = function (name, number) { }; +var k = function (number) { + if (number === void 0) { number = 1; } + return "hello"; +}; +var k1 = function (number) { + if (number === void 0) { number = 1; } + return "hello"; +}; var C = (function () { function C() { var k = function (j, k) { - if (j === void 0) { j = 1; } - if (k === void 0) { k = 0; } return [j, k]; - }; + }; // Per spec, no contextual signature can be extracted in this case. } return C; })(); diff --git a/tests/baselines/reference/functionExpressionContextualTyping1.types b/tests/baselines/reference/functionExpressionContextualTyping1.types new file mode 100644 index 00000000000..3a1ce95bb99 --- /dev/null +++ b/tests/baselines/reference/functionExpressionContextualTyping1.types @@ -0,0 +1,167 @@ +=== tests/cases/conformance/expressions/contextualTyping/functionExpressionContextualTyping1.ts === +enum E { red, blue } +>E : E, Symbol(E, Decl(functionExpressionContextualTyping1.ts, 0, 0)) +>red : E, Symbol(E.red, Decl(functionExpressionContextualTyping1.ts, 0, 8)) +>blue : E, Symbol(E.blue, Decl(functionExpressionContextualTyping1.ts, 0, 13)) + +var g0: (n: number, s:string) => number; +>g0 : (n: number, s: string) => number, Symbol(g0, Decl(functionExpressionContextualTyping1.ts, 2, 3)) +>n : number, Symbol(n, Decl(functionExpressionContextualTyping1.ts, 2, 9)) +>s : string, Symbol(s, Decl(functionExpressionContextualTyping1.ts, 2, 19)) + +var g: ((s: string, w: boolean) => void) | ((n: number) => number); +>g : ((s: string, w: boolean) => void) | ((n: number) => number), Symbol(g, Decl(functionExpressionContextualTyping1.ts, 3, 3)) +>s : string, Symbol(s, Decl(functionExpressionContextualTyping1.ts, 3, 9)) +>w : boolean, Symbol(w, Decl(functionExpressionContextualTyping1.ts, 3, 19)) +>n : number, Symbol(n, Decl(functionExpressionContextualTyping1.ts, 3, 45)) + +var g1: ((s: string, w: boolean) => void) | ((s: string, w: number) => string); +>g1 : ((s: string, w: boolean) => void) | ((s: string, w: number) => string), Symbol(g1, Decl(functionExpressionContextualTyping1.ts, 4, 3)) +>s : string, Symbol(s, Decl(functionExpressionContextualTyping1.ts, 4, 10)) +>w : boolean, Symbol(w, Decl(functionExpressionContextualTyping1.ts, 4, 20)) +>s : string, Symbol(s, Decl(functionExpressionContextualTyping1.ts, 4, 46)) +>w : number, Symbol(w, Decl(functionExpressionContextualTyping1.ts, 4, 56)) + +g1 = (j, m) => { } // Per spec, no contextual signature can be extracted in this case. +>g1 = (j, m) => { } : (j: any, m: any) => void +>g1 : ((s: string, w: boolean) => void) | ((s: string, w: number) => string), Symbol(g1, Decl(functionExpressionContextualTyping1.ts, 4, 3)) +>(j, m) => { } : (j: any, m: any) => void +>j : any, Symbol(j, Decl(functionExpressionContextualTyping1.ts, 6, 6)) +>m : any, Symbol(m, Decl(functionExpressionContextualTyping1.ts, 6, 8)) + +g = (k, h=true) => { k.toLowerCase() }; +>g = (k, h=true) => { k.toLowerCase() } : (k: any, h?: boolean) => void +>g : ((s: string, w: boolean) => void) | ((n: number) => number), Symbol(g, Decl(functionExpressionContextualTyping1.ts, 3, 3)) +>(k, h=true) => { k.toLowerCase() } : (k: any, h?: boolean) => void +>k : any, Symbol(k, Decl(functionExpressionContextualTyping1.ts, 7, 5)) +>h : boolean, Symbol(h, Decl(functionExpressionContextualTyping1.ts, 7, 7)) +>true : boolean +>k.toLowerCase() : any +>k.toLowerCase : any +>k : any, Symbol(k, Decl(functionExpressionContextualTyping1.ts, 7, 5)) +>toLowerCase : any + +g = (k) => { k.toLowerCase() }; +>g = (k) => { k.toLowerCase() } : (k: any) => void +>g : ((s: string, w: boolean) => void) | ((n: number) => number), Symbol(g, Decl(functionExpressionContextualTyping1.ts, 3, 3)) +>(k) => { k.toLowerCase() } : (k: any) => void +>k : any, Symbol(k, Decl(functionExpressionContextualTyping1.ts, 8, 5)) +>k.toLowerCase() : any +>k.toLowerCase : any +>k : any, Symbol(k, Decl(functionExpressionContextualTyping1.ts, 8, 5)) +>toLowerCase : any + +g = (i) => { +>g = (i) => { i.toExponential(); return i;} : (i: any) => any +>g : ((s: string, w: boolean) => void) | ((n: number) => number), Symbol(g, Decl(functionExpressionContextualTyping1.ts, 3, 3)) +>(i) => { i.toExponential(); return i;} : (i: any) => any +>i : any, Symbol(i, Decl(functionExpressionContextualTyping1.ts, 9, 5)) + + i.toExponential(); +>i.toExponential() : any +>i.toExponential : any +>i : any, Symbol(i, Decl(functionExpressionContextualTyping1.ts, 9, 5)) +>toExponential : any + + return i; +>i : any, Symbol(i, Decl(functionExpressionContextualTyping1.ts, 9, 5)) + +}; // Per spec, no contextual signature can be extracted in this case. + +var h: ((s: string, w: boolean) => void) | ((s: string, w: boolean) => string); +>h : ((s: string, w: boolean) => void) | ((s: string, w: boolean) => string), Symbol(h, Decl(functionExpressionContextualTyping1.ts, 14, 3)) +>s : string, Symbol(s, Decl(functionExpressionContextualTyping1.ts, 14, 9)) +>w : boolean, Symbol(w, Decl(functionExpressionContextualTyping1.ts, 14, 19)) +>s : string, Symbol(s, Decl(functionExpressionContextualTyping1.ts, 14, 45)) +>w : boolean, Symbol(w, Decl(functionExpressionContextualTyping1.ts, 14, 55)) + +h = (k, h) => { }; +>h = (k, h) => { } : (k: string, h: boolean) => void +>h : ((s: string, w: boolean) => void) | ((s: string, w: boolean) => string), Symbol(h, Decl(functionExpressionContextualTyping1.ts, 14, 3)) +>(k, h) => { } : (k: string, h: boolean) => void +>k : string, Symbol(k, Decl(functionExpressionContextualTyping1.ts, 15, 5)) +>h : boolean, Symbol(h, Decl(functionExpressionContextualTyping1.ts, 15, 7)) + +var i: typeof g0 | ((n: number, s: string) => string); +>i : ((n: number, s: string) => number) | ((n: number, s: string) => string), Symbol(i, Decl(functionExpressionContextualTyping1.ts, 17, 3)) +>g0 : (n: number, s: string) => number, Symbol(g0, Decl(functionExpressionContextualTyping1.ts, 2, 3)) +>n : number, Symbol(n, Decl(functionExpressionContextualTyping1.ts, 17, 21)) +>s : string, Symbol(s, Decl(functionExpressionContextualTyping1.ts, 17, 31)) + +i = (foo, bar) => { return foo + 1; } +>i = (foo, bar) => { return foo + 1; } : (foo: number, bar: string) => number +>i : ((n: number, s: string) => number) | ((n: number, s: string) => string), Symbol(i, Decl(functionExpressionContextualTyping1.ts, 17, 3)) +>(foo, bar) => { return foo + 1; } : (foo: number, bar: string) => number +>foo : number, Symbol(foo, Decl(functionExpressionContextualTyping1.ts, 18, 5)) +>bar : string, Symbol(bar, Decl(functionExpressionContextualTyping1.ts, 18, 9)) +>foo + 1 : number +>foo : number, Symbol(foo, Decl(functionExpressionContextualTyping1.ts, 18, 5)) +>1 : number + +i = (foo, bar) => { return "hello"; } +>i = (foo, bar) => { return "hello"; } : (foo: number, bar: string) => string +>i : ((n: number, s: string) => number) | ((n: number, s: string) => string), Symbol(i, Decl(functionExpressionContextualTyping1.ts, 17, 3)) +>(foo, bar) => { return "hello"; } : (foo: number, bar: string) => string +>foo : number, Symbol(foo, Decl(functionExpressionContextualTyping1.ts, 19, 5)) +>bar : string, Symbol(bar, Decl(functionExpressionContextualTyping1.ts, 19, 9)) +>"hello" : string + +var j: (name: string, num: number, boo: boolean) => void; +>j : (name: string, num: number, boo: boolean) => void, Symbol(j, Decl(functionExpressionContextualTyping1.ts, 20, 3)) +>name : string, Symbol(name, Decl(functionExpressionContextualTyping1.ts, 20, 8)) +>num : number, Symbol(num, Decl(functionExpressionContextualTyping1.ts, 20, 21)) +>boo : boolean, Symbol(boo, Decl(functionExpressionContextualTyping1.ts, 20, 34)) + +j = (name, number) => { }; +>j = (name, number) => { } : (name: string, number: number) => void +>j : (name: string, num: number, boo: boolean) => void, Symbol(j, Decl(functionExpressionContextualTyping1.ts, 20, 3)) +>(name, number) => { } : (name: string, number: number) => void +>name : string, Symbol(name, Decl(functionExpressionContextualTyping1.ts, 21, 5)) +>number : number, Symbol(number, Decl(functionExpressionContextualTyping1.ts, 21, 10)) + +var k: (n: E) => string = (number = 1) => { return "hello"; }; +>k : (n: E) => string, Symbol(k, Decl(functionExpressionContextualTyping1.ts, 23, 3)) +>n : E, Symbol(n, Decl(functionExpressionContextualTyping1.ts, 23, 8)) +>E : E, Symbol(E, Decl(functionExpressionContextualTyping1.ts, 0, 0)) +>(number = 1) => { return "hello"; } : (number?: E) => string +>number : E, Symbol(number, Decl(functionExpressionContextualTyping1.ts, 23, 27)) +>1 : number +>"hello" : string + +var k1: (n: {}) => string = (number = 1) => { return "hello"; }; +>k1 : (n: {}) => string, Symbol(k1, Decl(functionExpressionContextualTyping1.ts, 24, 3)) +>n : {}, Symbol(n, Decl(functionExpressionContextualTyping1.ts, 24, 9)) +>(number = 1) => { return "hello"; } : (number?: {}) => string +>number : {}, Symbol(number, Decl(functionExpressionContextualTyping1.ts, 24, 29)) +>1 : number +>"hello" : string + +class C { +>C : C, Symbol(C, Decl(functionExpressionContextualTyping1.ts, 24, 64)) +>T : T, Symbol(T, Decl(functionExpressionContextualTyping1.ts, 25, 8)) +>U : U, Symbol(U, Decl(functionExpressionContextualTyping1.ts, 25, 10)) + + 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[]), Symbol(k, Decl(functionExpressionContextualTyping1.ts, 27, 11)) +>j : T, Symbol(j, Decl(functionExpressionContextualTyping1.ts, 27, 17)) +>T : T, Symbol(T, Decl(functionExpressionContextualTyping1.ts, 25, 8)) +>k : U, Symbol(k, Decl(functionExpressionContextualTyping1.ts, 27, 22)) +>U : U, Symbol(U, Decl(functionExpressionContextualTyping1.ts, 25, 10)) +>T : T, Symbol(T, Decl(functionExpressionContextualTyping1.ts, 25, 8)) +>U : U, Symbol(U, Decl(functionExpressionContextualTyping1.ts, 25, 10)) +>j : number, Symbol(j, Decl(functionExpressionContextualTyping1.ts, 27, 45)) +>k : U, Symbol(k, Decl(functionExpressionContextualTyping1.ts, 27, 55)) +>U : U, Symbol(U, Decl(functionExpressionContextualTyping1.ts, 25, 10)) +>(j, k) => { return [j, k]; } : (j: any, k: any) => any[] +>j : any, Symbol(j, Decl(functionExpressionContextualTyping1.ts, 27, 77)) +>k : any, Symbol(k, Decl(functionExpressionContextualTyping1.ts, 27, 79)) + + return [j, k]; +>[j, k] : any[] +>j : any, Symbol(j, Decl(functionExpressionContextualTyping1.ts, 27, 77)) +>k : any, Symbol(k, Decl(functionExpressionContextualTyping1.ts, 27, 79)) + + } // Per spec, no contextual signature can be extracted in this case. + } +} diff --git a/tests/baselines/reference/functionExpressionContextualTyping2.errors.txt b/tests/baselines/reference/functionExpressionContextualTyping2.errors.txt new file mode 100644 index 00000000000..d9622c50e42 --- /dev/null +++ b/tests/baselines/reference/functionExpressionContextualTyping2.errors.txt @@ -0,0 +1,36 @@ +tests/cases/conformance/expressions/contextualTyping/functionExpressionContextualTyping2.ts(3,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(5,7): error TS2300: Duplicate identifier 'C'. +tests/cases/conformance/expressions/contextualTyping/functionExpressionContextualTyping2.ts(8,7): error TS2300: Duplicate identifier 'C'. +tests/cases/conformance/expressions/contextualTyping/functionExpressionContextualTyping2.ts(10,43): error TS2322: Type 'number' is not assignable to type 'T'. +tests/cases/conformance/expressions/contextualTyping/functionExpressionContextualTyping2.ts(10,50): error TS2322: Type 'number' is not assignable to type 'U'. + + +==== tests/cases/conformance/expressions/contextualTyping/functionExpressionContextualTyping2.ts (5 errors) ==== + var g0: (n: number, s: string) => number + var i: typeof g0 | ((n: number, s: string) => string); + i = (foo, bar) => { return true; } + ~ +!!! 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'. + + class C { } + ~ +!!! error TS2300: Duplicate identifier 'C'. + + var j: (c: C) => number = (j) => { return 1; } + class C { + ~ +!!! error TS2300: Duplicate identifier 'C'. + constructor() { + var k: (j: T, k: U) => (T|U)[] = (j = 1, k = 0) => { + ~~~~~ +!!! error TS2322: Type 'number' is not assignable to type 'T'. + ~~~~~ +!!! error TS2322: Type 'number' is not assignable to type 'U'. + return [j, k]; + } + } + } \ No newline at end of file diff --git a/tests/baselines/reference/functionExpressionContextualTyping2.js b/tests/baselines/reference/functionExpressionContextualTyping2.js new file mode 100644 index 00000000000..87d3e1ed9ef --- /dev/null +++ b/tests/baselines/reference/functionExpressionContextualTyping2.js @@ -0,0 +1,36 @@ +//// [functionExpressionContextualTyping2.ts] +var g0: (n: number, s: string) => number +var i: typeof g0 | ((n: number, s: string) => string); +i = (foo, bar) => { return true; } + +class C { } + +var j: (c: C) => number = (j) => { return 1; } +class C { + constructor() { + var k: (j: T, k: U) => (T|U)[] = (j = 1, k = 0) => { + return [j, k]; + } + } +} + +//// [functionExpressionContextualTyping2.js] +var g0; +var i; +i = function (foo, bar) { return true; }; +var C = (function () { + function C() { + } + return C; +})(); +var j = function (j) { return 1; }; +var C = (function () { + function C() { + var k = function (j, k) { + if (j === void 0) { j = 1; } + if (k === void 0) { k = 0; } + return [j, k]; + }; + } + return C; +})();