Conformance test for Spec Change in Section 3.8.2.2 parameter Declaration and 6.4 Destructuring parameter declarations

tests/baselines/reference/destructuringParameterDeclaration1ES5.errors.txt

@@ -0,0 +1,124 @@
+tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1ES5.ts(32,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/destructuringParameterDeclaration1ES5.ts(33,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/destructuringParameterDeclaration1ES5.ts(62,10): error TS2393: Duplicate function implementation.
+tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1ES5.ts(63,10): error TS2393: Duplicate function implementation.
+
+
+==== tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1ES5.ts (4 errors) ====
+    // 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 });
+    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)
+    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.
+
+    function d0(x?) { }
+             ~~
+!!! error TS2393: Duplicate function implementation.
+    function d0(x = 10) { }
+             ~~
+!!! error TS2393: Duplicate function implementation.
+
+    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]
+

tests/baselines/reference/destructuringParameterDeclaration1ES5.js

@@ -0,0 +1,226 @@
+//// [destructuringParameterDeclaration1ES5.ts]
+// 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 });
+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)
+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.
+
+function d0(x?) { }
+function d0(x = 10) { }
+
+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]
+
+
+//// [destructuringParameterDeclaration1ES5.js]
+// 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) {
+    var a = _a[0], b = _a[1], c = _a[2][0][0];
+}
+function a2(o) { }
+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 a4(_a) {
+    var x = _a.x, a = _a.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) {
+    if (z === void 0) { z = [undefined, null]; }
+}
+;
+function b2(z, o) {
+    if (z === void 0) { z = null; }
+    if (o === void 0) { o = { x: 0, y: undefined }; }
+}
+function b3(_a) {
+    var _b = (_a === void 0 ? { z: { x: "hi", y: { j: 1 } } } : _a).z, x = _b.x, j = _b.y.j;
+}
+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 });
+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) {
+    Foo[Foo["a"] = 0] = "a";
+})(Foo || (Foo = {}));
+function c0(_a) {
+    var _b = _a.z, x = _b.x, j = _b.y.j;
+}
+function c1(_a) {
+    var z = (_a === void 0 ? { z: 10 } : _a).z;
+}
+function c2(_a) {
+    var _b = _a.z, z = _b === void 0 ? 10 : _b;
+}
+function c3(_a) {
+    var b = (_a === void 0 ? { b: "hello" } : _a).b;
+}
+function c5(_a) {
+    var a = _a[0], b = _a[1], c = _a[2][0][0];
+}
+function c6(_a) {
+    var a = _a[0], b = _a[1], _b = _a[2][0][0], c = _b === void 0 ? 1 : _b;
+}
+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.
+function d0(x) { }
+function d0(x) {
+    if (x === void 0) { x = 10; }
+}
+var C2 = (function () {
+    function C2() {
+    }
+    C2.prototype.d3 = function () { };
+    C2.prototype.d4 = function () { };
+    C2.prototype.e0 = function (_a) {
+        var a = _a[0], b = _a[1], c = _a[2];
+    };
+    return C2;
+})();
+var C3 = (function () {
+    function C3() {
+    }
+    C3.prototype.d3 = function (_a) {
+        var a = _a[0], b = _a[1], c = _a[2];
+    };
+    C3.prototype.d4 = function (_a) {
+        var x = _a.x, y = _a.y, z = _a.z;
+    };
+    C3.prototype.e0 = function (_a) {
+        var a = _a[0], b = _a[1], c = _a[2];
+    };
+    return C3;
+})();
+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]