fix(compiler): remove unused export and unnecessary @internal from isUniqueSymbolDeclaration

Author: Akshit222

src/compiler/emitter.ts

@@ -423,39 +423,11 @@ import {
     WriteFileCallbackData,
     YieldExpression,
 } from "./_namespaces/ts.js";
-import {
-    isTypeReferenceNode,
-    TypeChecker,
-    TypeFlags,
-} 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);
 }
@@ -769,7 +741,6 @@ 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
@@ -870,7 +841,7 @@ export function emitFiles(
             extendedDiagnostics: compilerOptions.extendedDiagnostics,
         };
 
-        const typeChecker = emitTypeChecker;
+        // Create a printer to print the nodes
         const printer = createPrinter(printerOptions, {
             // resolver hooks
             hasGlobalName: resolver.hasGlobalName,
@@ -879,11 +850,12 @@ 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) {
@@ -928,8 +900,6 @@ 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) {
@@ -1221,7 +1191,7 @@ export const createPrinterWithRemoveCommentsNeverAsciiEscape: () => Printer = /*
 /** @internal */
 export const createPrinterWithRemoveCommentsOmitTrailingSemicolon: () => Printer = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true, omitTrailingSemicolon: true }));
 
-export function createPrinter(printerOptions: PrinterOptions = {}, handlers: PrintHandlers = {}, typeChecker?: TypeChecker): Printer {
+export function createPrinter(printerOptions: PrinterOptions = {}, handlers: PrintHandlers = {}): 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 */
@@ -3373,6 +3343,7 @@ 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);
@@ -3425,17 +3396,12 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
             writeKeyword("using");
         }
         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();
         emitList(node, node.declarations, ListFormat.VariableDeclarationList);
     }

src/compiler/transformers/declarations.ts

@@ -111,7 +111,6 @@ import {
     isFunctionDeclaration,
     isFunctionLike,
     isGlobalScopeAugmentation,
-    isIdentifier,
     isIdentifierText,
     isImportEqualsDeclaration,
     isIndexSignatureDeclaration,
@@ -146,7 +145,6 @@ import {
     isTypeNode,
     isTypeParameterDeclaration,
     isTypeQueryNode,
-    isTypeReferenceNode,
     isVarAwaitUsing,
     isVariableDeclaration,
     isVarUsing,
@@ -205,6 +203,7 @@ import {
     tryCast,
     TypeAliasDeclaration,
     TypeNode,
+    TypeOperatorNode,
     TypeParameterDeclaration,
     TypeReferenceNode,
     unescapeLeadingUnderscores,
@@ -219,17 +218,6 @@ 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,
@@ -1492,17 +1480,10 @@ export function transformDeclarations(context: TransformationContext): Transform
                             exportMappings.push([name, nameStr]);
                         }
                         const varDecl = factory.createVariableDeclaration(name, /*exclamationToken*/ undefined, type, /*initializer*/ undefined);
-                        const shouldForceConst = isUniqueSymbolByType(type);
-
-                        const declList = factory.createVariableDeclarationList(
-                            [varDecl],
-                            shouldForceConst ? NodeFlags.Const : NodeFlags.None,
-                        );
-
-                        return factory.createVariableStatement(
-                            isNonContextualKeywordName ? undefined : [factory.createToken(SyntaxKind.ExportKeyword)],
-                            declList,
-                        );
+                        const modifiers = isNonContextualKeywordName ? undefined : [factory.createToken(SyntaxKind.ExportKeyword)];
+                        const isConst = isUniqueSymbolType(type);
+                        const variableDeclarationList = factory.createVariableDeclarationList([varDecl], isConst ? NodeFlags.Const : NodeFlags.None);
+                        return factory.createVariableStatement(modifiers, variableDeclarationList);
                     });
                     if (!exportMappings.length) {
                         declarations = mapDefined(declarations, declaration => factory.replaceModifiers(declaration, ModifierFlags.None));
@@ -1840,6 +1821,13 @@ export function transformDeclarations(context: TransformationContext): Transform
         return isExportAssignment(node) || isExportDeclaration(node);
     }
 
+    function isUniqueSymbolType(type: TypeNode | undefined): boolean {
+        return !!type &&
+            type.kind === SyntaxKind.TypeOperator &&
+            (type as TypeOperatorNode).operator === SyntaxKind.UniqueKeyword &&
+            (type as TypeOperatorNode).type.kind === SyntaxKind.SymbolKeyword;
+    }
+
     function hasScopeMarker(statements: readonly Statement[]) {
         return some(statements, isScopeMarker);
     }