Simplify declaration emit for literal types.

Author: dragomirtitian

src/compiler/checker.ts

@@ -48387,8 +48387,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         // Get type of the symbol if this is the valid symbol otherwise get type at location
         const symbol = getSymbolOfDeclaration(declaration);
         let type = symbol && !(symbol.flags & (SymbolFlags.TypeLiteral | SymbolFlags.Signature))
-            ? getWidenedLiteralType(getTypeOfSymbol(symbol))
+            ? getTypeOfSymbol(symbol)
             : errorType;
+        if (!isReadonlySymbol(symbol)) {
+            type = getWidenedLiteralType(type);
+        }
         if (
             type.flags & TypeFlags.UniqueESSymbol &&
             type.symbol === symbol
@@ -48518,29 +48521,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return undefined;
     }
 
-    function isLiteralConstDeclaration(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration): boolean {
-        if (isDeclarationReadonly(node) || isVariableDeclaration(node) && isVarConstLike(node)) {
-            return isFreshLiteralType(getTypeOfSymbol(getSymbolOfDeclaration(node)));
-        }
-        return false;
-    }
-
-    function literalTypeToNode(type: FreshableType, enclosing: Node, tracker: SymbolTracker): Expression {
-        const enumResult = type.flags & TypeFlags.EnumLike ? nodeBuilder.symbolToExpression(type.symbol, SymbolFlags.Value, enclosing, /*flags*/ undefined, tracker)
-            : type === trueType ? factory.createTrue() : type === falseType && factory.createFalse();
-        if (enumResult) return enumResult;
-        const literalValue = (type as LiteralType).value;
-        return typeof literalValue === "object" ? factory.createBigIntLiteral(literalValue) :
-            typeof literalValue === "string" ? factory.createStringLiteral(literalValue) :
-            literalValue < 0 ? factory.createPrefixUnaryExpression(SyntaxKind.MinusToken, factory.createNumericLiteral(-literalValue)) :
-            factory.createNumericLiteral(literalValue);
-    }
-
-    function createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration, tracker: SymbolTracker) {
-        const type = getTypeOfSymbol(getSymbolOfDeclaration(node));
-        return literalTypeToNode(type as FreshableType, node, tracker);
-    }
-
     function getJsxFactoryEntity(location: Node): EntityName | undefined {
         return location ? (getJsxNamespace(location), (getSourceFileOfNode(location).localJsxFactory || _jsxFactoryEntity)) : _jsxFactoryEntity;
     }
@@ -48617,7 +48597,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             createTypeOfDeclaration,
             createReturnTypeOfSignatureDeclaration,
             createTypeOfExpression,
-            createLiteralConstValue,
             isSymbolAccessible,
             isEntityNameVisible,
             getConstantValue: nodeIn => {
@@ -48637,7 +48616,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             },
             getTypeReferenceDirectivesForEntityName,
             getTypeReferenceDirectivesForSymbol,
-            isLiteralConstDeclaration,
             isLateBound: (nodeIn: Declaration): nodeIn is LateBoundDeclaration => {
                 const node = getParseTreeNode(nodeIn, isDeclaration);
                 const symbol = node && getSymbolOfDeclaration(node);

src/compiler/emitter.ts

@@ -1168,7 +1168,6 @@ export const notImplementedResolver: EmitResolver = {
     createTypeOfDeclaration: notImplemented,
     createReturnTypeOfSignatureDeclaration: notImplemented,
     createTypeOfExpression: notImplemented,
-    createLiteralConstValue: notImplemented,
     isSymbolAccessible: notImplemented,
     isEntityNameVisible: notImplemented,
     // Returns the constant value this property access resolves to: notImplemented, or 'undefined' for a non-constant
@@ -1182,7 +1181,6 @@ export const notImplementedResolver: EmitResolver = {
     getExternalModuleFileFromDeclaration: notImplemented,
     getTypeReferenceDirectivesForEntityName: notImplemented,
     getTypeReferenceDirectivesForSymbol: notImplemented,
-    isLiteralConstDeclaration: notImplemented,
     getJsxFactoryEntity: notImplemented,
     getJsxFragmentFactoryEntity: notImplemented,
     getAllAccessorDeclarations: notImplemented,

src/compiler/transformers/declarations.ts

@@ -14,6 +14,7 @@ import {
     canHaveModifiers,
     canProduceDiagnostics,
     ClassDeclaration,
+    clonePrimitiveLiteralValue,
     compact,
     concatenate,
     ConditionalTypeNode,
@@ -98,6 +99,7 @@ import {
     isClassElement,
     isComputedPropertyName,
     isDeclaration,
+    isDeclarationReadonly,
     isEntityName,
     isEntityNameExpression,
     isExpandoPropertyDeclaration,
@@ -127,6 +129,7 @@ import {
     isModifier,
     isModuleDeclaration,
     isOmittedExpression,
+    isPrimitiveLiteralValue,
     isPrivateIdentifier,
     isPropertySignature,
     isSemicolonClassElement,
@@ -146,6 +149,7 @@ import {
     isTypeQueryNode,
     isUnparsedSource,
     isVarAwaitUsing,
+    isVarConstLike,
     isVariableDeclaration,
     isVarUsing,
     LateBoundDeclaration,
@@ -177,6 +181,7 @@ import {
     parseNodeFactory,
     pathContainsNodeModules,
     pathIsRelative,
+    PrimitiveLiteral,
     PropertyDeclaration,
     PropertySignature,
     pushIfUnique,
@@ -707,13 +712,16 @@ export function transformDeclarations(context: TransformationContext) {
         return newParam;
     }
 
-    function shouldPrintWithInitializer(node: Node) {
-        return canHaveLiteralInitializer(node) && resolver.isLiteralConstDeclaration(getParseTreeNode(node) as CanHaveLiteralInitializer); // TODO: Make safe
+    function shouldPrintWithInitializer(node: Node): node is Node & { initializer: PrimitiveLiteral; } {
+        if (canHaveLiteralInitializer(node) && node.initializer && !node.type && isPrimitiveLiteralValue(node.initializer)) {
+            return isDeclarationReadonly(node) || isVariableDeclaration(node) && isVarConstLike(node);
+        }
+        return false;
     }
 
     function ensureNoInitializer(node: CanHaveLiteralInitializer) {
         if (shouldPrintWithInitializer(node)) {
-            return resolver.createLiteralConstValue(getParseTreeNode(node) as CanHaveLiteralInitializer, symbolTracker); // TODO: Make safe
+            return clonePrimitiveLiteralValue(node.initializer);
         }
         return undefined;
     }
@@ -1956,7 +1964,7 @@ function getTypeAnnotationFromAccessor(accessor: AccessorDeclaration): TypeNode
 }
 
 type CanHaveLiteralInitializer = VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration;
-function canHaveLiteralInitializer(node: Node): boolean {
+function canHaveLiteralInitializer(node: Node): node is CanHaveLiteralInitializer {
     switch (node.kind) {
         case SyntaxKind.PropertyDeclaration:
         case SyntaxKind.PropertySignature:

src/compiler/types.ts

@@ -1384,6 +1384,15 @@ export type HasIllegalModifiers =
     | MissingDeclaration
     | NamespaceExportDeclaration;
 
+/** @internal */
+export type PrimitiveLiteral =
+    | BooleanLiteral
+    | NumericLiteral
+    | StringLiteral
+    | NoSubstitutionTemplateLiteral
+    | BigIntLiteral
+    | PrefixUnaryExpression;
+
 /**
  * Declarations that can contain other declarations. Corresponds with `ContainerFlags.IsContainer` in binder.ts.
  *
@@ -5706,7 +5715,6 @@ export interface EmitResolver {
     createTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration | PropertyAccessExpression | ElementAccessExpression | BinaryExpression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker, addUndefined?: boolean): TypeNode | undefined;
     createReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
     createTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
-    createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration, tracker: SymbolTracker): Expression;
     isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags | undefined, shouldComputeAliasToMarkVisible: boolean): SymbolAccessibilityResult;
     isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult;
     // Returns the constant value this property access resolves to, or 'undefined' for a non-constant
@@ -5720,7 +5728,6 @@ export interface EmitResolver {
     getExternalModuleFileFromDeclaration(declaration: ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration | ModuleDeclaration | ImportTypeNode | ImportCall): SourceFile | undefined;
     getTypeReferenceDirectivesForEntityName(name: EntityNameOrEntityNameExpression): [specifier: string, mode: ResolutionMode][] | undefined;
     getTypeReferenceDirectivesForSymbol(symbol: Symbol, meaning?: SymbolFlags): [specifier: string, mode: ResolutionMode][] | undefined;
-    isLiteralConstDeclaration(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration): boolean;
     getJsxFactoryEntity(location?: Node): EntityName | undefined;
     getJsxFragmentFactoryEntity(location?: Node): EntityName | undefined;
     getAllAccessorDeclarations(declaration: AccessorDeclaration): AllAccessorDeclarations;

src/compiler/utilities.ts

@@ -447,6 +447,7 @@ import {
     Pattern,
     PostfixUnaryExpression,
     PrefixUnaryExpression,
+    PrimitiveLiteral,
     PrinterOptions,
     PrintHandlers,
     PrivateIdentifier,
@@ -2350,6 +2351,14 @@ export function isLet(node: Node): boolean {
     return (getCombinedNodeFlags(node) & NodeFlags.BlockScoped) === NodeFlags.Let;
 }
 
+/** @internal */
+export function isVarConstLike(node: VariableDeclaration | VariableDeclarationList) {
+    const blockScopeKind = getCombinedNodeFlags(node) & NodeFlags.BlockScoped;
+    return blockScopeKind === NodeFlags.Const ||
+        blockScopeKind === NodeFlags.Using ||
+        blockScopeKind === NodeFlags.AwaitUsing;
+}
+
 /** @internal */
 export function isSuperCall(n: Node): n is SuperCall {
     return n.kind === SyntaxKind.CallExpression && (n as CallExpression).expression.kind === SyntaxKind.SuperKeyword;
@@ -10671,3 +10680,66 @@ export function replaceFirstStar(s: string, replacement: string): string {
 export function getNameFromImportAttribute(node: ImportAttribute) {
     return isIdentifier(node.name) ? node.name.escapedText : escapeLeadingUnderscores(node.name.text);
 }
+
+/** @internal */
+export function isPrimitiveLiteralValue(node: Expression, includeBigInt = true): node is PrimitiveLiteral {
+    Debug.type<PrimitiveLiteral>(node);
+    switch (node.kind) {
+        case SyntaxKind.TrueKeyword:
+        case SyntaxKind.FalseKeyword:
+        case SyntaxKind.NumericLiteral:
+        case SyntaxKind.StringLiteral:
+        case SyntaxKind.NoSubstitutionTemplateLiteral:
+            return true;
+        case SyntaxKind.BigIntLiteral:
+            return includeBigInt;
+        case SyntaxKind.PrefixUnaryExpression:
+            if (node.operator === SyntaxKind.MinusToken) {
+                return isNumericLiteral(node.operand) || (includeBigInt && isBigIntLiteral(node.operand));
+            }
+            if (node.operator === SyntaxKind.PlusToken) {
+                return isNumericLiteral(node.operand);
+            }
+            return false;
+        default:
+            assertType<never>(node);
+            return false;
+    }
+}
+
+/**
+ * @internal
+ *
+ * Clone literal value while normalizing it (converts octals/hex to base 10, uses double quotes strings)
+ */
+export function clonePrimitiveLiteralValue<T extends PrimitiveLiteral>(node: T): T;
+export function clonePrimitiveLiteralValue(node: PrimitiveLiteral): PrimitiveLiteral {
+    switch (node.kind) {
+        case SyntaxKind.NumericLiteral:
+            return factory.createNumericLiteral(node.text);
+        case SyntaxKind.BigIntLiteral:
+            return factory.createBigIntLiteral({ negative: false, base10Value: parsePseudoBigInt(node.text) });
+        case SyntaxKind.StringLiteral:
+        case SyntaxKind.NoSubstitutionTemplateLiteral:
+            return factory.createStringLiteral(node.text);
+        case SyntaxKind.FalseKeyword:
+            return factory.createFalse();
+        case SyntaxKind.TrueKeyword:
+            return factory.createTrue();
+        case SyntaxKind.PrefixUnaryExpression:
+            Debug.assert(isNumericLiteral(node.operand) || isBigIntLiteral(node.operand));
+            if (node.operator === SyntaxKind.PlusToken) {
+                return clonePrimitiveLiteralValue(node.operand);
+            }
+            else if (node.operator === SyntaxKind.MinusToken) {
+                return factory.createPrefixUnaryExpression(
+                    node.operator,
+                    clonePrimitiveLiteralValue(node.operand),
+                );
+            }
+            Debug.fail(`Unable to clone prefixed unary expression with operator ${Debug.formatSyntaxKind(node.operator)}`);
+            break;
+        default:
+            Debug.assertNever(node, `Unable to clone unknown literal type.`);
+    }
+}

tests/baselines/reference/ambientConstLiterals.js

@@ -61,18 +61,18 @@ declare enum E {
 }
 declare const c1 = "abc";
 declare const c2 = 123;
-declare const c3 = "abc";
-declare const c4 = 123;
-declare const c5 = 123;
-declare const c6 = -123;
+declare const c3: "abc";
+declare const c4: 123;
+declare const c5: 123;
+declare const c6: -123;
 declare const c7 = true;
-declare const c8 = E.A;
-declare const c8b = E["non identifier"];
+declare const c8: E.A;
+declare const c8b: (typeof E)["non identifier"];
 declare const c9: {
     x: string;
 };
 declare const c10: number[];
 declare const c11: string;
 declare const c12: number;
-declare const c13: string;
-declare const c14: number;
+declare const c13: "abc" | "def";
+declare const c14: 123 | 456;

tests/baselines/reference/computedEnumTypeWidening.js

@@ -170,14 +170,14 @@ declare enum E2 {
     D
 }
 declare function f4(): void;
-declare const c1 = E.B;
+declare const c1: E.B;
 declare const c2: E.B;
 declare let v1: E;
 declare let v2: E.B;
 declare class C {
     p1: E;
     p2: E.B;
-    readonly p3 = E.B;
+    readonly p3: E.B;
     readonly p4: E.B;
 }
 declare enum MyEnum {

tests/baselines/reference/declarationEmitConstantNoWidening.js

@@ -23,5 +23,5 @@ exports.Bar = Bar;
 //// [declarationEmitConstantNoWidening.d.ts]
 export declare const FOO = "FOO";
 export declare class Bar {
-    readonly type = "FOO";
+    readonly type: "FOO";
 }

tests/baselines/reference/declarationEmitEnumReadonlyProperty.js

@@ -33,6 +33,6 @@ declare enum E {
     B = "b"
 }
 declare class C {
-    readonly type = E.A;
+    readonly type: E.A;
 }
 declare let x: E.A;

tests/baselines/reference/enumDeclarationEmitInitializerHasImport.js

@@ -34,4 +34,4 @@ export declare enum Enum {
 }
 //// [consumer.d.ts]
 import provider = require('./provider');
-export declare const value = provider.Enum.Value1;
+export declare const value: provider.Enum.Value1;