tsc-ts 0.0.4 → 0.0.6

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

@@ -0,0 +1,4 @@
+import { type Node } from './ast.js';
+import { type NodeBuilder } from './node-builder.js';
+/** A copy of the existing type node `existing` for the builder's location, or undefined if it can't be reused. */
+export declare function tryReuseExistingNode(b: NodeBuilder, existing: Node): Node | undefined;

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

@@ -0,0 +1,647 @@
+// Reusing type nodes from source in built nodes: a copy of an existing type node with its names
+// checked to be accessible, or undefined if they aren't and it can't be rewritten.
+import { ArrayTypeNode, CallSignatureDeclaration, ConstructSignatureDeclaration, ConstructorTypeNode, FunctionTypeNode, IndexSignatureDeclaration, MethodSignatureDeclaration, ParameterDeclaration, PropertyDeclaration, ComputedPropertyName, ConditionalTypeNode, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocParameterOrPropertyTag, JSDocTypeExpression, JSDocTypeLiteral, JSDocVariadicType, PropertySignatureDeclaration, QualifiedName, TypeLiteralNode, UnionTypeNode, Identifier, ImportAttributes, ImportTypeNode, Token, IndexedAccessTypeNode, LiteralTypeNode, MappedTypeNode, NodeList, StringLiteral, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, getName, getText, getType, getInitializer, } from './ast.js';
+import { isFunctionLike, isInJSFile, isStringLiteralLike } from './ast-utilities.js';
+import { getSourceFileOfNode, getThisContainer, hasDynamicName, isExportsIdentifier, isIdentifierNamed, isModuleExportsAccessExpression, isPartOfParameterDeclaration, } from './binder-utilities.js';
+import { getDeclaredTypeOfSymbol, getDeclaredTypeOfTypeParameter, getInferTypeParameters, } from './checker-declared-types.js';
+import { getSignatureFromDeclaration } from './checker-signatures.js';
+import { getExportSymbolOfValueSymbolIfExported, getFirstIdentifier, getSymbolOfDeclaration, resolveEntityName, } from './checker-symbols.js';
+import { getTypeFromTypeNode } from './checker-type-nodes.js';
+import { hasLateBindableName } from './checker-utilities.js';
+import { SymbolTracker } from './transformers/declarations-resolver.js';
+import { getMeaningOfEntityNameReference } from './transformers/declarations-syntactic.js';
+import { VisitorBase } from './transformers/visitor-base.js';
+import { getSymbolIfSameReference, isSymbolAccessible } from './symbol-accessibility.js';
+import { BuilderTracker, TrackedSymbol, canReuseExistingJSTypeNode } from './node-builder.js';
+import { getSpecifierForModuleSymbol, lookupSymbolChain, symbolToTypeNode } from './node-builder-names.js';
+import { getExternalModuleFileFromDeclaration } from './checker-modules.js';
+import { getResolutionModeOverride } from './program-utilities.js';
+/** Errors and names tracked while reusing a node, replayed only if the reuse succeeds. */
+class RecoveryBoundary {
+    hadError = false;
+    deferredReports = [];
+    trackedSymbols = [];
+    markError(report) {
+        this.hadError = true;
+        if (report !== undefined)
+            this.deferredReports.push(report);
+    }
+}
+/** Records what the reuse reports in its boundary rather than reporting it. */
+class RecoveryTracker extends SymbolTracker {
+    inner;
+    bound;
+    constructor(inner, bound) {
+        super();
+        this.inner = inner;
+        this.bound = bound;
+    }
+    trackSymbol(symbol, enclosingDeclaration, meaning) {
+        this.bound.trackedSymbols.push(new TrackedSymbol(symbol, enclosingDeclaration, meaning));
+        return false;
+    }
+    reportInferenceFallback(node) {
+        return this.inner.reportInferenceFallback(node);
+    }
+    reportCyclicStructureError() {
+        const inner = this.inner;
+        this.bound.markError(() => inner.reportCyclicStructureError());
+        return false;
+    }
+    reportInaccessibleThisError() {
+        const inner = this.inner;
+        this.bound.markError(() => inner.reportInaccessibleThisError());
+        return false;
+    }
+    reportInaccessibleUniqueSymbolError() {
+        const inner = this.inner;
+        this.bound.markError(() => inner.reportInaccessibleUniqueSymbolError());
+        return false;
+    }
+    reportLikelyUnsafeImportRequiredError(specifier, symbolName) {
+        const inner = this.inner;
+        this.bound.markError(() => inner.reportLikelyUnsafeImportRequiredError(specifier, symbolName));
+        return false;
+    }
+    reportNonSerializableProperty(propertyName) {
+        const inner = this.inner;
+        this.bound.markError(() => inner.reportNonSerializableProperty(propertyName));
+        return false;
+    }
+    reportPrivateInBaseOfClassExpression(propertyName) {
+        const inner = this.inner;
+        this.bound.markError(() => inner.reportPrivateInBaseOfClassExpression(propertyName));
+        return false;
+    }
+    reportTruncationError() {
+        return this.inner.reportTruncationError();
+    }
+    reportNonlocalAugmentation(containingFile, parentSymbol, augmentingSymbol) {
+        return this.inner.reportNonlocalAugmentation(containingFile, parentSymbol, augmentingSymbol);
+    }
+    pushErrorFallbackNode(node) {
+        return this.inner.pushErrorFallbackNode(node);
+    }
+    popErrorFallbackNode() {
+        return this.inner.popErrorFallbackNode();
+    }
+}
+/** A copy of the existing type node `existing` for the builder's location, or undefined if it can't be reused. */
+export function tryReuseExistingNode(b, existing) {
+    const bound = new RecoveryBoundary();
+    const oldTracker = b.tracker;
+    const oldTrackedSymbols = b.trackedSymbols;
+    const oldEncounteredError = b.encounteredError;
+    const oldApproximateLength = b.approximateLength;
+    b.tracker = new BuilderTracker(b.reports, new RecoveryTracker(oldTracker, bound));
+    b.trackedSymbols = [];
+    const transformed = new ExistingNodeReuser(b, bound).visitNode(existing);
+    b.tracker = oldTracker;
+    b.trackedSymbols = oldTrackedSymbols;
+    b.encounteredError = oldEncounteredError;
+    b.approximateLength = oldApproximateLength;
+    for (const report of bound.deferredReports)
+        report();
+    if (bound.hadError)
+        return undefined;
+    for (const tracked of bound.trackedSymbols)
+        b.trackSymbol(tracked.symbol, tracked.enclosingDeclaration, tracked.meaning);
+    b.approximateLength += existing.end - existing.pos;
+    return transformed;
+}
+/** The result of naming an existing entity name at the builder's location. */
+class TrackedName {
+    introducesError;
+    node;
+    constructor(introducesError, node) {
+        this.introducesError = introducesError;
+        this.node = node;
+    }
+}
+/** Copies an existing node tree, checking and tracking the names it uses. */
+class ExistingNodeReuser extends VisitorBase {
+    b;
+    bound;
+    constructor(b, bound) {
+        super(b.context);
+        this.b = b;
+        this.bound = bound;
+    }
+    // Lists from other files lose their positions.
+    visitNodes(list) {
+        if (list === undefined)
+            return undefined;
+        const nodes = this.visitArray(list.nodes);
+        const result = new NodeList(-1, -1, nodes === list.nodes ? nodes.slice() : nodes);
+        return result;
+    }
+    visit(node) {
+        const b = this.b;
+        const bound = this.bound;
+        // After an error in a sibling the result is discarded anyway.
+        if (bound.hadError)
+            return node;
+        const trackedTop = b.trackedSymbols.length;
+        const reportsTop = bound.deferredReports.length;
+        const hadError = bound.hadError;
+        let exit = undefined;
+        if (isFunctionLike(node)) {
+            const signature = getSignatureFromDeclaration(b.c, node);
+            exit = b.enterNewScope(node, signature.parameters, signature.typeParameters, undefined, undefined);
+        }
+        else if (node instanceof MappedTypeNode) {
+            const symbol = getSymbolOfDeclaration(b.c, node.typeParameter);
+            exit = b.enterNewScope(node, undefined, [getDeclaredTypeOfTypeParameter(b.c, symbol)], undefined, undefined);
+        }
+        let result = this.visitWorker(node);
+        if (exit !== undefined)
+            exit();
+        // As tsgo, an unchanged subtree is copied without positions; the root gets them back below.
+        if (result === node && result !== undefined)
+            result = node.pos < 0 ? node.deepClone() : b.deepCloneNode(node);
+        if (result !== undefined)
+            result = b.setTextRange(result, node);
+        if (bound.hadError) {
+            if (isTypeNode(node) && node.kind !== 183 /* SyntaxKind.TypePredicate */) {
+                bound.hadError = hadError;
+                b.trackedSymbols.length = trackedTop;
+                bound.deferredReports.length = reportsTop;
+                // As tsgo: the type of the node, without checking it matches the expected type here.
+                return b.typeToTypeNode(b.getTypeFromTypeNode(node, false));
+            }
+            return b.setTextRange(node, node);
+        }
+        return result;
+    }
+    /** JSDoc type syntax as TypeScript types, or undefined for other nodes. */
+    visitJSDocType(node) {
+        const b = this.b;
+        if (node instanceof JSDocTypeExpression)
+            return this.visitNode(node.type);
+        if (node.kind === 310 /* SyntaxKind.JSDocAllType */)
+            return b.keyword(132 /* SyntaxKind.AnyKeyword */);
+        if (node instanceof JSDocNullableType)
+            return b.created(new UnionTypeNode(b.list([
+                this.visitNode(node.type),
+                b.created(new LiteralTypeNode(b.factory.createKeywordExpression(105 /* SyntaxKind.NullKeyword */))),
+            ])));
+        if (node instanceof JSDocOptionalType)
+            return b.created(new UnionTypeNode(b.list([this.visitNode(node.type), b.keyword(157 /* SyntaxKind.UndefinedKeyword */)])));
+        if (node instanceof JSDocNonNullableType)
+            return this.visitNode(node.type);
+        if (node instanceof JSDocVariadicType)
+            return b.created(new ArrayTypeNode(this.visitNode(node.type)));
+        if (node instanceof JSDocTypeLiteral) {
+            const members = [];
+            for (const t of node.jsdocPropertyTags ?? []) {
+                if (!(t instanceof JSDocParameterOrPropertyTag))
+                    continue;
+                if (t.kind !== 340 /* SyntaxKind.JSDocPropertyTag */ && t.kind !== 333 /* 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 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)));
+            }
+            return b.created(new TypeLiteralNode(b.list(members)));
+        }
+        return undefined;
+    }
+    attachSymbolToLeftmostIdentifier(leftmost, node, symbol) {
+        if (node === leftmost) {
+            let name = undefined;
+            if (symbol !== undefined && (symbol.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0)
+                name = this.b.typeParameterToName(getDeclaredTypeOfSymbol(this.b.c, symbol));
+            if (name === undefined)
+                name = this.b.identifier(getText(node));
+            name = this.b.setTextRange(name, node);
+            this.context.addEmitFlags(name, 131072 /* EmitFlags.NoAsciiEscaping */);
+            return name;
+        }
+        const copy = new LeftmostRenamer(this, leftmost, symbol).visitEachChild(node);
+        return this.b.setTextRange(copy, node);
+    }
+    renameLeftmost(leftmost, node, symbol) {
+        return this.attachSymbolToLeftmostIdentifier(leftmost, node, symbol);
+    }
+    trackExistingEntityName(node) {
+        const b = this.b;
+        const c = b.c;
+        const enclosingDeclaration = b.enclosingDeclaration;
+        const leftmost = getFirstIdentifier(node);
+        const leftmostParent = leftmost.parent;
+        if (isInJSFile(node) &&
+            (isExportsIdentifier(leftmost) ||
+                (leftmostParent !== undefined && isModuleExportsAccessExpression(leftmostParent)) ||
+                (leftmostParent instanceof QualifiedName &&
+                    isIdentifierNamed(leftmostParent.left, 'module') &&
+                    isExportsIdentifier(leftmostParent.right))))
+            return new TrackedName(true, b.setTextRange(b.deepCloneNode(node), node));
+        const meaning = getMeaningOfEntityNameReference(node);
+        if (leftmost.kind === 109 /* SyntaxKind.ThisKeyword */ || getText(leftmost) === 'this') {
+            // `this` isn't bound: find its symbol directly.
+            const container = getThisContainer(leftmost, false, false);
+            const sym = container === undefined ? undefined : getSymbolOfDeclaration(c, container);
+            let introducesError = false;
+            if (isSymbolAccessible(c, sym, leftmost, meaning, false).accessibility !== 0 /* SymbolAccessibility.Accessible */) {
+                introducesError = true;
+                b.tracker.reportInaccessibleThisError();
+            }
+            return new TrackedName(introducesError, this.attachSymbolToLeftmostIdentifier(leftmost, node, sym));
+        }
+        let sym = resolveEntityName(c, leftmost, meaning, true, true, undefined);
+        if (enclosingDeclaration !== undefined && !(sym !== undefined && (sym.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0)) {
+            if (sym !== undefined)
+                sym = getExportSymbolOfValueSymbolIfExported(c, sym);
+            // A transplanted declaration's names must mean the same at both locations.
+            const symAtLocation = resolveEntityName(c, leftmost, meaning, true, true, enclosingDeclaration);
+            if (symAtLocation === c.unknownSymbol ||
+                (symAtLocation === undefined && sym !== undefined) ||
+                (symAtLocation !== undefined &&
+                    sym !== undefined &&
+                    getSymbolIfSameReference(c, getExportSymbolOfValueSymbolIfExported(c, symAtLocation), sym) === undefined)) {
+                if (symAtLocation !== c.unknownSymbol)
+                    b.tracker.reportInferenceFallback(node);
+                return new TrackedName(true, b.setTextRange(b.deepCloneNode(node), node));
+            }
+            sym = symAtLocation;
+        }
+        if (sym !== undefined) {
+            // A parameter resolvable here is visible.
+            if ((sym.flags & 1 /* SymbolFlags.FunctionScopedVariable */) !== 0 &&
+                sym.valueDeclaration !== undefined &&
+                (isPartOfParameterDeclaration(sym.valueDeclaration) ||
+                    sym.valueDeclaration.kind === 333 /* SyntaxKind.JSDocParameterTag */))
+                return new TrackedName(false, this.attachSymbolToLeftmostIdentifier(leftmost, node, sym));
+            let introducesError = false;
+            if ((sym.flags & 262144 /* SymbolFlags.TypeParameter */) === 0 &&
+                !isDeclarationName(node) &&
+                isSymbolAccessible(c, sym, enclosingDeclaration, meaning, false).accessibility !==
+                    0 /* SymbolAccessibility.Accessible */) {
+                b.tracker.reportInferenceFallback(node);
+                introducesError = true;
+            }
+            else
+                b.trackSymbol(sym, enclosingDeclaration, meaning);
+            return new TrackedName(introducesError, this.attachSymbolToLeftmostIdentifier(leftmost, node, sym));
+        }
+        return new TrackedName(false, b.setTextRange(b.deepCloneNode(node), node));
+    }
+    /** A reference to the type `node` names, written from its symbol. */
+    serializeTypeName(node, isTypeOf, typeArguments) {
+        const b = this.b;
+        const meaning = isTypeOf ? 111551 /* SymbolFlags.Value */ : 788968 /* SymbolFlags.Type */;
+        const symbol = resolveEntityName(b.c, node, meaning, true, false, node);
+        if (symbol === undefined)
+            return undefined;
+        if (isSymbolAccessible(b.c, symbol, b.enclosingDeclaration, meaning, false).accessibility !==
+            0 /* SymbolAccessibility.Accessible */)
+            return undefined;
+        return symbolToTypeNode(b, symbol, meaning, typeArguments);
+    }
+    tryVisitIndexedAccess(node) {
+        const objectType = this.tryVisitSimpleTypeNode(node.objectType);
+        if (objectType === undefined)
+            return undefined;
+        return this.b.setTextRange(this.factory.updateIndexedAccessTypeNode(node, objectType, this.visitNode(node.indexType)), node);
+    }
+    tryVisitKeyOf(node) {
+        const t = this.tryVisitSimpleTypeNode(node.type);
+        if (t === undefined)
+            return undefined;
+        return this.b.setTextRange(this.factory.updateTypeOperatorNode(node, node.operator, t), node);
+    }
+    tryVisitTypeQuery(node) {
+        const name = this.trackExistingEntityName(node.exprName);
+        if (!name.introducesError)
+            return this.b.setTextRange(this.factory.updateTypeQueryNode(node, name.node, this.visitNodes(node.typeArguments)), node);
+        const serialized = this.serializeTypeName(node.exprName, true, this.visitNodes(node.typeArguments));
+        return serialized === undefined ? undefined : this.b.setTextRange(serialized, node.exprName);
+    }
+    tryVisitTypeReference(node) {
+        const b = this.b;
+        if (isConstTypeReference(node))
+            return undefined;
+        getTypeFromTypeNode(b.c, node);
+        const symbol = b.c.resolvedSymbols.get(node.id);
+        if (symbol === undefined)
+            return undefined;
+        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)
+                return undefined;
+        }
+        if (!canReuseExistingJSTypeNode(b, node, b.getTypeFromTypeNode(node, false)))
+            return undefined;
+        const name = this.trackExistingEntityName(node.typeName);
+        if (!name.introducesError)
+            return b.setTextRange(this.factory.updateTypeReferenceNode(node, name.node, this.visitNodes(node.typeArguments)), node);
+        const serialized = this.serializeTypeName(node.typeName, false, this.visitNodes(node.typeArguments));
+        return serialized === undefined ? undefined : b.setTextRange(serialized, node.typeName);
+    }
+    tryVisitSimpleTypeNode(node) {
+        // As tsgo, parenthesized types are kept.
+        const inner = node;
+        if (inner instanceof TypeReferenceNode)
+            return this.tryVisitTypeReference(inner);
+        if (inner instanceof TypeQueryNode)
+            return this.tryVisitTypeQuery(inner);
+        if (inner instanceof IndexedAccessTypeNode)
+            return this.tryVisitIndexedAccess(inner);
+        if (inner instanceof TypeOperatorNode && inner.operator === 143 /* SyntaxKind.KeyOfKeyword */)
+            return this.tryVisitKeyOf(inner);
+        return this.visitNode(node);
+    }
+    visitWorker(node) {
+        const b = this.b;
+        const factory = this.factory;
+        const bound = this.bound;
+        const jsdoc = this.visitJSDocType(node);
+        if (jsdoc !== undefined)
+            return jsdoc;
+        if (node instanceof TypeReferenceNode && node.typeName instanceof Identifier && node.typeName.text === '') {
+            const replacement = b.keyword(132 /* SyntaxKind.AnyKeyword */);
+            this.context.setOriginal(replacement, node);
+            return replacement;
+        }
+        // `this` types are copied as they are.
+        if (node.kind === 198 /* SyntaxKind.ThisType */)
+            return node;
+        if (node instanceof TypeParameterDeclaration) {
+            const name = this.trackExistingEntityName(node.name);
+            return factory.updateTypeParameterDeclaration(node, this.visitModifiers(node.modifiers), name.node, this.visitNode(node.constraint), this.visitNode(node.expression), this.visitNode(node.defaultType));
+        }
+        if (node instanceof IndexedAccessTypeNode) {
+            const result = this.tryVisitIndexedAccess(node);
+            if (result !== undefined)
+                return result;
+            bound.markError(undefined);
+            return node;
+        }
+        if (node instanceof TypeReferenceNode) {
+            const result = this.tryVisitTypeReference(node);
+            if (result !== undefined)
+                return result;
+            bound.markError(undefined);
+            return node;
+        }
+        if (node instanceof TypeQueryNode) {
+            const result = this.tryVisitTypeQuery(node);
+            if (result !== undefined)
+                return result;
+            bound.markError(undefined);
+            return node;
+        }
+        if (node instanceof TypeOperatorNode) {
+            if (node.operator === 158 /* SyntaxKind.UniqueKeyword */ && node.type.kind === 155 /* SyntaxKind.SymbolKeyword */) {
+                const nonFakeEnclosing = b.getEnclosingDeclarationIgnoringFakeScope();
+                let sameScope = false;
+                for (let current = node; current !== undefined; current = current.parent)
+                    if (current === nonFakeEnclosing)
+                        sameScope = true;
+                if (!sameScope) {
+                    bound.markError(undefined);
+                    return node;
+                }
+            }
+            else if (node.operator === 143 /* SyntaxKind.KeyOfKeyword */) {
+                const result = this.tryVisitKeyOf(node);
+                if (result !== undefined)
+                    return result;
+                bound.markError(undefined);
+                return node;
+            }
+        }
+        if (node instanceof ImportTypeNode && isLiteralImportType(node)) {
+            // The deprecated `assert` keyword isn't reused.
+            if (node.attributes !== undefined && node.attributes.token === 131 /* SyntaxKind.AssertKeyword */) {
+                bound.markError(undefined);
+                return node;
+            }
+            if (b.getTypeFromTypeNode(node, true) === undefined) {
+                bound.markError(undefined);
+                return node;
+            }
+            const originalSpecifier = node.argument.literal;
+            const specifier = getModuleSpecifierOverride(b, node, originalSpecifier);
+            let argument;
+            if (specifier === '')
+                argument = this.visitNode(node.argument);
+            else {
+                const literal = factory.createStringLiteral(specifier, 0 /* TokenFlags.None */);
+                b.context.setOriginal(literal, originalSpecifier);
+                argument = factory.created(new LiteralTypeNode(literal));
+            }
+            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 (!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 */) &&
+                getType(node) === undefined &&
+                getInitializer(node) === undefined)) {
+            // Untyped declarations get `any`.
+            let visited = this.visitEachChild(node);
+            if (visited === node)
+                visited = b.setTextRange(node.deepClone(), node);
+            withAnyType(b, visited);
+            return visited;
+        }
+        if (node instanceof ComputedPropertyName && isEntityNameExpressionNode(node.expression)) {
+            const tracked = this.trackExistingEntityName(node.expression);
+            if (!tracked.introducesError)
+                return factory.updateComputedPropertyName(node, tracked.node);
+            bound.markError(undefined);
+            return this.visitEachChild(node);
+        }
+        if (node instanceof TypePredicateNode) {
+            let parameterName;
+            if (node.parameterName instanceof Identifier) {
+                const tracked = this.trackExistingEntityName(node.parameterName);
+                if (tracked.introducesError)
+                    bound.markError(undefined);
+                parameterName = tracked.node;
+            }
+            else
+                parameterName = node.parameterName.deepClone();
+            return factory.updateTypePredicateNode(node, node.assertsModifier === undefined ? undefined : asToken(this.visitNode(node.assertsModifier)), parameterName, this.visitNode(node.type));
+        }
+        if (node instanceof ConditionalTypeNode) {
+            const checkType = this.visitNode(node.checkType);
+            const exit = b.enterNewScope(node, undefined, getInferTypeParameters(b.c, node), undefined, undefined);
+            const extendsType = this.visitNode(node.extendsType);
+            const trueType = this.visitNode(node.trueType);
+            exit();
+            const falseType = this.visitNode(node.falseType);
+            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 */) {
+            let result = this.visitEachChild(node);
+            if (result === node)
+                result = b.setTextRange(node.deepClone(), node);
+            this.context.addEmitFlags(result, 1 /* EmitFlags.SingleLine */);
+            return result;
+        }
+        if (isStringLiteralLike(node)) {
+            // The literal's characters are kept rather than escaped.
+            const copy = node.deepClone();
+            if (copy instanceof StringLiteral &&
+                (b.flags & 268435456 /* NodeBuilderFlags.UseSingleQuotesForStringLiteralType */) !== 0 &&
+                (copy.tokenFlags & 65536 /* TokenFlags.SingleQuote */) === 0) {
+                const literal = copy;
+                literal.tokenFlags = literal.tokenFlags | 65536 /* TokenFlags.SingleQuote */;
+            }
+            this.context.addEmitFlags(copy, 131072 /* EmitFlags.NoAsciiEscaping */);
+            return copy;
+        }
+        return this.visitEachChild(node);
+    }
+}
+/** Renames the leftmost identifier of an entity name, copying the rest. */
+class LeftmostRenamer extends VisitorBase {
+    owner;
+    leftmost;
+    symbol;
+    constructor(owner, leftmost, symbol) {
+        super(owner.context);
+        this.owner = owner;
+        this.leftmost = leftmost;
+        this.symbol = symbol;
+    }
+    visit(node) {
+        return this.owner.renameLeftmost(this.leftmost, node, this.symbol);
+    }
+}
+/** Gives a copied declaration or signature without a type the type `any`; false for other kinds. */
+function withAnyType(b, node) {
+    const any = b.keyword(132 /* SyntaxKind.AnyKeyword */);
+    if (node instanceof PropertyDeclaration) {
+        node.type = any;
+        node.initializer = undefined;
+    }
+    else if (node instanceof PropertySignatureDeclaration) {
+        node.type = any;
+        node.initializer = undefined;
+    }
+    else if (node instanceof ParameterDeclaration) {
+        node.modifiers = undefined;
+        node.type = any;
+        node.initializer = undefined;
+    }
+    else if (node instanceof MethodSignatureDeclaration)
+        node.type = any;
+    else if (node instanceof CallSignatureDeclaration)
+        node.type = any;
+    else if (node instanceof ConstructSignatureDeclaration)
+        node.type = any;
+    else if (node instanceof IndexSignatureDeclaration)
+        node.type = any;
+    else if (node instanceof FunctionTypeNode)
+        node.type = any;
+    else if (node instanceof ConstructorTypeNode)
+        node.type = any;
+    else
+        return false;
+    return true;
+}
+function asImportAttributes(node) {
+    if (node === undefined)
+        return undefined;
+    if (node instanceof ImportAttributes)
+        return node;
+    return undefined;
+}
+function asToken(node) {
+    if (node === undefined)
+        return undefined;
+    if (node instanceof Token)
+        return node;
+    return undefined;
+}
+function isConstTypeReference(node) {
+    return node.typeName instanceof Identifier && node.typeName.text === 'const' && node.typeArguments === undefined;
+}
+/**
+ * The specifier an `import("…")` type copied from another file takes in the file being written,
+ * or `''` to keep it.
+ */
+function getModuleSpecifierOverride(b, parent, literal) {
+    const c = b.c;
+    if (b.enclosingFile === getSourceFileOfNode(literal))
+        return '';
+    const mode = getResolutionModeOverride(parent.attributes);
+    const originalName = getText(literal);
+    let name = originalName;
+    getTypeFromTypeNode(c, parent);
+    const nodeSymbol = c.resolvedSymbols.get(parent.id);
+    const meaning = parent.isTypeOf ? 111551 /* SymbolFlags.Value */ : 788968 /* SymbolFlags.Type */;
+    const parentSymbol = nodeSymbol !== undefined &&
+        isSymbolAccessible(c, nodeSymbol, b.enclosingDeclaration, meaning, false).accessibility ===
+            0 /* SymbolAccessibility.Accessible */
+        ? lookupSymbolChain(b, nodeSymbol, meaning, true)[0]
+        : undefined;
+    if (parentSymbol !== undefined && isExternalModuleSymbol(parentSymbol))
+        name = getSpecifierForModuleSymbol(b, parentSymbol, mode);
+    else {
+        const targetFile = getExternalModuleFileFromDeclaration(c, parent);
+        if (targetFile !== undefined && targetFile.symbol !== undefined)
+            name = getSpecifierForModuleSymbol(b, targetFile.symbol, mode);
+    }
+    if (name.includes('/node_modules/')) {
+        b.encounteredError = true;
+        b.tracker.reportLikelyUnsafeImportRequiredError(name, '');
+    }
+    return name !== originalName ? name : '';
+}
+function isExternalModuleSymbol(symbol) {
+    return (symbol.flags & 1536 /* SymbolFlags.Module */) !== 0 && symbol.name.startsWith('"');
+}
+function isLiteralImportType(node) {
+    return node.argument instanceof LiteralTypeNode && node.argument.literal.kind === 10 /* SyntaxKind.StringLiteral */;
+}
+function isEntityNameExpressionNode(node) {
+    if (node.kind === 79 /* SyntaxKind.Identifier */)
+        return true;
+    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+        const name = getName(node);
+        return (name !== undefined &&
+            name.kind === 79 /* SyntaxKind.Identifier */ &&
+            isEntityNameExpressionNode(node.expression));
+    }
+    return false;
+}
+function isDeclarationName(node) {
+    const parent = node.parent;
+    return (parent !== undefined &&
+        node.kind !== 307 /* SyntaxKind.SourceFile */ &&
+        getName(parent) === node &&
+        parent.kind !== 184 /* SyntaxKind.TypeReference */);
+}
+function isTypeNode(node) {
+    return ((node.kind >= 183 /* SyntaxKind.FirstTypeNode */ && node.kind <= 206 /* SyntaxKind.LastTypeNode */) ||
+        node.kind === 132 /* SyntaxKind.AnyKeyword */ ||
+        node.kind === 159 /* SyntaxKind.UnknownKeyword */ ||
+        node.kind === 150 /* SyntaxKind.NumberKeyword */ ||
+        node.kind === 163 /* SyntaxKind.BigIntKeyword */ ||
+        node.kind === 151 /* SyntaxKind.ObjectKeyword */ ||
+        node.kind === 135 /* SyntaxKind.BooleanKeyword */ ||
+        node.kind === 154 /* SyntaxKind.StringKeyword */ ||
+        node.kind === 155 /* SyntaxKind.SymbolKeyword */ ||
+        node.kind === 115 /* SyntaxKind.VoidKeyword */ ||
+        node.kind === 157 /* SyntaxKind.UndefinedKeyword */ ||
+        node.kind === 146 /* SyntaxKind.NeverKeyword */ ||
+        node.kind === 141 /* SyntaxKind.IntrinsicKeyword */ ||
+        node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */);
+}