Fix emit destructuring in declaration file

Author: Yui T

src/compiler/emitter.ts

@@ -1042,19 +1042,35 @@ module ts {
             // If we are emitting property it isn't moduleElement and hence we already know it needs to be emitted
             // so there is no check needed to see if declaration is visible
             if (node.kind !== SyntaxKind.VariableDeclaration || resolver.isDeclarationVisible(node)) {
-                // If this node is a computed name, it can only be a symbol, because we've already skipped
-                // it if it's not a well known symbol. In that case, the text of the name will be exactly
-                // what we want, namely the name expression enclosed in brackets.
-                writeTextOfNode(currentSourceFile, node.name);
-                // If optional property emit ?
-                if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && hasQuestionToken(node)) {
-                    write("?");
-                }
-                if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && node.parent.kind === SyntaxKind.TypeLiteral) {
-                    emitTypeOfVariableDeclarationFromTypeLiteral(node);
+                // If the node.name is an object-binding-pattern, decent into each element and emit each element as variable declarations
+                if (node.name.kind === SyntaxKind.ObjectBindingPattern || node.name.kind === SyntaxKind.ArrayBindingPattern) {
+                    let elements = (<BindingPattern>node.name).elements;
+                    for (let i = 0, n = elements.length; i < n; ++i) {
+                        let element = elements[i];
+                        writeTextOfNode(currentSourceFile, element);
+                        writeTypeOfDeclaration(element, undefined, getVariableDeclarationTypeVisibilityError);
+                        // Do not emit comma if the element is the last element in the list
+                        if (i < n - 1) {
+                            write(", ");
+                        }
+                    }
                 }
-                else if (!(node.flags & NodeFlags.Private)) {
-                    writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError);
+                else {
+                    // If this node is a computed name, it can only be a symbol, because we've already skipped
+                    // it if it's not a well known symbol. In that case, the text of the name will be exactly
+                    // what we want, namely the name expression enclosed in brackets.
+                    writeTextOfNode(currentSourceFile, node.name);
+
+                    // If optional property emit ?
+                    if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && hasQuestionToken(node)) {
+                        write("?");
+                    }
+                    if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && node.parent.kind === SyntaxKind.TypeLiteral) {
+                        emitTypeOfVariableDeclarationFromTypeLiteral(node);
+                    }
+                    else if (!(node.flags & NodeFlags.Private)) {
+                        writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError);
+                    }
                 }
             }
 

tests/baselines/reference/emitDestructuringInDeclarationFile.js

@@ -0,0 +1,47 @@
+//// [emitDestructuringInDeclarationFile.ts]
+var {a, b} = { a:10, b:"10"};
+var {c, d}: {c:string, d:string} = { c:"true", d:"false" };
+let {k, j} = { k:true, j:{a:10}};
+
+var a1 = ["string", 10];
+var [x] = a1;
+var [x, y] = a1;
+var [x, y, z] = a1;
+let [x1] = a1;
+
+//// [emitDestructuringInDeclarationFile.js]
+var _a = {
+    a: 10,
+    b: "10"
+}, a = _a.a, b = _a.b;
+var _b = {
+    c: "true",
+    d: "false"
+}, c = _b.c, d = _b.d;
+var _c = {
+    k: true,
+    j: {
+        a: 10
+    }
+}, k = _c.k, j = _c.j;
+var a1 = [
+    "string",
+    10
+];
+var x = a1[0];
+var x = a1[0], y = a1[1];
+var x = a1[0], y = a1[1], z = a1[2];
+var x1 = a1[0];
+
+
+//// [emitDestructuringInDeclarationFile.d.ts]
+declare var a: number, b: string;
+declare var c: string, d: string;
+declare let k: boolean, j: {
+    a: number;
+};
+declare var a1: (string | number)[];
+declare var x: string | number;
+declare var x: string | number, y: string | number;
+declare var x: string | number, y: string | number, z: string | number;
+declare let x1: string | number;

tests/baselines/reference/emitDestructuringInDeclarationFile.types

@@ -0,0 +1,49 @@
+=== tests/cases/conformance/es6/destructuring/emitDestructuringInDeclarationFile.ts ===
+var {a, b} = { a:10, b:"10"};
+>a : number
+>b : string
+>{ a:10, b:"10"} : { a: number; b: string; }
+>a : number
+>b : string
+
+var {c, d}: {c:string, d:string} = { c:"true", d:"false" };
+>c : string
+>d : string
+>c : string
+>d : string
+>{ c:"true", d:"false" } : { c: string; d: string; }
+>c : string
+>d : string
+
+let {k, j} = { k:true, j:{a:10}};
+>k : boolean
+>j : { a: number; }
+>{ k:true, j:{a:10}} : { k: boolean; j: { a: number; }; }
+>k : boolean
+>j : { a: number; }
+>{a:10} : { a: number; }
+>a : number
+
+var a1 = ["string", 10];
+>a1 : (string | number)[]
+>["string", 10] : (string | number)[]
+
+var [x] = a1;
+>x : string | number
+>a1 : (string | number)[]
+
+var [x, y] = a1;
+>x : string | number
+>y : string | number
+>a1 : (string | number)[]
+
+var [x, y, z] = a1;
+>x : string | number
+>y : string | number
+>z : string | number
+>a1 : (string | number)[]
+
+let [x1] = a1;
+>x1 : string | number
+>a1 : (string | number)[]
+

tests/cases/conformance/es6/destructuring/emitDestructuringInDeclarationFile.ts

@@ -0,0 +1,10 @@
+// @declaration: true
+var {a, b} = { a:10, b:"10"};
+var {c, d}: {c:string, d:string} = { c:"true", d:"false" };
+let {k, j} = { k:true, j:{a:10}};
+
+var a1 = ["string", 10];
+var [x] = a1;
+var [x, y] = a1;
+var [x, y, z] = a1;
+let [x1] = a1;