Fix #17085

Author: weswigham

src/compiler/declarationEmitter.ts

@@ -1249,10 +1249,18 @@ namespace ts {
             writeLine();
         }
 
+        function bindingNameContainsVisibleBindingElement(node: BindingName): boolean {
+            return !!node && isBindingPattern(node) && some(node.elements, elem => !isOmittedExpression(elem) && (resolver.isDeclarationVisible(elem) || bindingNameContainsVisibleBindingElement(elem.name)));
+        }
+
+        function isVariableDeclarationVisible(node: VariableDeclaration) {
+            return resolver.isDeclarationVisible(node) || bindingNameContainsVisibleBindingElement(node.name);
+        }
+
         function emitVariableDeclaration(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration) {
             // 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 (node.kind !== SyntaxKind.VariableDeclaration || isVariableDeclarationVisible(node)) {
                 if (isBindingPattern(node.name)) {
                     emitBindingPattern(<BindingPattern>node.name);
                 }
@@ -1324,14 +1332,14 @@ namespace ts {
             }
 
             function emitBindingPattern(bindingPattern: BindingPattern) {
-                // Only select non-omitted expression from the bindingPattern's elements.
+                // Only select visible, non-omitted expression from the bindingPattern's elements.
                 // We have to do this to avoid emitting trailing commas.
                 // For example:
                 //      original: var [, c,,] = [ 2,3,4]
                 //      emitted: declare var c: number; // instead of declare var c:number, ;
                 const elements: Node[] = [];
                 for (const element of bindingPattern.elements) {
-                    if (element.kind !== SyntaxKind.OmittedExpression) {
+                    if (element.kind !== SyntaxKind.OmittedExpression && resolver.isDeclarationVisible(element)) {
                         elements.push(element);
                     }
                 }
@@ -1371,7 +1379,7 @@ namespace ts {
         }
 
         function isVariableStatementVisible(node: VariableStatement) {
-            return forEach(node.declarationList.declarations, varDeclaration => resolver.isDeclarationVisible(varDeclaration));
+            return forEach(node.declarationList.declarations, varDeclaration => isVariableDeclarationVisible(varDeclaration));
         }
 
         function writeVariableStatement(node: VariableStatement) {
@@ -1390,7 +1398,7 @@ namespace ts {
             else {
                 write("var ");
             }
-            emitCommaList(node.declarationList.declarations, emitVariableDeclaration, resolver.isDeclarationVisible);
+            emitCommaList(node.declarationList.declarations, emitVariableDeclaration, isVariableDeclarationVisible);
             write(";");
             writeLine();
         }

tests/baselines/reference/destructuredDeclarationEmit.js

@@ -0,0 +1,37 @@
+//// [tests/cases/compiler/destructuredDeclarationEmit.ts] ////
+
+//// [foo.ts]
+const foo = { bar: 'hello', bat: 'world' };
+export { foo };
+//// [index.ts]
+import { foo } from './foo';
+export { foo };
+
+const { bar: baz, bat } = foo;
+export { baz };
+
+//// [foo.js]
+"use strict";
+exports.__esModule = true;
+var foo = { bar: 'hello', bat: 'world' };
+exports.foo = foo;
+//// [index.js]
+"use strict";
+exports.__esModule = true;
+var foo_1 = require("./foo");
+exports.foo = foo_1.foo;
+var baz = foo_1.foo.bar, bat = foo_1.foo.bat;
+exports.baz = baz;
+
+
+//// [foo.d.ts]
+declare const foo: {
+    bar: string;
+    bat: string;
+};
+export { foo };
+//// [index.d.ts]
+import { foo } from './foo';
+export { foo };
+declare const baz: string;
+export { baz };

tests/baselines/reference/destructuredDeclarationEmit.symbols

@@ -0,0 +1,25 @@
+=== tests/cases/compiler/foo.ts ===
+const foo = { bar: 'hello', bat: 'world' };
+>foo : Symbol(foo, Decl(foo.ts, 0, 5))
+>bar : Symbol(bar, Decl(foo.ts, 0, 13))
+>bat : Symbol(bat, Decl(foo.ts, 0, 27))
+
+export { foo };
+>foo : Symbol(foo, Decl(foo.ts, 1, 8))
+
+=== tests/cases/compiler/index.ts ===
+import { foo } from './foo';
+>foo : Symbol(foo, Decl(index.ts, 0, 8))
+
+export { foo };
+>foo : Symbol(foo, Decl(index.ts, 1, 8))
+
+const { bar: baz, bat } = foo;
+>bar : Symbol(bar, Decl(foo.ts, 0, 13))
+>baz : Symbol(baz, Decl(index.ts, 3, 7))
+>bat : Symbol(bat, Decl(index.ts, 3, 17))
+>foo : Symbol(foo, Decl(index.ts, 0, 8))
+
+export { baz };
+>baz : Symbol(baz, Decl(index.ts, 4, 8))
+

tests/baselines/reference/destructuredDeclarationEmit.types

@@ -0,0 +1,28 @@
+=== tests/cases/compiler/foo.ts ===
+const foo = { bar: 'hello', bat: 'world' };
+>foo : { bar: string; bat: string; }
+>{ bar: 'hello', bat: 'world' } : { bar: string; bat: string; }
+>bar : string
+>'hello' : "hello"
+>bat : string
+>'world' : "world"
+
+export { foo };
+>foo : { bar: string; bat: string; }
+
+=== tests/cases/compiler/index.ts ===
+import { foo } from './foo';
+>foo : { bar: string; bat: string; }
+
+export { foo };
+>foo : { bar: string; bat: string; }
+
+const { bar: baz, bat } = foo;
+>bar : any
+>baz : string
+>bat : string
+>foo : { bar: string; bat: string; }
+
+export { baz };
+>baz : string
+

tests/cases/compiler/destructuredDeclarationEmit.ts

@@ -0,0 +1,10 @@
+// @declaration: true
+// @filename: foo.ts
+const foo = { bar: 'hello', bat: 'world' };
+export { foo };
+// @filename: index.ts
+import { foo } from './foo';
+export { foo };
+
+const { bar: baz, bat } = foo;
+export { baz };