Do visibility painting from collectLinkedAliases in checker to remove statefullness in declaration emit

Author: weswigham

src/compiler/checker.ts

@@ -4005,25 +4005,30 @@ namespace ts {
             }
         }
 
-        function collectLinkedAliases(node: Identifier): Node[] {
+        function collectLinkedAliases(node: Identifier, setVisibility?: boolean): Node[] | undefined {
             let exportSymbol: Symbol;
             if (node.parent && node.parent.kind === SyntaxKind.ExportAssignment) {
-                exportSymbol = resolveName(node.parent, node.escapedText, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias, Diagnostics.Cannot_find_name_0, node, /*isUse*/ false);
+                exportSymbol = resolveName(node, node.escapedText, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias, /*nameNotFoundMessage*/ undefined, node, /*isUse*/ false);
             }
             else if (node.parent.kind === SyntaxKind.ExportSpecifier) {
                 exportSymbol = getTargetOfExportSpecifier(<ExportSpecifier>node.parent, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
             }
-            const result: Node[] = [];
+            let result: Node[];
             if (exportSymbol) {
                 buildVisibleNodeList(exportSymbol.declarations);
             }
             return result;
 
             function buildVisibleNodeList(declarations: Declaration[]) {
                 forEach(declarations, declaration => {
-                    getNodeLinks(declaration).isVisible = true;
                     const resultNode = getAnyImportSyntax(declaration) || declaration;
-                    pushIfUnique(result, resultNode);
+                    if (setVisibility) {
+                        getNodeLinks(declaration).isVisible = true;
+                    }
+                    else {
+                        result = result || [];
+                        pushIfUnique(result, resultNode);
+                    }
 
                     if (isInternalModuleImportEqualsDeclaration(declaration)) {
                         // Add the referenced top container visible
@@ -22865,6 +22870,7 @@ namespace ts {
 
         function checkExportSpecifier(node: ExportSpecifier) {
             checkAliasSymbol(node);
+            collectLinkedAliases(node.propertyName || node.name, /*setVisibility*/ true); // Collect linked aliases to set visibility links
             if (!(<ExportDeclaration>node.parent.parent).moduleSpecifier) {
                 const exportedName = node.propertyName || node.name;
                 // find immediate value referenced by exported name (SymbolFlags.Alias is set so we don't chase down aliases)
@@ -22902,6 +22908,7 @@ namespace ts {
             }
             if (node.expression.kind === SyntaxKind.Identifier) {
                 markExportAsReferenced(node);
+                collectLinkedAliases(node.expression as Identifier, /*setVisibility*/ true); // Sets visibility flags on refernced nodes
             }
             else {
                 checkExpressionCached(node.expression);

tests/baselines/reference/mutuallyRecursiveInterfaceDeclaration.js

@@ -0,0 +1,23 @@
+//// [mutuallyRecursiveInterfaceDeclaration.ts]
+interface A {
+    b: B
+}
+
+interface B {
+    a: A
+}
+export {A, B}
+
+//// [mutuallyRecursiveInterfaceDeclaration.js]
+"use strict";
+exports.__esModule = true;
+
+
+//// [mutuallyRecursiveInterfaceDeclaration.d.ts]
+interface A {
+    b: B;
+}
+interface B {
+    a: A;
+}
+export { A, B };

tests/baselines/reference/mutuallyRecursiveInterfaceDeclaration.symbols

@@ -0,0 +1,20 @@
+=== tests/cases/compiler/mutuallyRecursiveInterfaceDeclaration.ts ===
+interface A {
+>A : Symbol(A, Decl(mutuallyRecursiveInterfaceDeclaration.ts, 0, 0))
+
+    b: B
+>b : Symbol(A.b, Decl(mutuallyRecursiveInterfaceDeclaration.ts, 0, 13))
+>B : Symbol(B, Decl(mutuallyRecursiveInterfaceDeclaration.ts, 2, 1))
+}
+
+interface B {
+>B : Symbol(B, Decl(mutuallyRecursiveInterfaceDeclaration.ts, 2, 1))
+
+    a: A
+>a : Symbol(B.a, Decl(mutuallyRecursiveInterfaceDeclaration.ts, 4, 13))
+>A : Symbol(A, Decl(mutuallyRecursiveInterfaceDeclaration.ts, 0, 0))
+}
+export {A, B}
+>A : Symbol(A, Decl(mutuallyRecursiveInterfaceDeclaration.ts, 7, 8))
+>B : Symbol(B, Decl(mutuallyRecursiveInterfaceDeclaration.ts, 7, 10))
+

tests/baselines/reference/mutuallyRecursiveInterfaceDeclaration.types

@@ -0,0 +1,20 @@
+=== tests/cases/compiler/mutuallyRecursiveInterfaceDeclaration.ts ===
+interface A {
+>A : A
+
+    b: B
+>b : B
+>B : B
+}
+
+interface B {
+>B : B
+
+    a: A
+>a : A
+>A : A
+}
+export {A, B}
+>A : any
+>B : any
+

tests/cases/compiler/mutuallyRecursiveInterfaceDeclaration.ts

@@ -0,0 +1,9 @@
+// @declaration: true
+interface A {
+    b: B
+}
+
+interface B {
+    a: A
+}
+export {A, B}