tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,7 @@
+import { type Node } from './ast.js';
+import { type Symbol } from './symbol.js';
+import { type Checker } from './checker.js';
+/** Checks the overloads of a function or method declaration's local and export symbols. */
+export declare function checkFunctionOrMethodSymbols(c: Checker, node: Node): void;
+/** Checks a function, method or constructor symbol's overloads and implementations, once. */
+export declare function checkFunctionOrConstructorSymbol(c: Checker, symbol: Symbol): void;

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

@@ -0,0 +1,270 @@
+// Overloads: consecutive declarations, implementations and modifier agreement of functions, methods and
+// constructors.
+import { getBody, getLocalSymbol, getMembers, getName, getStatements, getText, } from './ast.js';
+import { declarationNameToString, getNameOfDeclaration, getSourceFileOfNode, hasSyntacticModifier, isClassLike, isPropertyNameLiteral, isStatic, } from './binder-utilities.js';
+import { nodeIsMissing, nodeIsPresent } from './ast-utilities.js';
+import { createDiagnosticForNode } from './checker.js';
+import { getSymbolOfDeclaration } from './checker-symbols.js';
+import { isOptionalDeclaration } from './checker-symbol-types.js';
+import { getErasedSignature, getReturnTypeOfSignature, getSignatureFromDeclaration, getSignaturesOfSymbol, } from './checker-signatures.js';
+import { checkComputedPropertyName } from './checker-expressions.js';
+import { hasDynamicName, hasLateBindableName } from './checker-utilities.js';
+import { isSignatureAssignableTo, isTypeIdenticalTo, isTypeRelatedTo } from './relations.js';
+import { getEffectiveDeclarationFlags } from './checker-declarations.js';
+/** Checks the overloads of a function or method declaration's local and export symbols. */
+export function checkFunctionOrMethodSymbols(c, node) {
+    if (hasDynamicName(node) && !hasLateBindableName(c, node))
+        return;
+    const symbol = getSymbolOfDeclaration(c, node);
+    if (symbol === undefined)
+        return;
+    // Redeclared functions in JavaScript aren't duplicates.
+    if ((node.flags & 65536 /* NodeFlags.JavaScriptFile */) === 0)
+        checkFunctionOrConstructorSymbol(c, getLocalSymbol(node) ?? symbol);
+    // The export symbol: modifiers must agree across exported declarations.
+    if (symbol.parent !== undefined)
+        checkFunctionOrConstructorSymbol(c, symbol);
+}
+/** Checks a function, method or constructor symbol's overloads and implementations, once. */
+export function checkFunctionOrConstructorSymbol(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    if (links.functionOrConstructorChecked)
+        return;
+    links.functionOrConstructorChecked = true;
+    new OverloadChecker(c, symbol).check();
+}
+/** Modifiers all overloads must agree on. */
+function flagsToCheck() {
+    return (32 /* ModifierFlags.Export */ |
+        128 /* ModifierFlags.Ambient */ |
+        2 /* ModifierFlags.Private */ |
+        4 /* ModifierFlags.Protected */ |
+        64 /* ModifierFlags.Abstract */);
+}
+class OverloadChecker {
+    c;
+    symbol;
+    isConstructor;
+    constructor(c, symbol) {
+        this.c = c;
+        this.symbol = symbol;
+        this.isConstructor = (symbol.flags & 16384 /* SymbolFlags.Constructor */) !== 0;
+    }
+    check() {
+        const c = this.c;
+        const declarations = this.symbol.declarations;
+        let someNodeFlags = 0 /* ModifierFlags.None */;
+        let allNodeFlags = flagsToCheck();
+        let someHaveQuestionToken = false;
+        let allHaveQuestionToken = true;
+        let hasOverloads = false;
+        let bodyDeclaration = undefined;
+        let lastSeenNonAmbientDeclaration = undefined;
+        let previousDeclaration = undefined;
+        let duplicateFunctionDeclaration = false;
+        let multipleConstructorImplementation = false;
+        let hasNonAmbientClass = false;
+        const functionDeclarations = [];
+        for (const node of declarations) {
+            const inAmbientContext = (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
+            const parent = node.parent;
+            const inAmbientContextOrInterface = inAmbientContext ||
+                (parent !== undefined &&
+                    (parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */ || parent.kind === 188 /* SyntaxKind.TypeLiteral */));
+            // Only non-ambient declarations must be consecutive.
+            if (inAmbientContextOrInterface)
+                previousDeclaration = undefined;
+            if (isClassLike(node) && !inAmbientContext)
+                hasNonAmbientClass = true;
+            if (node.kind !== 263 /* SyntaxKind.FunctionDeclaration */ &&
+                node.kind !== 175 /* SyntaxKind.MethodDeclaration */ &&
+                node.kind !== 174 /* SyntaxKind.MethodSignature */ &&
+                node.kind !== 177 /* SyntaxKind.Constructor */)
+                continue;
+            functionDeclarations.push(node);
+            const currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck());
+            someNodeFlags |= currentNodeFlags;
+            allNodeFlags &= currentNodeFlags;
+            const optional = isOptionalDeclaration(node);
+            someHaveQuestionToken = someHaveQuestionToken || optional;
+            allHaveQuestionToken = allHaveQuestionToken && optional;
+            const bodyIsPresent = nodeIsPresent(getBody(node));
+            if (bodyIsPresent && bodyDeclaration !== undefined) {
+                if (this.isConstructor)
+                    multipleConstructorImplementation = true;
+                else
+                    duplicateFunctionDeclaration = true;
+            }
+            else if (previousDeclaration !== undefined &&
+                previousDeclaration.parent === node.parent &&
+                previousDeclaration.end !== node.pos &&
+                (previousDeclaration.flags & 8 /* NodeFlags.Reparsed */) === 0)
+                this.reportImplementationExpectedError(previousDeclaration);
+            if (bodyIsPresent) {
+                if (bodyDeclaration === undefined)
+                    bodyDeclaration = node;
+            }
+            else
+                hasOverloads = true;
+            previousDeclaration = node;
+            if (!inAmbientContextOrInterface)
+                lastSeenNonAmbientDeclaration = node;
+        }
+        if (multipleConstructorImplementation)
+            for (const d of functionDeclarations)
+                c.error(d, 563 /* Diagnostics.Multiple_constructor_implementations_are_not_allowed */);
+        if (duplicateFunctionDeclaration)
+            for (const d of functionDeclarations)
+                c.error(getNameOfDeclaration(d) ?? d, 564 /* Diagnostics.Duplicate_function_implementation */);
+        if (hasNonAmbientClass &&
+            !this.isConstructor &&
+            (this.symbol.flags & 16 /* SymbolFlags.Function */) !== 0 &&
+            declarations.length !== 0)
+            this.reportClassMergedWithFunction();
+        // Abstract methods need no implementation.
+        if (lastSeenNonAmbientDeclaration !== undefined &&
+            getBody(lastSeenNonAmbientDeclaration) === undefined &&
+            !hasSyntacticModifier(lastSeenNonAmbientDeclaration, 64 /* ModifierFlags.Abstract */) &&
+            !isOptionalDeclaration(lastSeenNonAmbientDeclaration))
+            this.reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
+        if (!hasOverloads)
+            return;
+        this.checkFlagAgreement(declarations, bodyDeclaration, someNodeFlags, allNodeFlags);
+        if (someHaveQuestionToken !== allHaveQuestionToken) {
+            const canonical = isOptionalDeclaration(getCanonicalOverload(declarations, bodyDeclaration));
+            for (const d of declarations)
+                if (isOptionalDeclaration(d) !== canonical)
+                    c.error(getNameOfDeclaration(d), 557 /* Diagnostics.Overload_signatures_must_all_be_optional_or_required */);
+        }
+        if (bodyDeclaration === undefined)
+            return;
+        const bodySignature = getSignatureFromDeclaration(c, bodyDeclaration);
+        for (const signature of getSignaturesOfSymbol(c, this.symbol)) {
+            if (isImplementationCompatibleWithOverload(c, bodySignature, signature))
+                continue;
+            c.error(signature.declaration, 565 /* Diagnostics.This_overload_signature_is_not_compatible_with_its_implementation_signature */).addRelatedInfo(createDiagnosticForNode(bodyDeclaration, 882 /* Diagnostics.The_implementation_signature_is_declared_here */, []));
+            break;
+        }
+    }
+    reportClassMergedWithFunction() {
+        const c = this.c;
+        const classes = [];
+        for (const d of this.symbol.declarations)
+            if (d.kind === 264 /* SyntaxKind.ClassDeclaration */)
+                classes.push(d);
+        for (const d of this.symbol.declarations) {
+            let message;
+            if (d.kind === 264 /* SyntaxKind.ClassDeclaration */)
+                message = 944 /* Diagnostics.Class_declaration_cannot_implement_overload_list_for_0 */;
+            else if (d.kind === 263 /* SyntaxKind.FunctionDeclaration */)
+                message = 945 /* Diagnostics.Function_with_bodies_can_only_merge_with_classes_that_are_ambient */;
+            else
+                continue;
+            const err = c.error(getNameOfDeclaration(d) ?? d, message, this.symbol.name);
+            for (const r of classes)
+                err.addRelatedInfo(createDiagnosticForNode(r, 1521 /* Diagnostics.Consider_adding_a_declare_modifier_to_this_class */, []));
+        }
+    }
+    checkFlagAgreement(overloads, implementation, someOverloadFlags, allOverloadFlags) {
+        // Only flags some, but not all, overloads have can deviate.
+        if ((someOverloadFlags ^ allOverloadFlags) === 0)
+            return;
+        const c = this.c;
+        const canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck());
+        // Overloads in different files need not agree on `export` and `declare`.
+        const files = [];
+        for (const o of overloads) {
+            const file = getSourceFileOfNode(o);
+            if (!files.includes(file))
+                files.push(file);
+        }
+        for (const file of files) {
+            const inFile = [];
+            for (const o of overloads)
+                if (getSourceFileOfNode(o) === file)
+                    inFile.push(o);
+            const canonicalFlagsForFile = getEffectiveDeclarationFlags(getCanonicalOverload(inFile, implementation), flagsToCheck());
+            for (const o of inFile) {
+                const flags = getEffectiveDeclarationFlags(o, flagsToCheck());
+                const deviation = flags ^ canonicalFlags;
+                const deviationInFile = flags ^ canonicalFlagsForFile;
+                if ((deviationInFile & 32 /* ModifierFlags.Export */) !== 0)
+                    c.error(getNameOfDeclaration(o), 554 /* Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported */);
+                else if ((deviationInFile & 128 /* ModifierFlags.Ambient */) !== 0)
+                    c.error(getNameOfDeclaration(o), 555 /* Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient */);
+                else if ((deviation & (2 /* ModifierFlags.Private */ | 4 /* ModifierFlags.Protected */)) !== 0)
+                    c.error(getNameOfDeclaration(o) ?? o, 556 /* Diagnostics.Overload_signatures_must_all_be_public_private_or_protected */);
+                else if ((deviation & 64 /* ModifierFlags.Abstract */) !== 0)
+                    c.error(getNameOfDeclaration(o), 672 /* Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract */);
+            }
+        }
+    }
+    reportImplementationExpectedError(node) {
+        const c = this.c;
+        const name = getName(node);
+        if (name !== undefined && nodeIsMissing(name))
+            return;
+        const subsequentNode = getNextSibling(node);
+        // Unparsable nodes may sit between overloads; only an adjacent node counts.
+        if (subsequentNode !== undefined && subsequentNode.pos === node.end && subsequentNode.kind === node.kind) {
+            const subsequentName = getName(subsequentNode);
+            const errorNode = subsequentName ?? subsequentNode;
+            if (name !== undefined && subsequentName !== undefined && isSameMemberName(c, name, subsequentName)) {
+                // Mixed static and instance members; other conflicts are reported by the binder.
+                if ((node.kind === 175 /* SyntaxKind.MethodDeclaration */ || node.kind === 174 /* SyntaxKind.MethodSignature */) &&
+                    isStatic(node) !== isStatic(subsequentNode))
+                    c.error(errorNode, isStatic(node)
+                        ? 558 /* Diagnostics.Function_overload_must_be_static */
+                        : 559 /* Diagnostics.Function_overload_must_not_be_static */);
+                return;
+            }
+            if (nodeIsPresent(getBody(subsequentNode))) {
+                c.error(errorNode, 560 /* Diagnostics.Function_implementation_name_must_be_0 */, declarationNameToString(getSourceFileOfNode(node), name));
+                return;
+            }
+        }
+        const errorNode = name ?? node;
+        if (this.isConstructor)
+            c.error(errorNode, 561 /* Diagnostics.Constructor_implementation_is_missing */);
+        else if (hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */))
+            c.error(errorNode, 676 /* Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive */);
+        else
+            c.error(errorNode, 562 /* Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration */);
+    }
+}
+/**
+ * The declaration whose flags overloads must agree with: the implementation when it shares the first
+ * overload's container (so overloads from other files aren't reported), else the first overload.
+ */
+function getCanonicalOverload(overloads, implementation) {
+    return implementation !== undefined && implementation.parent === overloads[0].parent
+        ? implementation
+        : overloads[0];
+}
+function getNextSibling(node) {
+    const parent = node.parent;
+    const list = getStatements(parent) ?? getMembers(parent);
+    if (list === undefined)
+        return undefined;
+    const index = list.nodes.indexOf(node);
+    return index >= 0 && index + 1 < list.nodes.length ? list.nodes[index + 1] : undefined;
+}
+function isSameMemberName(c, name, other) {
+    if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */ && other.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+        return getText(name) === getText(other);
+    if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */ && other.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+        return isTypeIdenticalTo(c, checkComputedPropertyName(c, name), checkComputedPropertyName(c, other));
+    return isPropertyNameLiteral(name) && isPropertyNameLiteral(other) && getText(name) === getText(other);
+}
+function isImplementationCompatibleWithOverload(c, implementation, overload) {
+    const erasedSource = getErasedSignature(c, implementation);
+    const erasedTarget = getErasedSignature(c, overload);
+    // The return types must be related in either direction.
+    const sourceReturnType = getReturnTypeOfSignature(c, erasedSource);
+    const targetReturnType = getReturnTypeOfSignature(c, erasedTarget);
+    if (targetReturnType === c.voidType ||
+        isTypeRelatedTo(c, targetReturnType, sourceReturnType, c.assignableRelation) ||
+        isTypeRelatedTo(c, sourceReturnType, targetReturnType, c.assignableRelation))
+        return isSignatureAssignableTo(c, erasedSource, erasedTarget, true);
+    return false;
+}

package/dist/api/compiler/checker-property-access.d.ts

@@ -0,0 +1,34 @@
+import { type Node } from './ast.js';
+import { type Checker } from './checker.js';
+import { type Diagnostic } from './diagnostics.js';
+import { type Symbol } from './symbol.js';
+import { CheckMode, type Type } from './checker-types.js';
+import { AssignmentKind } from './checker-narrowing.js';
+export declare function checkPropertyAccessExpressionOrQualifiedName(c: Checker, node: Node, left: Node, leftType: Type, right: Node, writeOnly: boolean, checkMode?: CheckMode): Type;
+/** A private name used as an expression, as in `#x in obj`; records its declaration. */
+export declare function checkPrivateIdentifierExpression(c: Checker, node: Node): Type;
+export declare function getSymbolForPrivateIdentifierExpression(c: Checker, node: Node): Symbol | undefined;
+export declare function isMethodAccessForCall(node: Node): boolean;
+/** Whether `node` is the operand of `delete`, through parentheses. */
+export declare function isDeleteTarget(node: Node): boolean;
+/** Whether assigning through `expr` targets a readonly entity, outside of initialization. */
+export declare function isAssignmentToReadonlyEntity(c: Checker, expr: Node, symbol: Symbol, assignmentKind: AssignmentKind): boolean;
+/** Checks that `prop` of `containingType` may be accessed at `node`; reports and returns false otherwise. */
+export declare function checkPropertyAccessibility(c: Checker, node: Node, isSuper: boolean, writing: boolean, containingType: Type, prop: Symbol): boolean;
+/** Whether `prop` of `containingType` may be accessed at `node`, without reporting errors. */
+export declare function isPropertyAccessible(c: Checker, node: Node, isSuper: boolean, isWrite: boolean, containingType: Type, prop: Symbol): boolean;
+/** The declaring class of a class member. */
+export declare function getDeclaringClass(c: Checker, prop: Symbol): Type | undefined;
+/** Reports a missing property once per name node, with the most helpful message available. */
+export declare function reportNonexistentProperty(c: Checker, propNode: Node, containingType: Type): void;
+/**
+ * `chain` under the reason an intersection reduced to `never` when `t` is one: a property with conflicting
+ * literal types, or one private in some constituents.
+ */
+export declare function elaborateNeverIntersection(c: Checker, chain: Diagnostic | undefined, node: Node, t: Type): Diagnostic | undefined;
+/** Whether the type's symbol has a static member `name`, as when an instance member was expected. */
+export declare function typeHasStaticProperty(c: Checker, name: string, containingType: Type): boolean;
+/** The value member with the closest name, for "Did you mean" suggestions. */
+export declare function getSuggestedSymbolForNonexistentProperty(c: Checker, name: Node, containingType: Type): Symbol | undefined;
+/** The value property of `containingType` with the closest name to `name`. */
+export declare function getSuggestionForNonexistentProperty(c: Checker, name: string, containingType: Type): Symbol | undefined;