tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/node-builder-pseudo.js

@@ -5,7 +5,7 @@ import { FunctionTypeNode, GetAccessorDeclaration, Identifier, KeywordTypeNode,
 import { isFunctionLike } from './ast-utilities.js';
 import { getSourceFileOfNode, isEntityNameExpression } from './binder-utilities.js';
 import { getContextualType, instantiateContextualType } from './checker-contextual.js';
-import { checkExpressionCached, isConstContext, isLiteralOfContextualType } from './checker-expressions.js';
+import { getTypeOfExpression, isConstContext, isLiteralOfContextualType } from './checker-expressions.js';
 import { getTypeWithFacts } from './checker-flow.js';
 import { getPropertiesOfType, getPropertyOfType } from './checker-members.js';
 import { getReturnTypeOfSignature, getSignatureFromDeclaration, getSingleCallSignature, getTypePredicateOfSignature, } from './checker-signatures.js';
@@ -31,7 +31,7 @@ export function newPseudoChecker(c) {
     return new PseudoChecker(c.strictNullChecks, new Map(), new NoNames(c.compilerOptions));
 }
 function isDeclaration(node) {
-    if (node.kind === 169 /* SyntaxKind.TypeParameter */)
+    if (node.kind === 170 /* SyntaxKind.TypeParameter */)
         return node.parent !== undefined;
     return isDeclarationNode(node);
 }
@@ -54,7 +54,8 @@ export function getRegularTypeOfExpression(c, node) {
     if ((parent instanceof QualifiedName && parent.right === node) ||
         (parent instanceof PropertyAccessExpression && parent.name === node))
         expr = parent;
-    return getRegularTypeOfLiteralType(c, checkExpressionCached(c, expr));
+    // Rechecks the expression, as tsgo does, unless its type needed control flow analysis.
+    return getRegularTypeOfLiteralType(c, getTypeOfExpression(c, expr));
 }
 function keyword(b, kind) {
     return b.created(new KeywordTypeNode(kind));
@@ -110,17 +111,17 @@ export function pseudoTypeToNode(b, t) {
                 return b.serializeReturnTypeForSignatureEx(getSignatureFromDeclaration(c, node), false);
             const parent = node.parent;
             // The declaration's type is widened as the checker widens it.
-            if (parent.kind === 254 /* SyntaxKind.ReturnStatement */) {
+            if (parent.kind === 255 /* SyntaxKind.ReturnStatement */) {
                 const enclosing = getContainingFunction(node);
                 if (isAccessorKind(enclosing))
                     return b.serializeTypeForDeclaration(enclosing, undefined, undefined, false);
                 return b.serializeReturnTypeForSignatureEx(getSignatureFromDeclaration(c, enclosing), false);
             }
-            if (parent.kind === 220 /* SyntaxKind.ArrowFunction */ && getBody(parent) === node)
+            if (parent.kind === 221 /* SyntaxKind.ArrowFunction */ && getBody(parent) === node)
                 return b.serializeReturnTypeForSignatureEx(getSignatureFromDeclaration(c, parent), false);
             if (isDeclaration(parent))
                 return b.serializeTypeForDeclaration(parent, undefined, undefined, false);
-            return b.typeToTypeNode(getTypeOfExpressionForPseudo(c, node));
+            return b.typeToTypeNode(getTypeOfExpression(c, node));
         }
         case 2 /* PseudoTypeKind.NoResult */: {
             const node = t.declaration;
@@ -309,7 +310,7 @@ function pseudoParameterToNode(b, p) {
     const parameter = b.created(new ParameterDeclaration(undefined, p.rest ? b.token(25 /* SyntaxKind.DotDotDotToken */) : undefined, 
     // Parameter names are always written from scratch.
     b.parameterToParameterDeclarationName(getSymbol(original), original), p.optional ? b.token(57 /* SyntaxKind.QuestionToken */) : undefined, pseudoTypeToNode(b, p.type), undefined));
-    if (original.kind === 170 /* SyntaxKind.Parameter */)
+    if (original.kind === 171 /* SyntaxKind.Parameter */)
         b.setCommentRange(parameter, original);
     return parameter;
 }
@@ -605,7 +606,7 @@ export function pseudoReturnTypeMatchesPredicate(b, rt, predicate) {
     const predicateIsAsserts = predicate.kind === 2 /* TypePredicateKind.AssertsThis */ || predicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */;
     if (isAsserts !== predicateIsAsserts)
         return false;
-    const isThis = node.parameterName.kind === 198 /* SyntaxKind.ThisType */;
+    const isThis = node.parameterName.kind === 199 /* SyntaxKind.ThisType */;
     const predicateIsThis = predicate.kind === 0 /* TypePredicateKind.This */ || predicate.kind === 2 /* TypePredicateKind.AssertsThis */;
     if (isThis !== predicateIsThis)
         return false;
@@ -622,9 +623,6 @@ export function pseudoReturnTypeMatchesPredicate(b, rt, predicate) {
         return false;
     return true;
 }
-function getTypeOfExpressionForPseudo(c, node) {
-    return checkExpressionCached(c, node);
-}
 /** The type a pseudo-type denotes, for the kinds that map to one directly. */
 export function pseudoTypeToType(b, t) {
     const c = b.c;
@@ -695,9 +693,9 @@ export function requiresAddingImplicitUndefinedForDeclaration(c, declaration, sy
     if ((declaration.flags & 16 /* NodeFlags.Synthesized */) !== 0)
         return false;
     switch (declaration.kind) {
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 340 /* SyntaxKind.JSDocPropertyTag */: {
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 341 /* SyntaxKind.JSDocPropertyTag */: {
             const symbol = symbolIn ?? getSymbolOfDeclaration(c, declaration);
             if (symbol === undefined)
                 return false;
@@ -705,11 +703,11 @@ export function requiresAddingImplicitUndefinedForDeclaration(c, declaration, sy
             return ((symbol.flags & 4 /* SymbolFlags.Property */) !== 0 &&
                 (symbol.flags & 16777216 /* SymbolFlags.Optional */) !== 0 &&
                 hasQuestionToken(declaration) &&
-                (symbol.checkFlags & 8192 /* CheckFlags.ReverseMapped */) !== 0 &&
+                (symbol.checkFlags & 65536 /* CheckFlags.ReverseMapped */) !== 0 &&
                 c.symbolLinks(symbol).reverseMappedMappedType !== undefined &&
                 containsNonMissingUndefinedType(c, t));
         }
-        case 170 /* SyntaxKind.Parameter */:
+        case 171 /* SyntaxKind.Parameter */:
             return requiresAddingImplicitUndefined(c, declaration, enclosingDeclaration);
     }
     return false;
@@ -717,26 +715,26 @@ export function requiresAddingImplicitUndefinedForDeclaration(c, declaration, sy
 /** Declarations whose type the builder writes from the declaration, as tsgo's `HasInferredType`. */
 export function hasInferredTypeKind(node) {
     switch (node.kind) {
-        case 170 /* SyntaxKind.Parameter */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 209 /* SyntaxKind.BindingElement */:
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */:
-        case 227 /* SyntaxKind.BinaryExpression */:
-        case 214 /* SyntaxKind.CallExpression */:
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 278 /* SyntaxKind.ExportAssignment */:
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
-        case 333 /* SyntaxKind.JSDocParameterTag */:
-        case 340 /* SyntaxKind.JSDocPropertyTag */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 210 /* SyntaxKind.BindingElement */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 334 /* SyntaxKind.JSDocParameterTag */:
+        case 341 /* SyntaxKind.JSDocPropertyTag */:
             return true;
     }
     return false;
 }
 export function isAccessorKind(node) {
-    return node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */;
+    return node.kind === 179 /* SyntaxKind.GetAccessor */ || node.kind === 180 /* SyntaxKind.SetAccessor */;
 }
 /** Whether a declaration is marked optional with `?`, as tsgo's `HasQuestionToken`. */
 export function hasQuestionToken(node) {

package/dist/api/compiler/node-builder-reuse.js

@@ -16,6 +16,7 @@ import { BuilderTracker, TrackedSymbol, canReuseExistingJSTypeNode } from './nod
 import { getSpecifierForModuleSymbol, lookupSymbolChain, symbolToTypeNode } from './node-builder-names.js';
 import { getExternalModuleFileFromDeclaration } from './checker-modules.js';
 import { getResolutionModeOverride } from './program-utilities.js';
+import { getMappedType } from './checker-types.js';
 /** Errors and names tracked while reusing a node, replayed only if the reuse succeeds. */
 class RecoveryBoundary {
     hadError = false;
@@ -162,7 +163,7 @@ class ExistingNodeReuser extends VisitorBase {
         if (result !== undefined)
             result = b.setTextRange(result, node);
         if (bound.hadError) {
-            if (isTypeNode(node) && node.kind !== 183 /* SyntaxKind.TypePredicate */) {
+            if (isTypeNode(node) && node.kind !== 184 /* SyntaxKind.TypePredicate */) {
                 bound.hadError = hadError;
                 b.trackedSymbols.length = trackedTop;
                 bound.deferredReports.length = reportsTop;
@@ -178,7 +179,7 @@ class ExistingNodeReuser extends VisitorBase {
         const b = this.b;
         if (node instanceof JSDocTypeExpression)
             return this.visitNode(node.type);
-        if (node.kind === 310 /* SyntaxKind.JSDocAllType */)
+        if (node.kind === 311 /* SyntaxKind.JSDocAllType */)
             return b.keyword(132 /* SyntaxKind.AnyKeyword */);
         if (node instanceof JSDocNullableType)
             return b.created(new UnionTypeNode(b.list([
@@ -196,12 +197,12 @@ class ExistingNodeReuser extends VisitorBase {
             for (const t of node.jsdocPropertyTags ?? []) {
                 if (!(t instanceof JSDocParameterOrPropertyTag))
                     continue;
-                if (t.kind !== 340 /* SyntaxKind.JSDocPropertyTag */ && t.kind !== 333 /* SyntaxKind.JSDocParameterTag */)
+                if (t.kind !== 341 /* SyntaxKind.JSDocPropertyTag */ && t.kind !== 334 /* SyntaxKind.JSDocParameterTag */)
                     continue;
                 const n = t.name;
                 const targetName = n instanceof QualifiedName ? n.right : n;
                 const name = this.visitNode(targetName);
-                const optional = t.isBracketed || (t.typeExpression !== undefined && t.typeExpression.kind === 313 /* SyntaxKind.JSDocOptionalType */);
+                const optional = t.isBracketed || (t.typeExpression !== undefined && t.typeExpression.kind === 314 /* SyntaxKind.JSDocOptionalType */);
                 const type = t.typeExpression === undefined ? undefined : this.visitNode(t.typeExpression);
                 members.push(b.created(new PropertySignatureDeclaration(undefined, name, optional ? b.token(57 /* SyntaxKind.QuestionToken */) : undefined, type, undefined)));
             }
@@ -273,7 +274,7 @@ class ExistingNodeReuser extends VisitorBase {
             if ((sym.flags & 1 /* SymbolFlags.FunctionScopedVariable */) !== 0 &&
                 sym.valueDeclaration !== undefined &&
                 (isPartOfParameterDeclaration(sym.valueDeclaration) ||
-                    sym.valueDeclaration.kind === 333 /* SyntaxKind.JSDocParameterTag */))
+                    sym.valueDeclaration.kind === 334 /* SyntaxKind.JSDocParameterTag */))
                 return new TrackedName(false, this.attachSymbolToLeftmostIdentifier(leftmost, node, sym));
             let introducesError = false;
             if ((sym.flags & 262144 /* SymbolFlags.TypeParameter */) === 0 &&
@@ -331,7 +332,7 @@ class ExistingNodeReuser extends VisitorBase {
         if ((symbol.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0) {
             const declaredType = getDeclaredTypeOfSymbol(b.c, symbol);
             // A type parameter remapped by the scope.
-            if (b.mapper !== undefined && b.mapper.map(declaredType) !== declaredType)
+            if (b.mapper !== undefined && getMappedType(declaredType, b.mapper) !== declaredType)
                 return undefined;
         }
         if (!canReuseExistingJSTypeNode(b, node, b.getTypeFromTypeNode(node, false)))
@@ -368,7 +369,7 @@ class ExistingNodeReuser extends VisitorBase {
             return replacement;
         }
         // `this` types are copied as they are.
-        if (node.kind === 198 /* SyntaxKind.ThisType */)
+        if (node.kind === 199 /* SyntaxKind.ThisType */)
             return node;
         if (node instanceof TypeParameterDeclaration) {
             const name = this.trackExistingEntityName(node.name);
@@ -438,15 +439,15 @@ class ExistingNodeReuser extends VisitorBase {
             return factory.updateImportTypeNode(node, node.isTypeOf, argument, node.attributes === undefined ? undefined : asImportAttributes(this.visitNode(node.attributes)), this.visitNode(node.qualifier), this.visitNodes(node.typeArguments));
         }
         const name = getName(node);
-        if (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */ && !hasLateBindableName(b.c, node)) {
+        if (name !== undefined && name.kind === 169 /* SyntaxKind.ComputedPropertyName */ && !hasLateBindableName(b.c, node)) {
             if (!hasDynamicName(node))
                 return this.visitEachChild(node);
             return undefined;
         }
         if ((isFunctionLike(node) && getType(node) === undefined) ||
-            ((node.kind === 173 /* SyntaxKind.PropertyDeclaration */ ||
-                node.kind === 172 /* SyntaxKind.PropertySignature */ ||
-                node.kind === 170 /* SyntaxKind.Parameter */) &&
+            ((node.kind === 174 /* SyntaxKind.PropertyDeclaration */ ||
+                node.kind === 173 /* SyntaxKind.PropertySignature */ ||
+                node.kind === 171 /* SyntaxKind.Parameter */) &&
                 getType(node) === undefined &&
                 getInitializer(node) === undefined)) {
             // Untyped declarations get `any`.
@@ -485,9 +486,9 @@ class ExistingNodeReuser extends VisitorBase {
             return factory.updateConditionalTypeNode(node, checkType, extendsType, trueType, falseType);
         }
         // Tuples, type literals and mapped types are written on one line.
-        if (node.kind === 190 /* SyntaxKind.TupleType */ ||
-            ((b.flags & 1024 /* NodeBuilderFlags.MultilineObjectLiterals */) === 0 && node.kind === 188 /* SyntaxKind.TypeLiteral */) ||
-            node.kind === 201 /* SyntaxKind.MappedType */) {
+        if (node.kind === 191 /* SyntaxKind.TupleType */ ||
+            ((b.flags & 1024 /* NodeBuilderFlags.MultilineObjectLiterals */) === 0 && node.kind === 189 /* SyntaxKind.TypeLiteral */) ||
+            node.kind === 202 /* SyntaxKind.MappedType */) {
             let result = this.visitEachChild(node);
             if (result === node)
                 result = b.setTextRange(node.deepClone(), node);
@@ -593,11 +594,11 @@ function getModuleSpecifierOverride(b, parent, literal) {
         ? lookupSymbolChain(b, nodeSymbol, meaning, true)[0]
         : undefined;
     if (parentSymbol !== undefined && isExternalModuleSymbol(parentSymbol))
-        name = getSpecifierForModuleSymbol(b, parentSymbol, mode);
+        name = getSpecifierForModuleSymbol(b, parentSymbol, mode).specifier;
     else {
         const targetFile = getExternalModuleFileFromDeclaration(c, parent);
         if (targetFile !== undefined && targetFile.symbol !== undefined)
-            name = getSpecifierForModuleSymbol(b, targetFile.symbol, mode);
+            name = getSpecifierForModuleSymbol(b, targetFile.symbol, mode).specifier;
     }
     if (name.includes('/node_modules/')) {
         b.encounteredError = true;
@@ -606,7 +607,7 @@ function getModuleSpecifierOverride(b, parent, literal) {
     return name !== originalName ? name : '';
 }
 function isExternalModuleSymbol(symbol) {
-    return (symbol.flags & 1536 /* SymbolFlags.Module */) !== 0 && symbol.name.startsWith('"');
+    return symbol.isExternalModule();
 }
 function isLiteralImportType(node) {
     return node.argument instanceof LiteralTypeNode && node.argument.literal.kind === 10 /* SyntaxKind.StringLiteral */;
@@ -614,7 +615,7 @@ function isLiteralImportType(node) {
 function isEntityNameExpressionNode(node) {
     if (node.kind === 79 /* SyntaxKind.Identifier */)
         return true;
-    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+    if (node.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
         const name = getName(node);
         return (name !== undefined &&
             name.kind === 79 /* SyntaxKind.Identifier */ &&
@@ -625,12 +626,12 @@ function isEntityNameExpressionNode(node) {
 function isDeclarationName(node) {
     const parent = node.parent;
     return (parent !== undefined &&
-        node.kind !== 307 /* SyntaxKind.SourceFile */ &&
+        node.kind !== 308 /* SyntaxKind.SourceFile */ &&
         getName(parent) === node &&
-        parent.kind !== 184 /* SyntaxKind.TypeReference */);
+        parent.kind !== 185 /* SyntaxKind.TypeReference */);
 }
 function isTypeNode(node) {
-    return ((node.kind >= 183 /* SyntaxKind.FirstTypeNode */ && node.kind <= 206 /* SyntaxKind.LastTypeNode */) ||
+    return ((node.kind >= 184 /* SyntaxKind.FirstTypeNode */ && node.kind <= 207 /* SyntaxKind.LastTypeNode */) ||
         node.kind === 132 /* SyntaxKind.AnyKeyword */ ||
         node.kind === 159 /* SyntaxKind.UnknownKeyword */ ||
         node.kind === 150 /* SyntaxKind.NumberKeyword */ ||
@@ -643,5 +644,5 @@ function isTypeNode(node) {
         node.kind === 157 /* SyntaxKind.UndefinedKeyword */ ||
         node.kind === 146 /* SyntaxKind.NeverKeyword */ ||
         node.kind === 141 /* SyntaxKind.IntrinsicKeyword */ ||
-        node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */);
+        node.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */);
 }

package/dist/api/compiler/node-builder.d.ts

@@ -14,6 +14,15 @@ export declare class TrackedSymbol {
     readonly meaning: SymbolFlags;
     constructor(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags);
 }
+/**
+ * The caches of tsgo's node builder that outlive one request: an emit resolver keeps one node builder, so the types
+ * serialized for one declaration are reused, as copies without positions, by the next ones in the file.
+ */
+export declare class NodeBuilderCaches {
+    readonly serializedTypes: Map<number, Map<string, SerializedTypeEntry>>;
+    readonly fakeScopes: Map<Node, string>;
+    constructor();
+}
 declare class SerializedTypeEntry {
     readonly node: Node;
     readonly truncating: boolean;
@@ -100,6 +109,8 @@ export declare class NodeBuilder {
     pseudo: PseudoChecker | undefined;
     /** Set for declaration emit, which writes unions in an order that doesn't depend on the checker's history. */
     declarationOrder: boolean;
+    /** When set, the symbol each identifier naming a symbol refers to. */
+    idToSymbol: Map<Node, Symbol> | undefined;
     constructor(c: Checker, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags, internalFlags: NodeBuilderInternalFlags, tracker: SymbolTracker | undefined, context?: EmitContext | undefined);
     get reportedDiagnostic(): boolean;
     set reportedDiagnostic(value: boolean);
@@ -116,6 +127,8 @@ export declare class NodeBuilder {
     get serializedTypes(): Map<number, Map<string, SerializedTypeEntry>>;
     /** The kind of fake scope a block stands for: `params` or `typeParams`. */
     get fakeScopes(): Map<Node, string>;
+    /** Uses `caches` for the types this builder serializes and its fake scopes, sharing them with other builders. */
+    useCaches(caches: NodeBuilderCaches): void;
     /** `result`, or undefined if serialization failed. */
     finish<T>(result: T | undefined): T | undefined;
     /** Reports a symbol the builder names; without a location it's only recorded. */
@@ -127,6 +140,8 @@ export declare class NodeBuilder {
     keyword(kind: SyntaxKind): Node;
     token(kind: SyntaxKind): Token;
     identifier(text: string): Identifier;
+    /** An identifier naming `symbol`, recorded in `idToSymbol`. */
+    symbolIdentifier(text: string, symbol: Symbol): Identifier;
     stringLiteral(text: string, isSingleQuote: boolean): StringLiteral;
     typeReference(name: Node, typeArguments: NodeList | undefined): Node;
     /** `...`, or `any /*elided*\/` without truncation. */
@@ -157,6 +172,8 @@ export declare class NodeBuilder {
     /** Writes `t` with `transform`, eliding its circular references; cached per enclosing declaration. */
     visitAndTransformType(t: Type, transform: TransformKind): Node | undefined;
     private typeToTypeNodeOrCircularityElision;
+    /** The placeholder for a circular reference; outside of display, it is an error. */
+    private createCyclicStructurePlaceholder;
     private conditionalTypeToTypeNode;
     private getParentSymbolOfTypeParameter;
     private typeReferenceToTypeNode;
@@ -249,7 +266,7 @@ export declare function getTupleElementLabel(c: Checker, flags: ElementFlags, la
  * The type node TypeScript would write for `type`. As in tsgo, the builder has a pseudochecker, so types
  * of declarations are written from what the source wrote where that denotes the type.
  */
-export declare function typeToTypeNode(c: Checker, type: Type, enclosingDeclaration: Node | undefined, flags: number, internalFlags?: NodeBuilderInternalFlags, tracker?: SymbolTracker | undefined): Node | undefined;
+export declare function typeToTypeNode(c: Checker, type: Type, enclosingDeclaration: Node | undefined, flags: number, internalFlags?: NodeBuilderInternalFlags, tracker?: SymbolTracker | undefined, idToSymbol?: Map<Node, Symbol> | undefined): Node | undefined;
 /** The declaration of kind `kind` TypeScript would write for `signature`, with a pseudochecker as `typeToTypeNode`. */
 export declare function signatureToSignatureDeclaration(c: Checker, signature: Signature, kind: SyntaxKind, enclosingDeclaration: Node | undefined, flags: number, internalFlags?: NodeBuilderInternalFlags, tracker?: SymbolTracker | undefined): Node | undefined;
 /**