Update tests files with more conformance from section 6.4
This commit is contained in:
parent
2499b3ebd5
commit
614469462a
12 changed files with 1129 additions and 93 deletions
|
@ -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;
|
||||
|
||||
|
||||
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
|
@ -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
|
||||
|
||||
|
||||
|
|
@ -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.
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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);
|
|
@ -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
|
||||
|
||||
|
||||
|
|
@ -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;
|
||||
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
@ -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
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
Loading…
Reference in a new issue