tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/relations.d.ts

@@ -0,0 +1,263 @@
+import { ModifierFlags, type Node } from './ast.js';
+import { Diagnostic, type DiagnosticMessage } from './diagnostics.js';
+import { type Symbol } from './symbol.js';
+import { type Checker } from './checker.js';
+import { type IndexInfo, type MappedType, type Signature, SignatureKind, Ternary, type Type, type UnionType, VarianceFlags } from './checker-types.js';
+import { typeListKey } from './checker-type-factory.js';
+import { findApplicableIndexInfo } from './checker-members.js';
+import { getMergedSymbol } from './checker-symbols.js';
+import { getPropertyNameFromType } from './checker-utilities.js';
+export declare const enum RelationComparisonResult {
+    None = 0,
+    Succeeded = 1,
+    Failed = 2,
+    ReportsUnmeasurable = 8,
+    ReportsUnreliable = 16,
+    ComplexityOverflow = 32,
+    StackDepthOverflow = 64,
+    ReportsMask = 24,
+    Overflow = 96
+}
+/**
+ * Cached results of one relation by numeric relation key (see getRelationKey): an open-addressing
+ * table of keys and one-byte results. Keys are never 0 (packed keys are positive, interned ones
+ * negative), so 0 marks a free slot. At 3/8 to 3/4 full it takes about 16 bytes per result, where a
+ * Map takes about 40 (a 24-byte entry, its share of the bucket table and of the spare capacity);
+ * relations are most of a checker's tables on programs with many structural comparisons.
+ */
+export declare class Relation {
+    private keys;
+    private results;
+    private count;
+    get(key: number): number;
+    set(key: number, result: number): void;
+    size(): number;
+    private grow;
+}
+declare const enum RecursionFlags {
+    None = 0,
+    Source = 1,
+    Target = 2,
+    Both = 3
+}
+declare const enum ExpandingFlags {
+    None = 0,
+    Source = 1,
+    Target = 2,
+    Both = 3
+}
+export declare const enum IntersectionState {
+    None = 0,
+    Source = 1,
+    Target = 2
+}
+export declare const enum SignatureCheckMode {
+    None = 0,
+    BivariantCallback = 1,
+    StrictCallback = 2,
+    IgnoreReturnTypes = 4,
+    StrictArity = 8,
+    StrictTopSignature = 16,
+    Callback = 3
+}
+/** An object identity shared by instantiations of the same type, for recursion limits. */
+/**
+ * The recursion identity of a type (`getRecursionIdentity`): a node, a symbol or a type, as a number
+ * (its id times 4 plus its kind), compared only for equality. A union of the three classes would be
+ * boxed in native builds on every call.
+ */
+export type RecursionId = number;
+/**
+ * Compares types for signature and property comparisons, and receives their error reports.
+ * Subclasses replace tsgo's comparer and error reporter callbacks.
+ */
+export declare abstract class TypeComparer {
+    abstract compare(source: Type, target: Type, reportErrors: boolean): Ternary;
+    /** Records an elaboration; the default ignores it. */
+    report(_message: DiagnosticMessage, _args: string[]): void;
+}
+export declare const enum ComparerKind {
+    Identical = 0,
+    SubtypeOf = 1,
+    Assignable = 2,
+    Equal = 3
+}
+export declare function getComparer(c: Checker, kind: ComparerKind): TypeComparer;
+export declare function compareTypesIdentical(c: Checker, s: Type, t: Type): Ternary;
+export declare function compareTypesSubtypeOf(c: Checker, s: Type, t: Type): Ternary;
+export declare function compareTypesAssignable(c: Checker, s: Type, t: Type): Ternary;
+export declare function compareTypesEqual(_c: Checker, s: Type, t: Type): Ternary;
+export declare function isTypeIdenticalTo(c: Checker, source: Type, target: Type): boolean;
+export declare function isTypeAssignableTo(c: Checker, source: Type, target: Type): boolean;
+export declare function isTypeSubtypeOf(c: Checker, source: Type, target: Type): boolean;
+export declare function isTypeStrictSubtypeOf(c: Checker, source: Type, target: Type): boolean;
+export declare function isTypeComparableTo(c: Checker, source: Type, target: Type): boolean;
+export declare function areTypesComparable(c: Checker, type1: Type, type2: Type): boolean;
+export declare function isTypeRelatedTo(c: Checker, source: Type, target: Type, relation: Relation): boolean;
+export declare function isSimpleTypeRelatedTo(c: Checker, source: Type, target: Type, relation: Relation, reporter: Relater | undefined): boolean;
+export declare function isUnknownLikeUnionType(c: Checker, t: Type): boolean;
+export declare class RelationKey {
+    key: number;
+    constrained: boolean;
+}
+/** An interned generic relation key (`writeTypeReference`'s tokens) and the next one with the same hash. */
+export declare class InternedRelationKey {
+    readonly tokens: number[];
+    readonly key: number;
+    next: InternedRelationKey | undefined;
+    constructor(tokens: number[], key: number);
+}
+export declare function getRelationKey(c: Checker, source: Type, target: Type, intersectionState: IntersectionState, isIdentity: boolean, ignoreConstraints: boolean): RelationKey;
+export declare function checkTypeAssignableTo(c: Checker, source: Type, target: Type, errorNode: Node | undefined, headMessage: DiagnosticMessage | undefined): boolean;
+export declare function checkTypeComparableTo(c: Checker, source: Type, target: Type, errorNode: Node | undefined, headMessage: DiagnosticMessage | undefined): boolean;
+/**
+ * Whether `source` is related to `target`. With an `errorNode`, reports at most one error, to
+ * `diagnosticOutput` when given.
+ */
+export declare function checkTypeRelatedTo(c: Checker, source: Type, target: Type, relation: Relation, errorNode: Node | undefined, headMessage: DiagnosticMessage | undefined, diagnosticOutput: Diagnostic[] | undefined): boolean;
+declare class ErrorChain {
+    readonly next: ErrorChain | undefined;
+    readonly message: DiagnosticMessage;
+    readonly args: string[];
+    constructor(next: ErrorChain | undefined, message: DiagnosticMessage, args: string[]);
+}
+/** The state of a relation check: its error chain, maybe-stack and recursion stacks. */
+export declare class Relater extends TypeComparer {
+    readonly c: Checker;
+    relation: Relation;
+    errorNode: Node | undefined;
+    errorChain: ErrorChain | undefined;
+    relatedInfo: Diagnostic[];
+    readonly maybeKeys: number[];
+    readonly maybeKeysSet: Set<number>;
+    /** Recursion stacks: the first `sourceDepth` and `targetDepth` entries are live. */
+    readonly sourceStack: Type[];
+    readonly targetStack: Type[];
+    sourceDepth: number;
+    targetDepth: number;
+    expandingFlags: ExpandingFlags;
+    overflow: boolean;
+    relationCount: number;
+    /** The intersection state passed to `compare` during signature comparisons. */
+    signatureIntersectionState: IntersectionState;
+    varianceSetsCheckFailed: boolean;
+    varianceCheckFailed: boolean;
+    varianceSetsErrorChain: boolean;
+    varianceErrorChain: ErrorChain | undefined;
+    constructor(c: Checker, relation: Relation, errorNode: Node | undefined);
+    /** Prepares this relater for a new check, as if newly constructed. */
+    reset(relation: Relation, errorNode: Node | undefined): void;
+    compare(source: Type, target: Type, reportErrors: boolean): Ternary;
+    report(message: DiagnosticMessage, args: string[]): void;
+    isRelatedToSimple(source: Type, target: Type): Ternary;
+    isRelatedTo(source: Type, target: Type, recursionFlags: RecursionFlags, reportErrors: boolean): Ternary;
+    isRelatedToEx(originalSource: Type, originalTarget: Type, recursionFlags: RecursionFlags, reportErrors: boolean, headMessage: DiagnosticMessage | undefined, intersectionState: IntersectionState): Ternary;
+    hasExcessProperties(source: Type, target: Type, reportErrors: boolean): boolean;
+    unionOrIntersectionRelatedTo(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    someTypeRelatedToType(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    eachTypeRelatedToType(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    getUndefinedStrippedTargetIfNeeded(source: Type, target: Type): Type;
+    typeRelatedToSomeType(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    typeRelatedToEachType(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    eachTypeRelatedToSomeType(source: Type, target: Type): Ternary;
+    /**
+     * Relates possibly recursive types: uses the global cache, assumes related when already
+     * comparing the pair, assumes related for deeply nested expansions, and overflows at depth 100.
+     */
+    recursiveTypeRelatedTo(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState, recursionFlags: RecursionFlags): Ternary;
+    resetMaybeStack(maybeStart: number, propagatingVarianceFlags: number, markAllAsSucceeded: boolean): void;
+    structuredTypeRelatedTo(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    /**
+     * Relates the type arguments of `structuredTypeRelatedToWorker`'s source and target by variance:
+     * a result when variance decides, else undefined to fall back to structure, with the caller's
+     * `varianceCheckFailed` and original error chain to update in the fields above. (A method rather
+     * than a closure over the caller's locals, which native builds would allocate on every call.)
+     */
+    relateVariances(sourceArgs: Type[], targetArgs: Type[], variances: VarianceFlags[], reportErrors: boolean, intersectionState: IntersectionState, saveChain: ErrorChain | undefined, saveRelated: Diagnostic[]): Ternary | undefined;
+    structuredTypeRelatedToWorker(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState, saveChain: ErrorChain | undefined, saveRelated: Diagnostic[]): Ternary;
+    typeRelatedToDiscriminatedType(source: Type, target: UnionType): Ternary;
+    relateToGenericMappedType(source: Type, target: MappedType, reportErrors: boolean): Ternary;
+    typeArgumentsRelatedTo(sources: Type[], targets: Type[], variances: VarianceFlags[], reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    mappedTypeRelatedTo(source: MappedType, target: MappedType, reportErrors: boolean): Ternary;
+    propertiesRelatedTo(source: Type, target: Type, reportErrors: boolean, excludedProperties: Set<string> | undefined, optionalsOnly: boolean, intersectionState: IntersectionState): Ternary;
+    propertyRelatedTo(source: Type, target: Type, sourceProp: Symbol, targetProp: Symbol, reportErrors: boolean, intersectionState: IntersectionState, skipOptional: boolean): Ternary;
+    /** `propertyRelatedTo` with `sourcePropType` in place of the source property's type when given. */
+    propertyRelatedToEx(source: Type, target: Type, sourceProp: Symbol, targetProp: Symbol, sourcePropType: Type | undefined, reportErrors: boolean, intersectionState: IntersectionState, skipOptional: boolean): Ternary;
+    isPropertySymbolTypeRelated(sourceProp: Symbol, targetProp: Symbol, sourcePropType: Type | undefined, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    reportUnmatchedProperty(source: Type, target: Type, unmatchedProperty: Symbol, requireOptionalProperties: boolean): void;
+    /** Mutability elaborations; false when property elaborations should be skipped. */
+    tryElaborateArrayLikeErrors(source: Type, target: Type, reportErrors: boolean): boolean;
+    propertiesIdenticalTo(source: Type, target: Type, excludedProperties: Set<string> | undefined): Ternary;
+    signaturesRelatedTo(source: Type, target: Type, kind: SignatureKind, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    constructorVisibilitiesAreCompatible(sourceSignature: Signature, targetSignature: Signature, reportErrors: boolean): boolean;
+    signatureRelatedTo(source: Signature, target: Signature, erase: boolean, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    signaturesIdenticalTo(source: Type, target: Type, kind: SignatureKind): Ternary;
+    indexSignaturesRelatedTo(source: Type, target: Type, sourceIsPrimitive: boolean, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    typeRelatedToIndexInfo(source: Type, targetInfo: IndexInfo, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    membersRelatedToIndexInfo(source: Type, targetInfo: IndexInfo, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    indexInfoRelatedTo(sourceInfo: IndexInfo, targetInfo: IndexInfo, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
+    indexSignaturesIdenticalTo(source: Type, target: Type): Ternary;
+    reportErrorResults(originalSource: Type, originalTarget: Type, source: Type, target: Type, headMessage: DiagnosticMessage | undefined): void;
+    tryElaborateErrorsForPrimitivesAndObjects(source: Type, target: Type): void;
+    reportRelationError(message: DiagnosticMessage | undefined, source: Type, target: Type): void;
+    reportError(message: DiagnosticMessage, args: string[]): void;
+    getChainMessage(index: number): DiagnosticMessage | undefined;
+    /** Whether the head's arguments match, with undefined as a wildcard. */
+    chainArgsMatch(a0: string | undefined, a1: string | undefined, a2: string | undefined): boolean;
+}
+export declare function getNormalizedType(c: Checker, t: Type, writing: boolean): Type;
+/** The one base of a class or interface reference that declares no members of its own, which it relates as. */
+export declare function getSingleBaseForNonAugmentingSubtype(c: Checker, t: Type): Type | undefined;
+export declare function isWeakType(c: Checker, t: Type): boolean;
+/** Whether `name` is known anywhere in `targetType`: declared, covered by an index signature, or in some constituent. */
+export declare function isKnownProperty(c: Checker, targetType: Type, name: string, isComparingJsxAttributes: boolean): boolean;
+export declare function isTypeSubsetOf(c: Checker, source: Type, target: Type): boolean;
+export declare function getRegularTypeOfObjectLiteral(c: Checker, t: Type): Type;
+export declare function isDiscriminantProperty(c: Checker, t: Type, name: string): boolean;
+/** The constituent selected by a key property's unit type; not computed yet. */
+export declare function getMatchingUnionConstituentForType(_c: Checker, _unionType: UnionType, _t: Type): Type | undefined;
+/** The constituent of the union `target` that `source` most likely meant, for error elaboration. */
+export declare function getBestMatchingTypeForElaboration(c: Checker, source: Type, target: Type): Type | undefined;
+export declare function getUnmatchedProperty(c: Checker, source: Type, target: Type, requireOptionalProperties: boolean, matchDiscriminantProperties: boolean): Symbol | undefined;
+/** Whether `getUnmatchedProperty` reports `targetProp`, a property of the target. */
+export declare function isUnmatchedProperty(c: Checker, source: Type, targetProp: Symbol, requireOptionalProperties: boolean, matchDiscriminantProperties: boolean): boolean;
+export declare function getUnmatchedProperties(c: Checker, source: Type, target: Type, requireOptionalProperties: boolean): Symbol[];
+export declare function isObjectTypeWithInferableIndex(c: Checker, t: Type): boolean;
+export declare function typeHasCallOrConstructSignatures(c: Checker, t: Type): boolean;
+/** Both names of the pair, fully qualified when they print the same. */
+export declare function getTypeNamesForErrorDisplay(c: Checker, left: Type, right: Type): [string, string];
+/**
+ * Puts `t` at `stack[depth]`. Recursion stacks keep their entries from `depth` on as stale slots,
+ * which avoids releasing an entry on every pop.
+ */
+export declare function setStackEntry(stack: Type[], depth: number, t: Type): void;
+/**
+ * Deeply nested: `maxDepth` or more same-identity types in `stack[0..depth)`, each newer than the
+ * last.
+ */
+export declare function isDeeplyNestedType(c: Checker, t: Type, stack: readonly Type[], depth: number, maxDepth: number): boolean;
+/** An identity shared by instantiations of a type, so infinitely expanding instantiations can be detected. */
+export declare function getRecursionIdentity(t: Type): RecursionId;
+export declare function isMarkerType(c: Checker, t: Type): boolean;
+export declare function getVariances(c: Checker, t: Type): VarianceFlags[];
+export declare function getAliasVariances(c: Checker, symbol: Symbol): VarianceFlags[];
+export declare function createMarkerType(c: Checker, symbol: Symbol, source: Type, target: Type): Type;
+export declare function getTypeParameterModifiers(tp: Type): ModifierFlags;
+export declare function isEmptyArrayLiteralType(c: Checker, t: Type): boolean;
+export declare function compareProperties(c: Checker, sourceProp: Symbol, targetProp: Symbol, compare: ComparerKind): Ternary;
+export declare function isSignatureAssignableTo(c: Checker, source: Signature, target: Signature, ignoreReturnTypes: boolean): boolean;
+export declare function compareSignaturesRelated(c: Checker, source: Signature, target: Signature, checkMode: SignatureCheckMode, reportErrors: boolean, comparer: TypeComparer, reportUnreliableMarkers: import('./checker-types.js').TypeMapper | undefined): Ternary;
+export declare function compareSignaturesIdentical(c: Checker, source: Signature, target: Signature, partialMatch: boolean, ignoreThisTypes: boolean, ignoreReturnTypes: boolean, compare: ComparerKind): Ternary;
+/**
+ * Whether `source` derives from `target` in the inheritance hierarchy, ignoring type parameters;
+ * `{}`, Object and Function are less derived than object-like types.
+ */
+export declare function isTypeDerivedFrom(c: Checker, source: Type, target: Type): boolean;
+export { findApplicableIndexInfo, getMergedSymbol, typeListKey, getPropertyNameFromType };
+/** The target properties that accept `undefined` only through `?`, under exactOptionalPropertyTypes. */
+export declare function getExactOptionalUnassignableProperties(c: Checker, source: Type, target: Type): Symbol[];
+/**
+ * Whether `source` may be `undefined` where the optional property type `target` takes it only by being
+ * missing, under exactOptionalPropertyTypes.
+ */
+export declare function isExactOptionalPropertyMismatch(c: Checker, source: Type | undefined, target: Type | undefined): boolean;