maxmustermann/TypeScript
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Update tests files with more conformance from section 6.4

Browse source
This commit is contained in:
Yui T 2015-04-16 13:35:56 -07:00
parent 2499b3ebd5
commit 614469462a
12 changed files with 1129 additions and 93 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

129
tests/baselines/reference/destructuringParameterDeclaration1.errors.txt
View file

@ -1,53 +1,65 @@
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(7,10): error TS2393: Duplicate function implementation.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(10,10): error TS2393: Duplicate function implementation.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(14,4): error TS2345: Argument of type '(string | number | string[][])[]' is not assignable to parameter of type '{ x: number; a: number; }'.
Property 'x' is missing in type '(string | number | string[][])[]'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(14,29): error TS1005: ',' expected.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(15,4): error TS2345: Argument of type '(string | number | string[][])[]' is not assignable to parameter of type '{ x: number; a: number; }'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(28,8): error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(28,16): error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(35,14): error TS2345: Argument of type '{ x: string; y: boolean; }' is not assignable to parameter of type '{ x: number; y: any; }'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(13,4): error TS2345: Argument of type '[number, string, string[][]]' is not assignable to parameter of type '[number, number, string[][]]'.
Types of property '1' are incompatible.
Type 'string' is not assignable to type 'number'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(13,29): error TS1005: ',' expected.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(14,4): error TS2345: Argument of type '[number, number, string[][], string]' is not assignable to parameter of type '[number, number, string[][]]'.
Types of property 'pop' are incompatible.
Type '() => string | number | string[][]' is not assignable to type '() => number | string[][]'.
Type 'string | number | string[][]' is not assignable to type 'number | string[][]'.
Type 'string' is not assignable to type 'number | string[][]'.
Type 'string' is not assignable to type 'string[][]'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(26,8): error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(26,16): error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(36,14): error TS2345: Argument of type '{ x: string; y: boolean; }' is not assignable to parameter of type '{ x: number; y: any; }'.
Types of property 'x' are incompatible.
Type 'string' is not assignable to type 'number'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(44,14): error TS2300: Duplicate identifier 'z'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(44,18): error TS2300: Duplicate identifier 'z'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(50,4): error TS2345: Argument of type '{ z: number; }' is not assignable to parameter of type '{ z: { x: any; y: { j: any; }; }; }'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(37,4): error TS2345: Argument of type '[string, number, number]' is not assignable to parameter of type '[undefined, null, undefined]'.
Types of property '0' are incompatible.
Type 'string' is not assignable to type 'undefined'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(38,4): error TS2345: Argument of type '[[string], number, [[boolean, boolean]]]' is not assignable to parameter of type '[[undefined], undefined, [[undefined, undefined]]]'.
Types of property '0' are incompatible.
Type '[string]' is not assignable to type '[undefined]'.
Types of property '0' are incompatible.
Type 'string' is not assignable to type 'undefined'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(47,14): error TS2300: Duplicate identifier 'z'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(47,18): error TS2300: Duplicate identifier 'z'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(53,4): error TS2345: Argument of type '{ z: number; }' is not assignable to parameter of type '{ z: { x: any; y: { j: any; }; }; }'.
Types of property 'z' are incompatible.
Type 'number' is not assignable to type '{ x: any; y: { j: any; }; }'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(52,4): error TS2345: Argument of type '{}' is not assignable to parameter of type '{ z: number; }'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(55,4): error TS2345: Argument of type '{}' is not assignable to parameter of type '{ z: number; }'.
Property 'z' is missing in type '{}'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(53,4): error TS2345: Argument of type '{ z: boolean; }' is not assignable to parameter of type '{ z: number; }'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(56,4): error TS2345: Argument of type '{ z: boolean; }' is not assignable to parameter of type '{ z: number; }'.
Types of property 'z' are incompatible.
Type 'boolean' is not assignable to type 'number'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(59,4): error TS2345: Argument of type '{ z: boolean; }' is not assignable to parameter of type '{ z?: number; }'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(62,4): error TS2345: Argument of type '{ z: boolean; }' is not assignable to parameter of type '{ z?: number; }'.
Types of property 'z' are incompatible.
Type 'boolean' is not assignable to type 'number'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(62,4): error TS2345: Argument of type '{ b: boolean; }' is not assignable to parameter of type '{ b: string | number; }'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(65,4): error TS2345: Argument of type '{ b: boolean; }' is not assignable to parameter of type '{ b: string | number; }'.
Types of property 'b' are incompatible.
Type 'boolean' is not assignable to type 'string | number'.
Type 'boolean' is not assignable to type 'number'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(66,4): error TS2345: Argument of type '[number, number, boolean, boolean]' is not assignable to parameter of type '[any, any, [[any]]]'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(69,4): error TS2345: Argument of type '[number, number, boolean, boolean]' is not assignable to parameter of type '[any, any, [[any]]]'.
Types of property '2' are incompatible.
Type 'boolean' is not assignable to type '[[any]]'.
Property '0' is missing in type 'Boolean'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(68,4): error TS2345: Argument of type '[number, number, [[string]]]' is not assignable to parameter of type '[any, any, [[number]]]'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(71,4): error TS2345: Argument of type '[number, number, [[string]]]' is not assignable to parameter of type '[any, any, [[number]]]'.
Types of property '2' are incompatible.
Type '[[string]]' is not assignable to type '[[number]]'.
Types of property '0' are incompatible.
Type '[string]' is not assignable to type '[number]'.
Types of property '0' are incompatible.
Type 'string' is not assignable to type 'number'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(73,10): error TS2393: Duplicate function implementation.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(74,10): error TS2393: Duplicate function implementation.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(75,13): error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(76,13): error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(97,7): error TS2420: Class 'C4' incorrectly implements interface 'F2'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(76,10): error TS2393: Duplicate function implementation.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(77,10): error TS2393: Duplicate function implementation.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(78,13): error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(79,13): error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(100,7): error TS2420: Class 'C4' incorrectly implements interface 'F2'.
Types of property 'd4' are incompatible.
Type '({x, y, c}: { x: any; y: any; c: any; }) => void' is not assignable to type '({x, y, z}?: { x: any; y: any; z: any; }) => any'.
Types of parameters '__0' and '__0' are incompatible.
Type '{ x: any; y: any; c: any; }' is not assignable to type '{ x: any; y: any; z: any; }'.
Property 'z' is missing in type '{ x: any; y: any; c: any; }'.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(98,8): error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(101,8): error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
==== tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts (23 errors) ====
@ -56,55 +68,70 @@ tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(
// in a parameter list must be unique within that parameter list.
// If the declaration includes a type annotation, the parameter is of that type
function a0(x: number, y: string, z: boolean) { }
function a1([a, b, [[c]]]: [number, number, string[][]]) { }
~~
!!! error TS2393: Duplicate function implementation.
function a2(o: { x: number, a: number }) { }
function a3({j, k, l: {m, n}, q: [a, b, c]}: { j: number, k: string, l: { m: boolean, n: number }, q: (number|string)[] }) { };
function a1({x, a}: { x: number, a: number }) { }
~~
!!! error TS2393: Duplicate function implementation.
function a4({x, a}: { x: number, a: number }) { }
a1([1, 2, [["world"]]]);
a1([1, 2, [["world"]], 3]);
a1([1, "string", [["world"]]); // Error
~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2345: Argument of type '(string | number | string[][])[]' is not assignable to parameter of type '{ x: number; a: number; }'.
!!! error TS2345: Property 'x' is missing in type '(string | number | string[][])[]'.
!!! error TS2345: Argument of type '[number, string, string[][]]' is not assignable to parameter of type '[number, number, string[][]]'.
!!! error TS2345: Types of property '1' are incompatible.
!!! error TS2345: Type 'string' is not assignable to type 'number'.
~
!!! error TS1005: ',' expected.
a1([1, 2, [["world"]], "string"]); // Error
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2345: Argument of type '(string | number | string[][])[]' is not assignable to parameter of type '{ x: number; a: number; }'.
!!! error TS2345: Argument of type '[number, number, string[][], string]' is not assignable to parameter of type '[number, number, string[][]]'.
!!! error TS2345: Types of property 'pop' are incompatible.
!!! error TS2345: Type '() => string | number | string[][]' is not assignable to type '() => number | string[][]'.
!!! error TS2345: Type 'string | number | string[][]' is not assignable to type 'number | string[][]'.
!!! error TS2345: Type 'string' is not assignable to type 'number | string[][]'.
!!! error TS2345: Type 'string' is not assignable to type 'string[][]'.
// If the declaration includes an initializer expression (which is permitted only
// when the parameter list occurs in conjunction with a function body),
// the parameter type is the widened form (section 3.11) of the type of the initializer expression.
function b1(z = 10, y = 60, u = () => true) { }
function b2(z = [undefined, null]) { };
function b3(z = null, o = { x: 0, y: undefined }) { }
function b4({z: {x, y: {j}}} = { z: { x: "hi", y: { j: 1 } } }) { }
function b1(z = [undefined, null]) { };
function b2(z = null, o = { x: 0, y: undefined }) { }
function b3({z: {x, y: {j}}} = { z: { x: "hi", y: { j: 1 } } }) { }
interface F1 {
b5(z = 10, [[a, b], d, {u}] = [[1, 2], "string", { u: false }]); // Error, no function body
b4(z = 10, [[a, b], d, {u}] = [[1, 2], "string", { u: false }]); // Error, no function body
~~~~~~
!!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
b6(z, y, [, a, b], {p, m: { q, r}});
b5(z, y, [, a, b], {p, m: { q, r}});
}
b2([1, 2, 3]); // z is widen to the type any[]
b3("string", { x: 200, y: "string" });
b3("string", { x: 200, y: true });
b3("string", { x: "string", y: true }); // Error
function b6([a, z, y] = [undefined, null, undefined]) { }
function b7([[a], b, [[c, d]]] = [[undefined], undefined, [[undefined, undefined]]]) { }
b1([1, 2, 3]); // z is widen to the type any[]
b2("string", { x: 200, y: "string" });
b2("string", { x: 200, y: true });
b2("string", { x: "string", y: true }); // Error
~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2345: Argument of type '{ x: string; y: boolean; }' is not assignable to parameter of type '{ x: number; y: any; }'.
!!! error TS2345: Types of property 'x' are incompatible.
!!! error TS2345: Type 'string' is not assignable to type 'number'.
b6(["string", 1, 2]); // Shouldn't be an error
~~~~~~~~~~~~~~~~
!!! error TS2345: Argument of type '[string, number, number]' is not assignable to parameter of type '[undefined, null, undefined]'.
!!! error TS2345: Types of property '0' are incompatible.
!!! error TS2345: Type 'string' is not assignable to type 'undefined'.
b7([["string"], 1, [[true, false]]]); // Shouldn't be an error
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2345: Argument of type '[[string], number, [[boolean, boolean]]]' is not assignable to parameter of type '[[undefined], undefined, [[undefined, undefined]]]'.
!!! error TS2345: Types of property '0' are incompatible.
!!! error TS2345: Type '[string]' is not assignable to type '[undefined]'.
!!! error TS2345: Types of property '0' are incompatible.
!!! error TS2345: Type 'string' is not assignable to type 'undefined'.
// If the declaration specifies a binding pattern, the parameter type is the implied type of that binding pattern (section 5.1.3)
@ -185,10 +212,10 @@ tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(
function d0(x = 10) { }
~~
!!! error TS2393: Duplicate function implementation.
function d1([a, b, c]?) { }
function d1([a, b, c]?) { } // Error, binding pattern can't be optional in implementation signature
~~~~~~~~~~
!!! error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
function d2({x, y, z}?) { }
function d2({x, y, z}?) { } // Error, binding pattern can't be optional in implementation signature
~~~~~~~~~~
!!! error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
@ -229,5 +256,17 @@ tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts(
function d5({x, y} = { x: 1, y: 2 }) { }
d5(); // Parameter is optional as its declaration included an initializer
// Destructuring parameter declarations do not permit type annotations on the individual binding patterns,
// as such annotations would conflict with the already established meaning of colons in object literals.
// Type annotations must instead be written on the top- level parameter declaration
function e1({x: number}) { } // x has type any NOT number
function e2({x}: { x: number }) { } // x is type number
function e3({x}: { x?: number }) { } // x is an optional with type number
function e4({x: [number,string,any] }) { } // x has type [any, any, any]
function e5({x: [a, b, c]}: { x: [number, number, number] }) { } // x has type [any, any, any]
function e6({x: [number, number, number]}) { } // should be an error, duplicate identifier;

98
tests/baselines/reference/destructuringParameterDeclaration1.js
View file

@ -4,11 +4,10 @@
// in a parameter list must be unique within that parameter list.
// If the declaration includes a type annotation, the parameter is of that type
function a0(x: number, y: string, z: boolean) { }
function a1([a, b, [[c]]]: [number, number, string[][]]) { }
function a2(o: { x: number, a: number }) { }
function a3({j, k, l: {m, n}, q: [a, b, c]}: { j: number, k: string, l: { m: boolean, n: number }, q: (number|string)[] }) { };
function a1({x, a}: { x: number, a: number }) { }
function a4({x, a}: { x: number, a: number }) { }
a1([1, 2, [["world"]]]);
a1([1, 2, [["world"]], 3]);
@ -20,20 +19,24 @@ a1([1, 2, [["world"]], "string"]); // Error
// when the parameter list occurs in conjunction with a function body),
// the parameter type is the widened form (section 3.11) of the type of the initializer expression.
function b1(z = 10, y = 60, u = () => true) { }
function b2(z = [undefined, null]) { };
function b3(z = null, o = { x: 0, y: undefined }) { }
function b4({z: {x, y: {j}}} = { z: { x: "hi", y: { j: 1 } } }) { }
function b1(z = [undefined, null]) { };
function b2(z = null, o = { x: 0, y: undefined }) { }
function b3({z: {x, y: {j}}} = { z: { x: "hi", y: { j: 1 } } }) { }
interface F1 {
b5(z = 10, [[a, b], d, {u}] = [[1, 2], "string", { u: false }]); // Error, no function body
b6(z, y, [, a, b], {p, m: { q, r}});
b4(z = 10, [[a, b], d, {u}] = [[1, 2], "string", { u: false }]); // Error, no function body
b5(z, y, [, a, b], {p, m: { q, r}});
}
b2([1, 2, 3]); // z is widen to the type any[]
b3("string", { x: 200, y: "string" });
b3("string", { x: 200, y: true });
b3("string", { x: "string", y: true }); // Error
function b6([a, z, y] = [undefined, null, undefined]) { }
function b7([[a], b, [[c, d]]] = [[undefined], undefined, [[undefined, undefined]]]) { }
b1([1, 2, 3]); // z is widen to the type any[]
b2("string", { x: 200, y: "string" });
b2("string", { x: 200, y: true });
b2("string", { x: "string", y: true }); // Error
b6(["string", 1, 2]); // Shouldn't be an error
b7([["string"], 1, [[true, false]]]); // Shouldn't be an error
// If the declaration specifies a binding pattern, the parameter type is the implied type of that binding pattern (section 5.1.3)
@ -73,8 +76,8 @@ c6([1, 2, [["string"]]]); // Error, implied type is [any, any, [[number]]] //
function d0(x?) { }
function d0(x = 10) { }
function d1([a, b, c]?) { }
function d2({x, y, z}?) { }
function d1([a, b, c]?) { } // Error, binding pattern can't be optional in implementation signature
function d2({x, y, z}?) { } // Error, binding pattern can't be optional in implementation signature
interface F2 {
d3([a, b, c]?);
@ -104,6 +107,18 @@ class C4 implements F2 {
function d5({x, y} = { x: 1, y: 2 }) { }
d5(); // Parameter is optional as its declaration included an initializer
// Destructuring parameter declarations do not permit type annotations on the individual binding patterns,
// as such annotations would conflict with the already established meaning of colons in object literals.
// Type annotations must instead be written on the top- level parameter declaration
function e1({x: number}) { } // x has type any NOT number
function e2({x}: { x: number }) { } // x is type number
function e3({x}: { x?: number }) { } // x is an optional with type number
function e4({x: [number,string,any] }) { } // x has type [any, any, any]
function e5({x: [a, b, c]}: { x: [number, number, number] }) { } // x has type [any, any, any]
function e6({x: [number, number, number]}) { } // should be an error, duplicate identifier;
@ -112,7 +127,6 @@ d5(); // Parameter is optional as its declaration included an initializer
// The identifiers specified in parameter declarations and binding patterns
// in a parameter list must be unique within that parameter list.
// If the declaration includes a type annotation, the parameter is of that type
function a0(x, y, z) { }
function a1(_a) {
var a = _a[0], b = _a[1], c = _a[2][0][0];
}
@ -121,7 +135,7 @@ function a3(_a) {
var j = _a.j, k = _a.k, _b = _a.l, m = _b.m, n = _b.n, _c = _a.q, a = _c[0], b = _c[1], c = _c[2];
}
;
function a1(_a) {
function a4(_a) {
var x = _a.x, a = _a.a;
}
a1([1, 2, [["world"]]]);
@ -131,26 +145,29 @@ a1([1, 2, [["world"]], "string"]); // Error
// If the declaration includes an initializer expression (which is permitted only
// when the parameter list occurs in conjunction with a function body),
// the parameter type is the widened form (section 3.11) of the type of the initializer expression.
function b1(z, y, u) {
if (z === void 0) { z = 10; }
if (y === void 0) { y = 60; }
if (u === void 0) { u = function () { return true; }; }
}
function b2(z) {
function b1(z) {
if (z === void 0) { z = [undefined, null]; }
}
;
function b3(z, o) {
function b2(z, o) {
if (z === void 0) { z = null; }
if (o === void 0) { o = { x: 0, y: undefined }; }
}
function b4(_a) {
function b3(_a) {
var _b = (_a === void 0 ? { z: { x: "hi", y: { j: 1 } } } : _a).z, x = _b.x, j = _b.y.j;
}
b2([1, 2, 3]); // z is widen to the type any[]
b3("string", { x: 200, y: "string" });
b3("string", { x: 200, y: true });
b3("string", { x: "string", y: true }); // Error
function b6(_a) {
var _b = _a === void 0 ? [undefined, null, undefined] : _a, a = _b[0], z = _b[1], y = _b[2];
}
function b7(_a) {
var _b = _a === void 0 ? [[undefined], undefined, [[undefined, undefined]]] : _a, a = _b[0][0], b = _b[1], _c = _b[2][0], c = _c[0], d = _c[1];
}
b1([1, 2, 3]); // z is widen to the type any[]
b2("string", { x: 200, y: "string" });
b2("string", { x: 200, y: true });
b2("string", { x: "string", y: true }); // Error
b6(["string", 1, 2]); // Shouldn't be an error
b7([["string"], 1, [[true, false]]]); // Shouldn't be an error
// If the declaration specifies a binding pattern, the parameter type is the implied type of that binding pattern (section 5.1.3)
var Foo;
(function (Foo) {
@ -201,10 +218,10 @@ function d0(x) {
}
function d1(_a) {
var a = _a[0], b = _a[1], c = _a[2];
}
} // Error, binding pattern can't be optional in implementation signature
function d2(_a) {
var x = _a.x, y = _a.y, z = _a.z;
}
} // Error, binding pattern can't be optional in implementation signature
var C2 = (function () {
function C2() {
}
@ -247,3 +264,24 @@ function d5(_a) {
var _b = _a === void 0 ? { x: 1, y: 2 } : _a, x = _b.x, y = _b.y;
}
d5(); // Parameter is optional as its declaration included an initializer
// Destructuring parameter declarations do not permit type annotations on the individual binding patterns,
// as such annotations would conflict with the already established meaning of colons in object literals.
// Type annotations must instead be written on the top- level parameter declaration
function e1(_a) {
var number = _a.x;
} // x has type any NOT number
function e2(_a) {
var x = _a.x;
} // x is type number
function e3(_a) {
var x = _a.x;
} // x is an optional with type number
function e4(_a) {
var _b = _a.x, number = _b[0], string = _b[1], any = _b[2];
} // x has type [any, any, any]
function e5(_a) {
var _b = _a.x, a = _b[0], b = _b[1], c = _b[2];
} // x has type [any, any, any]
function e6(_a) {
var _b = _a.x, number = _b[0], number = _b[1], number = _b[2];
} // should be an error, duplicate identifier;

169
tests/baselines/reference/destructuringParameterDeclaration1ES6.js Normal file
View file

@ -0,0 +1,169 @@
//// [destructuringParameterDeclaration1ES6.ts]
// Conformance for emitting ES6
// A parameter declaration may specify either an identifier or a binding pattern.
// The identifiers specified in parameter declarations and binding patterns
// in a parameter list must be unique within that parameter list.
// If the declaration includes a type annotation, the parameter is of that type
function a1([a, b, [[c]]]: [number, number, string[][]]) { }
function a2(o: { x: number, a: number }) { }
function a3({j, k, l: {m, n}, q: [a, b, c]}: { j: number, k: string, l: { m: boolean, n: number }, q: (number|string)[] }) { };
function a4({x, a}: { x: number, a: number }) { }
a1([1, 2, [["world"]]]);
a1([1, 2, [["world"]], 3]);
// If the declaration includes an initializer expression (which is permitted only
// when the parameter list occurs in conjunction with a function body),
// the parameter type is the widened form (section 3.11) of the type of the initializer expression.
function b1(z = [undefined, null]) { };
function b2(z = null, o = { x: 0, y: undefined }) { }
function b3({z: {x, y: {j}}} = { z: { x: "hi", y: { j: 1 } } }) { }
interface F1 {
b5(z, y, [, a, b], {p, m: { q, r}});
}
function b6([a, z, y] = [undefined, null, undefined]) { }
function b7([[a], b, [[c, d]]] = [[undefined], undefined, [[undefined, undefined]]]) { }
b1([1, 2, 3]); // z is widen to the type any[]
b2("string", { x: 200, y: "string" });
b2("string", { x: 200, y: true });
// If the declaration specifies a binding pattern, the parameter type is the implied type of that binding pattern (section 5.1.3)
enum Foo { a }
function c0({z: {x, y: {j}}}) { }
function c1({z} = { z: 10 }) { }
function c2({z = 10}) { }
function c3({b}: { b: number|string} = { b: "hello" }) { }
function c5([a, b, [[c]]]) { }
function c6([a, b, [[c=1]]]) { }
c0({z : { x: 1, y: { j: "world" } }}); // Implied type is { z: {x: any, y: {j: any}} }
c0({z : { x: "string", y: { j: true } }}); // Implied type is { z: {x: any, y: {j: any}} }
c1(); // Implied type is {z:number}?
c1({ z: 1 }) // Implied type is {z:number}?
c2({}); // Implied type is {z?: number}
c2({z:1}); // Implied type is {z?: number}
c3({ b: 1 }); // Implied type is { b: number|string }.
c5([1, 2, [["string"]]]); // Implied type is is [any, any, [[any]]]
c5([1, 2, [["string"]], false, true]); // Implied type is is [any, any, [[any]]]
// A parameter can be marked optional by following its name or binding pattern with a question mark (?)
// or by including an initializer.
interface F2 {
d3([a, b, c]?);
d4({x, y, z}?);
e0([a, b, c]);
}
class C2 implements F2 {
constructor() { }
d3() { }
d4() { }
e0([a, b, c]) { }
}
class C3 implements F2 {
d3([a, b, c]) { }
d4({x, y, z}) { }
e0([a, b, c]) { }
}
function d5({x, y} = { x: 1, y: 2 }) { }
d5(); // Parameter is optional as its declaration included an initializer
// Destructuring parameter declarations do not permit type annotations on the individual binding patterns,
// as such annotations would conflict with the already established meaning of colons in object literals.
// Type annotations must instead be written on the top- level parameter declaration
function e1({x: number}) { } // x has type any NOT number
function e2({x}: { x: number }) { } // x is type number
function e3({x}: { x?: number }) { } // x is an optional with type number
function e4({x: [number,string,any] }) { } // x has type [any, any, any]
function e5({x: [a, b, c]}: { x: [number, number, number] }) { } // x has type [any, any, any]
function e6({x: [number, number, number]}) { } // should be an error, duplicate identifier;
//// [destructuringParameterDeclaration1ES6.js]
// Conformance for emitting ES6
// A parameter declaration may specify either an identifier or a binding pattern.
// The identifiers specified in parameter declarations and binding patterns
// in a parameter list must be unique within that parameter list.
// If the declaration includes a type annotation, the parameter is of that type
function a1([a, b, [[c]]]) { }
function a2(o) { }
function a3({ j, k, l: { m, n }, q: [a, b, c] }) { }
;
function a4({ x, a }) { }
a1([1, 2, [["world"]]]);
a1([1, 2, [["world"]], 3]);
// If the declaration includes an initializer expression (which is permitted only
// when the parameter list occurs in conjunction with a function body),
// the parameter type is the widened form (section 3.11) of the type of the initializer expression.
function b1(z = [undefined, null]) { }
;
function b2(z = null, o = { x: 0, y: undefined }) { }
function b3({ z: { x, y: { j } } } = { z: { x: "hi", y: { j: 1 } } }) { }
function b6([a, z, y] = [undefined, null, undefined]) { }
function b7([[a], b, [[c, d]]] = [[undefined], undefined, [[undefined, undefined]]]) { }
b1([1, 2, 3]); // z is widen to the type any[]
b2("string", { x: 200, y: "string" });
b2("string", { x: 200, y: true });
// If the declaration specifies a binding pattern, the parameter type is the implied type of that binding pattern (section 5.1.3)
var Foo;
(function (Foo) {
Foo[Foo["a"] = 0] = "a";
})(Foo || (Foo = {}));
function c0({ z: { x, y: { j } } }) { }
function c1({ z } = { z: 10 }) { }
function c2({ z = 10 }) { }
function c3({ b } = { b: "hello" }) { }
function c5([a, b, [[c]]]) { }
function c6([a, b, [[c = 1]]]) { }
c0({ z: { x: 1, y: { j: "world" } } }); // Implied type is { z: {x: any, y: {j: any}} }
c0({ z: { x: "string", y: { j: true } } }); // Implied type is { z: {x: any, y: {j: any}} }
c1(); // Implied type is {z:number}?
c1({ z: 1 }); // Implied type is {z:number}?
c2({}); // Implied type is {z?: number}
c2({ z: 1 }); // Implied type is {z?: number}
c3({ b: 1 }); // Implied type is { b: number|string }.
c5([1, 2, [["string"]]]); // Implied type is is [any, any, [[any]]]
c5([1, 2, [["string"]], false, true]); // Implied type is is [any, any, [[any]]]
class C2 {
constructor() {
}
d3() { }
d4() { }
e0([a, b, c]) { }
}
class C3 {
d3([a, b, c]) { }
d4({ x, y, z }) { }
e0([a, b, c]) { }
}
function d5({ x, y } = { x: 1, y: 2 }) { }
d5(); // Parameter is optional as its declaration included an initializer
// Destructuring parameter declarations do not permit type annotations on the individual binding patterns,
// as such annotations would conflict with the already established meaning of colons in object literals.
// Type annotations must instead be written on the top- level parameter declaration
function e1({ x: number }) { } // x has type any NOT number
function e2({ x }) { } // x is type number
function e3({ x }) { } // x is an optional with type number
function e4({ x: [number, string, any] }) { } // x has type [any, any, any]
function e5({ x: [a, b, c] }) { } // x has type [any, any, any]
function e6({ x: [number, number, number] }) { } // should be an error, duplicate identifier;

378
tests/baselines/reference/destructuringParameterDeclaration1ES6.types Normal file
View file

@ -0,0 +1,378 @@
=== tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1ES6.ts ===
// Conformance for emitting ES6
// A parameter declaration may specify either an identifier or a binding pattern.
// The identifiers specified in parameter declarations and binding patterns
// in a parameter list must be unique within that parameter list.
// If the declaration includes a type annotation, the parameter is of that type
function a1([a, b, [[c]]]: [number, number, string[][]]) { }
>a1 : ([a, b, [[c]]]: [number, number, string[][]]) => void
>a : number
>b : number
>c : string
function a2(o: { x: number, a: number }) { }
>a2 : (o: { x: number; a: number; }) => void
>o : { x: number; a: number; }
>x : number
>a : number
function a3({j, k, l: {m, n}, q: [a, b, c]}: { j: number, k: string, l: { m: boolean, n: number }, q: (number|string)[] }) { };
>a3 : ({j, k, l: {m, n}, q: [a, b, c]}: { j: number; k: string; l: { m: boolean; n: number; }; q: (string | number)[]; }) => void
>j : number
>k : string
>l : unknown
>m : boolean
>n : number
>q : unknown
>a : string | number
>b : string | number
>c : string | number
>j : number
>k : string
>l : { m: boolean; n: number; }
>m : boolean
>n : number
>q : (string | number)[]
function a4({x, a}: { x: number, a: number }) { }
>a4 : ({x, a}: { x: number; a: number; }) => void
>x : number
>a : number
>x : number
>a : number
a1([1, 2, [["world"]]]);
>a1([1, 2, [["world"]]]) : void
>a1 : ([a, b, [[c]]]: [number, number, string[][]]) => void
>[1, 2, [["world"]]] : [number, number, string[][]]
>[["world"]] : string[][]
>["world"] : string[]
a1([1, 2, [["world"]], 3]);
>a1([1, 2, [["world"]], 3]) : void
>a1 : ([a, b, [[c]]]: [number, number, string[][]]) => void
>[1, 2, [["world"]], 3] : [number, number, string[][], number]
>[["world"]] : string[][]
>["world"] : string[]
// If the declaration includes an initializer expression (which is permitted only
// when the parameter list occurs in conjunction with a function body),
// the parameter type is the widened form (section 3.11) of the type of the initializer expression.
function b1(z = [undefined, null]) { };
>b1 : (z?: any[]) => void
>z : any[]
>[undefined, null] : null[]
>undefined : undefined
function b2(z = null, o = { x: 0, y: undefined }) { }
>b2 : (z?: any, o?: { x: number; y: any; }) => void
>z : any
>o : { x: number; y: any; }
>{ x: 0, y: undefined } : { x: number; y: undefined; }
>x : number
>y : undefined
>undefined : undefined
function b3({z: {x, y: {j}}} = { z: { x: "hi", y: { j: 1 } } }) { }
>b3 : ({z: {x, y: {j}}}?: { z: { x: string; y: { j: number; }; }; }) => void
>z : unknown
>x : string
>y : unknown
>j : number
>{ z: { x: "hi", y: { j: 1 } } } : { z: { x: string; y: { j: number; }; }; }
>z : { x: string; y: { j: number; }; }
>{ x: "hi", y: { j: 1 } } : { x: string; y: { j: number; }; }
>x : string
>y : { j: number; }
>{ j: 1 } : { j: number; }
>j : number
interface F1 {
>F1 : F1
b5(z, y, [, a, b], {p, m: { q, r}});
>b5 : (z: any, y: any, [, a, b]: [any, any, any], {p, m: { q, r}}: { p: any; m: { q: any; r: any; }; }) => any
>z : any
>y : any
>a : any
>b : any
>p : any
>m : unknown
>q : any
>r : any
}
function b6([a, z, y] = [undefined, null, undefined]) { }
>b6 : ([a, z, y]?: [undefined, null, undefined]) => void
>a : any
>z : any
>y : any
>[undefined, null, undefined] : [undefined, null, undefined]
>undefined : undefined
>undefined : undefined
function b7([[a], b, [[c, d]]] = [[undefined], undefined, [[undefined, undefined]]]) { }
>b7 : ([[a], b, [[c, d]]]?: [[undefined], undefined, [[undefined, undefined]]]) => void
>a : any
>b : any
>c : any
>d : any
>[[undefined], undefined, [[undefined, undefined]]] : [[undefined], undefined, [[undefined, undefined]]]
>[undefined] : [undefined]
>undefined : undefined
>undefined : undefined
>[[undefined, undefined]] : [[undefined, undefined]]
>[undefined, undefined] : [undefined, undefined]
>undefined : undefined
>undefined : undefined
b1([1, 2, 3]); // z is widen to the type any[]
>b1([1, 2, 3]) : void
>b1 : (z?: any[]) => void
>[1, 2, 3] : number[]
b2("string", { x: 200, y: "string" });
>b2("string", { x: 200, y: "string" }) : void
>b2 : (z?: any, o?: { x: number; y: any; }) => void
>{ x: 200, y: "string" } : { x: number; y: string; }
>x : number
>y : string
b2("string", { x: 200, y: true });
>b2("string", { x: 200, y: true }) : void
>b2 : (z?: any, o?: { x: number; y: any; }) => void
>{ x: 200, y: true } : { x: number; y: boolean; }
>x : number
>y : boolean
// If the declaration specifies a binding pattern, the parameter type is the implied type of that binding pattern (section 5.1.3)
enum Foo { a }
>Foo : Foo
>a : Foo
function c0({z: {x, y: {j}}}) { }
>c0 : ({z: {x, y: {j}}}: { z: { x: any; y: { j: any; }; }; }) => void
>z : unknown
>x : any
>y : unknown
>j : any
function c1({z} = { z: 10 }) { }
>c1 : ({z}?: { z: number; }) => void
>z : number
>{ z: 10 } : { z: number; }
>z : number
function c2({z = 10}) { }
>c2 : ({z = 10}: { z?: number; }) => void
>z : number
function c3({b}: { b: number|string} = { b: "hello" }) { }
>c3 : ({b}?: { b: string | number; }) => void
>b : string | number
>b : string | number
>{ b: "hello" } : { b: string; }
>b : string
function c5([a, b, [[c]]]) { }
>c5 : ([a, b, [[c]]]: [any, any, [[any]]]) => void
>a : any
>b : any
>c : any
function c6([a, b, [[c=1]]]) { }
>c6 : ([a, b, [[c=1]]]: [any, any, [[number]]]) => void
>a : any
>b : any
>c : number
c0({z : { x: 1, y: { j: "world" } }}); // Implied type is { z: {x: any, y: {j: any}} }
>c0({z : { x: 1, y: { j: "world" } }}) : void
>c0 : ({z: {x, y: {j}}}: { z: { x: any; y: { j: any; }; }; }) => void
>{z : { x: 1, y: { j: "world" } }} : { z: { x: number; y: { j: string; }; }; }
>z : { x: number; y: { j: string; }; }
>{ x: 1, y: { j: "world" } } : { x: number; y: { j: string; }; }
>x : number
>y : { j: string; }
>{ j: "world" } : { j: string; }
>j : string
c0({z : { x: "string", y: { j: true } }}); // Implied type is { z: {x: any, y: {j: any}} }
>c0({z : { x: "string", y: { j: true } }}) : void
>c0 : ({z: {x, y: {j}}}: { z: { x: any; y: { j: any; }; }; }) => void
>{z : { x: "string", y: { j: true } }} : { z: { x: string; y: { j: boolean; }; }; }
>z : { x: string; y: { j: boolean; }; }
>{ x: "string", y: { j: true } } : { x: string; y: { j: boolean; }; }
>x : string
>y : { j: boolean; }
>{ j: true } : { j: boolean; }
>j : boolean
c1(); // Implied type is {z:number}?
>c1() : void
>c1 : ({z}?: { z: number; }) => void
c1({ z: 1 }) // Implied type is {z:number}?
>c1({ z: 1 }) : void
>c1 : ({z}?: { z: number; }) => void
>{ z: 1 } : { z: number; }
>z : number
c2({}); // Implied type is {z?: number}
>c2({}) : void
>c2 : ({z = 10}: { z?: number; }) => void
>{} : {}
c2({z:1}); // Implied type is {z?: number}
>c2({z:1}) : void
>c2 : ({z = 10}: { z?: number; }) => void
>{z:1} : { z: number; }
>z : number
c3({ b: 1 }); // Implied type is { b: number|string }.
>c3({ b: 1 }) : void
>c3 : ({b}?: { b: string | number; }) => void
>{ b: 1 } : { b: number; }
>b : number
c5([1, 2, [["string"]]]); // Implied type is is [any, any, [[any]]]
>c5([1, 2, [["string"]]]) : void
>c5 : ([a, b, [[c]]]: [any, any, [[any]]]) => void
>[1, 2, [["string"]]] : [number, number, [[string]]]
>[["string"]] : [[string]]
>["string"] : [string]
c5([1, 2, [["string"]], false, true]); // Implied type is is [any, any, [[any]]]
>c5([1, 2, [["string"]], false, true]) : void
>c5 : ([a, b, [[c]]]: [any, any, [[any]]]) => void
>[1, 2, [["string"]], false, true] : [number, number, [[string]], boolean, boolean]
>[["string"]] : [[string]]
>["string"] : [string]
// A parameter can be marked optional by following its name or binding pattern with a question mark (?)
// or by including an initializer.
interface F2 {
>F2 : F2
d3([a, b, c]?);
>d3 : ([a, b, c]?: [any, any, any]) => any
>a : any
>b : any
>c : any
d4({x, y, z}?);
>d4 : ({x, y, z}?: { x: any; y: any; z: any; }) => any
>x : any
>y : any
>z : any
e0([a, b, c]);
>e0 : ([a, b, c]: [any, any, any]) => any
>a : any
>b : any
>c : any
}
class C2 implements F2 {
>C2 : C2
>F2 : F2
constructor() { }
d3() { }
>d3 : () => void
d4() { }
>d4 : () => void
e0([a, b, c]) { }
>e0 : ([a, b, c]: [any, any, any]) => void
>a : any
>b : any
>c : any
}
class C3 implements F2 {
>C3 : C3
>F2 : F2
d3([a, b, c]) { }
>d3 : ([a, b, c]: [any, any, any]) => void
>a : any
>b : any
>c : any
d4({x, y, z}) { }
>d4 : ({x, y, z}: { x: any; y: any; z: any; }) => void
>x : any
>y : any
>z : any
e0([a, b, c]) { }
>e0 : ([a, b, c]: [any, any, any]) => void
>a : any
>b : any
>c : any
}
function d5({x, y} = { x: 1, y: 2 }) { }
>d5 : ({x, y}?: { x: number; y: number; }) => void
>x : number
>y : number
>{ x: 1, y: 2 } : { x: number; y: number; }
>x : number
>y : number
d5(); // Parameter is optional as its declaration included an initializer
>d5() : void
>d5 : ({x, y}?: { x: number; y: number; }) => void
// Destructuring parameter declarations do not permit type annotations on the individual binding patterns,
// as such annotations would conflict with the already established meaning of colons in object literals.
// Type annotations must instead be written on the top- level parameter declaration
function e1({x: number}) { } // x has type any NOT number
>e1 : ({x: number}: { x: any; }) => void
>x : unknown
>number : any
function e2({x}: { x: number }) { } // x is type number
>e2 : ({x}: { x: number; }) => void
>x : number
>x : number
function e3({x}: { x?: number }) { } // x is an optional with type number
>e3 : ({x}: { x?: number; }) => void
>x : number
>x : number
function e4({x: [number,string,any] }) { } // x has type [any, any, any]
>e4 : ({x: [number,string,any] }: { x: [any, any, any]; }) => void
>x : unknown
>number : any
>string : any
>any : any
function e5({x: [a, b, c]}: { x: [number, number, number] }) { } // x has type [any, any, any]
>e5 : ({x: [a, b, c]}: { x: [number, number, number]; }) => void
>x : unknown
>a : number
>b : number
>c : number
>x : [number, number, number]
function e6({x: [number, number, number]}) { } // should be an error, duplicate identifier;
>e6 : ({x: [number, number, number]}: { x: [any, any, any]; }) => void
>x : unknown
>number : any
>number : any
>number : any

2
tests/baselines/reference/destructuringParameterDeclaration2.errors.txt
View file

@ -89,7 +89,7 @@ tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(
class C {
constructor(public ...a) { } // Rest parameter can't have accessibilityModifier
constructor(public ...a) { } // Error, rest parameter can't have accessibilityModifier
~~~
!!! error TS1005: ',' expected.
}

4
tests/baselines/reference/destructuringParameterDeclaration2.js
View file

@ -43,7 +43,7 @@ a11([1, 2, "string"]); // Error, parameter type is number[]
class C {
constructor(public ...a) { } // Rest parameter can't have accessibilityModifier
constructor(public ...a) { } // Error, rest parameter can't have accessibilityModifier
}
// Rest parameter with generic
@ -149,7 +149,7 @@ var C = (function () {
for (var _i = 1; _i < arguments.length; _i++) {
a[_i - 1] = arguments[_i];
}
} // Rest parameter can't have accessibilityModifier
} // Error, rest parameter can't have accessibilityModifier
return C;
})();
// Rest parameter with generic

81
tests/baselines/reference/destructuringParameterDeclaration2ES6.js Normal file
View file

@ -0,0 +1,81 @@
//// [destructuringParameterDeclaration2ES6.ts]
// If the parameter is a rest parameter, the parameter type is any[]
// A type annotation for a rest parameter must denote an array type.
// RestParameter:
// ... Identifier TypeAnnotation(opt)
type arrayString = Array<String>
type someArray = Array<String> | number[];
type stringOrNumArray = Array<String|Number>;
function a1(...x: (number|string)[]) { }
function a2(...a) { }
function a3(...a: Array<String>) { }
function a4(...a: arrayString) { }
function a5(...a: stringOrNumArray) { }
function a9([a, b, [[c]]]) { }
function a10([a, b, [[c]], ...x]) { }
function a11([a, b, c, ...x]: number[]) { }
var array = [1, 2, 3];
var array2 = [true, false, "hello"];
a2([...array]);
a1(...array);
a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]]
a10([1, 2, [["string"]], false, true]); // Parameter type is any[]
a10([1, 2, 3, false, true]); // Parameter type is any[]
a10([1, 2]); // Parameter type is any[]
a11([1, 2]); // Parameter type is number[]
// Rest parameter with generic
function foo<T>(...a: T[]) { }
foo<number|string>("hello", 1, 2);
foo("hello", "world");
enum E { a, b }
const enum E1 { a, b }
function foo1<T extends Number>(...a: T[]) { }
foo1(1, 2, 3, E.a);
foo1(1, 2, 3, E1.a, E.b);
//// [destructuringParameterDeclaration2ES6.js]
// If the parameter is a rest parameter, the parameter type is any[]
// A type annotation for a rest parameter must denote an array type.
function a1(...x) { }
function a2(...a) { }
function a3(...a) { }
function a4(...a) { }
function a5(...a) { }
function a9([a, b, [[c]]]) { }
function a10([a, b, [[c]], ...x]) { }
function a11([a, b, c, ...x]) { }
var array = [1, 2, 3];
var array2 = [true, false, "hello"];
a2([...array]);
a1(...array);
a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]]
a10([1, 2, [["string"]], false, true]); // Parameter type is any[]
a10([1, 2, 3, false, true]); // Parameter type is any[]
a10([1, 2]); // Parameter type is any[]
a11([1, 2]); // Parameter type is number[]
// Rest parameter with generic
function foo(...a) { }
foo("hello", 1, 2);
foo("hello", "world");
var E;
(function (E) {
E[E["a"] = 0] = "a";
E[E["b"] = 1] = "b";
})(E || (E = {}));
function foo1(...a) { }
foo1(1, 2, 3, E.a);
foo1(1, 2, 3, 0 /* a */, E.b);

170
tests/baselines/reference/destructuringParameterDeclaration2ES6.types Normal file
View file

@ -0,0 +1,170 @@
=== tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2ES6.ts ===
// If the parameter is a rest parameter, the parameter type is any[]
// A type annotation for a rest parameter must denote an array type.
// RestParameter:
// ... Identifier TypeAnnotation(opt)
type arrayString = Array<String>
>arrayString : String[]
>Array : T[]
>String : String
type someArray = Array<String> | number[];
>someArray : number[] | String[]
>Array : T[]
>String : String
type stringOrNumArray = Array<String|Number>;
>stringOrNumArray : (String | Number)[]
>Array : T[]
>String : String
>Number : Number
function a1(...x: (number|string)[]) { }
>a1 : (...x: (string | number)[]) => void
>x : (string | number)[]
function a2(...a) { }
>a2 : (...a: any[]) => void
>a : any[]
function a3(...a: Array<String>) { }
>a3 : (...a: String[]) => void
>a : String[]
>Array : T[]
>String : String
function a4(...a: arrayString) { }
>a4 : (...a: String[]) => void
>a : String[]
>arrayString : String[]
function a5(...a: stringOrNumArray) { }
>a5 : (...a: (String | Number)[]) => void
>a : (String | Number)[]
>stringOrNumArray : (String | Number)[]
function a9([a, b, [[c]]]) { }
>a9 : ([a, b, [[c]]]: [any, any, [[any]]]) => void
>a : any
>b : any
>c : any
function a10([a, b, [[c]], ...x]) { }
>a10 : ([a, b, [[c]], ...x]: Iterable<any>) => void
>a : any
>b : any
>c : any
>x : any[]
function a11([a, b, c, ...x]: number[]) { }
>a11 : ([a, b, c, ...x]: number[]) => void
>a : number
>b : number
>c : number
>x : number[]
var array = [1, 2, 3];
>array : number[]
>[1, 2, 3] : number[]
var array2 = [true, false, "hello"];
>array2 : (string | boolean)[]
>[true, false, "hello"] : (string | boolean)[]
a2([...array]);
>a2([...array]) : void
>a2 : (...a: any[]) => void
>[...array] : number[]
>...array : number
>array : number[]
a1(...array);
>a1(...array) : void
>a1 : (...x: (string | number)[]) => void
>...array : number
>array : number[]
a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]]
>a9([1, 2, [["string"]], false, true]) : void
>a9 : ([a, b, [[c]]]: [any, any, [[any]]]) => void
>[1, 2, [["string"]], false, true] : [number, number, [[string]], boolean, boolean]
>[["string"]] : [[string]]
>["string"] : [string]
a10([1, 2, [["string"]], false, true]); // Parameter type is any[]
>a10([1, 2, [["string"]], false, true]) : void
>a10 : ([a, b, [[c]], ...x]: Iterable<any>) => void
>[1, 2, [["string"]], false, true] : (number | boolean | string[][])[]
>[["string"]] : string[][]
>["string"] : string[]
a10([1, 2, 3, false, true]); // Parameter type is any[]
>a10([1, 2, 3, false, true]) : void
>a10 : ([a, b, [[c]], ...x]: Iterable<any>) => void
>[1, 2, 3, false, true] : (number | boolean)[]
a10([1, 2]); // Parameter type is any[]
>a10([1, 2]) : void
>a10 : ([a, b, [[c]], ...x]: Iterable<any>) => void
>[1, 2] : number[]
a11([1, 2]); // Parameter type is number[]
>a11([1, 2]) : void
>a11 : ([a, b, c, ...x]: number[]) => void
>[1, 2] : number[]
// Rest parameter with generic
function foo<T>(...a: T[]) { }
>foo : <T>(...a: T[]) => void
>T : T
>a : T[]
>T : T
foo<number|string>("hello", 1, 2);
>foo<number|string>("hello", 1, 2) : void
>foo : <T>(...a: T[]) => void
foo("hello", "world");
>foo("hello", "world") : void
>foo : <T>(...a: T[]) => void
enum E { a, b }
>E : E
>a : E
>b : E
const enum E1 { a, b }
>E1 : E1
>a : E1
>b : E1
function foo1<T extends Number>(...a: T[]) { }
>foo1 : <T extends Number>(...a: T[]) => void
>T : T
>Number : Number
>a : T[]
>T : T
foo1(1, 2, 3, E.a);
>foo1(1, 2, 3, E.a) : void
>foo1 : <T extends Number>(...a: T[]) => void
>E.a : E
>E : typeof E
>a : E
foo1(1, 2, 3, E1.a, E.b);
>foo1(1, 2, 3, E1.a, E.b) : void
>foo1 : <T extends Number>(...a: T[]) => void
>E1.a : E1
>E1 : typeof E1
>a : E1
>E.b : E
>E : typeof E
>b : E

43
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1.ts
View file

@ -3,11 +3,10 @@
// in a parameter list must be unique within that parameter list.
// If the declaration includes a type annotation, the parameter is of that type
function a0(x: number, y: string, z: boolean) { }
function a1([a, b, [[c]]]: [number, number, string[][]]) { }
function a2(o: { x: number, a: number }) { }
function a3({j, k, l: {m, n}, q: [a, b, c]}: { j: number, k: string, l: { m: boolean, n: number }, q: (number|string)[] }) { };
function a1({x, a}: { x: number, a: number }) { }
function a4({x, a}: { x: number, a: number }) { }
a1([1, 2, [["world"]]]);
a1([1, 2, [["world"]], 3]);
@ -19,20 +18,24 @@ a1([1, 2, [["world"]], "string"]); // Error
// when the parameter list occurs in conjunction with a function body),
// the parameter type is the widened form (section 3.11) of the type of the initializer expression.
function b1(z = 10, y = 60, u = () => true) { }
function b2(z = [undefined, null]) { };
function b3(z = null, o = { x: 0, y: undefined }) { }
function b4({z: {x, y: {j}}} = { z: { x: "hi", y: { j: 1 } } }) { }
function b1(z = [undefined, null]) { };
function b2(z = null, o = { x: 0, y: undefined }) { }
function b3({z: {x, y: {j}}} = { z: { x: "hi", y: { j: 1 } } }) { }
interface F1 {
b5(z = 10, [[a, b], d, {u}] = [[1, 2], "string", { u: false }]); // Error, no function body
b6(z, y, [, a, b], {p, m: { q, r}});
b4(z = 10, [[a, b], d, {u}] = [[1, 2], "string", { u: false }]); // Error, no function body
b5(z, y, [, a, b], {p, m: { q, r}});
}
b2([1, 2, 3]); // z is widen to the type any[]
b3("string", { x: 200, y: "string" });
b3("string", { x: 200, y: true });
b3("string", { x: "string", y: true }); // Error
function b6([a, z, y] = [undefined, null, undefined]) { }
function b7([[a], b, [[c, d]]] = [[undefined], undefined, [[undefined, undefined]]]) { }
b1([1, 2, 3]); // z is widen to the type any[]
b2("string", { x: 200, y: "string" });
b2("string", { x: 200, y: true });
b2("string", { x: "string", y: true }); // Error
b6(["string", 1, 2]); // Shouldn't be an error
b7([["string"], 1, [[true, false]]]); // Shouldn't be an error
// If the declaration specifies a binding pattern, the parameter type is the implied type of that binding pattern (section 5.1.3)
@ -72,8 +75,8 @@ c6([1, 2, [["string"]]]); // Error, implied type is [any, any, [[number]]] //
function d0(x?) { }
function d0(x = 10) { }
function d1([a, b, c]?) { }
function d2({x, y, z}?) { }
function d1([a, b, c]?) { } // Error, binding pattern can't be optional in implementation signature
function d2({x, y, z}?) { } // Error, binding pattern can't be optional in implementation signature
interface F2 {
d3([a, b, c]?);
@ -103,4 +106,16 @@ class C4 implements F2 {
function d5({x, y} = { x: 1, y: 2 }) { }
d5(); // Parameter is optional as its declaration included an initializer
// Destructuring parameter declarations do not permit type annotations on the individual binding patterns,
// as such annotations would conflict with the already established meaning of colons in object literals.
// Type annotations must instead be written on the top- level parameter declaration
function e1({x: number}) { } // x has type any NOT number
function e2({x}: { x: number }) { } // x is type number
function e3({x}: { x?: number }) { } // x is an optional with type number
function e4({x: [number,string,any] }) { } // x has type [any, any, any]
function e5({x: [a, b, c]}: { x: [number, number, number] }) { } // x has type [any, any, any]
function e6({x: [number, number, number]}) { } // should be an error, duplicate identifier;

99
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1ES6.ts Normal file
View file

@ -0,0 +1,99 @@
// Conformance for emitting ES6
// @target: es6
// A parameter declaration may specify either an identifier or a binding pattern.
// The identifiers specified in parameter declarations and binding patterns
// in a parameter list must be unique within that parameter list.
// If the declaration includes a type annotation, the parameter is of that type
function a1([a, b, [[c]]]: [number, number, string[][]]) { }
function a2(o: { x: number, a: number }) { }
function a3({j, k, l: {m, n}, q: [a, b, c]}: { j: number, k: string, l: { m: boolean, n: number }, q: (number|string)[] }) { };
function a4({x, a}: { x: number, a: number }) { }
a1([1, 2, [["world"]]]);
a1([1, 2, [["world"]], 3]);
// If the declaration includes an initializer expression (which is permitted only
// when the parameter list occurs in conjunction with a function body),
// the parameter type is the widened form (section 3.11) of the type of the initializer expression.
function b1(z = [undefined, null]) { };
function b2(z = null, o = { x: 0, y: undefined }) { }
function b3({z: {x, y: {j}}} = { z: { x: "hi", y: { j: 1 } } }) { }
interface F1 {
b5(z, y, [, a, b], {p, m: { q, r}});
}
function b6([a, z, y] = [undefined, null, undefined]) { }
function b7([[a], b, [[c, d]]] = [[undefined], undefined, [[undefined, undefined]]]) { }
b1([1, 2, 3]); // z is widen to the type any[]
b2("string", { x: 200, y: "string" });
b2("string", { x: 200, y: true });
// If the declaration specifies a binding pattern, the parameter type is the implied type of that binding pattern (section 5.1.3)
enum Foo { a }
function c0({z: {x, y: {j}}}) { }
function c1({z} = { z: 10 }) { }
function c2({z = 10}) { }
function c3({b}: { b: number|string} = { b: "hello" }) { }
function c5([a, b, [[c]]]) { }
function c6([a, b, [[c=1]]]) { }
c0({z : { x: 1, y: { j: "world" } }}); // Implied type is { z: {x: any, y: {j: any}} }
c0({z : { x: "string", y: { j: true } }}); // Implied type is { z: {x: any, y: {j: any}} }
c1(); // Implied type is {z:number}?
c1({ z: 1 }) // Implied type is {z:number}?
c2({}); // Implied type is {z?: number}
c2({z:1}); // Implied type is {z?: number}
c3({ b: 1 }); // Implied type is { b: number|string }.
c5([1, 2, [["string"]]]); // Implied type is is [any, any, [[any]]]
c5([1, 2, [["string"]], false, true]); // Implied type is is [any, any, [[any]]]
// A parameter can be marked optional by following its name or binding pattern with a question mark (?)
// or by including an initializer.
interface F2 {
d3([a, b, c]?);
d4({x, y, z}?);
e0([a, b, c]);
}
class C2 implements F2 {
constructor() { }
d3() { }
d4() { }
e0([a, b, c]) { }
}
class C3 implements F2 {
d3([a, b, c]) { }
d4({x, y, z}) { }
e0([a, b, c]) { }
}
function d5({x, y} = { x: 1, y: 2 }) { }
d5(); // Parameter is optional as its declaration included an initializer
// Destructuring parameter declarations do not permit type annotations on the individual binding patterns,
// as such annotations would conflict with the already established meaning of colons in object literals.
// Type annotations must instead be written on the top- level parameter declaration
function e1({x: number}) { } // x has type any NOT number
function e2({x}: { x: number }) { } // x is type number
function e3({x}: { x?: number }) { } // x is an optional with type number
function e4({x: [number,string,any] }) { } // x has type [any, any, any]
function e5({x: [a, b, c]}: { x: [number, number, number] }) { } // x has type [any, any, any]
function e6({x: [number, number, number]}) { } // should be an error, duplicate identifier;

2
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts
View file

@ -42,7 +42,7 @@ a11([1, 2, "string"]); // Error, parameter type is number[]
class C {
constructor(public ...a) { } // Rest parameter can't have accessibilityModifier
constructor(public ...a) { } // Error, rest parameter can't have accessibilityModifier
}
// Rest parameter with generic

47
tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2ES6.ts Normal file
View file

@ -0,0 +1,47 @@
// @target: es6
// If the parameter is a rest parameter, the parameter type is any[]
// A type annotation for a rest parameter must denote an array type.
// RestParameter:
// ... Identifier TypeAnnotation(opt)
type arrayString = Array<String>
type someArray = Array<String> | number[];
type stringOrNumArray = Array<String|Number>;
function a1(...x: (number|string)[]) { }
function a2(...a) { }
function a3(...a: Array<String>) { }
function a4(...a: arrayString) { }
function a5(...a: stringOrNumArray) { }
function a9([a, b, [[c]]]) { }
function a10([a, b, [[c]], ...x]) { }
function a11([a, b, c, ...x]: number[]) { }
var array = [1, 2, 3];
var array2 = [true, false, "hello"];
a2([...array]);
a1(...array);
a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]]
a10([1, 2, [["string"]], false, true]); // Parameter type is any[]
a10([1, 2, 3, false, true]); // Parameter type is any[]
a10([1, 2]); // Parameter type is any[]
a11([1, 2]); // Parameter type is number[]
// Rest parameter with generic
function foo<T>(...a: T[]) { }
foo<number|string>("hello", 1, 2);
foo("hello", "world");
enum E { a, b }
const enum E1 { a, b }
function foo1<T extends Number>(...a: T[]) { }
foo1(1, 2, 3, E.a);
foo1(1, 2, 3, E1.a, E.b);