tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/instantiation.js

@@ -1,7 +1,7 @@
 // Instantiation: mappers that need the checker, and `instantiateType` for every kind of type.
 import { lazyObjectFlags, sideOf, sideOfIfAny } from './side-state.js';
 import { NodeVisitor, getBody, getInitializer, getParameters, getType, getTypeArguments as getTypeArgumentNodes, getTypeParameters as getTypeParameterNodes, } from './ast.js';
-import { cachedTypeKey, IndexInfo, Signature, TypeAlias, TypeMapper, emptyTypes, newTypeMapper, SimpleTypeMapper, TypeListCache, } from './checker-types.js';
+import { cachedTypeKey, IndexInfo, Signature, TypeAlias, TypeMapper, emptyTypes, newTypeMapper, SimpleTypeMapper, TypeListCache, getMappedType, } from './checker-types.js';
 import { createDeferredTypeReference, createNormalizedTypeReference, getIntersectionType, getIntersectionTypeEx, getPropagatingFlagsOfTypes, getTemplateLiteralType, getTypeArguments, getUnionTypeEx, newObjectType, aliasKey, typesOf, typeListHash, } from './checker-type-factory.js';
 import { getOuterTypeParameters } from './checker-declared-types.js';
 import { getSymbolFromTypeReference, getResolvedSymbolOfIdentifier } from './checker-type-nodes.js';
@@ -10,6 +10,7 @@ import { getConstraintDeclaration } from './checker-declared-types.js';
 import { isTypeAssignableTo } from './relations.js';
 import { getFirstIdentifier } from './checker-symbols.js';
 import { copyDeclarations, declarationCount, getDeclarations, getSymbolId, } from './symbol.js';
+import { symbolToString } from './type-printer.js';
 // ---- Mappers that need the checker
 /** Applies `m1`, then instantiates its result with `m2`, or applies `m2` when `m1` doesn't map. */
 export class CompositeTypeMapper extends TypeMapper {
@@ -23,8 +24,8 @@ export class CompositeTypeMapper extends TypeMapper {
         this.m2 = m2;
     }
     map(type) {
-        const t1 = this.m1.map(type);
-        return t1 !== type ? instantiateType(this.c, t1, this.m2) : this.m2.map(type);
+        const t1 = getMappedType(type, this.m1);
+        return t1 !== type ? instantiateType(this.c, t1, this.m2) : getMappedType(type, this.m2);
     }
 }
 /** Records unreliable or unmeasurable variance when it sees a marker type. */
@@ -103,25 +104,36 @@ export function instantiateTypeWithAlias(c, type, mapper, alias) {
     if (!could && (type.alias === undefined || !aliasCouldContainTypeVariables(c, type)))
         return type;
     if (c.instantiationDepth === 100 || c.instantiationCount >= 5000000) {
-        // Probably infinitely expanding generic types; stop with the error type.
-        c.error(c.currentNode, 737 /* Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite */);
+        // Probably infinitely expanding generic types; stop with the error type, naming the types whose
+        // instantiations nest three or more times.
+        const circularTypeNames = getCircularTypeNames(c);
+        if (circularTypeNames.length === 1)
+            c.error(c.currentNode, 1193 /* Diagnostics.Instantiations_of_type_0_appear_infinitely_circular */, circularTypeNames[0]);
+        else if (circularTypeNames.length > 1)
+            c.error(c.currentNode, 1194 /* Diagnostics.Instantiations_of_the_following_types_appear_infinitely_circular_Colon_0 */, quotedAndCommaSeparated(circularTypeNames));
+        else
+            c.error(c.currentNode, 744 /* Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite */);
         return c.errorType;
     }
-    const depth = c.activeMapperDepth;
-    const activeMappers = c.activeMappers;
-    let index = depth - 1;
-    while (index >= 0 && activeMappers[index] !== mapper)
-        index--;
+    const depth = c.activeMapperDepth | 0;
+    const mapperId = mapper.id | 0;
+    let index = (depth - 1) | 0;
+    while (index >= 0 && c.activeMapperIds[index] !== mapperId)
+        index = (index - 1) | 0;
     if (index === -1) {
         // A newly active mapper has no cached instantiations; its cache is created when a nested
         // instantiation with the same mapper stores one.
-        if (depth < activeMappers.length) {
-            activeMappers[depth] = mapper;
+        if (depth === c.activeMapperIds.length) {
+            const grown = new Int32Array(depth * 2);
+            grown.set(c.activeMapperIds);
+            c.activeMapperIds = grown;
+        }
+        c.activeMapperIds[depth] = mapperId;
+        if (depth < c.activeMapperCaches.length) {
             c.activeMapperCaches[depth] = undefined;
             c.activeMapperAliasCaches[depth] = undefined;
         }
         else {
-            activeMappers.push(mapper);
             c.activeMapperCaches.push(undefined);
             c.activeMapperAliasCaches.push(undefined);
         }
@@ -144,7 +156,13 @@ export function instantiateTypeWithAlias(c, type, mapper, alias) {
     }
     c.instantiationCount++;
     c.totalInstantiations++;
-    c.instantiationDepth++;
+    const instantiationDepth = c.instantiationDepth;
+    const instantiationStack = c.instantiationStack;
+    if (instantiationDepth < instantiationStack.length)
+        instantiationStack[instantiationDepth] = type;
+    else
+        instantiationStack.push(type);
+    c.instantiationDepth = instantiationDepth + 1;
     const result = instantiateTypeWorker(c, type, mapper, alias);
     if (index === -1) {
         // The mapper's slot stays until it is reused; its caches are released now.
@@ -187,6 +205,33 @@ export function instantiateTypeWithAlias(c, type, mapper, alias) {
     c.instantiationDepth--;
     return result;
 }
+/**
+ * The names of the types that are instantiated three or more times on the current instantiation stack, by
+ * their alias where they have one, in the order they reach the third, each once.
+ */
+function getCircularTypeNames(c) {
+    const counts = new Map();
+    const names = [];
+    const stack = c.instantiationStack;
+    for (let i = 0; i < c.instantiationDepth; i++) {
+        const t = stack[i];
+        const count = (counts.get(t) ?? 0) + 1;
+        counts.set(t, count);
+        if (count !== 3)
+            continue;
+        const symbol = t.alias !== undefined ? t.alias.symbol : t.symbol;
+        if (symbol === undefined || symbol.name.length === 0 || symbol.name.charCodeAt(0) === 0xfffe)
+            continue;
+        const name = symbolToString(c, symbol);
+        if (!names.includes(name))
+            names.push(name);
+    }
+    return names;
+}
+/** `'a', 'b', 'c'`. */
+export function quotedAndCommaSeparated(items) {
+    return items.map((item) => "'" + item + "'").join(', ');
+}
 function aliasCouldContainTypeVariables(c, type) {
     const alias = type.alias;
     if (alias === undefined || alias.typeArguments.length === 0)
@@ -261,18 +306,18 @@ function isNonGenericTopLevelType(type) {
         return false;
     let declaration;
     for (const d of getDeclarations(alias.symbol))
-        if (d.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ || d.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */) {
+        if (d.kind === 267 /* SyntaxKind.TypeAliasDeclaration */ || d.kind === 346 /* SyntaxKind.JSTypeAliasDeclaration */) {
             declaration = d;
             break;
         }
     if (declaration === undefined)
         return false;
     for (let n = declaration.parent; n !== undefined; n = n.parent) {
-        if (n.kind === 307 /* SyntaxKind.SourceFile */)
+        if (n.kind === 308 /* SyntaxKind.SourceFile */)
             return true;
-        if (n.kind === 268 /* SyntaxKind.ModuleDeclaration */)
+        if (n.kind === 269 /* SyntaxKind.ModuleDeclaration */)
             return false;
-        if (n.kind !== 269 /* SyntaxKind.ModuleBlock */)
+        if (n.kind !== 270 /* SyntaxKind.ModuleBlock */)
             return false;
     }
     return false;
@@ -280,7 +325,7 @@ function isNonGenericTopLevelType(type) {
 function instantiateTypeWorker(c, type, mapper, alias) {
     const flags = type.flags;
     if ((flags & 524288 /* TypeFlags.TypeParameter */) !== 0)
-        return mapper.map(type);
+        return getMappedType(type, mapper);
     if ((flags & 1048576 /* TypeFlags.Object */) !== 0) {
         const objectFlags = type.objectFlags;
         if ((objectFlags & (4 /* ObjectFlags.Reference */ | 16 /* ObjectFlags.Anonymous */ | 32 /* ObjectFlags.Mapped */)) === 0)
@@ -357,7 +402,7 @@ function instantiateTypeWorker(c, type, mapper, alias) {
 }
 /** Instantiates anonymous types, deferred references, instantiation expressions and mapped types. */
 function getObjectTypeInstantiation(c, type, mapper, alias) {
-    if ((type.objectFlags & 4 /* ObjectFlags.Reference */) === 0 && c.withoutOuterTypeParameters.get(type.id) !== 0)
+    if ((type.objectFlags & 4 /* ObjectFlags.Reference */) === 0 && c.withoutOuterTypeParameters.has(type.id))
         return type;
     let declaration;
     if ((type.objectFlags & 4 /* ObjectFlags.Reference */) !== 0)
@@ -403,7 +448,7 @@ function getObjectTypeInstantiation(c, type, mapper, alias) {
     }
     if (typeParameters.length === 0) {
         if ((type.objectFlags & 4 /* ObjectFlags.Reference */) === 0)
-            c.withoutOuterTypeParameters.set(type.id, 1);
+            c.withoutOuterTypeParameters.add(type.id);
         return type;
     }
     // The type arguments, mapped as `combineTypeMappers(c, type.mapper, mapper)` maps them, into a
@@ -412,10 +457,10 @@ function getObjectTypeInstantiation(c, type, mapper, alias) {
     const mapped = c.freeTypeLists.pop() ?? [];
     for (const tp of typeParameters) {
         if (typeMapper === undefined)
-            mapped.push(mapper.map(tp));
+            mapped.push(getMappedType(tp, mapper));
         else {
-            const t1 = typeMapper.map(tp);
-            mapped.push(t1 !== tp ? instantiateType(c, t1, mapper) : mapper.map(tp));
+            const t1 = getMappedType(tp, typeMapper);
+            mapped.push(t1 !== tp ? instantiateType(c, t1, mapper) : getMappedType(tp, mapper));
         }
     }
     const newAlias = alias ?? instantiateTypeAlias(c, type.alias, mapper);
@@ -481,9 +526,9 @@ class ReferenceFinder extends NodeVisitor {
     containsReference(node) {
         const tp = this.tp;
         switch (node.kind) {
-            case 198 /* SyntaxKind.ThisType */:
+            case 199 /* SyntaxKind.ThisType */:
                 return tp.isThisType;
-            case 184 /* SyntaxKind.TypeReference */: {
+            case 185 /* SyntaxKind.TypeReference */: {
                 const args = getTypeArgumentNodes(node);
                 if (!tp.isThisType &&
                     (args === undefined || args.nodes.length === 0) &&
@@ -491,14 +536,14 @@ class ReferenceFinder extends NodeVisitor {
                     return true;
                 break;
             }
-            case 187 /* SyntaxKind.TypeQuery */: {
+            case 188 /* SyntaxKind.TypeQuery */: {
                 const firstIdentifier = getFirstIdentifier(node.exprName);
                 if (firstIdentifier.kind !== 109 /* SyntaxKind.ThisKeyword */ &&
                     !(firstIdentifier.kind === 79 /* SyntaxKind.Identifier */ && firstIdentifier.text === 'this')) {
                     const symbol = getResolvedSymbolOfIdentifier(this.c, firstIdentifier);
                     const tpDeclaration = tp.symbol.declaration;
                     let scope;
-                    if (tpDeclaration.kind === 169 /* SyntaxKind.TypeParameter */)
+                    if (tpDeclaration.kind === 170 /* SyntaxKind.TypeParameter */)
                         scope = tpDeclaration.parent;
                     else if (tp.isThisType)
                         scope = tpDeclaration;
@@ -516,8 +561,8 @@ class ReferenceFinder extends NodeVisitor {
                 }
                 return true;
             }
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 174 /* SyntaxKind.MethodSignature */: {
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 175 /* SyntaxKind.MethodSignature */: {
                 const returnType = getType(node);
                 if (returnType === undefined && getBody(node) !== undefined)
                     return true;
@@ -558,9 +603,9 @@ export function isTypeParameterPossiblyReferenced(c, tp, node) {
     const finder = new ReferenceFinder(c, typeParameter);
     const container = tp.symbol.declaration.parent;
     for (let n = node; n !== container; n = n.parent) {
-        if (n === undefined || n.kind === 242 /* SyntaxKind.Block */)
+        if (n === undefined || n.kind === 243 /* SyntaxKind.Block */)
             return true;
-        if (n.kind === 195 /* SyntaxKind.ConditionalType */ && finder.containsReference(n.extendsType))
+        if (n.kind === 196 /* SyntaxKind.ConditionalType */ && finder.containsReference(n.extendsType))
             return true;
     }
     return finder.containsReference(node);
@@ -697,11 +742,18 @@ export function instantiateSymbol(c, symbol, mapper) {
  * is resolved yet, so lazily instantiated members record it when tsgo would instantiate them.
  */
 export function keepsSymbolUnderInstantiation(c, symbol, mapper) {
-    const symbolId = getSymbolId(symbol);
-    if (mapper.mapsThisOnly() && isThisless(symbol))
+    if (mapper.mapsThisOnly() && isThisless(symbol)) {
+        getSymbolId(symbol);
         return true;
-    // A resolved type that can't change under instantiation keeps the symbol.
-    const type = c.symbolTypes.get(symbolId);
+    }
+    return keepsSymbolTypeUnderInstantiation(c, symbol);
+}
+/**
+ * Whether the resolved type of `symbol` (and its write type) can't change under instantiation, so that
+ * `instantiateSymbol` keeps it whatever the mapper. Once true, it stays true: types are resolved once.
+ */
+export function keepsSymbolTypeUnderInstantiation(c, symbol) {
+    const type = c.symbolTypes.get(getSymbolId(symbol));
     if (type !== undefined && !couldContainTypeVariables(c, type)) {
         if ((symbol.flags & 65536 /* SymbolFlags.SetAccessor */) === 0)
             return true;
@@ -723,7 +775,7 @@ export function newInstantiatedSymbol(c, symbol, mapper) {
     result.checkFlags =
         1 /* CheckFlags.Instantiated */ |
             (symbol.checkFlags &
-                (8 /* CheckFlags.Readonly */ | 4096 /* CheckFlags.Late */ | 16384 /* CheckFlags.OptionalParameter */ | 32768 /* CheckFlags.RestParameter */));
+                (8 /* CheckFlags.Readonly */ | 32768 /* CheckFlags.Late */ | 131072 /* CheckFlags.OptionalParameter */ | 262144 /* CheckFlags.RestParameter */));
     copyDeclarations(result, symbol);
     result.parent = symbol.parent;
     result.valueDeclaration = symbol.valueDeclaration;
@@ -739,15 +791,15 @@ export function isThisless(symbol) {
         return false;
     const declaration = symbol.declaration;
     switch (declaration.kind) {
-        case 170 /* SyntaxKind.Parameter */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
             return isThislessVariableLikeDeclaration(declaration);
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 174 /* SyntaxKind.MethodSignature */:
-        case 177 /* SyntaxKind.Constructor */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
             return isThislessFunctionLikeDeclaration(declaration);
     }
     return false;
@@ -769,11 +821,11 @@ function isThislessType(node) {
         case 115 /* SyntaxKind.VoidKeyword */:
         case 157 /* SyntaxKind.UndefinedKeyword */:
         case 146 /* SyntaxKind.NeverKeyword */:
-        case 202 /* SyntaxKind.LiteralType */:
+        case 203 /* SyntaxKind.LiteralType */:
             return true;
-        case 189 /* SyntaxKind.ArrayType */:
+        case 190 /* SyntaxKind.ArrayType */:
             return isThislessType(node.elementType);
-        case 184 /* SyntaxKind.TypeReference */: {
+        case 185 /* SyntaxKind.TypeReference */: {
             const args = getTypeArgumentNodes(node);
             if (args !== undefined)
                 for (const a of args.nodes)
@@ -786,7 +838,7 @@ function isThislessType(node) {
 }
 function isThislessFunctionLikeDeclaration(node) {
     const returnType = getType(node);
-    if (node.kind !== 177 /* SyntaxKind.Constructor */ && (returnType === undefined || !isThislessType(returnType)))
+    if (node.kind !== 178 /* SyntaxKind.Constructor */ && (returnType === undefined || !isThislessType(returnType)))
         return false;
     const parameters = getParameters(node);
     if (parameters !== undefined)

package/dist/api/compiler/jsdoc.js

@@ -1,7 +1,7 @@
 // JSDoc comment parsing, a port of tsgo's parser/jsdoc.go.
 //
 // Comment indentation is measured in UTF-8 bytes, as in tsgo, so comment text matches it exactly.
-import { ArrayTypeNode, ExpressionWithTypeArguments, Identifier, JSDoc, JSDocAugmentsTag, JSDocCallbackTag, JSDocDeprecatedTag, JSDocImplementsTag, JSDocImportTag, JSDocLink, JSDocLinkCode, JSDocLinkPlain, JSDocNameReference, JSDocOverloadTag, JSDocOverrideTag, JSDocParameterOrPropertyTag, JSDocPrivateTag, JSDocProtectedTag, JSDocPublicTag, JSDocReadonlyTag, JSDocReturnTag, JSDocSatisfiesTag, JSDocSeeTag, JSDocSignature, JSDocTemplateTag, JSDocText, JSDocThisTag, JSDocThrowsTag, JSDocTypeExpression, JSDocTypeLiteral, JSDocTypeTag, JSDocTypedefTag, JSDocUnknownTag, ModuleDeclaration, NodeList, PropertyAccessExpression, QualifiedName, TypeParameterDeclaration, TypeReferenceNode, getTagName, getType, } from './ast.js';
+import { ArrayTypeNode, ExpressionWithTypeArguments, Identifier, JSDoc, JSDocAugmentsTag, JSDocCallbackTag, JSDocDeprecatedTag, JSDocImplementsTag, JSDocImportTag, JSDocLink, JSDocLinkCode, JSDocLinkPlain, JSDocNameReference, JSDocOverloadTag, JSDocOverrideTag, JSDocParameterOrPropertyTag, JSDocPrivateTag, JSDocProtectedTag, JSDocPublicTag, JSDocReadonlyTag, JSDocReturnTag, JSDocSatisfiesTag, JSDocSeeTag, JSDocSignature, JSDocTemplateTag, JSDocText, JSDocThisTag, JSDocThrowsTag, JSDocTypeExpression, JSDocTypeLiteral, JSDocTypeTag, JSDocTypedefTag, JSDocUnknownTag, ModuleDeclaration, NodeList, PropertyAccessExpression, QualifiedName, TypeParameterDeclaration, TypeReferenceNode, getTagName, getType, getText, } from './ast.js';
 import { isReservedWord, tokenIsIdentifierOrKeyword } from './ast-utilities.js';
 import { isWhiteSpaceLike } from './character-codes.js';
 import { Diagnostic } from './diagnostics.js';
@@ -27,13 +27,13 @@ class CommentText {
 export function getJSDocCommentRanges(node, text) {
     const ranges = [];
     switch (node.kind) {
-        case 170 /* SyntaxKind.Parameter */:
-        case 169 /* SyntaxKind.TypeParameter */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 282 /* SyntaxKind.ExportSpecifier */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 170 /* SyntaxKind.TypeParameter */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 283 /* SyntaxKind.ExportSpecifier */:
             addRanges(ranges, getTrailingCommentRanges(text, node.pos));
             addRanges(ranges, getLeadingCommentRanges(text, node.pos));
             break;
@@ -656,7 +656,7 @@ export class JSDocParser {
             typeExpression = nestedTypeLiteral;
             isNameFirst = true;
         }
-        const kind = target === 1 /* PropertyLikeParse.Property */ ? 340 /* SyntaxKind.JSDocPropertyTag */ : 333 /* SyntaxKind.JSDocParameterTag */;
+        const kind = target === 1 /* PropertyLikeParse.Property */ ? 341 /* SyntaxKind.JSDocPropertyTag */ : 334 /* SyntaxKind.JSDocParameterTag */;
         return p.finishNode(new JSDocParameterOrPropertyTag(kind, tagName, name, isBracketed, typeExpression, isNameFirst, comment), start);
     }
     parseNestedTypeLiteral(typeExpression, name, target, indent) {
@@ -675,24 +675,24 @@ export class JSDocParser {
                 p.rewind(state);
                 break;
             }
-            if (child.kind === 333 /* SyntaxKind.JSDocParameterTag */ || child.kind === 340 /* SyntaxKind.JSDocPropertyTag */)
+            if (child.kind === 334 /* SyntaxKind.JSDocParameterTag */ || child.kind === 341 /* SyntaxKind.JSDocPropertyTag */)
                 children.push(child);
-            else if (child.kind === 337 /* SyntaxKind.JSDocTemplateTag */)
+            else if (child.kind === 338 /* SyntaxKind.JSDocTemplateTag */)
                 this.reportTemplateAfterTypedef(child);
         }
         if (children.length === 0)
             return undefined;
-        const literal = p.finishNode(new JSDocTypeLiteral(children, type.kind === 189 /* SyntaxKind.ArrayType */), pos);
+        const literal = p.finishNode(new JSDocTypeLiteral(children, type.kind === 190 /* SyntaxKind.ArrayType */), pos);
         return p.finishNode(new JSDocTypeExpression(literal), pos);
     }
     reportTemplateAfterTypedef(tag) {
         const tagName = getTagName(tag);
-        this.p.parseErrorAt(tagName.pos, tagName.end, 1768 /* Diagnostics.A_JSDoc_template_tag_may_not_follow_a_typedef_callback_or_overload_tag */);
+        this.p.parseErrorAt(tagName.pos, tagName.end, 1788 /* Diagnostics.A_JSDoc_template_tag_may_not_follow_a_typedef_callback_or_overload_tag */);
         return true;
     }
     parseReturnTag(previousTags, start, tagName, indent, indentText) {
         const p = this.p;
-        if (hasTagOfKind(previousTags, 334 /* SyntaxKind.JSDocReturnTag */))
+        if (hasTagOfKind(previousTags, 335 /* SyntaxKind.JSDocReturnTag */))
             p.parseErrorAt(tagName.pos, p.scanner.getTokenStart(), 173 /* Diagnostics.X_0_tag_already_specified */, [tagName.text]);
         const typeExpression = this.tryParseTypeExpression();
         return p.finishNode(new JSDocReturnTag(tagName, typeExpression, this.parseTrailingTagComments(start, p.nodePos(), indent, indentText)), start);
@@ -700,7 +700,7 @@ export class JSDocParser {
     /** `indent` -1 skips trailing comments, as for a type tag nested in a typedef. */
     parseTypeTag(previousTags, start, tagName, indent, indentText) {
         const p = this.p;
-        if (hasTagOfKind(previousTags, 336 /* SyntaxKind.JSDocTypeTag */))
+        if (hasTagOfKind(previousTags, 337 /* SyntaxKind.JSDocTypeTag */))
             p.parseErrorAt(tagName.pos, p.scanner.getTokenStart(), 173 /* Diagnostics.X_0_tag_already_specified */, [tagName.text]);
         const typeExpression = this.parseJSDocTypeExpression(true);
         const comments = indent !== -1 ? this.parseTrailingTagComments(start, p.nodePos(), indent, indentText) : undefined;
@@ -790,7 +790,7 @@ export class JSDocParser {
         const typeNameOrNamespaceName = this.parseJSDocIdentifierName(undefined);
         if (this.parseOptionalJsdoc(24 /* SyntaxKind.DotToken */)) {
             const body = this.parseJSDocTypeNameWithNamespace(true);
-            const jsDocNamespaceNode = new ModuleDeclaration(undefined, 145 /* SyntaxKind.NamespaceKeyword */, typeNameOrNamespaceName, body);
+            const jsDocNamespaceNode = new ModuleDeclaration(undefined, 145 /* SyntaxKind.NamespaceKeyword */, typeNameOrNamespaceName, undefined, body);
             if (nested)
                 jsDocNamespaceNode.flags |= 32 /* NodeFlags.NestedNamespace */;
             return p.finishNode(jsDocNamespaceNode, start);
@@ -823,7 +823,7 @@ export class JSDocParser {
                     break;
                 }
                 hasChildren = true;
-                if (child.kind === 337 /* SyntaxKind.JSDocTemplateTag */) {
+                if (child.kind === 338 /* SyntaxKind.JSDocTemplateTag */) {
                     this.reportTemplateAfterTypedef(child);
                 }
                 else if (child instanceof JSDocTypeTag) {
@@ -831,9 +831,9 @@ export class JSDocParser {
                         childTypeTag = child;
                     }
                     else {
-                        const lastError = p.parseErrorAtCurrentToken(1762 /* Diagnostics.A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags */);
+                        const lastError = p.parseErrorAtCurrentToken(1782 /* Diagnostics.A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags */);
                         if (lastError !== undefined)
-                            lastError.addRelatedInfo(newDiagnosticAtStart(1763 /* Diagnostics.The_tag_was_first_specified_here */));
+                            lastError.addRelatedInfo(newDiagnosticAtStart(1783 /* Diagnostics.The_tag_was_first_specified_here */));
                     }
                 }
                 else {
@@ -841,7 +841,7 @@ export class JSDocParser {
                 }
             }
             if (hasChildren) {
-                const isArrayType = typeExpressionType !== undefined && typeExpressionType.kind === 189 /* SyntaxKind.ArrayType */;
+                const isArrayType = typeExpressionType !== undefined && typeExpressionType.kind === 190 /* SyntaxKind.ArrayType */;
                 const jsdocTypeLiteral = new JSDocTypeLiteral(jsdocPropertyTags, isArrayType);
                 const childType = childTypeTag !== undefined && childTypeTag.typeExpression !== undefined
                     ? getType(childTypeTag.typeExpression)
@@ -889,7 +889,7 @@ export class JSDocParser {
                 p.rewind(state);
                 break;
             }
-            if (child.kind === 337 /* SyntaxKind.JSDocTemplateTag */)
+            if (child.kind === 338 /* SyntaxKind.JSDocTemplateTag */)
                 this.reportTemplateAfterTypedef(child);
             else
                 parameters.push(child);
@@ -903,7 +903,7 @@ export class JSDocParser {
         const state = p.mark();
         if (this.parseOptionalJsdoc(59 /* SyntaxKind.AtToken */)) {
             const tag = this.parseTag([], indent);
-            if (tag.kind === 334 /* SyntaxKind.JSDocReturnTag */)
+            if (tag.kind === 335 /* SyntaxKind.JSDocReturnTag */)
                 returnTag = tag;
         }
         if (returnTag === undefined)
@@ -1116,7 +1116,7 @@ function textsEqual(a, b) {
     while (!(a instanceof Identifier) || !(b instanceof Identifier)) {
         if (a instanceof QualifiedName &&
             b instanceof QualifiedName &&
-            a.right.text === b.right.text) {
+            getText(a.right) === getText(b.right)) {
             a = a.left;
             b = b.left;
         }

package/dist/api/compiler/link-tables.d.ts

@@ -1,4 +1,3 @@
-import type { Symbol } from './symbol.js';
 /** Links are stored in pages of 256 ids. */
 export declare const enum LinkPaging {
     Bits = 8,
@@ -66,13 +65,16 @@ export declare class PagedIdSet {
     clear(): void;
 }
 /**
- * A page of a `CompactSymbolLinkTable`: one bit per id of the page in eight 32-id words, the number
- * of symbols stored before each word, and the symbols in id order. The words are fields, so a
- * lookup reads one object before the symbols. The class isn't generic, so natively the words are
- * 32-bit fields: every write stores an int32.
+ * A page of a `CompactLinkTable`'s presence bits: one bit per id of the page in eight 32-id words, the
+ * number of values stored before each word, and the position of the page's values in the table's
+ * `values`. The words are fields, so a lookup reads one object before the values. Natively the words
+ * are 32-bit fields, since every write stores an int32. A class that is generic or has a generic
+ * subclass keeps its number fields as doubles, so the values the bits index are in the table's
+ * `values`, not in this class or a subclass.
  */
 declare class CompactLinkPage {
-    readonly values: Symbol[];
+    /** The position of the page's values in the table's `values`. */
+    readonly position: number;
     private w0;
     private w1;
     private w2;
@@ -84,29 +86,57 @@ declare class CompactLinkPage {
     /** Byte `w & 3` of `before0` (words 1 to 3) or of `before1` (words 4 to 7): the values before word `w`. */
     private before0;
     private before1;
-    constructor();
+    constructor(position: number);
     /** The presence bits of ids `32 * word` to `32 * word + 31`. */
     word(word: number): number;
     setWord(word: number, bits: number): void;
     /** The index in `values` of the value of `slot` (an id's low bits), or of where it goes. */
     rank(slot: number, bits: number): number;
-    /** Adds `delta` to the counts of the words after `word`. */
+    /**
+     * Adds 1 (`delta` 1) or subtracts 1 (`delta` -1) from the counts of the words after `word`, a byte
+     * of `before0` or `before1` each. No byte carries or borrows: a count is at most 224, and a count
+     * that goes down includes the value removed.
+     */
     shiftCounts(word: number, delta: number): void;
 }
 /**
- * Symbols by node id, for ids a checker resolves in one in four to one in eight of the ids of the
- * pages it touches, as it resolves the identifiers and names of the files it checks. Pages of
- * `LinkPaging.Size` ids keep a presence bit per id and only the symbols stored, so a symbol costs
- * about one array slot. A `LinkTable` page costs a slot for every id, and a `Map` entry also
- * stores its key and a share of the hash buckets. At fewer values per page than that, the page's
- * own allocations outweigh what it saves, and a `SparseLinkTable` costs less.
+ * Values by node or symbol id, for ids a checker stores a value for in more than about one in
+ * sixteen of the ids of the pages it touches: the symbols it resolves for the identifiers and names
+ * of the files it checks (one in four to one in eight), the types and signatures it resolves for
+ * their type nodes and calls (one in twelve to one in seventeen), and the symbol columns most
+ * symbols leave empty, such as the name type of a property (one in ten to one in three with
+ * `--checkers 16`, where every checker touches symbols across the whole program). Pages of
+ * `LinkPaging.Size` ids keep a presence bit per id and only the values stored, so a value costs
+ * about one array slot. A `LinkTable` page costs a slot for every id, and a `Map` entry also stores
+ * its key and a share of the hash buckets. At fewer values per page than that, the page's own
+ * allocations outweigh what it saves, and a `SparseLinkTable` costs less.
  */
-export declare class CompactSymbolLinkTable {
+export declare class CompactLinkTable<T> {
+    /**
+     * The pages by `id >> LinkPaging.Bits`, up to the highest page stored; undefined where a page stores
+     * nothing. A checker stores values in a few percent of the pages of a large program, so the values
+     * are kept apart, one list for each page stored, rather than in a second slot per page.
+     */
     readonly pages: (CompactLinkPage | undefined)[];
-    /** The number of symbols stored. */
+    /** The values of each page stored, in id order, at the page's `position`. */
+    readonly values: T[][];
+    /** The number of values stored. */
     size: number;
-    get(id: number): Symbol | undefined;
-    set(id: number, value: Symbol | undefined): void;
+    get(id: number): T | undefined;
+    set(id: number, value: T | undefined): void;
+    clear(): void;
+}
+/**
+ * Int32 values by id, zero where none is stored, in a `CompactLinkTable`: pages of
+ * `LinkPaging.Size` ids keep a presence bit per id and only the nonzero values. For columns where a
+ * checker stores a value for fewer than about one in three of the ids of the pages it touches, such
+ * as the reference kinds of the symbols its files reference: an `IntLinkTable` page costs four bytes
+ * for every id.
+ */
+export declare class CompactIntLinkTable {
+    private readonly table;
+    get(id: number): number;
+    set(id: number, value: number): void;
     clear(): void;
 }
 export {};