Don't add excess properties to type nodes in typeToTypeNode

Author: rbuckton

src/compiler/checker.ts

@@ -5759,7 +5759,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                         context.truncating = true;
                     }
                     context.approximateLength += cachedResult.addedLength;
-                    return deepCloneOrReuseNode(cachedResult) as TypeNode as T;
+                    return deepCloneOrReuseNode(cachedResult.node) as T;
                 }
 
                 let depth: number | undefined;
@@ -5775,11 +5775,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 const result = transform(type);
                 const addedLength = context.approximateLength - startLength;
                 if (!context.reportedDiagnostic && !context.encounteredError) {
-                    if (context.truncating) {
-                        (result as any).truncating = true;
-                    }
-                    (result as any).addedLength = addedLength;
-                    links?.serializedTypes?.set(key, result as TypeNode as TypeNode & {truncating?: boolean, addedLength: number});
+                    links?.serializedTypes?.set(key, { node: result, truncating: context.truncating, addedLength });
                 }
                 context.visitedTypes.delete(typeId);
                 if (id) {

src/compiler/types.ts

@@ -5919,12 +5919,19 @@ export interface NodeLinks {
     isExhaustive?: boolean | 0;         // Is node an exhaustive switch statement (0 indicates in-process resolution)
     skipDirectInference?: true;         // Flag set by the API `getContextualType` call on a node when `Completions` is passed to force the checker to skip making inferences to a node's type
     declarationRequiresScopeChange?: boolean; // Set by `useOuterVariableScopeInParameter` in checker when downlevel emit would change the name resolution scope inside of a parameter.
-    serializedTypes?: ESMap<string, TypeNode & {truncating?: boolean, addedLength: number}>; // Collection of types serialized at this location
+    serializedTypes?: ESMap<string, SerializedTypeEntry>; // Collection of types serialized at this location
 
     contextualType?: Type;              // Used to temporarily assign a contextual type during overload resolution
     inferenceContext?: InferenceContext; // Inference context for contextual type
 }
 
+/** @internal */
+export interface SerializedTypeEntry {
+    node: TypeNode;
+    truncating?: boolean;
+    addedLength: number;
+}
+
 export const enum TypeFlags {
     Any             = 1 << 0,
     Unknown         = 1 << 1,