From f3f3994f25d74bc31ad73f54cd1ce21760ed66b9 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 11 Sep 2014 14:52:14 -0700 Subject: [PATCH] Added tests. --- ...edMethodWithOverloadedArguments.errors.txt | 96 ++++++++++++++ ...OverloadedMethodWithOverloadedArguments.js | 125 ++++++++++++++++++ .../moduleWithStatementsOfEveryKind.js | 8 ++ .../moduleWithStatementsOfEveryKind.types | 14 ++ ...InitializersForwardReferencing.errors.txt} | 8 +- ...arameterInitializersForwardReferencing.js} | 17 ++- ...arameterInitializersForwardReferencing.ts} | 6 +- .../moduleWithStatementsOfEveryKind.ts | 8 ++ ...OverloadedMethodWithOverloadedArguments.ts | 86 ++++++++++++ 9 files changed, 362 insertions(+), 6 deletions(-) create mode 100644 tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.errors.txt create mode 100644 tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.js rename tests/baselines/reference/{defaultArgsForwardReferencing.errors.txt => parameterInitializersForwardReferencing.errors.txt} (83%) rename tests/baselines/reference/{defaultArgsForwardReferencing.js => parameterInitializersForwardReferencing.js} (76%) rename tests/cases/{compiler/defaultArgsForwardReferencing.ts => conformance/functions/parameterInitializersForwardReferencing.ts} (68%) create mode 100644 tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts diff --git a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.errors.txt b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.errors.txt new file mode 100644 index 0000000000000..95fec27cff6d5 --- /dev/null +++ b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.errors.txt @@ -0,0 +1,96 @@ +==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts (4 errors) ==== + + module m1 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); + } + + ////////////////////////////////////// + + module m2 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + declare function testFunction(s: string): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); + ~~~~~~~~~~~~ +!!! Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. + } + + ////////////////////////////////////// + + module m3 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); + } + + ////////////////////////////////////// + + module m4 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + declare function testFunction(s: string): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); + ~~~~~~~~~~~~ +!!! Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. + } + + ////////////////////////////////////// + + module m5 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => U, progress?: (preservation: any) => void): Promise; + } + + declare function testFunction(n: number): Promise; + declare function testFunction(s: string): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); + ~~~~~~~~~~~~ +!!! Argument of type '{ (n: number): Promise; (s: string): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. + } + + ////////////////////////////////////// + + module m6 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + declare function testFunction(s: string): Promise; + declare function testFunction(b: boolean): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); + ~~~~~~~~~~~~ +!!! Argument of type '{ (n: number): Promise; (s: string): Promise; (b: boolean): Promise; }' is not assignable to parameter of type '(x: number) => Promise'. + } + \ No newline at end of file diff --git a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.js b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.js new file mode 100644 index 0000000000000..9bfb6eec1135b --- /dev/null +++ b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.js @@ -0,0 +1,125 @@ +//// [genericCallToOverloadedMethodWithOverloadedArguments.ts] + +module m1 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); +} + +////////////////////////////////////// + +module m2 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + declare function testFunction(s: string): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); +} + +////////////////////////////////////// + +module m3 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); +} + +////////////////////////////////////// + +module m4 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + declare function testFunction(s: string): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); +} + +////////////////////////////////////// + +module m5 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => U, progress?: (preservation: any) => void): Promise; + } + + declare function testFunction(n: number): Promise; + declare function testFunction(s: string): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); +} + +////////////////////////////////////// + +module m6 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + declare function testFunction(s: string): Promise; + declare function testFunction(b: boolean): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); +} + + +//// [genericCallToOverloadedMethodWithOverloadedArguments.js] +var m1; +(function (m1) { + var numPromise; + var newPromise = numPromise.then(testFunction); +})(m1 || (m1 = {})); +////////////////////////////////////// +var m2; +(function (m2) { + var numPromise; + var newPromise = numPromise.then(testFunction); +})(m2 || (m2 = {})); +////////////////////////////////////// +var m3; +(function (m3) { + var numPromise; + var newPromise = numPromise.then(testFunction); +})(m3 || (m3 = {})); +////////////////////////////////////// +var m4; +(function (m4) { + var numPromise; + var newPromise = numPromise.then(testFunction); +})(m4 || (m4 = {})); +////////////////////////////////////// +var m5; +(function (m5) { + var numPromise; + var newPromise = numPromise.then(testFunction); +})(m5 || (m5 = {})); +////////////////////////////////////// +var m6; +(function (m6) { + var numPromise; + var newPromise = numPromise.then(testFunction); +})(m6 || (m6 = {})); diff --git a/tests/baselines/reference/moduleWithStatementsOfEveryKind.js b/tests/baselines/reference/moduleWithStatementsOfEveryKind.js index d30c36584b865..8496588c5bb4c 100644 --- a/tests/baselines/reference/moduleWithStatementsOfEveryKind.js +++ b/tests/baselines/reference/moduleWithStatementsOfEveryKind.js @@ -22,6 +22,10 @@ module A { return 'hello ' + s; } var ol = { s: 'hello', id: 2, isvalid: true }; + + declare class DC { + static x: number; + } } module Y { @@ -47,6 +51,10 @@ module Y { return 'hello ' + s; } export var ol = { s: 'hello', id: 2, isvalid: true }; + + export declare class DC { + static x: number; + } } diff --git a/tests/baselines/reference/moduleWithStatementsOfEveryKind.types b/tests/baselines/reference/moduleWithStatementsOfEveryKind.types index 263da21f52414..0bade1f2d8efe 100644 --- a/tests/baselines/reference/moduleWithStatementsOfEveryKind.types +++ b/tests/baselines/reference/moduleWithStatementsOfEveryKind.types @@ -71,6 +71,13 @@ module A { >s : string >id : number >isvalid : boolean + + declare class DC { +>DC : DC + + static x: number; +>x : number + } } module Y { @@ -145,5 +152,12 @@ module Y { >s : string >id : number >isvalid : boolean + + export declare class DC { +>DC : DC + + static x: number; +>x : number + } } diff --git a/tests/baselines/reference/defaultArgsForwardReferencing.errors.txt b/tests/baselines/reference/parameterInitializersForwardReferencing.errors.txt similarity index 83% rename from tests/baselines/reference/defaultArgsForwardReferencing.errors.txt rename to tests/baselines/reference/parameterInitializersForwardReferencing.errors.txt index 2b8250f6fb442..c528203fdd193 100644 --- a/tests/baselines/reference/defaultArgsForwardReferencing.errors.txt +++ b/tests/baselines/reference/parameterInitializersForwardReferencing.errors.txt @@ -1,4 +1,4 @@ -==== tests/cases/compiler/defaultArgsForwardReferencing.ts (10 errors) ==== +==== tests/cases/conformance/functions/parameterInitializersForwardReferencing.ts (10 errors) ==== function left(a, b = a, c = b) { a; b; @@ -55,4 +55,8 @@ ~ !!! Initializer of parameter 'b' cannot reference identifier 'c' declared after it. ~ -!!! Initializer of parameter 'c' cannot reference identifier 'd' declared after it. \ No newline at end of file +!!! Initializer of parameter 'c' cannot reference identifier 'd' declared after it. + + // Should not produce errors - can reference later parameters if they occur within a function expression initializer. + function f(a, b = function () { return c; }, c = b()) { + } \ No newline at end of file diff --git a/tests/baselines/reference/defaultArgsForwardReferencing.js b/tests/baselines/reference/parameterInitializersForwardReferencing.js similarity index 76% rename from tests/baselines/reference/defaultArgsForwardReferencing.js rename to tests/baselines/reference/parameterInitializersForwardReferencing.js index 4e9a5ae60e343..90fa1bdcd23e3 100644 --- a/tests/baselines/reference/defaultArgsForwardReferencing.js +++ b/tests/baselines/reference/parameterInitializersForwardReferencing.js @@ -1,4 +1,4 @@ -//// [defaultArgsForwardReferencing.ts] +//// [parameterInitializersForwardReferencing.ts] function left(a, b = a, c = b) { a; b; @@ -35,9 +35,13 @@ class C { } // Function expressions -var x = (a = b, b = c, c = d) => { var d; }; +var x = (a = b, b = c, c = d) => { var d; }; + +// Should not produce errors - can reference later parameters if they occur within a function expression initializer. +function f(a, b = function () { return c; }, c = b()) { +} -//// [defaultArgsForwardReferencing.js] +//// [parameterInitializersForwardReferencing.js] function left(a, b, c) { if (b === void 0) { b = a; } if (c === void 0) { c = b; } @@ -97,3 +101,10 @@ var x = function (a, b, c) { if (c === void 0) { c = d; } var d; }; +// Should not produce errors - can reference later parameters if they occur within a function expression initializer. +function f(a, b, c) { + if (b === void 0) { b = function () { + return c; + }; } + if (c === void 0) { c = b(); } +} diff --git a/tests/cases/compiler/defaultArgsForwardReferencing.ts b/tests/cases/conformance/functions/parameterInitializersForwardReferencing.ts similarity index 68% rename from tests/cases/compiler/defaultArgsForwardReferencing.ts rename to tests/cases/conformance/functions/parameterInitializersForwardReferencing.ts index c169f7d23e898..fa3549ea2c5bd 100644 --- a/tests/cases/compiler/defaultArgsForwardReferencing.ts +++ b/tests/cases/conformance/functions/parameterInitializersForwardReferencing.ts @@ -34,4 +34,8 @@ class C { } // Function expressions -var x = (a = b, b = c, c = d) => { var d; }; \ No newline at end of file +var x = (a = b, b = c, c = d) => { var d; }; + +// Should not produce errors - can reference later parameters if they occur within a function expression initializer. +function f(a, b = function () { return c; }, c = b()) { +} \ No newline at end of file diff --git a/tests/cases/conformance/internalModules/moduleBody/moduleWithStatementsOfEveryKind.ts b/tests/cases/conformance/internalModules/moduleBody/moduleWithStatementsOfEveryKind.ts index 202c84013ed31..6991795b26c8f 100644 --- a/tests/cases/conformance/internalModules/moduleBody/moduleWithStatementsOfEveryKind.ts +++ b/tests/cases/conformance/internalModules/moduleBody/moduleWithStatementsOfEveryKind.ts @@ -21,6 +21,10 @@ module A { return 'hello ' + s; } var ol = { s: 'hello', id: 2, isvalid: true }; + + declare class DC { + static x: number; + } } module Y { @@ -46,4 +50,8 @@ module Y { return 'hello ' + s; } export var ol = { s: 'hello', id: 2, isvalid: true }; + + export declare class DC { + static x: number; + } } diff --git a/tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts new file mode 100644 index 0000000000000..b1db7364ab28a --- /dev/null +++ b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallToOverloadedMethodWithOverloadedArguments.ts @@ -0,0 +1,86 @@ + +module m1 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); +} + +////////////////////////////////////// + +module m2 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + declare function testFunction(s: string): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); +} + +////////////////////////////////////// + +module m3 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); +} + +////////////////////////////////////// + +module m4 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + declare function testFunction(s: string): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); +} + +////////////////////////////////////// + +module m5 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => U, progress?: (preservation: any) => void): Promise; + } + + declare function testFunction(n: number): Promise; + declare function testFunction(s: string): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); +} + +////////////////////////////////////// + +module m6 { + interface Promise { + then(cb: (x: T) => Promise): Promise; + then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; + } + + declare function testFunction(n: number): Promise; + declare function testFunction(s: string): Promise; + declare function testFunction(b: boolean): Promise; + + var numPromise: Promise; + var newPromise = numPromise.then(testFunction); +}