Fix unique symbol .d.ts generation and add baseline test

Author: Akshit222

src/compiler/emitter.ts

@@ -423,15 +423,41 @@ import {
     WriteFileCallbackData,
     YieldExpression,
 } from "./_namespaces/ts.js";
+import { isTypeReferenceNode, TypeFlags, TypeChecker } from "./_namespaces/ts.js";
 import * as performance from "./_namespaces/ts.performance.js";
-
 const brackets = createBracketsMap();
 
+
+
 /** @internal */
+export function isUniqueSymbolDeclaration(node: VariableDeclarationList, checker: TypeChecker): boolean {
+    return node.declarations.some((decl: VariableDeclaration) => {
+        // 1. If type is explicitly written, handle as before
+        const typeNode: TypeNode | undefined = decl.type;
+        if (typeNode) {
+            if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName)) {
+                if (typeNode.typeName.escapedText.toString() === "unique symbol") {
+                    return true;
+                }
+            }
+            if ((typeNode.kind as SyntaxKind) === SyntaxKind.UniqueKeyword) {
+                return true;
+            }
+        }
+        // 2. Otherwise, check the inferred type
+        const type = checker.getTypeAtLocation(decl.name);
+        if (type.flags & TypeFlags.UniqueESSymbol) {
+            return true;
+        }
+
+        return false;
+    });
+}
+
 export function isBuildInfoFile(file: string): boolean {
     return fileExtensionIs(file, Extension.TsBuildInfo);
 }
-
+ 
 /**
  * Iterates over the source files that are expected to have an emit output.
  *
@@ -741,6 +767,7 @@ export function emitFiles(
     onlyBuildInfo: boolean,
     forceDtsEmit?: boolean,
     skipBuildInfo?: boolean,
+    emitTypeChecker?: TypeChecker,
 ): EmitResult {
     // Why var? It avoids TDZ checks in the runtime which can be costly.
     // See: https://github.com/microsoft/TypeScript/issues/52924
@@ -841,7 +868,7 @@ export function emitFiles(
             extendedDiagnostics: compilerOptions.extendedDiagnostics,
         };
 
-        // Create a printer to print the nodes
+        const typeChecker = emitTypeChecker;
         const printer = createPrinter(printerOptions, {
             // resolver hooks
             hasGlobalName: resolver.hasGlobalName,
@@ -850,12 +877,11 @@ export function emitFiles(
             onEmitNode: transform.emitNodeWithNotification,
             isEmitNotificationEnabled: transform.isEmitNotificationEnabled,
             substituteNode: transform.substituteNode,
-        });
+        }, typeChecker);
 
         Debug.assert(transform.transformed.length === 1, "Should only see one output from the transform");
         printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform, printer, compilerOptions);
 
-        // Clean up emit nodes on parse tree
         transform.dispose();
 
         if (emittedFilesList) {
@@ -900,6 +926,8 @@ export function emitFiles(
             }
         }
 
+        // TypeChecker is already captured in the closure above
+
         const declBlocked = (!!declarationTransform.diagnostics && !!declarationTransform.diagnostics.length) || !!host.isEmitBlocked(declarationFilePath) || !!compilerOptions.noEmit;
         emitSkipped = emitSkipped || declBlocked;
         if (!declBlocked || forceDtsEmit) {
@@ -1191,7 +1219,7 @@ export const createPrinterWithRemoveCommentsNeverAsciiEscape: () => Printer = /*
 /** @internal */
 export const createPrinterWithRemoveCommentsOmitTrailingSemicolon: () => Printer = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true, omitTrailingSemicolon: true }));
 
-export function createPrinter(printerOptions: PrinterOptions = {}, handlers: PrintHandlers = {}): Printer {
+export function createPrinter(printerOptions: PrinterOptions = {}, handlers: PrintHandlers = {}, typeChecker?: TypeChecker): Printer {
     // Why var? It avoids TDZ checks in the runtime which can be costly.
     // See: https://github.com/microsoft/TypeScript/issues/52924
     /* eslint-disable no-var */
@@ -3343,7 +3371,6 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
         writeSpace();
         emit(node.caseBlock);
     }
-
     function emitLabeledStatement(node: LabeledStatement) {
         emit(node.label);
         emitTokenWithComment(SyntaxKind.ColonToken, node.label.end, writePunctuation, node);
@@ -3394,18 +3421,24 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
             writeKeyword("await");
             writeSpace();
             writeKeyword("using");
-        }
-        else {
-            const head = isLet(node) ? "let" :
+        } else {
+            // Check if unique symbol and use const instead of var
+            const isUnique = typeChecker && isUniqueSymbolDeclaration(node, typeChecker);
+            const head =
+                isLet(node) ? "let" :
                 isVarConst(node) ? "const" :
                 isVarUsing(node) ? "using" :
+                isUnique ? "const" :
                 "var";
+            
             writeKeyword(head);
         }
-        writeSpace();
+    
+            writeSpace();
         emitList(node, node.declarations, ListFormat.VariableDeclarationList);
     }
 
+
     function emitFunctionDeclaration(node: FunctionDeclaration) {
         emitFunctionDeclarationOrExpression(node);
     }

src/compiler/transformers/declarations.ts

@@ -111,6 +111,7 @@ import {
     isFunctionDeclaration,
     isFunctionLike,
     isGlobalScopeAugmentation,
+    isIdentifier,
     isIdentifierText,
     isImportEqualsDeclaration,
     isIndexSignatureDeclaration,
@@ -140,6 +141,7 @@ import {
     isStringLiteralLike,
     isTupleTypeNode,
     isTypeAliasDeclaration,
+    isTypeReferenceNode,
     isTypeElement,
     isTypeLiteralNode,
     isTypeNode,
@@ -217,6 +219,18 @@ import {
     VisitResult,
 } from "../_namespaces/ts.js";
 
+
+function isUniqueSymbolByType(type: TypeNode | undefined): boolean {
+    if (!type) return false;
+    
+    if (type.kind === SyntaxKind.TypeOperator && (type as any).operator === SyntaxKind.UniqueKeyword) return true;
+
+    if (isTypeReferenceNode(type) && isIdentifier(type.typeName)) {
+        if (type.typeName.escapedText === "unique symbol") return true;
+    }
+    return false;
+}
+
 /** @internal */
 export function getDeclarationDiagnostics(
     host: EmitHost,
@@ -1479,7 +1493,15 @@ export function transformDeclarations(context: TransformationContext): Transform
                             exportMappings.push([name, nameStr]);
                         }
                         const varDecl = factory.createVariableDeclaration(name, /*exclamationToken*/ undefined, type, /*initializer*/ undefined);
-                        return factory.createVariableStatement(isNonContextualKeywordName ? undefined : [factory.createToken(SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([varDecl]));
+                        const shouldForceConst = isUniqueSymbolByType(type);
+
+                        const declList = factory.createVariableDeclarationList(
+                            [varDecl],
+                            shouldForceConst ? NodeFlags.Const : NodeFlags.None
+                        );
+                        
+                        return factory.createVariableStatement(
+                            isNonContextualKeywordName ? undefined : [factory.createToken(SyntaxKind.ExportKeyword)],declList);
                     });
                     if (!exportMappings.length) {
                         declarations = mapDefined(declarations, declaration => factory.replaceModifiers(declaration, ModifierFlags.None));
@@ -1971,4 +1993,4 @@ function isProcessedComponent(node: Node): node is ProcessedComponent {
             return true;
     }
     return false;
-}
+}

tests/baselines/reference/api/typescript.d.ts

@@ -9499,9 +9499,10 @@ declare namespace ts {
      * @param context A lexical environment context for the visitor.
      */
     function visitEachChild<T extends Node>(node: T | undefined, visitor: Visitor, context: TransformationContext | undefined, nodesVisitor?: typeof visitNodes, tokenVisitor?: Visitor): T | undefined;
+    function isBuildInfoFile(file: string): boolean;
     function getTsBuildInfoEmitOutputFilePath(options: CompilerOptions): string | undefined;
     function getOutputFileNames(commandLine: ParsedCommandLine, inputFileName: string, ignoreCase: boolean): readonly string[];
-    function createPrinter(printerOptions?: PrinterOptions, handlers?: PrintHandlers): Printer;
+    function createPrinter(printerOptions?: PrinterOptions, handlers?: PrintHandlers, typeChecker?: TypeChecker): Printer;
     enum ProgramUpdateLevel {
         /** Program is updated with same root file names and options */
         Update = 0,

tests/baselines/reference/uniqueSymbolReassignment.errors.txt

@@ -0,0 +1,48 @@
+uniqueSymbolReassignment.ts(2,18): error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later.
+uniqueSymbolReassignment.ts(7,23): error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later.
+uniqueSymbolReassignment.ts(19,26): error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later.
+uniqueSymbolReassignment.ts(20,26): error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later.
+
+
+==== uniqueSymbolReassignment.ts (4 errors) ====
+    // This is a unique symbol (const + Symbol())
+    const mySymbol = Symbol('Symbols.mySymbol');
+                     ~~~~~~
+!!! error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later.
+    const Symbols = {
+        mySymbol
+    } as const;
+    
+    const anotherUnique = Symbol('symbols.anotherUnique');
+                          ~~~~~~
+!!! error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later.
+    const Symbols2 = {
+        anotherUnique
+    } as const;
+    
+    function myFunction() {}
+    
+    // Attach the unique ones
+    myFunction.mySymbol = Symbols.mySymbol;
+    myFunction.anotherUnique = Symbols2.anotherUnique;
+    
+    // Non-unique symbols (regular Symbol() without const)
+    const nonUniqueSymbol1 = Symbol('nonUnique1');
+                             ~~~~~~
+!!! error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later.
+    const nonUniqueSymbol2 = Symbol('nonUnique2');
+                             ~~~~~~
+!!! error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later.
+    
+    // Plain text variables (not symbols at all)
+    const normalVar = "not a symbol";
+    const symbolName = "this contains symbol but is not one";
+    
+    // Attach those as well
+    myFunction.nonUnique1 = nonUniqueSymbol1;
+    myFunction.nonUnique2 = nonUniqueSymbol2;
+    myFunction.normalVar = normalVar;
+    myFunction.symbolName = symbolName;
+    
+    export { myFunction };
+    

tests/baselines/reference/uniqueSymbolReassignment.js

@@ -0,0 +1,65 @@
+//// [tests/cases/compiler/uniqueSymbolReassignment.ts] ////
+
+//// [uniqueSymbolReassignment.ts]
+// This is a unique symbol (const + Symbol())
+const mySymbol = Symbol('Symbols.mySymbol');
+const Symbols = {
+    mySymbol
+} as const;
+
+const anotherUnique = Symbol('symbols.anotherUnique');
+const Symbols2 = {
+    anotherUnique
+} as const;
+
+function myFunction() {}
+
+// Attach the unique ones
+myFunction.mySymbol = Symbols.mySymbol;
+myFunction.anotherUnique = Symbols2.anotherUnique;
+
+// Non-unique symbols (regular Symbol() without const)
+const nonUniqueSymbol1 = Symbol('nonUnique1');
+const nonUniqueSymbol2 = Symbol('nonUnique2');
+
+// Plain text variables (not symbols at all)
+const normalVar = "not a symbol";
+const symbolName = "this contains symbol but is not one";
+
+// Attach those as well
+myFunction.nonUnique1 = nonUniqueSymbol1;
+myFunction.nonUnique2 = nonUniqueSymbol2;
+myFunction.normalVar = normalVar;
+myFunction.symbolName = symbolName;
+
+export { myFunction };
+
+
+//// [uniqueSymbolReassignment.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.myFunction = myFunction;
+// This is a unique symbol (const + Symbol())
+var mySymbol = Symbol('Symbols.mySymbol');
+var Symbols = {
+    mySymbol: mySymbol
+};
+var anotherUnique = Symbol('symbols.anotherUnique');
+var Symbols2 = {
+    anotherUnique: anotherUnique
+};
+function myFunction() { }
+// Attach the unique ones
+myFunction.mySymbol = Symbols.mySymbol;
+myFunction.anotherUnique = Symbols2.anotherUnique;
+// Non-unique symbols (regular Symbol() without const)
+var nonUniqueSymbol1 = Symbol('nonUnique1');
+var nonUniqueSymbol2 = Symbol('nonUnique2');
+// Plain text variables (not symbols at all)
+var normalVar = "not a symbol";
+var symbolName = "this contains symbol but is not one";
+// Attach those as well
+myFunction.nonUnique1 = nonUniqueSymbol1;
+myFunction.nonUnique2 = nonUniqueSymbol2;
+myFunction.normalVar = normalVar;
+myFunction.symbolName = symbolName;