tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/name-resolver.d.ts

@@ -0,0 +1,43 @@
+import { type Node, ParameterDeclaration, Tristate } from './ast.js';
+import { type DiagnosticMessage } from './diagnostics.js';
+import { type CompilerOptions } from './options.js';
+import { Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
+export declare class NameResolver {
+    readonly compilerOptions: CompilerOptions;
+    /** The global symbol table; empty unless the checker sets it. */
+    globals: SymbolTable;
+    argumentsSymbol: Symbol | undefined;
+    requireSymbol: Symbol | undefined;
+    constructor(compilerOptions: CompilerOptions);
+    /** The symbol of `name` in `symbols` with a `meaning`. Ignores aliases and merging by default. */
+    lookup(symbols: SymbolTable, name: string, meaning: SymbolFlags): Symbol | undefined;
+    /** The (merged) symbol of a declaration. */
+    getSymbolOfDeclaration(node: Node): Symbol | undefined;
+    /** Reports an error; the default reports nothing. */
+    error(_location: Node, _message: DiagnosticMessage, _args: readonly string[]): void;
+    symbolReferenced(_symbol: Symbol, _meaning: SymbolFlags): void;
+    /** Whether a function's parameters need their own scope, cached per function; Unknown if not cached. */
+    getRequiresScopeChangeCache(_node: Node): Tristate;
+    setRequiresScopeChangeCache(_node: Node, _value: Tristate): void;
+    /** Handles a reference from a property initializer to a constructor local; true to resolve to nothing. */
+    onPropertyWithInvalidInitializer(_location: Node, _name: string, _declaration: Node, _result: Symbol | undefined): boolean;
+    /** Reports a failed lookup; `location` is undefined for global lookups. */
+    onFailedToResolveSymbol(_location: Node | undefined, _name: string, _meaning: SymbolFlags, _message: DiagnosticMessage): void;
+    /** Checks a successful lookup; `location` is undefined for global lookups. */
+    onSuccessfullyResolvedSymbol(_location: Node | undefined, _result: Symbol, _meaning: SymbolFlags, _lastLocation: Node | undefined, _associatedDeclarationForContainingInitializerOrBindingName: Node | undefined, _withinDeferredContext: boolean): void;
+    /** The symbol for `arguments`; the default is a transient property symbol. */
+    getArgumentsSymbol(): Symbol;
+    /**
+     * Resolves `name` with `meaning` from `location`. With a `nameNotFoundMessage`, reports
+     * through the hooks; `isUse` counts it as a reference.
+     */
+    resolve(location: Node | undefined, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage | undefined, isUse: boolean, excludeGlobals: boolean): Symbol | undefined;
+    /**
+     * Whether a parameter default refers outside the function: names declared in the body
+     * aren't in scope there unless emit moves the parameter into the body.
+     */
+    useOuterVariableScopeInParameter(result: Symbol, location: Node, lastLocation: Node): boolean;
+    requiresScopeChange(node: ParameterDeclaration): boolean;
+}
+/** The local symbol of an `export default` declaration. */
+export declare function getLocalSymbolForExportDefault(symbol: Symbol): Symbol | undefined;

package/dist/api/compiler/name-resolver.js

@@ -0,0 +1,509 @@
+// Name resolution: finds the symbol a name refers to by walking up the scopes from a location.
+//
+// The checker subclasses `NameResolver` to resolve aliases and merged symbols, report errors
+// and record uses; the defaults here only read the binder's tables.
+import { BindingElement, ConditionalTypeNode, HeritageClause, ModuleDeclaration, NodeVisitor, getAsteriskToken, getBody, getLocalSymbol, getLocals, getModuleSpecifier, getName, getParameters, getSymbol, getText, getType, } from './ast.js';
+import { isFunctionLike, isFunctionLikeDeclarationKind, isInJSFile, isRequireCall } from './ast-utilities.js';
+import { findConstructorDeclaration, getDeclarationOfKind, getImmediatelyInvokedFunctionExpression, getSourceFileOfNode, hasSyntacticModifier, hasStaticModifier, isClassElement, isClassLike, isConstAssertion, isExternalOrCommonJSModule, isGlobalSourceFile, isNullishCoalesce, isOptionalChain, isPartOfParameterDeclaration, isStatic, isTypeNodeKind, } from './binder-utilities.js';
+import { getEmitScriptTarget, getIsolatedModules, getUseDefineForClassFields, } from './options.js';
+import { Symbol } from './symbol.js';
+export class NameResolver {
+    compilerOptions;
+    /** The global symbol table; empty unless the checker sets it. */
+    globals;
+    argumentsSymbol;
+    requireSymbol;
+    constructor(compilerOptions) {
+        this.compilerOptions = compilerOptions;
+        this.globals = new Map();
+        this.argumentsSymbol = undefined;
+        this.requireSymbol = undefined;
+    }
+    // Hooks
+    /** The symbol of `name` in `symbols` with a `meaning`. Ignores aliases and merging by default. */
+    lookup(symbols, name, meaning) {
+        if (meaning === 0 /* SymbolFlags.None */)
+            return undefined;
+        const symbol = symbols.get(name);
+        return symbol !== undefined && (symbol.flags & meaning) !== 0 ? symbol : undefined;
+    }
+    /** The (merged) symbol of a declaration. */
+    getSymbolOfDeclaration(node) {
+        return symbolOfNode(node);
+    }
+    /** Reports an error; the default reports nothing. */
+    error(_location, _message, _args) { }
+    symbolReferenced(_symbol, _meaning) { }
+    /** Whether a function's parameters need their own scope, cached per function; Unknown if not cached. */
+    getRequiresScopeChangeCache(_node) {
+        return 0 /* Tristate.Unknown */;
+    }
+    setRequiresScopeChangeCache(_node, _value) { }
+    /** Handles a reference from a property initializer to a constructor local; true to resolve to nothing. */
+    onPropertyWithInvalidInitializer(_location, _name, _declaration, _result) {
+        return false;
+    }
+    /** Reports a failed lookup; `location` is undefined for global lookups. */
+    onFailedToResolveSymbol(_location, _name, _meaning, _message) { }
+    /** Checks a successful lookup; `location` is undefined for global lookups. */
+    onSuccessfullyResolvedSymbol(_location, _result, _meaning, _lastLocation, _associatedDeclarationForContainingInitializerOrBindingName, _withinDeferredContext) { }
+    /** The symbol for `arguments`; the default is a transient property symbol. */
+    getArgumentsSymbol() {
+        let symbol = this.argumentsSymbol;
+        if (symbol === undefined) {
+            symbol = new Symbol(4 /* SymbolFlags.Property */ | 33554432 /* SymbolFlags.Transient */, 'arguments');
+            this.argumentsSymbol = symbol;
+        }
+        return symbol;
+    }
+    /**
+     * Resolves `name` with `meaning` from `location`. With a `nameNotFoundMessage`, reports
+     * through the hooks; `isUse` counts it as a reference.
+     */
+    resolve(location, name, meaning, nameNotFoundMessage, isUse, excludeGlobals) {
+        let result;
+        let lastLocation;
+        let lastSelfReferenceLocation;
+        let propertyWithInvalidInitializer;
+        let associatedDeclarationForContainingInitializerOrBindingName;
+        let withinDeferredContext = false;
+        // For did-you-mean suggestions, which start at the original location.
+        const originalLocation = location;
+        const nameIsConst = name === 'const';
+        let current = location;
+        loop: while (current !== undefined) {
+            // `const` in `as const` is the expression's constant type, not a lookup.
+            if (nameIsConst && isConstAssertion(current))
+                return undefined;
+            // From the name of a namespace or enum, skip its own scope: its locals could conflict.
+            if ((current.kind === 268 /* SyntaxKind.ModuleDeclaration */ || current.kind === 267 /* SyntaxKind.EnumDeclaration */) &&
+                lastLocation !== undefined &&
+                getName(current) === lastLocation) {
+                lastLocation = current;
+                current = current.parent;
+                if (current === undefined)
+                    break;
+            }
+            const locals = getLocalsOf(current);
+            // Locals of a global source file are merged into the globals.
+            if (locals !== undefined && !isGlobalSourceFile(current)) {
+                result = this.lookup(locals, name, meaning);
+                if (result !== undefined) {
+                    let useResult = true;
+                    if (isFunctionLike(current) && lastLocation !== undefined && lastLocation !== getBody(current)) {
+                        // Type parameters are in scope in the whole signature, but local types only in the
+                        // body; parameters only in the body, parameter list and return type. JSDoc types
+                        // are parented above type parameters, so this doesn't apply to them.
+                        if ((meaning & result.flags & 788968 /* SymbolFlags.Type */) !== 0 && lastLocation.kind !== 315 /* SyntaxKind.JSDoc */) {
+                            useResult =
+                                (result.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0 &&
+                                    ((lastLocation.flags & 16 /* NodeFlags.Synthesized */) !== 0 ||
+                                        lastLocation === getType(current) ||
+                                        lastLocation.kind === 170 /* SyntaxKind.Parameter */ ||
+                                        lastLocation.kind === 333 /* SyntaxKind.JSDocParameterTag */ ||
+                                        lastLocation.kind === 334 /* SyntaxKind.JSDocReturnTag */ ||
+                                        lastLocation.kind === 169 /* SyntaxKind.TypeParameter */);
+                        }
+                        if ((meaning & result.flags & 3 /* SymbolFlags.Variable */) !== 0) {
+                            if (this.useOuterVariableScopeInParameter(result, current, lastLocation))
+                                useResult = false;
+                            else if ((result.flags & 1 /* SymbolFlags.FunctionScopedVariable */) !== 0) {
+                                // Initializers referencing later parameters are checked separately.
+                                useResult =
+                                    lastLocation.kind === 170 /* SyntaxKind.Parameter */ ||
+                                        (lastLocation.flags & 16 /* NodeFlags.Synthesized */) !== 0 ||
+                                        (lastLocation === getType(current) && isInParameter(result.valueDeclaration));
+                            }
+                        }
+                    }
+                    else if (current instanceof ConditionalTypeNode) {
+                        // `infer T` is only in scope in the true branch.
+                        useResult = lastLocation === current.trueType;
+                    }
+                    if (useResult)
+                        break loop;
+                    result = undefined;
+                }
+            }
+            withinDeferredContext = withinDeferredContext || isDeferredContext(current, lastLocation);
+            switch (current.kind) {
+                case 307 /* SyntaxKind.SourceFile */:
+                case 268 /* SyntaxKind.ModuleDeclaration */: {
+                    if (current.kind === 307 /* SyntaxKind.SourceFile */ && !isExternalOrCommonJSModule(current))
+                        break;
+                    const moduleSymbol = this.getSymbolOfDeclaration(current);
+                    if (moduleSymbol === undefined)
+                        break;
+                    const moduleExports = moduleSymbol.exports ?? emptyTable;
+                    if (current.kind === 307 /* SyntaxKind.SourceFile */ ||
+                        ((current.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && !isGlobalScopeAugmentationNode(current))) {
+                        // An external module: the local name of its default export is in scope.
+                        result = moduleExports.get("default" /* InternalSymbolName.Default */);
+                        if (result !== undefined) {
+                            const localSymbol = getLocalSymbolForExportDefault(result);
+                            if (localSymbol !== undefined && (result.flags & meaning) !== 0 && localSymbol.name === name)
+                                break loop;
+                            result = undefined;
+                        }
+                        // A name exported only by an export specifier isn't in scope. This checks the
+                        // flags without resolving the alias, which could be circular.
+                        const moduleExport = moduleExports.get(name);
+                        if (moduleExport !== undefined &&
+                            moduleExport.flags === 2097152 /* SymbolFlags.Alias */ &&
+                            (getDeclarationOfKind(moduleExport, 282 /* SyntaxKind.ExportSpecifier */) !== undefined ||
+                                getDeclarationOfKind(moduleExport, 281 /* SyntaxKind.NamespaceExport */) !== undefined))
+                            break;
+                    }
+                    if (name !== "default" /* InternalSymbolName.Default */) {
+                        result = this.lookup(moduleExports, name, meaning & 2623475 /* SymbolFlags.ModuleMember */);
+                        if (result !== undefined) {
+                            if (current.kind === 307 /* SyntaxKind.SourceFile */ &&
+                                current.commonJSModuleIndicator !== undefined &&
+                                (result.flags & 788968 /* SymbolFlags.Type */) === 0)
+                                result = undefined;
+                            else
+                                break loop;
+                        }
+                    }
+                    break;
+                }
+                case 267 /* SyntaxKind.EnumDeclaration */: {
+                    const enumSymbol = this.getSymbolOfDeclaration(current);
+                    if (enumSymbol === undefined)
+                        break;
+                    result = this.lookup(enumSymbol.exports ?? emptyTable, name, meaning & 8 /* SymbolFlags.EnumMember */);
+                    if (result !== undefined) {
+                        if (nameNotFoundMessage !== undefined &&
+                            getIsolatedModules(this.compilerOptions) &&
+                            (current.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
+                            result.valueDeclaration !== undefined &&
+                            getSourceFileOfNode(current) !== getSourceFileOfNode(result.valueDeclaration)) {
+                            const flagName = this.compilerOptions.verbatimModuleSyntax === true ? 'verbatimModuleSyntax' : 'isolatedModules';
+                            this.error(originalLocation, 230 /* Diagnostics.Cannot_access_0_from_another_file_without_qualification_when_1_is_enabled_Use_2_instead */, [name, flagName, enumSymbol.name + '.' + name]);
+                        }
+                        break loop;
+                    }
+                    break;
+                }
+                case 173 /* SyntaxKind.PropertyDeclaration */:
+                    if (!isStatic(current)) {
+                        const ctor = findConstructorDeclaration(current.parent);
+                        if (ctor !== undefined) {
+                            const ctorLocals = getLocalsOf(ctor);
+                            // Remembered to report later.
+                            if (ctorLocals !== undefined && this.lookup(ctorLocals, name, meaning & 111551 /* SymbolFlags.Value */) !== undefined)
+                                propertyWithInvalidInitializer = current;
+                        }
+                    }
+                    break;
+                case 264 /* SyntaxKind.ClassDeclaration */:
+                case 232 /* SyntaxKind.ClassExpression */:
+                case 265 /* SyntaxKind.InterfaceDeclaration */: {
+                    const classSymbol = this.getSymbolOfDeclaration(current);
+                    result =
+                        classSymbol === undefined
+                            ? undefined
+                            : this.lookup(classSymbol.members ?? emptyTable, name, meaning & 788968 /* SymbolFlags.Type */);
+                    if (result !== undefined) {
+                        // Ignore type parameters declared elsewhere.
+                        if (!isTypeParameterSymbolDeclaredInContainer(result, current)) {
+                            result = undefined;
+                            break;
+                        }
+                        // Type parameters aren't in scope in static members.
+                        if (lastLocation !== undefined && isStatic(lastLocation)) {
+                            if (nameNotFoundMessage !== undefined)
+                                this.error(originalLocation, 480 /* Diagnostics.Static_members_cannot_reference_class_type_parameters */, noArgs);
+                            return undefined;
+                        }
+                        break loop;
+                    }
+                    if (current.kind === 232 /* SyntaxKind.ClassExpression */ && (meaning & 32 /* SymbolFlags.Class */) !== 0) {
+                        const className = getName(current);
+                        if (className !== undefined && name === getText(className)) {
+                            result = symbolOfNode(current);
+                            break loop;
+                        }
+                    }
+                    break;
+                }
+                case 234 /* SyntaxKind.ExpressionWithTypeArguments */: {
+                    const heritage = current.parent;
+                    if (lastLocation === current.expression &&
+                        heritage instanceof HeritageClause &&
+                        heritage.token === 95 /* SyntaxKind.ExtendsKeyword */) {
+                        const container = heritage.parent;
+                        if (isClassLike(container)) {
+                            const classSymbol = this.getSymbolOfDeclaration(container);
+                            result =
+                                classSymbol === undefined
+                                    ? undefined
+                                    : this.lookup(classSymbol.members ?? emptyTable, name, meaning & 788968 /* SymbolFlags.Type */);
+                            if (result !== undefined) {
+                                if (nameNotFoundMessage !== undefined)
+                                    this.error(originalLocation, 716 /* Diagnostics.Base_class_expressions_cannot_reference_class_type_parameters */, noArgs);
+                                return undefined;
+                            }
+                        }
+                    }
+                    break;
+                }
+                case 168 /* SyntaxKind.ComputedPropertyName */: {
+                    // A class's computed property names can't reference its own type parameters.
+                    const grandparent = current.parent.parent;
+                    if (isClassLike(grandparent) || grandparent.kind === 265 /* SyntaxKind.InterfaceDeclaration */) {
+                        const containerSymbol = this.getSymbolOfDeclaration(grandparent);
+                        result =
+                            containerSymbol === undefined
+                                ? undefined
+                                : this.lookup(containerSymbol.members ?? emptyTable, name, meaning & 788968 /* SymbolFlags.Type */);
+                        if (result !== undefined) {
+                            if (nameNotFoundMessage !== undefined)
+                                this.error(originalLocation, 633 /* Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type */, noArgs);
+                            return undefined;
+                        }
+                    }
+                    break;
+                }
+                case 175 /* SyntaxKind.MethodDeclaration */:
+                case 177 /* SyntaxKind.Constructor */:
+                case 178 /* SyntaxKind.GetAccessor */:
+                case 179 /* SyntaxKind.SetAccessor */:
+                case 263 /* SyntaxKind.FunctionDeclaration */:
+                    if ((meaning & 3 /* SymbolFlags.Variable */) !== 0 && name === 'arguments') {
+                        result = this.getArgumentsSymbol();
+                        break loop;
+                    }
+                    break;
+                case 219 /* SyntaxKind.FunctionExpression */: {
+                    if ((meaning & 3 /* SymbolFlags.Variable */) !== 0 && name === 'arguments') {
+                        result = this.getArgumentsSymbol();
+                        break loop;
+                    }
+                    const functionName = current.name;
+                    if ((meaning & 16 /* SymbolFlags.Function */) !== 0 && functionName !== undefined && name === functionName.text) {
+                        result = symbolOfNode(current);
+                        break loop;
+                    }
+                    break;
+                }
+                case 171 /* SyntaxKind.Decorator */: {
+                    // Decorators resolve at the class: a parameter's at its class member, a member's at the class.
+                    let parent = current.parent;
+                    if (parent !== undefined && parent.kind === 170 /* SyntaxKind.Parameter */) {
+                        current = parent;
+                        parent = current.parent;
+                    }
+                    if (parent !== undefined && (isClassElement(parent) || parent.kind === 264 /* SyntaxKind.ClassDeclaration */))
+                        current = parent;
+                    break;
+                }
+                case 170 /* SyntaxKind.Parameter */: {
+                    const parameter = current;
+                    if (lastLocation !== undefined &&
+                        (lastLocation === parameter.initializer ||
+                            (lastLocation === parameter.name && isBindingPattern(lastLocation))) &&
+                        associatedDeclarationForContainingInitializerOrBindingName === undefined)
+                        associatedDeclarationForContainingInitializerOrBindingName = current;
+                    break;
+                }
+                case 209 /* SyntaxKind.BindingElement */: {
+                    const element = current;
+                    if (lastLocation !== undefined &&
+                        (lastLocation === element.initializer ||
+                            (lastLocation === element.name && isBindingPattern(lastLocation))) &&
+                        isPartOfParameterDeclaration(current) &&
+                        associatedDeclarationForContainingInitializerOrBindingName === undefined)
+                        associatedDeclarationForContainingInitializerOrBindingName = current;
+                    break;
+                }
+                case 196 /* SyntaxKind.InferType */:
+                    if ((meaning & 262144 /* SymbolFlags.TypeParameter */) !== 0) {
+                        const typeParameter = current.typeParameter;
+                        if (name === typeParameter.name.text) {
+                            result = symbolOfNode(typeParameter);
+                            break loop;
+                        }
+                    }
+                    break;
+                case 282 /* SyntaxKind.ExportSpecifier */: {
+                    // `export { a as b } from "m"`: `a` resolves outside this module.
+                    const specifier = current;
+                    const exportDeclaration = current.parent.parent;
+                    if (lastLocation !== undefined &&
+                        lastLocation === specifier.propertyName &&
+                        getModuleSpecifier(exportDeclaration) !== undefined)
+                        current = exportDeclaration.parent;
+                    break;
+                }
+            }
+            if (isSelfReferenceLocation(current, lastLocation))
+                lastSelfReferenceLocation = current;
+            lastLocation = current;
+            current = current.parent;
+        }
+        // A use from inside the declaration it resolves to is a self-reference, not a use.
+        if (isUse &&
+            result !== undefined &&
+            (lastSelfReferenceLocation === undefined || result !== symbolOfNode(lastSelfReferenceLocation)))
+            this.symbolReferenced(result, meaning);
+        if (result === undefined && !excludeGlobals)
+            result = this.lookup(this.globals, name, meaning | 1073741824 /* SymbolFlags.GlobalLookup */);
+        if (result === undefined &&
+            originalLocation !== undefined &&
+            isInJSFile(originalLocation) &&
+            originalLocation.parent !== undefined &&
+            isRequireCall(originalLocation.parent, false))
+            return this.requireSymbol;
+        if (nameNotFoundMessage !== undefined) {
+            if (propertyWithInvalidInitializer !== undefined &&
+                this.onPropertyWithInvalidInitializer(originalLocation, name, propertyWithInvalidInitializer, result))
+                return undefined;
+            if (result === undefined)
+                this.onFailedToResolveSymbol(originalLocation, name, meaning, nameNotFoundMessage);
+            else
+                this.onSuccessfullyResolvedSymbol(originalLocation, result, meaning, lastLocation, associatedDeclarationForContainingInitializerOrBindingName, withinDeferredContext);
+        }
+        return result;
+    }
+    /**
+     * Whether a parameter default refers outside the function: names declared in the body
+     * aren't in scope there unless emit moves the parameter into the body.
+     */
+    useOuterVariableScopeInParameter(result, location, lastLocation) {
+        if (lastLocation.kind !== 170 /* SyntaxKind.Parameter */)
+            return false;
+        const body = getBody(location);
+        const declaration = result.valueDeclaration;
+        if (body === undefined || declaration === undefined || declaration.pos < body.pos || declaration.end > body.end)
+            return false;
+        // Static fields in class expressions, optional chains and `??` before ES2020, and object
+        // rest in binding patterns before ES2017 move parameters into the body.
+        let requiresScopeChange = this.getRequiresScopeChangeCache(location);
+        if (requiresScopeChange === 0 /* Tristate.Unknown */) {
+            requiresScopeChange = 1 /* Tristate.False */;
+            for (const parameter of getParameters(location).nodes)
+                if (this.requiresScopeChange(parameter))
+                    requiresScopeChange = 2 /* Tristate.True */;
+            this.setRequiresScopeChangeCache(location, requiresScopeChange);
+        }
+        return requiresScopeChange !== 2 /* Tristate.True */;
+    }
+    requiresScopeChange(node) {
+        const visitor = new ScopeChangeFinder(this.compilerOptions);
+        return (visitor.requiresScopeChange(node.name) ||
+            (node.initializer !== undefined && visitor.requiresScopeChange(node.initializer)));
+    }
+}
+/** Finds syntax that makes emit move a parameter into the function body. */
+class ScopeChangeFinder extends NodeVisitor {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    visitNode(node) {
+        return this.requiresScopeChange(node);
+    }
+    requiresScopeChange(node) {
+        switch (node.kind) {
+            case 220 /* SyntaxKind.ArrowFunction */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 177 /* SyntaxKind.Constructor */:
+                return false;
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 303 /* SyntaxKind.PropertyAssignment */:
+                return this.requiresScopeChange(getName(node));
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+                if (hasStaticModifier(node))
+                    return !getEmitStandardClassFields(this.options);
+                return this.requiresScopeChange(getName(node));
+        }
+        if (isNullishCoalesce(node) || isOptionalChain(node))
+            return getEmitScriptTarget(this.options) < 7 /* ScriptTarget.ES2020 */;
+        if (node instanceof BindingElement &&
+            node.dotDotDotToken !== undefined &&
+            node.parent.kind === 207 /* SyntaxKind.ObjectBindingPattern */)
+            return getEmitScriptTarget(this.options) < 4 /* ScriptTarget.ES2017 */;
+        if (isTypeNodeKind(node.kind))
+            return false;
+        return node.forEachChild(this);
+    }
+}
+const noArgs = [];
+const emptyTable = new Map();
+/** Whether class fields are emitted as standard `[[Define]]` fields. */
+function getEmitStandardClassFields(options) {
+    return getUseDefineForClassFields(options) && getEmitScriptTarget(options) >= 9 /* ScriptTarget.ES2022 */;
+}
+function symbolOfNode(node) {
+    return getSymbol(node);
+}
+function getLocalsOf(node) {
+    return getLocals(node);
+}
+function isBindingPattern(node) {
+    return node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */;
+}
+function isGlobalScopeAugmentationNode(node) {
+    return node instanceof ModuleDeclaration && node.keyword === 162 /* SyntaxKind.GlobalKeyword */;
+}
+function isInParameter(declaration) {
+    for (let current = declaration; current !== undefined; current = current.parent)
+        if (current.kind === 170 /* SyntaxKind.Parameter */)
+            return true;
+    return false;
+}
+/** The local symbol of an `export default` declaration. */
+export function getLocalSymbolForExportDefault(symbol) {
+    const declarations = symbol.declarations;
+    if (declarations.length === 0 || !hasSyntacticModifier(declarations[0], 2048 /* ModifierFlags.Default */))
+        return undefined;
+    for (const declaration of declarations) {
+        const localSymbol = getLocalSymbol(declaration);
+        if (localSymbol !== undefined)
+            return localSymbol;
+    }
+    return undefined;
+}
+/** Whether a reference at `location` runs later than its scope's own code, like in a function body. */
+function isDeferredContext(location, lastLocation) {
+    if (location.kind !== 220 /* SyntaxKind.ArrowFunction */ && location.kind !== 219 /* SyntaxKind.FunctionExpression */) {
+        // Instance property initializers run in the constructor; a declaration's name runs in its scope.
+        return (location.kind === 187 /* SyntaxKind.TypeQuery */ ||
+            ((isFunctionLikeDeclarationKind(location.kind) ||
+                (location.kind === 173 /* SyntaxKind.PropertyDeclaration */ && !isStatic(location))) &&
+                (lastLocation === undefined || lastLocation !== getName(location))));
+    }
+    if (lastLocation !== undefined && lastLocation === getName(location))
+        return false;
+    // Immediately invoked generators and async functions aren't part of the containing flow.
+    if (getAsteriskToken(location) !== undefined || hasSyntacticModifier(location, 1024 /* ModifierFlags.Async */))
+        return true;
+    return getImmediatelyInvokedFunctionExpression(location) === undefined;
+}
+function isTypeParameterSymbolDeclaredInContainer(symbol, container) {
+    for (const declaration of symbol.declarations)
+        if (declaration.kind === 169 /* SyntaxKind.TypeParameter */ && declaration.parent === container)
+            return true;
+    return false;
+}
+function isSelfReferenceLocation(node, lastLocation) {
+    switch (node.kind) {
+        case 170 /* SyntaxKind.Parameter */:
+            return lastLocation !== undefined && lastLocation === getName(node);
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+            // `namespace N { N; }`
+            return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,32 @@
+import { type Node, type NodeList, SourceFile } from './ast.js';
+import type { Checker } from './checker.js';
+import { ModuleSpecifierPreferences } from './module-specifiers.js';
+import { ModuleKind } from './options.js';
+import { type Symbol, SymbolFlags } from './symbol.js';
+import { type NodeBuilder } from './node-builder.js';
+/** The chain of symbols naming `symbol`, reported to the tracker. */
+export declare function lookupSymbolChain(b: NodeBuilder, symbol: Symbol, meaning: SymbolFlags, yieldModuleSymbol: boolean): Symbol[];
+/** A type node naming `symbol` with `mask`: a type reference, `typeof`, indexed access or `import("…")`. */
+export declare function symbolToTypeNode(b: NodeBuilder, symbol: Symbol, mask: SymbolFlags, typeArguments: NodeList | undefined): Node | undefined;
+/** `ref`'s names appended to the reference `root`, for an outer type parameter group. */
+export declare function appendReferenceToType(b: NodeBuilder, root: Node, ref: Node): Node;
+/** An entity name for `symbol`; with `expectsIdentifier`, a qualified name is an error unless allowed. */
+export declare function symbolToName(b: NodeBuilder, symbol: Symbol, meaning: SymbolFlags, expectsIdentifier: boolean): Node;
+/** The symbol's name qualified by its parents' names, without looking up a chain. */
+export declare function symbolToEntityNameNode(b: NodeBuilder, symbol: Symbol): Node;
+export declare function symbolToExpression(b: NodeBuilder, symbol: Symbol, meaning: SymbolFlags): Node;
+/**
+ * A readable name for a symbol, not for the right of a `.`: quoted if from a string literal,
+ * and a number as written (`0o11`, not `9`).
+ */
+export declare function getNameOfSymbolAsWritten(b: NodeBuilder, symbol: Symbol): string;
+/** The name node of a property. */
+export declare function getPropertyNameNodeForSymbol(b: NodeBuilder, symbol: Symbol): Node;
+/**
+ * The specifier an `import("…")` type names a module with: an ambient module's name, the file
+ * name without an enclosing file, else what module specifier generation gives for the enclosing
+ * file. `overrideImportMode` is `None` for the mode of the enclosing import or file.
+ */
+export declare function getSpecifierForModuleSymbol(b: NodeBuilder, symbol: Symbol, overrideImportMode: ModuleKind): string;
+/** Specifiers `importingFile` can import the module `moduleSymbol` with, best first. */
+export declare function getModuleSpecifiers(c: Checker, moduleSymbol: Symbol, importingFile: SourceFile, preferences: ModuleSpecifierPreferences, overrideImportMode: ModuleKind): string[];