In services, show the aliasSymbol for a type even if it's not accessible in the current scope (microsoft#17433)

Andy · web-flow · commit 10c8d5effada · 2017-08-15T10:23:45.000-07:00
* In services, show the aliasSymbol for a type even if it's not accessible in the current scope

* Rename flag
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -2156,6 +2156,11 @@ namespace ts {
             return false;
         }
 
+        function isTypeSymbolAccessible(typeSymbol: Symbol, enclosingDeclaration: Node): boolean {
+            const access = isSymbolAccessible(typeSymbol, enclosingDeclaration, SymbolFlags.Type, /*shouldComputeAliasesToMakeVisible*/ false);
+            return access.accessibility === SymbolAccessibility.Accessible;
+        }
+
         /**
          * Check if the given symbol in given enclosing declaration is accessible and mark all associated alias to be visible if requested
          *
@@ -2486,8 +2491,7 @@ namespace ts {
                     // Ignore constraint/default when creating a usage (as opposed to declaration) of a type parameter.
                     return createTypeReferenceNode(name, /*typeArguments*/ undefined);
                 }
-                if (!inTypeAlias && type.aliasSymbol &&
-                    isSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration, SymbolFlags.Type, /*shouldComputeAliasesToMakeVisible*/ false).accessibility === SymbolAccessibility.Accessible) {
+                if (!inTypeAlias && type.aliasSymbol && isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration)) {
                     const name = symbolToTypeReferenceName(type.aliasSymbol);
                     const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
                     return createTypeReferenceNode(name, typeArgumentNodes);
@@ -3254,7 +3258,7 @@ namespace ts {
                         buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, nextFlags);
                     }
                     else if (!(flags & TypeFormatFlags.InTypeAlias) && type.aliasSymbol &&
-                        isSymbolAccessible(type.aliasSymbol, enclosingDeclaration, SymbolFlags.Type, /*shouldComputeAliasesToMakeVisible*/ false).accessibility === SymbolAccessibility.Accessible) {
+                        ((flags & TypeFormatFlags.UseAliasDefinedOutsideCurrentScope) || isTypeSymbolAccessible(type.aliasSymbol, enclosingDeclaration))) {
                         const typeArguments = type.aliasTypeArguments;
                         writeSymbolTypeReference(type.aliasSymbol, typeArguments, 0, length(typeArguments), nextFlags);
                     }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2722,6 +2722,8 @@ namespace ts {
         AddUndefined                    = 1 << 13,  // Add undefined to types of initialized, non-optional parameters
         WriteClassExpressionAsTypeLiteral = 1 << 14, // Write a type literal instead of (Anonymous class)
         InArrayType                     = 1 << 15,  // Writing an array element type
+        UseAliasDefinedOutsideCurrentScope = 1 << 16, // For a `type T = ... ` defined in a different file, write `T` instead of its value,
+                                                      // even though `T` can't be accessed in the current scope.
     }
 
     export const enum SymbolFormatFlags {
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
@@ -1261,6 +1261,7 @@ namespace ts {
     }
 
     export function signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[] {
+        flags |= TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
         return mapToDisplayParts(writer => {
             typechecker.getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags);
         });
diff --git a/tests/cases/fourslash/quickInfoTypeAliasDefinedInDifferentFile.ts b/tests/cases/fourslash/quickInfoTypeAliasDefinedInDifferentFile.ts
@@ -0,0 +1,11 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: /a.ts
+////export type X = { x: number };
+////export function f(x: X): void {}
+
+// @Filename: /b.ts
+////import { f } from "./a";
+/////**/f({ x: 1 });
+
+verify.quickInfoAt("", "(alias) f(x: X): void\nimport f");

Original file line number	Diff line number	Diff line change
`@@ -2156,6 +2156,11 @@ namespace ts {`
`2156`	`2156`	`return false;`
`2157`	`2157`	`}`
`2158`	`2158`
	`2159`	`+ function isTypeSymbolAccessible(typeSymbol: Symbol, enclosingDeclaration: Node): boolean {`
	`2160`	`+ const access = isSymbolAccessible(typeSymbol, enclosingDeclaration, SymbolFlags.Type, /shouldComputeAliasesToMakeVisible/ false);`
	`2161`	`+ return access.accessibility === SymbolAccessibility.Accessible;`
	`2162`	`+ }`
	`2163`	`+`
`2159`	`2164`	`/**`
`2160`	`2165`	`* Check if the given symbol in given enclosing declaration is accessible and mark all associated alias to be visible if requested`
`2161`	`2166`	`*`
`@@ -2486,8 +2491,7 @@ namespace ts {`
`2486`	`2491`	`// Ignore constraint/default when creating a usage (as opposed to declaration) of a type parameter.`
`2487`	`2492`	`return createTypeReferenceNode(name, /typeArguments/ undefined);`
`2488`	`2493`	`}`
`2489`		`- if (!inTypeAlias && type.aliasSymbol &&`
`2490`		`- isSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration, SymbolFlags.Type, /shouldComputeAliasesToMakeVisible/ false).accessibility === SymbolAccessibility.Accessible) {`
	`2494`	`+ if (!inTypeAlias && type.aliasSymbol && isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration)) {`
`2491`	`2495`	`const name = symbolToTypeReferenceName(type.aliasSymbol);`
`2492`	`2496`	`const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);`
`2493`	`2497`	`return createTypeReferenceNode(name, typeArgumentNodes);`
`@@ -3254,7 +3258,7 @@ namespace ts {`
`3254`	`3258`	`buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, nextFlags);`
`3255`	`3259`	`}`
`3256`	`3260`	`else if (!(flags & TypeFormatFlags.InTypeAlias) && type.aliasSymbol &&`
`3257`		`- isSymbolAccessible(type.aliasSymbol, enclosingDeclaration, SymbolFlags.Type, /shouldComputeAliasesToMakeVisible/ false).accessibility === SymbolAccessibility.Accessible) {`
	`3261`	`+ ((flags & TypeFormatFlags.UseAliasDefinedOutsideCurrentScope) \|\| isTypeSymbolAccessible(type.aliasSymbol, enclosingDeclaration))) {`
`3258`	`3262`	`const typeArguments = type.aliasTypeArguments;`
`3259`	`3263`	`writeSymbolTypeReference(type.aliasSymbol, typeArguments, 0, length(typeArguments), nextFlags);`
`3260`	`3264`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2722,6 +2722,8 @@ namespace ts {`
`2722`	`2722`	`AddUndefined = 1 << 13, // Add undefined to types of initialized, non-optional parameters`
`2723`	`2723`	`WriteClassExpressionAsTypeLiteral = 1 << 14, // Write a type literal instead of (Anonymous class)`
`2724`	`2724`	`InArrayType = 1 << 15, // Writing an array element type`
	`2725`	+ UseAliasDefinedOutsideCurrentScope = 1 << 16, // For a `type T = ... ` defined in a different file, write `T` instead of its value,
	`2726`	+ // even though `T` can't be accessed in the current scope.
`2725`	`2727`	`}`
`2726`	`2728`
`2727`	`2729`	`export const enum SymbolFormatFlags {`
Original file line number	Diff line number	Diff line change
`@@ -1261,6 +1261,7 @@ namespace ts {`
`1261`	`1261`	`}`
`1262`	`1262`
`1263`	`1263`	`export function signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[] {`
	`1264`	`+ flags \|= TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;`
`1264`	`1265`	`return mapToDisplayParts(writer => {`
`1265`	`1266`	`typechecker.getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags);`
`1266`	`1267`	`});`