Merge pull request microsoft#10953 from Microsoft/emitTypeAliasInDeclarationFile

Serialize inferred type alias when type alias symbol is not accessible

Author: yuit

src/compiler/checker.ts

@@ -1758,15 +1758,23 @@ namespace ts {
             return false;
         }
 
-        function isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessibilityResult {
+        /**
+         * Check if the given symbol in given enclosing declaration is accessible and mark all associated alias to be visible if requested
+         *
+         * @param symbol a Symbol to check if accessible
+         * @param enclosingDeclaration a Node containing reference to the symbol
+         * @param meaning a SymbolFlags to check if such meaning of the symbol is accessible
+         * @param shouldComputeAliasToMakeVisible a boolean value to indicate whether to return aliases to be mark visible in case the symbol is accessible
+         */
+        function isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, shouldComputeAliasesToMakeVisible: boolean): SymbolAccessibilityResult {
             if (symbol && enclosingDeclaration && !(symbol.flags & SymbolFlags.TypeParameter)) {
                 const initialSymbol = symbol;
                 let meaningToLook = meaning;
                 while (symbol) {
                     // Symbol is accessible if it by itself is accessible
                     const accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook, /*useOnlyExternalAliasing*/ false);
                     if (accessibleSymbolChain) {
-                        const hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0]);
+                        const hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0], shouldComputeAliasesToMakeVisible);
                         if (!hasAccessibleDeclarations) {
                             return <SymbolAccessibilityResult>{
                                 accessibility: SymbolAccessibility.NotAccessible,
@@ -1830,7 +1838,7 @@ namespace ts {
             return isAmbientModule(declaration) || (declaration.kind === SyntaxKind.SourceFile && isExternalOrCommonJsModule(<SourceFile>declaration));
         }
 
-        function hasVisibleDeclarations(symbol: Symbol): SymbolVisibilityResult {
+        function hasVisibleDeclarations(symbol: Symbol, shouldComputeAliasToMakeVisible: boolean): SymbolVisibilityResult {
             let aliasesToMakeVisible: AnyImportSyntax[];
             if (forEach(symbol.declarations, declaration => !getIsDeclarationVisible(declaration))) {
                 return undefined;
@@ -1846,14 +1854,19 @@ namespace ts {
                     if (anyImportSyntax &&
                         !(getModifierFlags(anyImportSyntax) & ModifierFlags.Export) && // import clause without export
                         isDeclarationVisible(<Declaration>anyImportSyntax.parent)) {
-                        getNodeLinks(declaration).isVisible = true;
-                        if (aliasesToMakeVisible) {
-                            if (!contains(aliasesToMakeVisible, anyImportSyntax)) {
-                                aliasesToMakeVisible.push(anyImportSyntax);
+                        // In function "buildTypeDisplay" where we decide whether to write type-alias or serialize types,
+                        // we want to just check if type- alias is accessible or not but we don't care about emitting those alias at that time
+                        // since we will do the emitting later in trackSymbol.
+                        if (shouldComputeAliasToMakeVisible) {
+                            getNodeLinks(declaration).isVisible = true;
+                            if (aliasesToMakeVisible) {
+                                if (!contains(aliasesToMakeVisible, anyImportSyntax)) {
+                                    aliasesToMakeVisible.push(anyImportSyntax);
+                                }
+                            }
+                            else {
+                                aliasesToMakeVisible = [anyImportSyntax];
                             }
-                        }
-                        else {
-                            aliasesToMakeVisible = [anyImportSyntax];
                         }
                         return true;
                     }
@@ -1888,7 +1901,7 @@ namespace ts {
             const symbol = resolveName(enclosingDeclaration, (<Identifier>firstIdentifier).text, meaning, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined);
 
             // Verify if the symbol is accessible
-            return (symbol && hasVisibleDeclarations(symbol)) || <SymbolVisibilityResult>{
+            return (symbol && hasVisibleDeclarations(symbol, /*shouldComputeAliasToMakeVisible*/ true)) || <SymbolVisibilityResult>{
                 accessibility: SymbolAccessibility.NotAccessible,
                 errorSymbolName: getTextOfNode(firstIdentifier),
                 errorNode: firstIdentifier
@@ -2163,7 +2176,9 @@ namespace ts {
                         // The specified symbol flags need to be reinterpreted as type flags
                         buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, nextFlags);
                     }
-                    else if (!(flags & TypeFormatFlags.InTypeAlias) && type.flags & (TypeFlags.Anonymous | TypeFlags.UnionOrIntersection) && type.aliasSymbol) {
+                    else if (!(flags & TypeFormatFlags.InTypeAlias) && type.flags & (TypeFlags.Anonymous | TypeFlags.UnionOrIntersection) && type.aliasSymbol &&
+                        isSymbolAccessible(type.aliasSymbol, enclosingDeclaration, SymbolFlags.Type, /*shouldComputeAliasesToMakeVisible*/ false).accessibility === SymbolAccessibility.Accessible) {
+                        // Only write out inferred type with its corresponding type-alias if type-alias is visible
                         const typeArguments = type.aliasTypeArguments;
                         writeSymbolTypeReference(type.aliasSymbol, typeArguments, 0, typeArguments ? typeArguments.length : 0, nextFlags);
                     }

src/compiler/declarationEmitter.ts

@@ -306,7 +306,7 @@ namespace ts {
         }
 
         function trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
-            handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning));
+            handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning, /*shouldComputeAliasesToMakeVisible*/ true));
             recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForSymbol(symbol, meaning));
         }
 

src/compiler/types.ts

@@ -2144,7 +2144,7 @@ namespace ts {
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeBaseConstructorTypeOfClass(node: ClassLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
-        isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessibilityResult;
+        isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, shouldComputeAliasToMarkVisible: boolean): SymbolAccessibilityResult;
         isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;

tests/baselines/reference/controlFlowBinaryOrExpression.types

@@ -62,21 +62,21 @@ declare function isHTMLCollection(sourceObj: any): sourceObj is HTMLCollection;
 >HTMLCollection : HTMLCollection
 
 type EventTargetLike = {a: string} | HTMLCollection | NodeList;
->EventTargetLike : EventTargetLike
+>EventTargetLike : NodeList | HTMLCollection | { a: string; }
 >a : string
 >HTMLCollection : HTMLCollection
 >NodeList : NodeList
 
 var sourceObj: EventTargetLike = <any>undefined;
->sourceObj : EventTargetLike
->EventTargetLike : EventTargetLike
+>sourceObj : NodeList | HTMLCollection | { a: string; }
+>EventTargetLike : NodeList | HTMLCollection | { a: string; }
 ><any>undefined : any
 >undefined : undefined
 
 if (isNodeList(sourceObj)) {
 >isNodeList(sourceObj) : boolean
 >isNodeList : (sourceObj: any) => sourceObj is NodeList
->sourceObj : EventTargetLike
+>sourceObj : NodeList | HTMLCollection | { a: string; }
 
     sourceObj.length;
 >sourceObj.length : number
@@ -87,7 +87,7 @@ if (isNodeList(sourceObj)) {
 if (isHTMLCollection(sourceObj)) {
 >isHTMLCollection(sourceObj) : boolean
 >isHTMLCollection : (sourceObj: any) => sourceObj is HTMLCollection
->sourceObj : EventTargetLike
+>sourceObj : NodeList | HTMLCollection | { a: string; }
 
     sourceObj.length;
 >sourceObj.length : number
@@ -99,7 +99,7 @@ if (isNodeList(sourceObj) || isHTMLCollection(sourceObj)) {
 >isNodeList(sourceObj) || isHTMLCollection(sourceObj) : boolean
 >isNodeList(sourceObj) : boolean
 >isNodeList : (sourceObj: any) => sourceObj is NodeList
->sourceObj : EventTargetLike
+>sourceObj : NodeList | HTMLCollection | { a: string; }
 >isHTMLCollection(sourceObj) : boolean
 >isHTMLCollection : (sourceObj: any) => sourceObj is HTMLCollection
 >sourceObj : HTMLCollection | { a: string; }

tests/baselines/reference/declarationEmitArrayTypesFromGenericArrayUsage.js

@@ -0,0 +1,10 @@
+//// [declarationEmitArrayTypesFromGenericArrayUsage.ts]
+interface A extends Array<string> { }
+
+
+//// [declarationEmitArrayTypesFromGenericArrayUsage.js]
+
+
+//// [declarationEmitArrayTypesFromGenericArrayUsage.d.ts]
+interface A extends Array<string> {
+}

tests/baselines/reference/declarationEmitArrayTypesFromGenericArrayUsage.symbols

@@ -0,0 +1,5 @@
+=== tests/cases/compiler/declarationEmitArrayTypesFromGenericArrayUsage.ts ===
+interface A extends Array<string> { }
+>A : Symbol(A, Decl(declarationEmitArrayTypesFromGenericArrayUsage.ts, 0, 0))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+

tests/baselines/reference/declarationEmitArrayTypesFromGenericArrayUsage.types

@@ -0,0 +1,5 @@
+=== tests/cases/compiler/declarationEmitArrayTypesFromGenericArrayUsage.ts ===
+interface A extends Array<string> { }
+>A : A
+>Array : T[]
+

tests/baselines/reference/declarationEmit_bindingPatterns.js renamed to tests/baselines/reference/declarationEmitBindingPatterns.js

@@ -1,12 +1,12 @@
-//// [declarationEmit_bindingPatterns.ts]
+//// [declarationEmitBindingPatterns.ts]
 
 const k = ({x: z = 'y'}) => { }
 
 var a;
 function f({} = a, [] = a, { p: {} = a} = a) {
 }
 
-//// [declarationEmit_bindingPatterns.js]
+//// [declarationEmitBindingPatterns.js]
 var k = function (_a) {
     var _b = _a.x, z = _b === void 0 ? 'y' : _b;
 };
@@ -18,7 +18,7 @@ function f(_a, _b, _c) {
 }
 
 
-//// [declarationEmit_bindingPatterns.d.ts]
+//// [declarationEmitBindingPatterns.d.ts]
 declare const k: ({x: z}: {
     x?: string;
 }) => void;

tests/baselines/reference/declarationEmitBindingPatterns.symbols

@@ -0,0 +1,17 @@
+=== tests/cases/compiler/declarationEmitBindingPatterns.ts ===
+
+const k = ({x: z = 'y'}) => { }
+>k : Symbol(k, Decl(declarationEmitBindingPatterns.ts, 1, 5))
+>x : Symbol(x)
+>z : Symbol(z, Decl(declarationEmitBindingPatterns.ts, 1, 12))
+
+var a;
+>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3))
+
+function f({} = a, [] = a, { p: {} = a} = a) {
+>f : Symbol(f, Decl(declarationEmitBindingPatterns.ts, 3, 6))
+>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3))
+>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3))
+>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3))
+>a : Symbol(a, Decl(declarationEmitBindingPatterns.ts, 3, 3))
+}

tests/baselines/reference/declarationEmit_bindingPatterns.types renamed to tests/baselines/reference/declarationEmitBindingPatterns.types

@@ -1,4 +1,4 @@
-=== tests/cases/compiler/declarationEmit_bindingPatterns.ts ===
+=== tests/cases/compiler/declarationEmitBindingPatterns.ts ===
 
 const k = ({x: z = 'y'}) => { }
 >k : ({x: z}: { x?: string; }) => void