From 4a0af76064ae039efd99b47133eb35a21c1cc43f Mon Sep 17 00:00:00 2001 From: Jason Freeman Date: Tue, 24 Mar 2015 16:52:00 -0700 Subject: [PATCH] Add tests for iterator spread in call --- .../reference/iteratorSpreadInCall.errors.txt | 21 +++++ .../reference/iteratorSpreadInCall.js | 32 ++++++++ .../iteratorSpreadInCall10.errors.txt | 22 +++++ .../reference/iteratorSpreadInCall10.js | 34 ++++++++ .../reference/iteratorSpreadInCall11.js | 34 ++++++++ .../reference/iteratorSpreadInCall11.types | 45 +++++++++++ .../reference/iteratorSpreadInCall12.js | 66 +++++++++++++++ .../reference/iteratorSpreadInCall12.types | 81 +++++++++++++++++++ .../iteratorSpreadInCall2.errors.txt | 21 +++++ .../reference/iteratorSpreadInCall2.js | 32 ++++++++ .../reference/iteratorSpreadInCall3.js | 32 ++++++++ .../reference/iteratorSpreadInCall3.types | 41 ++++++++++ .../iteratorSpreadInCall4.errors.txt | 21 +++++ .../reference/iteratorSpreadInCall4.js | 32 ++++++++ .../reference/iteratorSpreadInCall5.js | 56 +++++++++++++ .../reference/iteratorSpreadInCall5.types | 72 +++++++++++++++++ .../iteratorSpreadInCall6.errors.txt | 36 +++++++++ .../reference/iteratorSpreadInCall6.js | 56 +++++++++++++ .../iteratorSpreadInCall7.errors.txt | 36 +++++++++ .../reference/iteratorSpreadInCall7.js | 57 +++++++++++++ .../iteratorSpreadInCall8.errors.txt | 39 +++++++++ .../reference/iteratorSpreadInCall8.js | 61 ++++++++++++++ .../iteratorSpreadInCall9.errors.txt | 39 +++++++++ .../reference/iteratorSpreadInCall9.js | 63 +++++++++++++++ .../es6/spread/iteratorSpreadInCall.ts | 16 ++++ .../es6/spread/iteratorSpreadInCall10.ts | 17 ++++ .../es6/spread/iteratorSpreadInCall11.ts | 17 ++++ .../es6/spread/iteratorSpreadInCall12.ts | 32 ++++++++ .../es6/spread/iteratorSpreadInCall2.ts | 16 ++++ .../es6/spread/iteratorSpreadInCall3.ts | 16 ++++ .../es6/spread/iteratorSpreadInCall4.ts | 16 ++++ .../es6/spread/iteratorSpreadInCall5.ts | 29 +++++++ .../es6/spread/iteratorSpreadInCall6.ts | 29 +++++++ .../es6/spread/iteratorSpreadInCall7.ts | 29 +++++++ .../es6/spread/iteratorSpreadInCall8.ts | 32 ++++++++ .../es6/spread/iteratorSpreadInCall9.ts | 32 ++++++++ 36 files changed, 1310 insertions(+) create mode 100644 tests/baselines/reference/iteratorSpreadInCall.errors.txt create mode 100644 tests/baselines/reference/iteratorSpreadInCall.js create mode 100644 tests/baselines/reference/iteratorSpreadInCall10.errors.txt create mode 100644 tests/baselines/reference/iteratorSpreadInCall10.js create mode 100644 tests/baselines/reference/iteratorSpreadInCall11.js create mode 100644 tests/baselines/reference/iteratorSpreadInCall11.types create mode 100644 tests/baselines/reference/iteratorSpreadInCall12.js create mode 100644 tests/baselines/reference/iteratorSpreadInCall12.types create mode 100644 tests/baselines/reference/iteratorSpreadInCall2.errors.txt create mode 100644 tests/baselines/reference/iteratorSpreadInCall2.js create mode 100644 tests/baselines/reference/iteratorSpreadInCall3.js create mode 100644 tests/baselines/reference/iteratorSpreadInCall3.types create mode 100644 tests/baselines/reference/iteratorSpreadInCall4.errors.txt create mode 100644 tests/baselines/reference/iteratorSpreadInCall4.js create mode 100644 tests/baselines/reference/iteratorSpreadInCall5.js create mode 100644 tests/baselines/reference/iteratorSpreadInCall5.types create mode 100644 tests/baselines/reference/iteratorSpreadInCall6.errors.txt create mode 100644 tests/baselines/reference/iteratorSpreadInCall6.js create mode 100644 tests/baselines/reference/iteratorSpreadInCall7.errors.txt create mode 100644 tests/baselines/reference/iteratorSpreadInCall7.js create mode 100644 tests/baselines/reference/iteratorSpreadInCall8.errors.txt create mode 100644 tests/baselines/reference/iteratorSpreadInCall8.js create mode 100644 tests/baselines/reference/iteratorSpreadInCall9.errors.txt create mode 100644 tests/baselines/reference/iteratorSpreadInCall9.js create mode 100644 tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts create mode 100644 tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts create mode 100644 tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts create mode 100644 tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts create mode 100644 tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts create mode 100644 tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts create mode 100644 tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts create mode 100644 tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts create mode 100644 tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts create mode 100644 tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts create mode 100644 tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts create mode 100644 tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts diff --git a/tests/baselines/reference/iteratorSpreadInCall.errors.txt b/tests/baselines/reference/iteratorSpreadInCall.errors.txt new file mode 100644 index 0000000000..614153192d --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall.errors.txt @@ -0,0 +1,21 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts(1,1): error TS2346: Supplied parameters do not match any signature of call target. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts (1 errors) ==== + foo(...new SymbolIterator); + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. + + function foo(s: symbol) { } + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall.js b/tests/baselines/reference/iteratorSpreadInCall.js new file mode 100644 index 0000000000..0dcff404f5 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall.js @@ -0,0 +1,32 @@ +//// [iteratorSpreadInCall.ts] +foo(...new SymbolIterator); + +function foo(s: symbol) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall.js] +foo(...new SymbolIterator); +function foo(s) { +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall10.errors.txt b/tests/baselines/reference/iteratorSpreadInCall10.errors.txt new file mode 100644 index 0000000000..04d9045e86 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall10.errors.txt @@ -0,0 +1,22 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts(1,1): error TS2346: Supplied parameters do not match any signature of call target. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts (1 errors) ==== + foo(...new SymbolIterator); + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. + + function foo(s: T[]) { return s[0] } + + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall10.js b/tests/baselines/reference/iteratorSpreadInCall10.js new file mode 100644 index 0000000000..5c400ae2c3 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall10.js @@ -0,0 +1,34 @@ +//// [iteratorSpreadInCall10.ts] +foo(...new SymbolIterator); + +function foo(s: T[]) { return s[0] } + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall10.js] +foo(...new SymbolIterator); +function foo(s) { + return s[0]; +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall11.js b/tests/baselines/reference/iteratorSpreadInCall11.js new file mode 100644 index 0000000000..a3cccb9640 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall11.js @@ -0,0 +1,34 @@ +//// [iteratorSpreadInCall11.ts] +foo(...new SymbolIterator); + +function foo(...s: T[]) { return s[0] } + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall11.js] +foo(...new SymbolIterator); +function foo(...s) { + return s[0]; +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall11.types b/tests/baselines/reference/iteratorSpreadInCall11.types new file mode 100644 index 0000000000..a37fc6e223 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall11.types @@ -0,0 +1,45 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts === +foo(...new SymbolIterator); +>foo(...new SymbolIterator) : symbol +>foo : (...s: T[]) => T +>...new SymbolIterator : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator + +function foo(...s: T[]) { return s[0] } +>foo : (...s: T[]) => T +>T : T +>s : T[] +>T : T +>s[0] : T +>s : T[] + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall12.js b/tests/baselines/reference/iteratorSpreadInCall12.js new file mode 100644 index 0000000000..dd95cab0cf --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall12.js @@ -0,0 +1,66 @@ +//// [iteratorSpreadInCall12.ts] +new Foo(...[...new SymbolIterator, ...[...new StringIterator]]); + +class Foo { + constructor(...s: T[]) { } +} + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall12.js] +new Foo(...[ + ...new SymbolIterator, + ...[ + ...new StringIterator + ] +]); +class Foo { + constructor(...s) { + } +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall12.types b/tests/baselines/reference/iteratorSpreadInCall12.types new file mode 100644 index 0000000000..78ce973a53 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall12.types @@ -0,0 +1,81 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts === +new Foo(...[...new SymbolIterator, ...[...new StringIterator]]); +>new Foo(...[...new SymbolIterator, ...[...new StringIterator]]) : Foo +>Foo : typeof Foo +>...[...new SymbolIterator, ...[...new StringIterator]] : string | symbol +>[...new SymbolIterator, ...[...new StringIterator]] : (string | symbol)[] +>...new SymbolIterator : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator +>...[...new StringIterator] : string +>[...new StringIterator] : string[] +>...new StringIterator : string +>new StringIterator : StringIterator +>StringIterator : typeof StringIterator + +class Foo { +>Foo : Foo +>T : T + + constructor(...s: T[]) { } +>s : T[] +>T : T +} + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} + +class StringIterator { +>StringIterator : StringIterator + + next() { +>next : () => { value: string; done: boolean; } + + return { +>{ value: "", done: false } : { value: string; done: boolean; } + + value: "", +>value : string + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : StringIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall2.errors.txt b/tests/baselines/reference/iteratorSpreadInCall2.errors.txt new file mode 100644 index 0000000000..bd994ab37b --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall2.errors.txt @@ -0,0 +1,21 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts(1,1): error TS2346: Supplied parameters do not match any signature of call target. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts (1 errors) ==== + foo(...new SymbolIterator); + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. + + function foo(s: symbol[]) { } + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall2.js b/tests/baselines/reference/iteratorSpreadInCall2.js new file mode 100644 index 0000000000..d833cd77fb --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall2.js @@ -0,0 +1,32 @@ +//// [iteratorSpreadInCall2.ts] +foo(...new SymbolIterator); + +function foo(s: symbol[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall2.js] +foo(...new SymbolIterator); +function foo(s) { +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall3.js b/tests/baselines/reference/iteratorSpreadInCall3.js new file mode 100644 index 0000000000..17d0a3ed37 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall3.js @@ -0,0 +1,32 @@ +//// [iteratorSpreadInCall3.ts] +foo(...new SymbolIterator); + +function foo(...s: symbol[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall3.js] +foo(...new SymbolIterator); +function foo(...s) { +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall3.types b/tests/baselines/reference/iteratorSpreadInCall3.types new file mode 100644 index 0000000000..07eb149ba3 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall3.types @@ -0,0 +1,41 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts === +foo(...new SymbolIterator); +>foo(...new SymbolIterator) : void +>foo : (...s: symbol[]) => void +>...new SymbolIterator : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator + +function foo(...s: symbol[]) { } +>foo : (...s: symbol[]) => void +>s : symbol[] + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall4.errors.txt b/tests/baselines/reference/iteratorSpreadInCall4.errors.txt new file mode 100644 index 0000000000..0e0a40a512 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall4.errors.txt @@ -0,0 +1,21 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts(1,1): error TS2346: Supplied parameters do not match any signature of call target. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts (1 errors) ==== + foo(...new SymbolIterator); + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. + + function foo(s1: symbol, ...s: symbol[]) { } + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall4.js b/tests/baselines/reference/iteratorSpreadInCall4.js new file mode 100644 index 0000000000..e1888f4763 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall4.js @@ -0,0 +1,32 @@ +//// [iteratorSpreadInCall4.ts] +foo(...new SymbolIterator); + +function foo(s1: symbol, ...s: symbol[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall4.js] +foo(...new SymbolIterator); +function foo(s1, ...s) { +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall5.js b/tests/baselines/reference/iteratorSpreadInCall5.js new file mode 100644 index 0000000000..2b7be4cdce --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall5.js @@ -0,0 +1,56 @@ +//// [iteratorSpreadInCall5.ts] +foo(...new SymbolIterator, ...new StringIterator); + +function foo(...s: (symbol | string)[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall5.js] +foo(...new SymbolIterator, ...new StringIterator); +function foo(...s) { +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall5.types b/tests/baselines/reference/iteratorSpreadInCall5.types new file mode 100644 index 0000000000..6e924a1ef4 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall5.types @@ -0,0 +1,72 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts === +foo(...new SymbolIterator, ...new StringIterator); +>foo(...new SymbolIterator, ...new StringIterator) : void +>foo : (...s: (string | symbol)[]) => void +>...new SymbolIterator : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator +>...new StringIterator : string +>new StringIterator : StringIterator +>StringIterator : typeof StringIterator + +function foo(...s: (symbol | string)[]) { } +>foo : (...s: (string | symbol)[]) => void +>s : (string | symbol)[] + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} + +class StringIterator { +>StringIterator : StringIterator + + next() { +>next : () => { value: string; done: boolean; } + + return { +>{ value: "", done: false } : { value: string; done: boolean; } + + value: "", +>value : string + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : StringIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall6.errors.txt b/tests/baselines/reference/iteratorSpreadInCall6.errors.txt new file mode 100644 index 0000000000..be085beb63 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall6.errors.txt @@ -0,0 +1,36 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts(1,28): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number | symbol'. + Type 'string' is not assignable to type 'symbol'. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts (1 errors) ==== + foo(...new SymbolIterator, ...new StringIterator); + ~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number | symbol'. +!!! error TS2345: Type 'string' is not assignable to type 'symbol'. + + function foo(...s: (symbol | number)[]) { } + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } + + class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall6.js b/tests/baselines/reference/iteratorSpreadInCall6.js new file mode 100644 index 0000000000..87e96d039d --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall6.js @@ -0,0 +1,56 @@ +//// [iteratorSpreadInCall6.ts] +foo(...new SymbolIterator, ...new StringIterator); + +function foo(...s: (symbol | number)[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall6.js] +foo(...new SymbolIterator, ...new StringIterator); +function foo(...s) { +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall7.errors.txt b/tests/baselines/reference/iteratorSpreadInCall7.errors.txt new file mode 100644 index 0000000000..51cae1d72b --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall7.errors.txt @@ -0,0 +1,36 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts(1,1): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. + Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts (1 errors) ==== + foo(...new SymbolIterator, ...new StringIterator); + ~~~ +!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +!!! error TS2453: Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'. + + function foo(...s: T[]) { return s[0]; } + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } + + class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall7.js b/tests/baselines/reference/iteratorSpreadInCall7.js new file mode 100644 index 0000000000..1b7e53ba47 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall7.js @@ -0,0 +1,57 @@ +//// [iteratorSpreadInCall7.ts] +foo(...new SymbolIterator, ...new StringIterator); + +function foo(...s: T[]) { return s[0]; } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall7.js] +foo(...new SymbolIterator, ...new StringIterator); +function foo(...s) { + return s[0]; +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall8.errors.txt b/tests/baselines/reference/iteratorSpreadInCall8.errors.txt new file mode 100644 index 0000000000..d7913458b6 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall8.errors.txt @@ -0,0 +1,39 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts(1,5): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. + Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts (1 errors) ==== + new Foo(...new SymbolIterator, ...new StringIterator); + ~~~ +!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +!!! error TS2453: Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'. + + class Foo { + constructor(...s: T[]) { } + } + + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } + + class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall8.js b/tests/baselines/reference/iteratorSpreadInCall8.js new file mode 100644 index 0000000000..ac22bbcf5a --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall8.js @@ -0,0 +1,61 @@ +//// [iteratorSpreadInCall8.ts] +new Foo(...new SymbolIterator, ...new StringIterator); + +class Foo { + constructor(...s: T[]) { } +} + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall8.js] +new Foo(...new SymbolIterator, ...new StringIterator); +class Foo { + constructor(...s) { + } +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall9.errors.txt b/tests/baselines/reference/iteratorSpreadInCall9.errors.txt new file mode 100644 index 0000000000..da2ee7f8ef --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall9.errors.txt @@ -0,0 +1,39 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts(1,5): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. + Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts (1 errors) ==== + new Foo(...new SymbolIterator, ...[...new StringIterator]); + ~~~ +!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +!!! error TS2453: Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'. + + class Foo { + constructor(...s: T[]) { } + } + + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } + + class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall9.js b/tests/baselines/reference/iteratorSpreadInCall9.js new file mode 100644 index 0000000000..2efd94683c --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall9.js @@ -0,0 +1,63 @@ +//// [iteratorSpreadInCall9.ts] +new Foo(...new SymbolIterator, ...[...new StringIterator]); + +class Foo { + constructor(...s: T[]) { } +} + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall9.js] +new Foo(...new SymbolIterator, ...[ + ...new StringIterator +]); +class Foo { + constructor(...s) { + } +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts new file mode 100644 index 0000000000..85d07e5699 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts @@ -0,0 +1,16 @@ +//@target: ES6 +foo(...new SymbolIterator); + +function foo(s: symbol) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts new file mode 100644 index 0000000000..bf8ad336fb --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts @@ -0,0 +1,17 @@ +//@target: ES6 +foo(...new SymbolIterator); + +function foo(s: T[]) { return s[0] } + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts new file mode 100644 index 0000000000..182e454cfc --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts @@ -0,0 +1,17 @@ +//@target: ES6 +foo(...new SymbolIterator); + +function foo(...s: T[]) { return s[0] } + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts new file mode 100644 index 0000000000..a0bd1ede19 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts @@ -0,0 +1,32 @@ +//@target: ES6 +new Foo(...[...new SymbolIterator, ...[...new StringIterator]]); + +class Foo { + constructor(...s: T[]) { } +} + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts new file mode 100644 index 0000000000..4a8fd9ff38 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts @@ -0,0 +1,16 @@ +//@target: ES6 +foo(...new SymbolIterator); + +function foo(s: symbol[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts new file mode 100644 index 0000000000..b6e8fe0c86 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts @@ -0,0 +1,16 @@ +//@target: ES6 +foo(...new SymbolIterator); + +function foo(...s: symbol[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts new file mode 100644 index 0000000000..2a73fd6f3c --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts @@ -0,0 +1,16 @@ +//@target: ES6 +foo(...new SymbolIterator); + +function foo(s1: symbol, ...s: symbol[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts new file mode 100644 index 0000000000..c17c4156e6 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts @@ -0,0 +1,29 @@ +//@target: ES6 +foo(...new SymbolIterator, ...new StringIterator); + +function foo(...s: (symbol | string)[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts new file mode 100644 index 0000000000..2c6150f804 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts @@ -0,0 +1,29 @@ +//@target: ES6 +foo(...new SymbolIterator, ...new StringIterator); + +function foo(...s: (symbol | number)[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts new file mode 100644 index 0000000000..56fb7936eb --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts @@ -0,0 +1,29 @@ +//@target: ES6 +foo(...new SymbolIterator, ...new StringIterator); + +function foo(...s: T[]) { return s[0]; } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts new file mode 100644 index 0000000000..e5b969456b --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts @@ -0,0 +1,32 @@ +//@target: ES6 +new Foo(...new SymbolIterator, ...new StringIterator); + +class Foo { + constructor(...s: T[]) { } +} + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts new file mode 100644 index 0000000000..470f99844b --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts @@ -0,0 +1,32 @@ +//@target: ES6 +new Foo(...new SymbolIterator, ...[...new StringIterator]); + +class Foo { + constructor(...s: T[]) { } +} + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file