Emit type queries for inaccessible unique symbol aliases

Preserve const alias identities in declaration output and refresh the unique-symbol declaration baselines.

Co-authored-by: Codex <codex@openai.com>

Author: michaelfig

tsc/internal/checker/nodebuilderimpl.go

@@ -2352,6 +2352,14 @@ func (b *NodeBuilderImpl) serializeTypeForDeclaration(declaration *ast.Declarati
 			remove()
 		}
 	}
+	if result == nil {
+		if declaration != nil && ast.IsVariableDeclaration(declaration) && t.flags&TypeFlagsUniqueESSymbol != 0 && !b.ch.IsValueSymbolAccessible(t.symbol, b.ctx.enclosingDeclaration) {
+			initializer := declaration.Initializer()
+			if initializer != nil && ast.IsEntityNameExpression(initializer) {
+				result = b.f.NewTypeQueryNode(b.f.DeepCloneNode(initializer), nil)
+			}
+		}
+	}
 	if result == nil {
 		if reportedInferenceFallback {
 			oldSuppress := b.ctx.suppressReportInferenceFallback

tsc/testdata/baselines/reference/conformance/uniqueSymbolsDeclarations.js

@@ -415,10 +415,10 @@ declare let letCall: symbol;
 declare var varCall: symbol;
 declare const constType: unique symbol;
 declare const constTypeAndCall: unique symbol;
-declare const constInitToConstCall: symbol;
+declare const constInitToConstCall: typeof constCall;
 declare const constInitToLetCall: symbol;
 declare const constInitToVarCall: symbol;
-declare const constInitToConstDeclAmbient: symbol;
+declare const constInitToConstDeclAmbient: typeof constType;
 declare let letInitToConstCall: symbol;
 declare let letInitToLetCall: symbol;
 declare let letInitToVarCall: symbol;
@@ -452,9 +452,9 @@ declare class C {
     readwriteCall: symbol;
 }
 declare const c: C;
-declare const constInitToCReadonlyStaticCall: symbol;
-declare const constInitToCReadonlyStaticType: symbol;
-declare const constInitToCReadonlyStaticTypeAndCall: symbol;
+declare const constInitToCReadonlyStaticCall: typeof C.readonlyStaticCall;
+declare const constInitToCReadonlyStaticType: typeof C.readonlyStaticType;
+declare const constInitToCReadonlyStaticTypeAndCall: typeof C.readonlyStaticTypeAndCall;
 declare const constInitToCReadwriteStaticCall: symbol;
 declare const constInitToCReadonlyStaticCallWithTypeQuery: typeof C.readonlyStaticCall;
 declare const constInitToCReadonlyStaticTypeWithTypeQuery: typeof C.readonlyStaticType;
@@ -470,7 +470,7 @@ interface I {
     readonly readonlyType: unique symbol;
 }
 declare const i: I;
-declare const constInitToIReadonlyType: symbol;
+declare const constInitToIReadonlyType: I["readonlyType"];
 declare const constInitToIReadonlyTypeWithTypeQuery: typeof i.readonlyType;
 declare const constInitToIReadonlyTypeWithIndexedAccess: I["readonlyType"];
 type L = {
@@ -480,8 +480,8 @@ type L = {
     };
 };
 declare const l: L;
-declare const constInitToLReadonlyType: symbol;
-declare const constInitToLReadonlyNestedType: symbol;
+declare const constInitToLReadonlyType: typeof l.readonlyType;
+declare const constInitToLReadonlyNestedType: typeof l.nested.readonlyNestedType;
 declare const constInitToLReadonlyTypeWithTypeQuery: typeof l.readonlyType;
 declare const constInitToLReadonlyNestedTypeWithTypeQuery: typeof l.nested.readonlyNestedType;
 declare const constInitToLReadonlyTypeWithIndexedAccess: L["readonlyType"];
@@ -510,15 +510,15 @@ declare const o2: {
     method5(p?: symbol): symbol;
 };
 declare class C0 {
-    static readonly a: symbol;
-    static readonly b: symbol;
-    static readonly c: symbol;
+    static readonly a: typeof s;
+    static readonly b: typeof N.s;
+    static readonly c: typeof N.s;
     static d: symbol;
     static e: symbol;
     static f: symbol;
-    readonly a: symbol;
-    readonly b: symbol;
-    readonly c: symbol;
+    readonly a: typeof s;
+    readonly b: typeof N.s;
+    readonly c: typeof N.s;
     d: symbol;
     e: symbol;
     f: symbol;

tsc/testdata/baselines/reference/conformance/uniqueSymbolsDeclarations.types

@@ -29,7 +29,7 @@ const constTypeAndCall: unique symbol = Symbol();
 
 // declaration from initializer
 const constInitToConstCall = constCall;
->constInitToConstCall : symbol
+>constInitToConstCall : unique symbol
 >constCall : unique symbol
 
 const constInitToLetCall = letCall;
@@ -41,7 +41,7 @@ const constInitToVarCall = varCall;
 >varCall : symbol
 
 const constInitToConstDeclAmbient = constType;
->constInitToConstDeclAmbient : symbol
+>constInitToConstDeclAmbient : unique symbol
 >constType : unique symbol
 
 let letInitToConstCall = constCall;
@@ -194,19 +194,19 @@ declare const c: C;
 >c : C
 
 const constInitToCReadonlyStaticCall = C.readonlyStaticCall;
->constInitToCReadonlyStaticCall : symbol
+>constInitToCReadonlyStaticCall : unique symbol
 >C.readonlyStaticCall : unique symbol
 >C : typeof C
 >readonlyStaticCall : unique symbol
 
 const constInitToCReadonlyStaticType = C.readonlyStaticType;
->constInitToCReadonlyStaticType : symbol
+>constInitToCReadonlyStaticType : unique symbol
 >C.readonlyStaticType : unique symbol
 >C : typeof C
 >readonlyStaticType : unique symbol
 
 const constInitToCReadonlyStaticTypeAndCall = C.readonlyStaticTypeAndCall;
->constInitToCReadonlyStaticTypeAndCall : symbol
+>constInitToCReadonlyStaticTypeAndCall : unique symbol
 >C.readonlyStaticTypeAndCall : unique symbol
 >C : typeof C
 >readonlyStaticTypeAndCall : unique symbol
@@ -304,7 +304,7 @@ declare const i: I;
 >i : I
 
 const constInitToIReadonlyType = i.readonlyType;
->constInitToIReadonlyType : symbol
+>constInitToIReadonlyType : unique symbol
 >i.readonlyType : unique symbol
 >i : I
 >readonlyType : unique symbol
@@ -342,13 +342,13 @@ declare const l: L;
 >l : L
 
 const constInitToLReadonlyType = l.readonlyType;
->constInitToLReadonlyType : symbol
+>constInitToLReadonlyType : unique symbol
 >l.readonlyType : unique symbol
 >l : L
 >readonlyType : unique symbol
 
 const constInitToLReadonlyNestedType = l.nested.readonlyNestedType;
->constInitToLReadonlyNestedType : symbol
+>constInitToLReadonlyNestedType : unique symbol
 >l.nested.readonlyNestedType : unique symbol
 >l.nested : { readonly readonlyNestedType: unique symbol; }
 >l : L
@@ -529,17 +529,17 @@ class C0 {
 >C0 : C0
 
     static readonly a = s;
->a : symbol
+>a : unique symbol
 >s : unique symbol
 
     static readonly b = N.s;
->b : symbol
+>b : unique symbol
 >N.s : unique symbol
 >N : typeof N
 >s : unique symbol
 
     static readonly c = N["s"];
->c : symbol
+>c : unique symbol
 >N["s"] : unique symbol
 >N : typeof N
 >"s" : "s"
@@ -561,17 +561,17 @@ class C0 {
 >"s" : "s"
 
     readonly a = s;
->a : symbol
+>a : unique symbol
 >s : unique symbol
 
     readonly b = N.s;
->b : symbol
+>b : unique symbol
 >N.s : unique symbol
 >N : typeof N
 >s : unique symbol
 
     readonly c = N["s"];
->c : symbol
+>c : unique symbol
 >N["s"] : unique symbol
 >N : typeof N
 >"s" : "s"