tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/checker-javascript.d.ts

@@ -0,0 +1,42 @@
+import { BinaryExpression, type Node } from './ast.js';
+import { type Symbol } from './symbol.js';
+import type { Checker } from './checker.js';
+import { type Type } from './checker-types.js';
+/** The type of the CommonJS `module` symbol or its `exports` property. */
+export declare function getTypeOfModuleExportsSymbol(c: Checker, symbol: Symbol): Type;
+/** The type of a symbol declared by JavaScript assignments or `Object.defineProperty` calls. */
+export declare function getWidenedTypeForAssignmentDeclaration(c: Checker, symbol: Symbol): Type;
+export declare function getRightMostAssignedExpression(node: Node): Node;
+/** Whether a symbol is a property declared by `this.x` assignments in a constructor. */
+export declare function isConstructorDeclaredThisProperty(c: Checker, symbol: Symbol): boolean;
+/**
+ * Whether `node` is `this.x` in the constructor whose assignments type x: x is declared by `this.x`
+ * assignments there, or is an auto-typed property declaration.
+ */
+export declare function isThisPropertyAccessInConstructor(c: Checker, node: Node, prop: Symbol): boolean;
+/** The type of `this.x` in a constructor, or of an auto-typed property: the control flow type of its assignments. */
+export declare function getFlowTypeOfAutoTypedProperty(c: Checker, reference: Node, prop: Symbol | undefined): Type;
+/**
+ * The contextual type of the right operand of `left = right`: the type of `left`, except for
+ * `module.exports = …` and assignment declarations, which would be circular.
+ */
+export declare function getContextualTypeForAssignmentExpression(c: Checker, binary: BinaryExpression): Type | undefined;
+/** Whether `node` is `require("m")` with the CommonJS `require`, not a local function of that name. */
+export declare function isCommonJSRequire(c: Checker, node: Node): boolean;
+/** The type of the module a `require("m")` call names. */
+export declare function resolveExternalModuleTypeByLiteral(c: Checker, name: Node): Type;
+/** Whether a JavaScript declaration declares an alias: a `require` or an exported entity name. */
+export declare function isJSAliasDeclaration(node: Node): boolean;
+/** `this` in `obj.x = function () {}` is `obj`, except for CommonJS `exports.x = function () {}`. */
+export declare function getThisTypeOfAssignedFunction(c: Checker, func: Node): Type | undefined;
+/** The type of an empty object literal with expando members, `const o = {}; o.x = 1`. */
+export declare function getTypeOfExpandoObjectLiteral(c: Checker, node: Node): Type | undefined;
+/** Whether an object literal is in a JavaScript file and has no contextual type. */
+export declare function isJSObjectLiteral(c: Checker, node: Node): boolean;
+/**
+ * Whether reading or writing unknown members of `t` is allowed: a JavaScript object literal, a union of
+ * them, an intersection with one, or a type variable constrained to one. Not under noImplicitAny.
+ */
+export declare function isJSLiteralType(c: Checker, t: Type): boolean;
+/** `exports.x = undefined` is ignored when x has other assignment declarations. */
+export declare function isUndefinedAssignmentToCommonJSExport(c: Checker, left: Node, rightType: Type): boolean;

package/dist/api/compiler/checker-javascript.js

@@ -0,0 +1,441 @@
+// JavaScript semantics: CommonJS `module.exports`, `exports.x` and `require`, expando assignments
+// (`f.x = …`, `o = {}; o.x = …`), `this.x` assignment declarations and auto-typed properties,
+// `Object.defineProperty` declarations, and object literals that allow unknown members.
+import { BinaryExpression, NodeVisitor, PropertyAccessExpression, getArguments, getExpression, getInitializer, getProperties, getSymbol, getText, getType, } from './ast.js';
+import { isFunctionLike, isInJSFile, isRequireCall } from './ast-utilities.js';
+import { getSymbolNameForPrivateIdentifier } from './binder.js';
+import { getAssignmentDeclarationKind, expressionIsAlias, getDeclarationOfKind, getSourceFileOfNode, getThisContainer, isAccessExpression, isJsonSourceFile, isStringOrNumericLiteralLike, isVariableDeclarationInitializedToRequire, } from './binder-utilities.js';
+import { createAnonymousType, filterType, getRegularTypeOfLiteralType, getUnionType, typesOf, } from './checker-type-factory.js';
+import { getExportSymbolOfValueSymbolIfExported, getSymbolOfDeclaration, resolveName } from './checker-symbols.js';
+import { resolveExternalModuleName, resolveExternalModuleSymbol } from './checker-modules.js';
+import { getTypeFromTypeNode } from './checker-type-nodes.js';
+import { getPropertyOfType, getResolvedBaseConstraint, getTypeOfPropertyOfType } from './checker-members.js';
+import { getApparentTypeOfContextualTypeEx, getTypeOfPropertyOfContextualType, } from './checker-contextual.js';
+import { getPropertyNameFromType, isTypeUsableAsPropertyName } from './checker-utilities.js';
+import { getReturnTypeOfSignature, getSingleCallSignature, getTypeAtPosition } from './checker-signatures.js';
+import { checkExpressionCached, checkExpressionForMutableLocation, getResolvedSymbol, getTypeOfExpression, } from './checker-expressions.js';
+import { getFlowTypeOfReference, isMatchingReference } from './checker-narrowing.js';
+import { isEmptyArrayLiteralType } from './relations.js';
+import { getTypeOfSymbol, getWidenedType, reportImplicitAny } from './checker-symbol-types.js';
+import { getFlowTypeInConstructor, getFlowTypeOfProperty, getTypeOfPropertyInBaseClass, isAutoTypedProperty, } from './checker-classes.js';
+/** The type of the CommonJS `module` symbol or its `exports` property. */
+export function getTypeOfModuleExportsSymbol(c, symbol) {
+    if (symbol.name === 'exports') {
+        const target = resolveExternalModuleSymbol(c, getSymbolOfDeclaration(c, symbol.valueDeclaration), false);
+        return target !== undefined ? getTypeOfSymbol(c, target) : c.errorType;
+    }
+    return createAnonymousType(c, symbol, symbol.members, [], [], []);
+}
+/** The type of a symbol declared by JavaScript assignments or `Object.defineProperty` calls. */
+export function getWidenedTypeForAssignmentDeclaration(c, symbol) {
+    let t;
+    const kind = getThisAssignmentKind(c, symbol);
+    const location = c.symbolLinks(symbol).thisAssignmentLocation;
+    if (kind === 1 /* ThisAssignmentKind.Typed */)
+        t = getTypeFromTypeNode(c, location);
+    else if (kind === 2 /* ThisAssignmentKind.Constructor */)
+        t = getFlowTypeInConstructor(c, symbol, location);
+    else if (kind === 3 /* ThisAssignmentKind.Method */)
+        t = getTypeOfPropertyInBaseClass(c, symbol);
+    if (t === undefined) {
+        const types = [];
+        const declarations = symbol.declarations;
+        for (let i = 0; i < declarations.length; i++) {
+            const declaration = declarations[i];
+            const declaredType = declaration instanceof BinaryExpression ? declaration.type : undefined;
+            if (declaredType !== undefined) {
+                t = getTypeFromTypeNode(c, declaredType);
+                break;
+            }
+            const assignedType = getAssignmentDeclarationInitializerType(c, declaration);
+            // An initial `exports.x = undefined` is ignored when there are other declarations.
+            if (assignedType !== undefined &&
+                (getAssignmentDeclarationKind(declaration) !== 2 /* JSDeclarationKind.ExportsProperty */ ||
+                    i !== 0 ||
+                    declarations.length === 1 ||
+                    (assignedType.flags & 4 /* TypeFlags.Undefined */) === 0) &&
+                !types.includes(assignedType))
+                types.push(assignedType);
+        }
+        if (kind === 3 /* ThisAssignmentKind.Method */ && types.length > 0 && c.strictNullChecks) {
+            if (!types.includes(c.undefinedOrMissingType))
+                types.push(c.undefinedOrMissingType);
+        }
+        if (t === undefined)
+            t = types.length !== 0 ? getUnionType(c, types) : c.anyType;
+    }
+    t = getWidenedType(c, t);
+    // An all-nullable or empty union is an implicit any in JS files.
+    if (symbol.valueDeclaration !== undefined &&
+        isInJSFile(symbol.valueDeclaration) &&
+        filterType(c, t, isNonNullableType) === c.neverType) {
+        reportImplicitAny(c, symbol.valueDeclaration, c.anyType);
+        return c.anyType;
+    }
+    return t;
+}
+function isNonNullableType(t) {
+    return (t.flags & ~12 /* TypeFlags.Nullable */) !== 0;
+}
+function getAssignmentDeclarationInitializerType(c, node) {
+    if (node instanceof BinaryExpression) {
+        let t;
+        switch (getAssignmentDeclarationKind(node)) {
+            case 1 /* JSDeclarationKind.ModuleExports */:
+            case 2 /* JSDeclarationKind.ExportsProperty */:
+                t = getRegularTypeOfLiteralType(c, checkExpressionCached(c, getRightMostAssignedExpression(node)));
+                break;
+            case 3 /* JSDeclarationKind.ThisProperty */:
+                if (containsSameNamedThisProperty(c, node.left, node.right))
+                    return undefined;
+                t = checkExpressionForMutableLocation(c, node.right);
+                break;
+            default:
+                t = checkExpressionForMutableLocation(c, node.right);
+        }
+        if (isEmptyArrayLiteralType(c, t) && !hasParentWithTypeAnnotation(c, node.symbol)) {
+            reportImplicitAny(c, node, c.anyArrayType);
+            return c.anyArrayType;
+        }
+        return t;
+    }
+    if (node.kind === 214 /* SyntaxKind.CallExpression */)
+        return getTypeFromPropertyDescriptor(c, getArguments(node).nodes[2]);
+    return undefined;
+}
+export function getRightMostAssignedExpression(node) {
+    let current = node;
+    while (current instanceof BinaryExpression && current.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */)
+        current = current.right;
+    return current;
+}
+/** Whether the parent of an expando symbol is a function expression whose variable is annotated. */
+function hasParentWithTypeAnnotation(c, symbol) {
+    const parent = symbol.parent;
+    if (parent === undefined || parent.valueDeclaration === undefined)
+        return false;
+    const kind = parent.valueDeclaration.kind;
+    if (kind !== 219 /* SyntaxKind.FunctionExpression */ && kind !== 220 /* SyntaxKind.ArrowFunction */)
+        return false;
+    const annotated = getSymbolOfDeclaration(c, parent.valueDeclaration.parent);
+    return (annotated !== undefined &&
+        annotated.valueDeclaration !== undefined &&
+        getType(annotated.valueDeclaration) !== undefined);
+}
+/** Finds a reference to a `this.x` property outside nested functions. */
+class SameNamedThisPropertyFinder extends NodeVisitor {
+    c;
+    thisProperty;
+    constructor(c, thisProperty) {
+        super();
+        this.c = c;
+        this.thisProperty = thisProperty;
+    }
+    visitNode(node) {
+        if (isMatchingReference(this.c, this.thisProperty, node))
+            return true;
+        if (isFunctionLike(node))
+            return false;
+        return node.forEachChild(this);
+    }
+}
+function containsSameNamedThisProperty(c, thisProperty, expression) {
+    return new SameNamedThisPropertyFinder(c, thisProperty).visitNode(expression);
+}
+function getTypeFromPropertyDescriptor(c, node) {
+    const objectLiteralType = checkExpressionCached(c, node);
+    const valueType = getTypeOfPropertyOfType(c, objectLiteralType, 'value');
+    if (valueType !== undefined)
+        return valueType;
+    const getFunc = getTypeOfPropertyOfType(c, objectLiteralType, 'get');
+    if (getFunc !== undefined) {
+        const getSig = getSingleCallSignature(c, getFunc);
+        if (getSig !== undefined)
+            return getReturnTypeOfSignature(c, getSig);
+    }
+    const setFunc = getTypeOfPropertyOfType(c, objectLiteralType, 'set');
+    if (setFunc !== undefined) {
+        const setSig = getSingleCallSignature(c, setFunc);
+        if (setSig !== undefined)
+            return getTypeAtPosition(c, setSig, 0);
+    }
+    return c.anyType;
+}
+// ---- `this.x` assignment declarations
+function getThisAssignmentKind(c, symbol) {
+    if (!(symbol.valueDeclaration instanceof BinaryExpression))
+        return 0 /* ThisAssignmentKind.None */;
+    const links = c.symbolLinks(symbol);
+    if (links.thisAssignmentKind !== 0)
+        return (links.thisAssignmentKind - 1);
+    let allThis = true;
+    let typeAnnotation;
+    for (const declaration of symbol.declarations) {
+        if (!(declaration instanceof BinaryExpression)) {
+            allThis = false;
+            break;
+        }
+        const left = declaration.left;
+        if (getAssignmentDeclarationKind(declaration) === 3 /* JSDeclarationKind.ThisProperty */ &&
+            (left.kind !== 213 /* SyntaxKind.ElementAccessExpression */ || isStringOrNumericLiteralLike(getArgumentExpression(left)))) {
+            if (declaration.type !== undefined)
+                typeAnnotation = declaration.type;
+        }
+        else {
+            allThis = false;
+            break;
+        }
+    }
+    let kind = 0 /* ThisAssignmentKind.None */;
+    let location;
+    if (allThis) {
+        if (typeAnnotation !== undefined) {
+            location = typeAnnotation;
+            kind = 1 /* ThisAssignmentKind.Typed */;
+        }
+        else {
+            location = getDeclaringConstructor(symbol);
+            kind = location === undefined ? 3 /* ThisAssignmentKind.Method */ : 2 /* ThisAssignmentKind.Constructor */;
+        }
+    }
+    links.thisAssignmentKind = kind + 1;
+    links.thisAssignmentLocation = location;
+    return kind;
+}
+function getArgumentExpression(node) {
+    return node.argumentExpression;
+}
+/** Whether a symbol is a property declared by `this.x` assignments in a constructor. */
+export function isConstructorDeclaredThisProperty(c, symbol) {
+    return getThisAssignmentKind(c, symbol) === 2 /* ThisAssignmentKind.Constructor */;
+}
+function getDeclaringConstructor(symbol) {
+    for (const declaration of symbol.declarations) {
+        const container = getThisContainer(declaration, false, false);
+        if (container.kind === 177 /* SyntaxKind.Constructor */)
+            return container;
+    }
+    return undefined;
+}
+/**
+ * Whether `node` is `this.x` in the constructor whose assignments type x: x is declared by `this.x`
+ * assignments there, or is an auto-typed property declaration.
+ */
+export function isThisPropertyAccessInConstructor(c, node, prop) {
+    let constructor;
+    if (isConstructorDeclaredThisProperty(c, prop))
+        constructor = c.symbolLinks(prop).thisAssignmentLocation;
+    else if (isThisProperty(node) && isAutoTypedProperty(c, prop))
+        constructor = getDeclaringConstructor(prop);
+    return getThisContainer(node, true, false) === constructor;
+}
+function isThisProperty(node) {
+    return isAccessExpression(node) && getExpression(node).kind === 109 /* SyntaxKind.ThisKeyword */;
+}
+/** The type of `this.x` in a constructor, or of an auto-typed property: the control flow type of its assignments. */
+export function getFlowTypeOfAutoTypedProperty(c, reference, prop) {
+    if (prop === undefined)
+        return getFlowTypeOfReference(c, reference, c.autoType, c.undefinedType, undefined);
+    return getFlowTypeOfProperty(c, reference, prop);
+}
+// ---- Contextual types
+/** The leftmost expression of a property access, element access or call chain. */
+function getLeftmostAccessExpression(node) {
+    let current = node;
+    while (isAccessExpression(current) || current.kind === 214 /* SyntaxKind.CallExpression */)
+        current = getExpression(current);
+    return current;
+}
+/**
+ * The contextual type of the right operand of `left = right`: the type of `left`, except for
+ * `module.exports = …` and assignment declarations, which would be circular.
+ */
+export function getContextualTypeForAssignmentExpression(c, binary) {
+    const left = binary.left;
+    const target = getLeftmostAccessExpression(left);
+    if (target.kind === 79 /* SyntaxKind.Identifier */ && (getResolvedSymbol(c, target).flags & 134217728 /* SymbolFlags.ModuleExports */) !== 0)
+        return undefined;
+    if (isAccessExpression(left)) {
+        const expr = getExpression(left);
+        switch (expr.kind) {
+            case 79 /* SyntaxKind.Identifier */: {
+                const symbol = getExportSymbolOfValueSymbolIfExported(c, getResolvedSymbol(c, expr));
+                if ((symbol.flags & 134217728 /* SymbolFlags.ModuleExports */) !== 0)
+                    return undefined;
+                if (binary.symbol === undefined)
+                    break;
+                // `F.id = expr` takes a contextual type only from an annotated variable F.
+                const declaration = symbol.valueDeclaration;
+                if (declaration === undefined || declaration.kind !== 261 /* SyntaxKind.VariableDeclaration */)
+                    return undefined;
+                const typeNode = getType(declaration);
+                if (typeNode === undefined)
+                    return undefined;
+                if (left instanceof PropertyAccessExpression)
+                    return getTypeOfPropertyOfContextualType(c, getTypeFromTypeNode(c, typeNode), getText(left.name));
+                const nameType = checkExpressionCached(c, getArgumentExpression(left));
+                if (isTypeUsableAsPropertyName(nameType))
+                    return getTypeOfPropertyOfContextualType(c, getTypeFromTypeNode(c, typeNode), getPropertyNameFromType(nameType));
+                return getTypeOfExpression(c, left);
+            }
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.ElementAccessExpression */:
+                if (binary.symbol !== undefined)
+                    return undefined;
+                break;
+            case 109 /* SyntaxKind.ThisKeyword */: {
+                const thisType = getTypeOfExpression(c, expr);
+                let symbol;
+                if (left instanceof PropertyAccessExpression) {
+                    const name = left.name;
+                    if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */) {
+                        if (thisType.symbol !== undefined)
+                            symbol = getPropertyOfType(c, thisType, getSymbolNameForPrivateIdentifier(thisType.symbol, getText(name)));
+                    }
+                    else
+                        symbol = getPropertyOfType(c, thisType, getText(name));
+                }
+                else {
+                    const propType = checkExpressionCached(c, getArgumentExpression(left));
+                    if (isTypeUsableAsPropertyName(propType))
+                        symbol = getPropertyOfType(c, thisType, getPropertyNameFromType(propType));
+                }
+                const d = symbol?.valueDeclaration;
+                // `this.x = expr` where x is a property with no type annotation or initializer.
+                if (d !== undefined &&
+                    (d.kind === 173 /* SyntaxKind.PropertyDeclaration */ || d.kind === 172 /* SyntaxKind.PropertySignature */) &&
+                    getType(d) === undefined &&
+                    getInitializer(d) === undefined)
+                    return undefined;
+                // An assignment declaration `this.x = expr` without a JSDoc type.
+                const declaration = binary.symbol?.valueDeclaration;
+                if (declaration !== undefined && getType(declaration) === undefined)
+                    return undefined;
+                break;
+            }
+        }
+    }
+    return getTypeOfExpression(c, left);
+}
+// ---- CommonJS `require`
+/** Whether `node` is `require("m")` with the CommonJS `require`, not a local function of that name. */
+export function isCommonJSRequire(c, node) {
+    if (!isRequireCall(node, true))
+        return false;
+    const callee = getExpression(node);
+    const resolved = resolveName(c, callee, getText(callee), 111551 /* SymbolFlags.Value */, undefined, true, false);
+    if (resolved === c.requireSymbol)
+        return true;
+    // A declared `require` must be an ambient function or variable.
+    if (resolved === undefined || (resolved.flags & 2097152 /* SymbolFlags.Alias */) !== 0)
+        return false;
+    let kind = 0 /* SyntaxKind.Unknown */;
+    if ((resolved.flags & 16 /* SymbolFlags.Function */) !== 0)
+        kind = 263 /* SyntaxKind.FunctionDeclaration */;
+    else if ((resolved.flags & 3 /* SymbolFlags.Variable */) !== 0)
+        kind = 261 /* SyntaxKind.VariableDeclaration */;
+    if (kind === 0 /* SyntaxKind.Unknown */)
+        return false;
+    const declaration = getDeclarationOfKind(resolved, kind);
+    return declaration !== undefined && (declaration.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
+}
+/** The type of the module a `require("m")` call names. */
+export function resolveExternalModuleTypeByLiteral(c, name) {
+    const moduleSymbol = resolveExternalModuleName(c, name, name, false);
+    if (moduleSymbol !== undefined) {
+        const resolved = resolveExternalModuleSymbol(c, moduleSymbol, false);
+        if (resolved !== undefined)
+            return getTypeOfSymbol(c, resolved);
+    }
+    return c.anyType;
+}
+/** Whether a JavaScript declaration declares an alias: a `require` or an exported entity name. */
+export function isJSAliasDeclaration(node) {
+    if (node.kind !== 227 /* SyntaxKind.BinaryExpression */)
+        return isVariableDeclarationInitializedToRequire(node);
+    const kind = getAssignmentDeclarationKind(node);
+    return ((kind === 1 /* JSDeclarationKind.ModuleExports */ || kind === 2 /* JSDeclarationKind.ExportsProperty */) &&
+        expressionIsAlias(node.right));
+}
+/** `this` in `obj.x = function () {}` is `obj`, except for CommonJS `exports.x = function () {}`. */
+export function getThisTypeOfAssignedFunction(c, func) {
+    let parent = func.parent;
+    while (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+        parent = parent.parent;
+    // Compound assignments like `??=` count too.
+    if (!(parent instanceof BinaryExpression) ||
+        parent.operatorToken.kind < 63 /* SyntaxKind.FirstAssignment */ ||
+        parent.operatorToken.kind > 78 /* SyntaxKind.LastAssignment */)
+        return undefined;
+    const target = parent.left;
+    if (!isAccessExpression(target))
+        return undefined;
+    const expression = getExpression(target);
+    if (isInJSFile(func) &&
+        expression.kind === 79 /* SyntaxKind.Identifier */ &&
+        getSourceFileOfNode(parent).commonJSModuleIndicator !== undefined &&
+        (getResolvedSymbol(c, expression).flags & 134217728 /* SymbolFlags.ModuleExports */) !== 0)
+        return undefined;
+    return getWidenedType(c, checkExpressionCached(c, expression));
+}
+// ---- Object literals
+/** The type of an empty object literal with expando members, `const o = {}; o.x = 1`. */
+export function getTypeOfExpandoObjectLiteral(c, node) {
+    const symbol = getSymbol(node);
+    if (getProperties(node).nodes.length !== 0 || symbol === undefined)
+        return undefined;
+    const exports = symbol.exports;
+    if (exports === undefined || exports.size === 0)
+        return undefined;
+    const result = createAnonymousType(c, symbol, exports, [], [], []);
+    if (isInJSFile(node) && !isJsonSourceFile(getSourceFileOfNode(node)))
+        result.objectFlags |= 4096 /* ObjectFlags.JSLiteral */;
+    return result;
+}
+/** Whether an object literal is in a JavaScript file and has no contextual type. */
+export function isJSObjectLiteral(c, node) {
+    if (!isInJSFile(node) || isJsonSourceFile(getSourceFileOfNode(node)))
+        return false;
+    return getApparentTypeOfContextualTypeEx(c, node, 0 /* ContextFlags.None */) === undefined;
+}
+/**
+ * Whether reading or writing unknown members of `t` is allowed: a JavaScript object literal, a union of
+ * them, an intersection with one, or a type variable constrained to one. Not under noImplicitAny.
+ */
+export function isJSLiteralType(c, t) {
+    if (c.noImplicitAny)
+        return false;
+    if ((t.objectFlags & 4096 /* ObjectFlags.JSLiteral */) !== 0)
+        return true;
+    if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        for (const u of typesOf(t))
+            if (!isJSLiteralType(c, u))
+                return false;
+        return true;
+    }
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        for (const u of typesOf(t))
+            if (isJSLiteralType(c, u))
+                return true;
+        return false;
+    }
+    if ((t.flags & 132644864 /* TypeFlags.Instantiable */) !== 0) {
+        const constraint = getResolvedBaseConstraint(c, t);
+        return constraint !== t && isJSLiteralType(c, constraint);
+    }
+    return false;
+}
+/** `exports.x = undefined` is ignored when x has other assignment declarations. */
+export function isUndefinedAssignmentToCommonJSExport(c, left, rightType) {
+    const parent = left.parent;
+    if (!(parent instanceof BinaryExpression))
+        return false;
+    // Typed locals keep scriptc's field reads static after `instanceof`.
+    const assignment = parent;
+    if (assignment.symbol === undefined)
+        return false;
+    if (getAssignmentDeclarationKind(assignment) !== 2 /* JSDeclarationKind.ExportsProperty */)
+        return false;
+    const symbol = c.resolvedSymbols.get(left.id);
+    return symbol !== undefined && symbol.declarations.length > 1 && (rightType.flags & 4 /* TypeFlags.Undefined */) !== 0;
+}

package/dist/api/compiler/checker-jsdoc.d.ts

@@ -0,0 +1,30 @@
+import { type ExpressionWithTypeArguments, type Node } from './ast.js';
+import type { Checker } from './checker.js';
+import type { Signature, Type } from './checker-types.js';
+/** The type a JSDoc type reference to a JavaScript-style name means, if it is one. */
+export declare function getIntendedTypeFromJSDocTypeReference(c: Checker, node: Node): Type | undefined;
+/** The JSDoc `@type` of a function, method or arrow function in a JavaScript file. */
+export declare function getFullSignatureTypeNode(node: Node): Node | undefined;
+/** The signature a JSDoc `@type` tag gives a function. */
+export declare function getSignatureOfFullSignatureType(c: Checker, node: Node): Signature | undefined;
+/** The type of a parameter of a function typed by a JSDoc `@type` tag. */
+export declare function getParameterTypeOfFullSignature(c: Checker, fn: Node, parameter: Node): Type | undefined;
+/** The return type of a function typed by a JSDoc `@type` tag. */
+export declare function getReturnTypeOfFullSignature(c: Checker, fn: Node): Type | undefined;
+/** A JSDoc `@type` on a function needs a call signature taking at least its parameters. */
+export declare function checkJSDocFullSignature(c: Checker, fn: Node): void;
+/**
+ * Reports `@param` tags of a JavaScript function naming no parameter, and qualified `@param` names
+ * without a parent `@param {object}`.
+ */
+export declare function checkUnmatchedJSDocParameters(c: Checker, node: Node): void;
+/** An `@augments` or `@extends` tag naming another class than the `extends` clause. */
+export declare class AugmentsMismatch {
+    readonly name: Node;
+    readonly tagName: string;
+    readonly className: string;
+    readonly extendsName: string;
+    constructor(name: Node, tagName: string, className: string, extendsName: string);
+}
+/** The `@augments` or `@extends` tag of a class whose class name differs from its `extends` clause. */
+export declare function findMismatchedAugmentsTag(classLike: Node, extendsType: ExpressionWithTypeArguments): AugmentsMismatch | undefined;