tsc-ts 0.0.5 → 0.0.6

package/dist/api/compiler/transformers/declarations-diagnostics.js

@@ -6,6 +6,7 @@ import { isFunctionLikeDeclarationKind } from '../ast-utilities.js';
 import { Diagnostic } from '../diagnostics.js';
 import { isStatement } from '../printer/utilities.js';
 import { isParameterPropertyDeclaration } from './utilities.js';
+import { getDeclarations } from '../symbol.js';
 export function createDiagnosticForNode(node, message, args) {
     const file = getSourceFileOfNode(node);
     const range = getErrorRangeForNode(file, node);
@@ -527,7 +528,7 @@ export function getAllAccessorDeclarations(accessor) {
     let other = undefined;
     const symbol = getSymbol(accessor);
     if (symbol !== undefined)
-        for (const declaration of symbol.declarations)
+        for (const declaration of getDeclarations(symbol))
             if (declaration.kind === otherKind) {
                 other = declaration;
                 break;

package/dist/api/compiler/transformers/declarations-pseudo.js

@@ -6,6 +6,7 @@ import { ArrayLiteralExpression, ArrowFunction, FunctionExpression, MethodDeclar
 import { isFunctionLike, nodeIsMissing } from '../ast-utilities.js';
 import { getCombinedNodeFlags, hasSyntacticModifier, isIdentifierNamed } from '../binder-utilities.js';
 import { getAllAccessorDeclarations } from './declarations-diagnostics.js';
+import { declarationCount, getDeclarations } from '../symbol.js';
 export class PseudoType {
     kind;
     constructor(kind) {
@@ -249,7 +250,7 @@ export class PseudoChecker {
         // A property declared more than once has the type of its first declaration; only the checker
         // knows which, so the type is still written from this one but counted as uncertain.
         const symbol = getSymbol(node);
-        if (symbol !== undefined && symbol.declarations.length > 1)
+        if (symbol !== undefined && declarationCount(symbol) > 1)
             this.uncertain++;
         if (node instanceof PropertyDeclaration) {
             const initializer = node.initializer;
@@ -277,7 +278,8 @@ export class PseudoChecker {
         const initializer = declaration.initializer;
         // As tsgo, the file's own declarations; merged ones are left to the checker's type comparison.
         const symbol = declaration.symbol;
-        if (initializer !== undefined && (symbol === undefined || countVariableDeclarations(symbol.declarations) === 1)) {
+        if (initializer !== undefined &&
+            (symbol === undefined || countVariableDeclarations(getDeclarations(symbol)) === 1)) {
             if (!isContextuallyTyped(declaration)) {
                 // Const template literals may become literal types, so they aren't inferred.
                 if ((getCombinedNodeFlags(declaration) & 2 /* NodeFlags.Const */) !== 0 &&

package/dist/api/compiler/transformers/declarations-syntactic.d.ts

@@ -1,11 +1,11 @@
 import { FileReference, Identifier, type ImportDeclaration, ModifierFlags, type Node, SourceFile, type EntityName } from '../ast.js';
 import type { CompilerOptions, ModuleKind } from '../options.js';
 import type { EmitContext } from '../printer/emit-context.js';
-import { Symbol, SymbolFlags } from '../symbol.js';
 import type { SyntacticEmitResolver } from './emit-resolver.js';
 import type { TypeReferenceSerializationKind } from './type-serialization.js';
 import type { Evaluation } from './reference-resolver.js';
 import { DeclarationEmitResolver, NodeBuilderFlags, SymbolAccessibilityResult, type SymbolTracker } from './declarations-resolver.js';
+import { Symbol, SymbolFlags } from '../symbol.js';
 /** How much of a file's declaration types needed inference. */
 export declare class InferenceCounts {
     /** Types without annotations or literal initializers. */

package/dist/api/compiler/transformers/declarations-syntactic.js

@@ -10,9 +10,9 @@ import { NameResolver } from '../name-resolver.js';
 import { ModuleKind as ModuleKinds } from '../options.js';
 import { combinePaths, getDirectoryPath, getNormalizedAbsolutePath, normalizePath } from '../path.js';
 import { isIdentifierText } from '../scanner.js';
-import { Symbol, addDeclaration } from '../symbol.js';
 import { DeclarationEmitResolver, SymbolAccessibilityResult, accessible, } from './declarations-resolver.js';
 import { DirectType, InferredType, MaybeConstType, NoResultType, ObjectLiteralType, PseudoChecker, SignatureType, TupleType, UnionType, collectReturnStatements, couldAlreadyReferToUndefined, isConstTypeReference, isInConstContext, lastRequiredParameterIndex, typesOf, undefinedType, } from './declarations-pseudo.js';
+import { addDeclaration, declarationCount, getDeclarations, setDeclarations, Symbol, } from '../symbol.js';
 const emptyTable = new Map();
 /** Name resolution without module resolution: an import may name anything. */
 class DeclarationNameResolver extends NameResolver {
@@ -139,7 +139,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
         while (symbol !== undefined && !visited.has(symbol)) {
             visited.add(symbol);
             let next = undefined;
-            for (const declaration of symbol.declarations) {
+            for (const declaration of getDeclarations(symbol)) {
                 this.visibility.set(declaration, true);
                 if (declaration instanceof ImportEqualsDeclaration &&
                     !(declaration.moduleReference instanceof ExternalModuleReference)) {
@@ -270,7 +270,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
     /** Accessible if every declaration is visible or can be made so by keeping an unexported statement. */
     hasVisibleDeclarations(symbol, shouldComputeAliasesToMakeVisible) {
         const aliases = [];
-        for (const declaration of symbol.declarations) {
+        for (const declaration of getDeclarations(symbol)) {
             if (declaration.kind === 79 /* SyntaxKind.Identifier */ || this.isDeclarationVisible(declaration))
                 continue;
             let statement = undefined;
@@ -349,7 +349,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
         if (symbol === undefined)
             return false;
         const signatures = [];
-        const declarations = symbol.declarations;
+        const declarations = getDeclarations(symbol);
         for (let i = 0; i < declarations.length; i++) {
             const declaration = declarations[i];
             if (!isFunctionLike(declaration))
@@ -388,7 +388,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
             if (symbol === undefined)
                 return undefined;
             const resolved = symbol.exportSymbol ?? symbol;
-            return resolved.valueDeclaration ?? (resolved.declarations.length > 0 ? resolved.declarations[0] : undefined);
+            return resolved.valueDeclaration ?? (declarationCount(resolved) > 0 ? resolved.declaration : undefined);
         }
         if (!(node instanceof PropertyAccessExpression) || !(node.name instanceof Identifier))
             return undefined;
@@ -620,7 +620,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
     }
     hasMergedDeclarations(declaration) {
         const symbol = getSymbol(declaration);
-        return symbol !== undefined && this.pseudo.getMergedSymbol(symbol).declarations.length > symbol.declarations.length;
+        return symbol !== undefined && declarationCount(this.pseudo.getMergedSymbol(symbol)) > declarationCount(symbol);
     }
     /** Whether a parameter's pseudo-type already has `undefined`, so none is added. */
     pseudoContainsUndefined(type) {
@@ -1135,7 +1135,7 @@ class PseudoTypeWriter {
 }
 /** Parameters and type parameters are in scope where the signature's types are written. */
 function isSignatureLocal(symbol) {
-    const declaration = symbol.valueDeclaration ?? (symbol.declarations.length > 0 ? symbol.declarations[0] : undefined);
+    const declaration = symbol.valueDeclaration ?? (declarationCount(symbol) > 0 ? symbol.declaration : undefined);
     return (declaration !== undefined &&
         (declaration.kind === 170 /* SyntaxKind.Parameter */ || declaration.kind === 169 /* SyntaxKind.TypeParameter */));
 }
@@ -1488,7 +1488,7 @@ function mergeInto(target, source, mergedSymbols) {
         if (mergedSymbols.get(existing) !== existing) {
             // The first merge replaces the first file's symbol with a copy.
             merged = new Symbol(existing.flags, name);
-            merged.declarations = existing.declarations.slice();
+            setDeclarations(merged, getDeclarations(existing).slice());
             merged.valueDeclaration = existing.valueDeclaration;
             merged.exports = copyTable(existing.exports);
             merged.members = copyTable(existing.members);
@@ -1497,7 +1497,7 @@ function mergeInto(target, source, mergedSymbols) {
             target.set(name, merged);
         }
         merged.flags |= symbol.flags;
-        for (const declaration of symbol.declarations)
+        for (const declaration of getDeclarations(symbol))
             addDeclaration(merged, declaration);
         merged.valueDeclaration ??= symbol.valueDeclaration;
         if (symbol.exports !== undefined) {

package/dist/api/compiler/transformers/declarations-tracker.d.ts

@@ -1,8 +1,8 @@
 import { type Node, type SourceFile } from '../ast.js';
 import { type Diagnostic } from '../diagnostics.js';
-import { type Symbol, SymbolFlags } from '../symbol.js';
 import { DiagnosticContext } from './declarations-diagnostics.js';
 import { type DeclarationEmitResolver, type SymbolAccessibilityResult, SymbolTracker } from './declarations-resolver.js';
+import { type Symbol, SymbolFlags } from '../symbol.js';
 export declare class DeclarationTracker extends SymbolTracker {
     readonly resolver: DeclarationEmitResolver;
     readonly isolatedDeclarations: boolean;

package/dist/api/compiler/transformers/declarations-tracker.js

@@ -4,6 +4,7 @@ import { BinaryExpression, ExportAssignment, Identifier, getExpression } from '.
 import { getNameOfDeclaration, getSourceFileOfNode } from '../binder-utilities.js';
 import { createDiagnosticForNode, createIsolatedDeclarationError, getSymbolAccessibilityDiagnostic, nameToString, noDiagnosticContext, textOfNode, } from './declarations-diagnostics.js';
 import { SymbolTracker, } from './declarations-resolver.js';
+import { getDeclarations } from '../symbol.js';
 export class DeclarationTracker extends SymbolTracker {
     resolver;
     isolatedDeclarations;
@@ -105,14 +106,14 @@ export class DeclarationTracker extends SymbolTracker {
     }
     reportNonlocalAugmentation(containingFile, parentSymbol, augmentingSymbol) {
         let primary = undefined;
-        for (const declaration of parentSymbol.declarations)
+        for (const declaration of getDeclarations(parentSymbol))
             if (getSourceFileOfNode(declaration) === containingFile) {
                 primary = declaration;
                 break;
             }
         if (primary === undefined)
             return false;
-        for (const augmentation of augmentingSymbol.declarations) {
+        for (const augmentation of getDeclarations(augmentingSymbol)) {
             if (getSourceFileOfNode(augmentation) === containingFile)
                 continue;
             const diagnostic = createDiagnosticForNode(augmentation, 1384 /* Diagnostics.Declaration_augments_declaration_in_another_file_This_cannot_be_serialized */, []);

package/dist/api/compiler/transformers/declarations.js

@@ -13,6 +13,7 @@ import { getRelativePathToDirectoryOrUrl } from '../sourcemap.js';
 import { DiagnosticContext, canProduceDiagnostics, createDiagnosticForNode, declarationContext, declarationNameContext, noDiagnosticContext, } from './declarations-diagnostics.js';
 import { DeclarationTracker } from './declarations-tracker.js';
 import { Transformer } from './transformer.js';
+import { declarationCount, getDeclarations } from '../symbol.js';
 export class DeclarationTransformer extends Transformer {
     host;
     options;
@@ -191,9 +192,9 @@ export class DeclarationTransformer extends Transformer {
     reportMultipleModuleExports(file) {
         const symbol = file.symbol;
         const exportEquals = symbol === undefined || symbol.exports === undefined ? undefined : symbol.exports.get('export=');
-        if (exportEquals === undefined || exportEquals.declarations.length <= 1)
+        if (exportEquals === undefined || declarationCount(exportEquals) <= 1)
             return false;
-        for (const declaration of exportEquals.declarations)
+        for (const declaration of getDeclarations(exportEquals))
             this.tracker.addDiagnostic(createDiagnosticForNode(declaration, 1513 /* Diagnostics.Multiple_module_exports_assignments_cannot_be_serialized_for_declaration_emit */, []));
         return true;
     }
@@ -694,7 +695,7 @@ export class DeclarationTransformer extends Transformer {
     /** A private method is written as a property without a type. */
     omitPrivateMethodType(input) {
         const symbol = getSymbol(input);
-        if (symbol !== undefined && symbol.declarations.length > 0 && symbol.declarations[0] !== input)
+        if (symbol !== undefined && declarationCount(symbol) > 0 && symbol.declaration !== input)
             return undefined;
         const result = this.factory.created(new PropertyDeclaration(this.ensureModifiers(input), getName(input), undefined, undefined, undefined));
         this.context.assignCommentRange(result, input);
@@ -2275,7 +2276,7 @@ function isCommonJSAliasExport(node) {
     if (!(node instanceof BinaryExpression) || !(node.right instanceof Identifier))
         return false;
     const symbol = node.symbol;
-    return symbol !== undefined && symbol.declarations.length === 1;
+    return symbol !== undefined && declarationCount(symbol) === 1;
 }
 function getLeftmostAccessExpression(node) {
     let current = node;
@@ -2290,7 +2291,7 @@ function shouldEmitFunctionProperties(fn) {
     const symbol = fn.symbol;
     if (symbol === undefined)
         return false;
-    for (const declaration of symbol.declarations)
+    for (const declaration of getDeclarations(symbol))
         if (declaration instanceof FunctionDeclaration && declaration.body !== undefined)
             return true;
     return false;

package/dist/api/compiler/transformers/reference-resolver.d.ts

@@ -48,8 +48,9 @@ export declare class ReferenceResolver {
     private readonly enumValues;
     private readonly computedEnums;
     private readonly aliasTargets;
-    /** Value symbols of identifiers resolved as expressions, as the checker caches them. */
+    /** Value symbols of identifiers resolved as expressions, as the checker caches them, by node id. */
     private readonly resolvedSymbols;
+    /** 1 for each identifier, by node id, that resolved to no value symbol. */
     private readonly unresolvedReferences;
     private readonly unresolvedAliases;
     private readonly resolvingAliases;

package/dist/api/compiler/transformers/reference-resolver.js

@@ -4,11 +4,12 @@
 import { ElementAccessExpression, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, Identifier, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ModuleDeclaration, NamespaceImport, NumericLiteral, ParenthesizedExpression, PrefixUnaryExpression, PropertyAccessExpression, QualifiedName, SourceFile, BinaryExpression, NoSubstitutionTemplateLiteral, StringLiteral, TemplateExpression, TemplateMiddle, TemplateSpan, TemplateTail, VariableDeclaration, ExternalModuleReference, getInitializer, getIsTypeOnly, getModuleSpecifier, getLocals, getName, getSymbol, getType, } from '../ast.js';
 import { isFunctionLike } from '../ast-utilities.js';
 import { getCombinedNodeFlags, getRootDeclaration, getSourceFileOfNode, isEnumConst, isExternalOrCommonJSModule, } from '../binder-utilities.js';
+import { IntLinkTable, LinkTable } from '../link-tables.js';
 import { NameResolver } from '../name-resolver.js';
 import { isSameNode } from './utilities.js';
 import { pathIsRelative } from '../path.js';
 import { shouldPreserveConstEnums } from '../options.js';
-import { Symbol, addDeclaration } from '../symbol.js';
+import { addDeclaration, declarationAt, declarationCount, getDeclarations, setDeclarations, Symbol, } from '../symbol.js';
 /** The result of evaluating a constant expression, as the checker's evaluator returns it. */
 export class Evaluation {
     kind;
@@ -126,7 +127,7 @@ export class MergedGlobals {
                 ((source.flags | resolved.flags) & 67108864 /* SymbolFlags.Assignment */) === 0)
                 return source;
             result = new Symbol(resolved.flags | 33554432 /* SymbolFlags.Transient */, resolved.name);
-            result.declarations = resolved.declarations.slice();
+            setDeclarations(result, getDeclarations(resolved).slice());
             result.parent = resolved.parent;
             result.valueDeclaration = resolved.valueDeclaration;
             result.members = resolved.members === undefined ? undefined : new Map(resolved.members);
@@ -144,8 +145,8 @@ export class MergedGlobals {
         result.flags |= sourceFlags;
         if (source.valueDeclaration !== undefined)
             setValueDeclaration(result, source.valueDeclaration);
-        for (let i = 0; i < source.declarations.length; i++)
-            addDeclaration(result, source.declarations[i]);
+        for (let i = 0; i < declarationCount(source); i++)
+            addDeclaration(result, declarationAt(source, i));
         if (source.members !== undefined) {
             if (result.members === undefined)
                 result.members = new Map();
@@ -244,8 +245,9 @@ export class ReferenceResolver {
     enumValues;
     computedEnums;
     aliasTargets;
-    /** Value symbols of identifiers resolved as expressions, as the checker caches them. */
+    /** Value symbols of identifiers resolved as expressions, as the checker caches them, by node id. */
     resolvedSymbols;
+    /** 1 for each identifier, by node id, that resolved to no value symbol. */
     unresolvedReferences;
     unresolvedAliases;
     resolvingAliases;
@@ -262,8 +264,8 @@ export class ReferenceResolver {
         this.enumValues = new Map();
         this.computedEnums = new Set();
         this.aliasTargets = new Map();
-        this.resolvedSymbols = new Map();
-        this.unresolvedReferences = new Set();
+        this.resolvedSymbols = new LinkTable();
+        this.unresolvedReferences = new IntLinkTable();
         this.unresolvedAliases = new Set();
         this.resolvingAliases = new Set();
         this.specifierModules = new Map();
@@ -283,24 +285,24 @@ export class ReferenceResolver {
     }
     /** The value an identifier in an expression refers to, cached for later queries of the identifier. */
     getResolvedSymbol(node) {
-        const cached = this.resolvedSymbols.get(node);
+        const cached = this.resolvedSymbols.get(node.id);
         if (cached !== undefined)
             return cached;
-        if (this.unresolvedReferences.has(node))
+        if (this.unresolvedReferences.get(node.id) !== 0)
             return undefined;
         const symbol = this.resolveName(node, node.text, 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */);
         if (symbol === undefined)
-            this.unresolvedReferences.add(node);
+            this.unresolvedReferences.set(node.id, 1);
         else
-            this.resolvedSymbols.set(node, symbol);
+            this.resolvedSymbols.set(node.id, symbol);
         return symbol;
     }
     getReferencedValueSymbol(reference, startInDeclarationContainer) {
         // An identifier resolved as an expression keeps that meaning, as with the checker's cache.
-        const cached = this.resolvedSymbols.get(reference);
+        const cached = this.resolvedSymbols.get(reference.id);
         if (cached !== undefined)
             return cached;
-        if (this.unresolvedReferences.has(reference))
+        if (this.unresolvedReferences.get(reference.id) !== 0)
             return undefined;
         let location = reference;
         const parent = reference.parent;
@@ -360,7 +362,7 @@ export class ReferenceResolver {
     getReferencedImportDeclaration(node) {
         // As the checker: an identifier that didn't resolve as a value may still name an alias.
         const reference = node;
-        let symbol = this.resolvedSymbols.get(reference);
+        let symbol = this.resolvedSymbols.get(reference.id);
         if (symbol === undefined)
             symbol = this.resolveName(node, node.text, valueMeaning);
         if (symbol === undefined ||
@@ -394,7 +396,7 @@ export class ReferenceResolver {
             return undefined;
         const symbol = this.getExportSymbolOfValueSymbolIfExported(resolved);
         const declarations = [];
-        for (const declaration of symbol.declarations)
+        for (const declaration of getDeclarations(symbol))
             if (isValueDeclarationKind(declaration.kind))
                 declarations.push(declaration);
         return declarations;
@@ -444,7 +446,7 @@ export class ReferenceResolver {
         const star = exports.get("\uFFFEexport" /* InternalSymbolName.ExportStar */);
         if (star === undefined)
             return false;
-        for (const declaration of star.declarations) {
+        for (const declaration of getDeclarations(star)) {
             if (!(declaration instanceof ExportDeclaration))
                 continue;
             const target = this.resolveExternalModuleSymbol(this.resolveModuleSpecifier(declaration, declaration.moduleSpecifier));
@@ -456,9 +458,9 @@ export class ReferenceResolver {
     }
     /** Whether a symbol is declared in the global scope. */
     isGlobalSymbol(symbol) {
-        if (symbol.declarations.length === 0)
+        if (declarationCount(symbol) === 0)
             return false;
-        const container = getDeclarationContainer(symbol.declarations[0]);
+        const container = getDeclarationContainer(symbol.declaration);
         return container instanceof SourceFile && !isExternalOrCommonJSModule(container);
     }
     /** Whether a symbol is a value at runtime: const enums aren't unless preserved. */
@@ -677,7 +679,7 @@ export class ReferenceResolver {
         const star = exports.get("\uFFFEexport" /* InternalSymbolName.ExportStar */);
         if (star === undefined)
             return undefined;
-        for (const declaration of star.declarations) {
+        for (const declaration of getDeclarations(star)) {
             if (!(declaration instanceof ExportDeclaration))
                 continue;
             const target = this.resolveExternalModuleSymbol(this.resolveModuleSpecifier(declaration, declaration.moduleSpecifier));
@@ -877,7 +879,7 @@ export class ReferenceResolver {
             return noEvaluation;
         if (expression instanceof Identifier && (expression.text === 'Infinity' || expression.text === 'NaN')) {
             // A global `Infinity` or `NaN`; without lib files these don't resolve at all.
-            if (symbol.declarations.length > 0 && isAmbientGlobal(symbol))
+            if (declarationCount(symbol) > 0 && isAmbientGlobal(symbol))
                 return numberEvaluation(expression.text === 'NaN' ? NaN : Infinity);
         }
         if ((symbol.flags & 8 /* SymbolFlags.EnumMember */) !== 0)
@@ -983,8 +985,8 @@ export function isEntityNameExpressionNode(node) {
     return false;
 }
 function isAmbientGlobal(symbol) {
-    for (let i = 0; i < symbol.declarations.length; i++)
-        if ((symbol.declarations[i].flags & 8388608 /* NodeFlags.Ambient */) === 0)
+    for (let i = 0; i < declarationCount(symbol); i++)
+        if ((declarationAt(symbol, i).flags & 8388608 /* NodeFlags.Ambient */) === 0)
             return false;
     return true;
 }
@@ -1067,8 +1069,8 @@ function isAliasSymbolDeclaration(node) {
     return false;
 }
 export function getDeclarationOfAliasSymbol(symbol) {
-    for (let i = symbol.declarations.length - 1; i >= 0; i--) {
-        const declaration = symbol.declarations[i];
+    for (let i = declarationCount(symbol) - 1; i >= 0; i--) {
+        const declaration = declarationAt(symbol, i);
         if (isAliasSymbolDeclaration(declaration))
             return declaration;
     }

package/dist/api/compiler/transformers/subtree-facts.d.ts

@@ -1,6 +1,7 @@
 import { type Node, NodeVisitor } from '../ast.js';
 /** Memoized `containsTypeScript` answers for one emit. */
 export declare class TypeScriptFacts extends NodeVisitor {
+    /** The answer for each node, by node id. */
     private readonly cache;
     private found;
     constructor();

package/dist/api/compiler/transformers/subtree-facts.js

@@ -1,20 +1,22 @@
 // Whether a subtree contains TypeScript-only syntax, computed as tsgo's subtree facts are.
 // Transforms skip subtrees without it; that also decides how malformed code is emitted.
 import { ClassDeclaration, ClassExpression, ConstructorDeclaration, ExportAssignment, ExportDeclaration, ExportSpecifier, FunctionDeclaration, GetAccessorDeclaration, Identifier, ImportClause, ImportEqualsDeclaration, ImportSpecifier, MethodDeclaration, NodeVisitor, ParameterDeclaration, PropertyDeclaration, SetAccessorDeclaration, VariableDeclaration, VariableStatement, ArrowFunction, FunctionExpression, CallExpression, NewExpression, TaggedTemplateExpression, ExpressionWithTypeArguments, JsxOpeningElement, JsxSelfClosingElement, HeritageClause, getModifiers, } from '../ast.js';
+import { ClusteredIntLinkTable } from '../link-tables.js';
 import { isTypeNodeKind } from '../printer/utilities.js';
 /** Memoized `containsTypeScript` answers for one emit. */
 export class TypeScriptFacts extends NodeVisitor {
+    /** The answer for each node, by node id. */
     cache;
     found;
     constructor() {
         super();
-        this.cache = new Map();
+        this.cache = new ClusteredIntLinkTable();
         this.found = false;
     }
     containsTypeScript(node) {
-        const cached = this.cache.get(node);
-        if (cached !== undefined)
-            return cached;
+        const cached = this.cache.get(node.id);
+        if (cached !== 0)
+            return cached === 2 /* Answer.Yes */;
         const own = ownFacts(node);
         let result = (own & 1 /* Facts.TypeScript */) !== 0;
         if (!result && (own & 2 /* Facts.Final */) === 0) {
@@ -24,7 +26,7 @@ export class TypeScriptFacts extends NodeVisitor {
             result = this.found;
             this.found = saved;
         }
-        this.cache.set(node, result);
+        this.cache.set(node.id, result ? 2 /* Answer.Yes */ : 1 /* Answer.No */);
         return result;
     }
     visitNode(node) {

package/dist/api/compiler/transformers/syntax-facts.d.ts

@@ -30,6 +30,7 @@ export declare const enum SubtreeFacts {
 }
 /** Memoized subtree facts for one emit; synthesized nodes get theirs on first use. */
 export declare class SyntaxFacts extends NodeVisitor {
+    /** The facts of each node, by node id, with `computedFacts` set. */
     private readonly cache;
     private collected;
     constructor();

package/dist/api/compiler/transformers/syntax-facts.js

@@ -1,23 +1,27 @@
 // What syntax a subtree contains, computed as tsgo's subtree facts are. Downlevel transforms
 // skip subtrees without the syntax they lower.
 import { BindingElement, CallExpression, CatchClause, ForInOrOfStatement, Identifier, MetaProperty, NodeVisitor, NoSubstitutionTemplateLiteral, PropertyAccessExpression, TemplateHead, TemplateMiddle, TemplateTail, VariableDeclarationList, getModifiers, getName, } from '../ast.js';
+import { ClusteredIntLinkTable } from '../link-tables.js';
 import { isTypeNodeKind } from '../printer/utilities.js';
 import { getElementsOfBindingOrAssignmentPattern, getTargetOfBindingOrAssignmentElement } from './destructuring.js';
+/** Marks a computed entry of `SyntaxFacts.cache`, whose facts may be `None`. */
+const computedFacts = 1 << 30;
 /** Memoized subtree facts for one emit; synthesized nodes get theirs on first use. */
 export class SyntaxFacts extends NodeVisitor {
+    /** The facts of each node, by node id, with `computedFacts` set. */
     cache;
     collected;
     constructor() {
         super();
-        this.cache = new Map();
+        this.cache = new ClusteredIntLinkTable();
         this.collected = 0 /* SubtreeFacts.None */;
     }
     of(node) {
-        const cached = this.cache.get(node);
-        if (cached !== undefined)
-            return cached;
+        const cached = this.cache.get(node.id);
+        if (cached !== 0)
+            return cached & ~computedFacts;
         const facts = this.compute(node);
-        this.cache.set(node, facts);
+        this.cache.set(node.id, facts | computedFacts);
         return facts;
     }
     has(node, facts) {

package/dist/api/compiler/transformers/type-serialization.js

@@ -5,7 +5,7 @@
 // inherited members) serialize as `Object`.
 import { ArrayTypeNode, EnumDeclaration, Identifier, ImportClause, InterfaceDeclaration, LiteralTypeNode, ParenthesizedTypeNode, PrefixUnaryExpression, QualifiedName, TypeAliasDeclaration, TypeLiteralNode, TypeOperatorNode, TypeParameterDeclaration, TypeReferenceNode, UnionTypeNode, VariableDeclaration, getIsTypeOnly, } from '../ast.js';
 import { getStrictOptionValue } from '../options.js';
-import { Symbol } from '../symbol.js';
+import { declarationAt, declarationCount, getDeclarations, Symbol } from '../symbol.js';
 /** What an unresolvable alias resolves to, as the checker's unknown symbol. */
 const unknownSymbol = new Symbol(1073741823 /* SymbolFlags.All */, 'unknown');
 /** Nested type aliases followed before giving up. */
@@ -17,9 +17,9 @@ export function getTypeReferenceSerializationKind(resolver, typeName, location)
     let isTypeOnly = false;
     if (typeName instanceof QualifiedName) {
         const root = resolveEntityName(resolver, getFirstIdentifier(typeName), 111551 /* SymbolFlags.Value */, true, location);
-        if (root !== undefined && root !== unknownSymbol && root.declarations.length > 0) {
+        if (root !== undefined && root !== unknownSymbol && declarationCount(root) > 0) {
             isTypeOnly = true;
-            for (const declaration of root.declarations)
+            for (const declaration of getDeclarations(root))
                 if (!isTypeOnlyImportOrExportDeclaration(declaration)) {
                     isTypeOnly = false;
                     break;
@@ -120,8 +120,8 @@ function hasConstructSignature(resolver, type, location, depth) {
         const symbol = resolveEntityName(resolver, type.typeName, 788968 /* SymbolFlags.Type */, false, location);
         if (symbol === undefined || symbol === unknownSymbol)
             return false;
-        for (let i = 0; i < symbol.declarations.length; i++) {
-            const declaration = symbol.declarations[i];
+        for (let i = 0; i < declarationCount(symbol); i++) {
+            const declaration = declarationAt(symbol, i);
             if (declaration instanceof InterfaceDeclaration &&
                 hasMember(declaration.members.nodes, 181 /* SyntaxKind.ConstructSignature */))
                 return true;
@@ -160,22 +160,22 @@ class TypeClassifier {
         if ((flags & 32 /* SymbolFlags.Class */) !== 0)
             return 11 /* TypeReferenceSerializationKind.ObjectType */;
         if ((flags & 524288 /* SymbolFlags.TypeAlias */) !== 0) {
-            for (let i = 0; i < symbol.declarations.length; i++) {
-                const declaration = symbol.declarations[i];
+            for (let i = 0; i < declarationCount(symbol); i++) {
+                const declaration = declarationAt(symbol, i);
                 if (declaration instanceof TypeAliasDeclaration)
                     return this.ofTypeNode(declaration.type, declaration, depth + 1);
             }
             return 11 /* TypeReferenceSerializationKind.ObjectType */;
         }
         if ((flags & 262144 /* SymbolFlags.TypeParameter */) !== 0) {
-            const declaration = symbol.declarations.length > 0 ? symbol.declarations[0] : undefined;
+            const declaration = declarationCount(symbol) > 0 ? symbol.declaration : undefined;
             if (declaration instanceof TypeParameterDeclaration && declaration.constraint !== undefined)
                 return this.ofTypeNode(declaration.constraint, declaration, depth + 1);
             return 11 /* TypeReferenceSerializationKind.ObjectType */;
         }
         if ((flags & 64 /* SymbolFlags.Interface */) !== 0) {
-            for (let i = 0; i < symbol.declarations.length; i++) {
-                const declaration = symbol.declarations[i];
+            for (let i = 0; i < declarationCount(symbol); i++) {
+                const declaration = declarationAt(symbol, i);
                 if (declaration instanceof InterfaceDeclaration &&
                     hasMember(declaration.members.nodes, 180 /* SyntaxKind.CallSignature */))
                     return 10 /* TypeReferenceSerializationKind.TypeWithCallSignature */;
@@ -187,8 +187,8 @@ class TypeClassifier {
     ofEnum(symbol) {
         let strings = false;
         let numbers = false;
-        for (let i = 0; i < symbol.declarations.length; i++) {
-            const declaration = symbol.declarations[i];
+        for (let i = 0; i < declarationCount(symbol); i++) {
+            const declaration = declarationAt(symbol, i);
             if (!(declaration instanceof EnumDeclaration))
                 continue;
             const members = declaration.members.nodes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsc-ts",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "The TypeScript 7 compiler, ported to TypeScript and compiled to a native executable.",
   "license": "Apache-2.0",
   "repository": {
@@ -29,18 +29,18 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@scriptc/threads": "0.3.6"
+    "@scriptc/threads": "0.4.1"
   },
   "engines": {
     "node": ">=20"
   },
   "optionalDependencies": {
-    "@tsc-ts/darwin-arm64": "0.0.5",
-    "@tsc-ts/darwin-x64": "0.0.5",
-    "@tsc-ts/linux-arm64-gnu": "0.0.5",
-    "@tsc-ts/linux-arm64-musl": "0.0.5",
-    "@tsc-ts/linux-x64-gnu": "0.0.5",
-    "@tsc-ts/linux-x64-musl": "0.0.5",
-    "@tsc-ts/win32-x64-msvc": "0.0.5"
+    "@tsc-ts/darwin-arm64": "0.0.6",
+    "@tsc-ts/darwin-x64": "0.0.6",
+    "@tsc-ts/linux-arm64-gnu": "0.0.6",
+    "@tsc-ts/linux-arm64-musl": "0.0.6",
+    "@tsc-ts/linux-x64-gnu": "0.0.6",
+    "@tsc-ts/linux-x64-musl": "0.0.6",
+    "@tsc-ts/win32-x64-msvc": "0.0.6"
   }
 }