tsc-ts 0.0.4 → 0.0.5

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

@@ -0,0 +1,315 @@
+// Deprecation suggestions: uses of declarations marked `@deprecated` in JSDoc report
+// `'X' is deprecated.` with the tag as related information.
+import { JSDoc, JSDocDeprecatedTag, getExpression, getName, getTagName, getText, } from './ast.js';
+import { isTypeDeclaration } from './ast-utilities.js';
+import { isAccessExpression, getCombinedNodeFlags, getSourceFileOfNode, skipParentheses } from './binder-utilities.js';
+import { createDiagnosticForNode } from './checker.js';
+import { getJSDoc } from './parser.js';
+import { getDeclarationOfAliasSymbol, getParentOfSymbol, resolveAlias } from './checker-symbols.js';
+import { getTargetOfAliasDeclaration } from './checker-modules.js';
+import { hasMatchingArgument } from './checker-narrowing.js';
+import { entityNameToString } from './checker-expressions.js';
+import { isErrorType } from './checker-type-factory.js';
+import { getPropertyOfType } from './checker-members.js';
+import { signatureToString } from './type-printer.js';
+/** Whether `declaration`, or the statement it belongs to, has a `@deprecated` JSDoc tag. */
+export function isDeprecatedDeclaration(declaration) {
+    if ((getCombinedNodeFlags(declaration) & 67108864 /* NodeFlags.PossiblyContainsDeprecatedTag */) === 0)
+        return false;
+    // The JSDoc is on the node with the flag, e.g. the variable statement of a declaration.
+    for (let n = declaration; n !== undefined; n = n.parent)
+        if ((n.flags & 67108864 /* NodeFlags.PossiblyContainsDeprecatedTag */) !== 0)
+            return getJSDocDeprecatedTag(n) !== undefined;
+    return false;
+}
+function getJSDocDeprecatedTag(node) {
+    for (const jsDoc of getJSDoc(getSourceFileOfNode(node), node)) {
+        if (!(jsDoc instanceof JSDoc) || jsDoc.tags === undefined)
+            continue;
+        for (const tag of jsDoc.tags.nodes)
+            if (tag instanceof JSDocDeprecatedTag)
+                return tag;
+    }
+    return undefined;
+}
+/**
+ * Whether `symbol` is deprecated: an interface member when any declaration is, other merged
+ * members when all are.
+ */
+export function isDeprecatedSymbol(c, symbol) {
+    const declarations = symbol.declarations;
+    const parentSymbol = getParentOfSymbol(c, symbol);
+    if (parentSymbol !== undefined && declarations.length > 1)
+        return (parentSymbol.flags & 64 /* SymbolFlags.Interface */) !== 0
+            ? someDeprecatedDeclaration(declarations)
+            : everyDeprecatedDeclaration(declarations);
+    return ((symbol.valueDeclaration !== undefined && isDeprecatedDeclaration(symbol.valueDeclaration)) ||
+        (declarations.length !== 0 && everyDeprecatedDeclaration(declarations)));
+}
+function someDeprecatedDeclaration(declarations) {
+    for (const d of declarations)
+        if (isDeprecatedDeclaration(d))
+            return true;
+    return false;
+}
+function everyDeprecatedDeclaration(declarations) {
+    for (const d of declarations)
+        if (!isDeprecatedDeclaration(d))
+            return false;
+    return true;
+}
+export function addDeprecatedSuggestion(c, location, declarations, deprecatedEntity) {
+    const diagnostic = createDiagnosticForNode(location, 1475 /* Diagnostics.X_0_is_deprecated */, [deprecatedEntity]);
+    return addDeprecatedSuggestionWorker(c, declarations, diagnostic);
+}
+function addDeprecatedSuggestionWorker(c, declarations, diagnostic) {
+    for (const declaration of declarations) {
+        const deprecatedTag = getJSDocDeprecatedTag(declaration);
+        if (deprecatedTag !== undefined) {
+            diagnostic.addRelatedInfo(createDiagnosticForNode(deprecatedTag, 930 /* Diagnostics.The_declaration_was_marked_as_deprecated_here */, []));
+            break;
+        }
+    }
+    c.addSuggestion(diagnostic);
+    return diagnostic;
+}
+/** Reports a call, `new`, tagged template, decorator or JSX element resolved to a deprecated signature. */
+export function checkDeprecatedSignature(c, signature, node) {
+    if ((signature.flags & 256 /* SignatureFlags.IsSignatureCandidateForOverloadFailure */) !== 0)
+        return;
+    const declaration = signature.declaration;
+    if (declaration === undefined || !isDeprecatedDeclaration(declaration))
+        return;
+    const name = tryGetPropertyAccessOrIdentifierToString(getInvokedExpression(node));
+    const signatureString = signatureToString(c, signature);
+    const diagnostic = name !== ''
+        ? createDiagnosticForNode(getDeprecatedSuggestionNode(node), 1477 /* Diagnostics.The_signature_0_of_1_is_deprecated */, [
+            signatureString,
+            name,
+        ])
+        : createDiagnosticForNode(getDeprecatedSuggestionNode(node), 1475 /* Diagnostics.X_0_is_deprecated */, [signatureString]);
+    addDeprecatedSuggestionWorker(c, [declaration], diagnostic);
+}
+function getInvokedExpression(node) {
+    switch (node.kind) {
+        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+            return node.tag;
+        case 287 /* SyntaxKind.JsxOpeningElement */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+            return getTagName(node);
+        case 227 /* SyntaxKind.BinaryExpression */:
+            return node.right;
+        case 290 /* SyntaxKind.JsxOpeningFragment */:
+            return node;
+    }
+    return getExpression(node);
+}
+function tryGetPropertyAccessOrIdentifierToString(expr) {
+    switch (expr.kind) {
+        case 212 /* SyntaxKind.PropertyAccessExpression */: {
+            const base = tryGetPropertyAccessOrIdentifierToString(getExpression(expr));
+            return base !== '' ? base + '.' + entityNameToString(getName(expr)) : '';
+        }
+        case 213 /* SyntaxKind.ElementAccessExpression */: {
+            const base = tryGetPropertyAccessOrIdentifierToString(getExpression(expr));
+            const argument = expr.argumentExpression;
+            return base !== '' && isPropertyNameLiteral(argument) ? base + '.' + getText(argument) : '';
+        }
+        case 79 /* SyntaxKind.Identifier */:
+            return getText(expr);
+        case 296 /* SyntaxKind.JsxNamespacedName */: {
+            const name = expr;
+            return getText(name.namespace) + ':' + getText(name.name);
+        }
+    }
+    return '';
+}
+function isPropertyNameLiteral(node) {
+    switch (node.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 80 /* SyntaxKind.PrivateIdentifier */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+            return true;
+    }
+    return false;
+}
+/** The part of a use that a deprecation suggestion underlines. */
+export function getDeprecatedSuggestionNode(node) {
+    const current = skipParentheses(node);
+    switch (current.kind) {
+        case 214 /* SyntaxKind.CallExpression */:
+        case 171 /* SyntaxKind.Decorator */:
+        case 215 /* SyntaxKind.NewExpression */:
+            return getDeprecatedSuggestionNode(getExpression(current));
+        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+            return getDeprecatedSuggestionNode(current.tag);
+        case 287 /* SyntaxKind.JsxOpeningElement */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+            return getDeprecatedSuggestionNode(getTagName(current));
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+            return current.argumentExpression;
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+            return getName(current);
+        case 184 /* SyntaxKind.TypeReference */: {
+            const typeName = current.typeName;
+            if (typeName.kind === 167 /* SyntaxKind.QualifiedName */)
+                return typeName.right;
+        }
+    }
+    return current;
+}
+/**
+ * Whether a use of a deprecated function or method counts: calls are reported through their
+ * signature, unless the reference is also an argument.
+ */
+function isUncalledFunctionReference(c, node, symbol) {
+    if ((symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */)) === 0)
+        return true;
+    let parent = node.parent;
+    while (parent !== undefined && isAccessExpression(parent))
+        parent = parent.parent;
+    if (parent === undefined)
+        parent = node.parent;
+    if (isCallLikeExpression(parent))
+        return ((parent.kind === 214 /* SyntaxKind.CallExpression */ || parent.kind === 215 /* SyntaxKind.NewExpression */) &&
+            node.kind === 79 /* SyntaxKind.Identifier */ &&
+            hasMatchingArgument(c, parent, node));
+    for (const d of symbol.declarations)
+        if (isFunctionLikeKind(d.kind) && !isDeprecatedDeclaration(d))
+            return false;
+    return true;
+}
+function isCallLikeExpression(node) {
+    switch (node.kind) {
+        case 287 /* SyntaxKind.JsxOpeningElement */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 290 /* SyntaxKind.JsxOpeningFragment */:
+        case 214 /* SyntaxKind.CallExpression */:
+        case 215 /* SyntaxKind.NewExpression */:
+        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+        case 171 /* SyntaxKind.Decorator */:
+            return true;
+        case 227 /* SyntaxKind.BinaryExpression */:
+            return node.operatorToken.kind === 103 /* SyntaxKind.InstanceOfKeyword */;
+    }
+    return false;
+}
+function isFunctionLikeKind(kind) {
+    switch (kind) {
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 177 /* SyntaxKind.Constructor */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 174 /* SyntaxKind.MethodSignature */:
+        case 180 /* SyntaxKind.CallSignature */:
+        case 318 /* SyntaxKind.JSDocSignature */:
+        case 181 /* SyntaxKind.ConstructSignature */:
+        case 182 /* SyntaxKind.IndexSignature */:
+        case 185 /* SyntaxKind.FunctionType */:
+        case 186 /* SyntaxKind.ConstructorType */:
+            return true;
+    }
+    return false;
+}
+/** Resolves an alias, reporting the first deprecated alias along the way to its target. */
+export function resolveAliasWithDeprecationCheck(c, symbol, location) {
+    if ((symbol.flags & 2097152 /* SymbolFlags.Alias */) === 0 ||
+        isDeprecatedSymbol(c, symbol) ||
+        getDeclarationOfAliasSymbol(symbol) === undefined)
+        return symbol;
+    const targetSymbol = resolveAlias(c, symbol);
+    if (targetSymbol === c.unknownSymbol)
+        return targetSymbol;
+    let current = symbol;
+    while ((current.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+        const target = getImmediateAliasedSymbol(c, current);
+        if (target === undefined || target === targetSymbol)
+            break;
+        if (target.declarations.length !== 0) {
+            if (isDeprecatedSymbol(c, target)) {
+                addDeprecatedSuggestion(c, location, target.declarations, target.name);
+                break;
+            }
+            if (current === targetSymbol)
+                break;
+            current = target;
+        }
+    }
+    return targetSymbol;
+}
+function getImmediateAliasedSymbol(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    if (links.immediateTarget === undefined)
+        links.immediateTarget = getTargetOfAliasDeclaration(c, getDeclarationOfAliasSymbol(symbol));
+    return links.immediateTarget;
+}
+// ---- Uses
+/** Resolves the alias an identifier refers to and reports a deprecated target. */
+export function checkDeprecatedIdentifier(c, node, localOrExportSymbol) {
+    const targetSymbol = resolveAliasWithDeprecationCheck(c, localOrExportSymbol, node);
+    if (targetSymbol.declarations.length !== 0 &&
+        isDeprecatedSymbol(c, targetSymbol) &&
+        isUncalledFunctionReference(c, node, targetSymbol))
+        addDeprecatedSuggestion(c, node, targetSymbol.declarations, getText(node));
+}
+/** Reports a property access to a deprecated property. */
+export function checkDeprecatedProperty(c, node, right, prop) {
+    const targetPropSymbol = resolveAliasWithDeprecationCheck(c, prop, right);
+    if (isDeprecatedSymbol(c, targetPropSymbol) &&
+        isUncalledFunctionReference(c, node, targetPropSymbol) &&
+        targetPropSymbol.declarations.length !== 0)
+        addDeprecatedSuggestion(c, right, targetPropSymbol.declarations, getText(right));
+}
+/** Reports a property access resolved through a deprecated index signature. */
+export function checkDeprecatedIndexSignature(c, right, declaration) {
+    if (declaration !== undefined && isDeprecatedDeclaration(declaration))
+        addDeprecatedSuggestion(c, right, [declaration], getText(right));
+}
+/** Reports an element access or indexed access type selecting a deprecated property. */
+export function checkDeprecatedIndexedAccess(c, accessNode, prop, propName) {
+    if (prop.declarations.length === 0 ||
+        !isDeprecatedSymbol(c, prop) ||
+        !isUncalledFunctionReference(c, accessNode, prop))
+        return;
+    const deprecatedNode = accessNode.kind === 213 /* SyntaxKind.ElementAccessExpression */
+        ? accessNode.argumentExpression
+        : accessNode.kind === 200 /* SyntaxKind.IndexedAccessType */
+            ? accessNode.indexType
+            : accessNode;
+    addDeprecatedSuggestion(c, deprecatedNode, prop.declarations, propName);
+}
+/** Reports a type reference or import type naming a deprecated type. */
+export function checkDeprecatedTypeReference(c, node, type) {
+    if (isErrorType(c, type))
+        return;
+    const symbol = c.resolvedSymbols.get(node.id);
+    if (symbol === undefined)
+        return;
+    for (const d of symbol.declarations) {
+        if (isTypeDeclaration(d) && isDeprecatedDeclaration(d)) {
+            addDeprecatedSuggestion(c, getDeprecatedSuggestionNode(node), symbol.declarations, symbol.name);
+            return;
+        }
+    }
+}
+/** Reports an import specifier importing a deprecated declaration. */
+export function checkDeprecatedImportSpecifier(c, node, symbol) {
+    const targetSymbol = resolveAliasWithDeprecationCheck(c, symbol, node);
+    if (isDeprecatedSymbol(c, targetSymbol) && targetSymbol.declarations.length !== 0)
+        addDeprecatedSuggestion(c, node, targetSymbol.declarations, targetSymbol.name);
+}
+/** Reports a JSX attribute setting a deprecated property of the element's contextual props type. */
+export function checkDeprecatedJsxAttribute(c, contextualType, attribute) {
+    const name = attribute.name;
+    if (name.kind !== 79 /* SyntaxKind.Identifier */)
+        return;
+    const prop = getPropertyOfType(c, contextualType, getText(name));
+    if (prop !== undefined && prop.declarations.length !== 0 && isDeprecatedSymbol(c, prop))
+        addDeprecatedSuggestion(c, name, prop.declarations, getText(name));
+}

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

@@ -0,0 +1,34 @@
+import { type BindingElement, type Node } from './ast.js';
+import { type Symbol } from './symbol.js';
+import type { Checker } from './checker.js';
+import { CheckMode, type Type } from './checker-types.js';
+/** The type of a binding element, from the type of the declaration it destructures. */
+export declare function getTypeForBindingElement(c: Checker, declaration: Node): Type | undefined;
+export declare function getTypeForBindingElementParent(c: Checker, node: Node, checkMode: CheckMode): Type | undefined;
+export declare function getBindingElementTypeFromParentType(c: Checker, declaration: BindingElement, parentTypeIn: Type, noTupleBoundsCheck: boolean): Type;
+/** `t` without undefined, also when it's a generic type whose constraint includes undefined. */
+export declare function getNonUndefinedType(c: Checker, t: Type): Type;
+/** The type implied by a binding pattern, for declarations without annotations or initializers. */
+export declare function getTypeFromBindingPattern(c: Checker, pattern: Node, includePatternInType: boolean, reportErrors: boolean): Type;
+/**
+ * The initializer type of a parameter or its binding element, padded with the members its binding
+ * pattern defaults or binds past the end of a tuple.
+ */
+export declare function padParameterInitializerType(c: Checker, declaration: Node, t: Type): Type;
+/**
+ * A parameter's tuple initializer type, padded with optional elements for the pattern's elements
+ * past its end, so `([x, y] = [1])` gets `[number, any?]`.
+ */
+export declare function padTupleType(c: Checker, t: Type, pattern: Node): Type;
+/** Checks an assignment of `sourceType` to a target, which may be an object or array literal pattern. */
+export declare function checkDestructuringAssignment(c: Checker, node: Node, sourceTypeIn: Type, checkMode: CheckMode, rightIsThis: boolean): Type;
+/** Whether a destructuring element has a default value. */
+export declare function hasDefaultValue(node: Node): boolean;
+/** The type of an object rest element: `source` without the named properties. */
+export declare function getRestType(c: Checker, sourceIn: Type, properties: readonly Node[], symbol: Symbol | undefined): Type;
+/** Approximates own properties: non-methods, plus methods declared outside classes. */
+export declare function isSpreadableProperty(prop: Symbol): boolean;
+/** `prop` as a member of a spread or rest type, with the given readonlyness. */
+export declare function getSpreadSymbol(c: Checker, prop: Symbol, readonly: boolean): Symbol;
+/** Whether a type may be spread into an object or destructured by an object rest element. */
+export declare function isValidSpreadType(c: Checker, t: Type): boolean;