@lpc-lang/core/compiler/debug.d.ts

LPC Language Compiler Library

import { AnyFunction, AssertionLevel, Node, NodeArray, Type, Symbol, SymbolFlags, TypeFlags, ObjectFlags, SignatureFlags, SyntaxKind, NodeFlags, ModifierFlags, FlowNode, FlowFlags, TypeMapper, TypeMapKind, NodeCheckFlags, Macro, VarianceFlags } from "./_namespaces/lpc";
import * as lpc from "./_namespaces/lpc.js";
export declare namespace Debug {
    let currentLogLevel: lpc.LogLevel;
    let isDebugging: boolean;
    let loggingHost: LoggingHost | undefined;
    function attachNodeArrayDebugInfo(array: NodeArray<Node>): void;
    function formatVariance(varianceFlags: VarianceFlags): string;
    function formatNodeCheckFlags(flags: NodeCheckFlags | undefined): string;
    function fail(message?: string, stackCrawlMark?: AnyFunction): never;
    function assertLessThan(a: number, b: number, msg?: string, stackCrawlMark?: AnyFunction): void;
    function assertIsDefined<T>(value: T, message?: string, stackCrawlMark?: AnyFunction): asserts value is NonNullable<T>;
    function failBadSyntaxKind(node: Node, message?: string, stackCrawlMark?: AnyFunction): never;
    /**
     * Formats an enum value as a string for debugging and debug assertions.
     */
    function formatEnum(value: number, enumObject: any, isFlags?: boolean): string;
    function formatSymbolFlags(flags: SymbolFlags | undefined): string;
    function formatObjectFlags(flags: ObjectFlags | undefined): string;
    function formatSignatureFlags(flags: SignatureFlags | undefined): string;
    function formatTypeFlags(flags: TypeFlags | undefined): string;
    function assertEachIsDefined<T extends Node>(value: NodeArray<T>, message?: string, stackCrawlMark?: AnyFunction): asserts value is NodeArray<T>;
    function assertEachIsDefined<T>(value: readonly T[], message?: string, stackCrawlMark?: AnyFunction): asserts value is readonly NonNullable<T>[];
    function checkEachDefined<T, A extends readonly T[]>(value: A, message?: string, stackCrawlMark?: AnyFunction): A;
    /**
     * Injects debug information into frequently used types.
     */
    function enableDebugInfo(): void;
    function assertEqual<T>(a: T, b: T, msg?: string, msg2?: string, stackCrawlMark?: AnyFunction): void;
    function assertGreaterThanOrEqual(a: number, b: number, stackCrawlMark?: AnyFunction): void;
    function assertLessThanOrEqual(a: number, b: number, stackCrawlMark?: AnyFunction): void;
    function checkDefined<T>(value: T | null | undefined, message?: string, stackCrawlMark?: AnyFunction): T;
    function formatSyntaxKind(kind: SyntaxKind | undefined): string;
    function formatNodeFlags(flags: NodeFlags | undefined): string;
    function formatModifierFlags(flags: ModifierFlags | undefined): string;
    function assert(expression: unknown, message?: string, verboseDebugInfo?: string | (() => string), stackCrawlMark?: AnyFunction): asserts expression;
    function formatFlowFlags(flags: FlowFlags | undefined): string;
    function attachMacroDebugInfo(macro: Macro): void;
    function attachFlowNodeDebugInfo(flowNode: FlowNode): FlowNode;
    function formatControlFlowGraph(flowNode: FlowNode): string;
    /**
     * Asserts a value has the specified type in typespace only (does not perform a runtime assertion).
     * This is useful in cases where we switch on `node.kind` and can be reasonably sure the type is accurate, and
     * as a result can reduce the number of unnecessary casts.
     */
    function type<T>(value: unknown): asserts value is T;
    type DebugType = Type & {
        __debugTypeToString(): string;
    };
    class DebugTypeMapper {
        kind: TypeMapKind;
        __debugToString(): string;
    }
    function assertNever(member: never, message?: string, stackCrawlMark?: AnyFunction): never;
    function attachDebugPrototypeIfDebug(mapper: TypeMapper): TypeMapper;
    function shouldAssert(level: AssertionLevel): boolean;
    function getFunctionName(func: AnyFunction): any;
    function assertNode<T extends Node, U extends T>(node: T | undefined, test: (node: T) => node is U, message?: string, stackCrawlMark?: AnyFunction): asserts node is U;
    function assertNode(node: Node | undefined, test: ((node: Node) => boolean) | undefined, message?: string, stackCrawlMark?: AnyFunction): void;
    function setAssertionLevel(level: AssertionLevel): void;
    function formatSymbol(symbol: Symbol): string;
    function assertEachNode<T extends Node, U extends T>(nodes: NodeArray<T>, test: (node: T) => node is U, message?: string, stackCrawlMark?: AnyFunction): asserts nodes is NodeArray<U>;
    function assertEachNode<T extends Node, U extends T>(nodes: readonly T[], test: (node: T) => node is U, message?: string, stackCrawlMark?: AnyFunction): asserts nodes is readonly U[];
    function assertEachNode<T extends Node, U extends T>(nodes: NodeArray<T> | undefined, test: (node: T) => node is U, message?: string, stackCrawlMark?: AnyFunction): asserts nodes is NodeArray<U> | undefined;
    function assertEachNode<T extends Node, U extends T>(nodes: readonly T[] | undefined, test: (node: T) => node is U, message?: string, stackCrawlMark?: AnyFunction): asserts nodes is readonly U[] | undefined;
    function assertEachNode(nodes: readonly Node[], test: ((node: Node) => boolean) | undefined, message?: string, stackCrawlMark?: AnyFunction): void;
    function assertOptionalNode<T extends Node, U extends T>(node: T, test: (node: T) => node is U, message?: string, stackCrawlMark?: AnyFunction): asserts node is U;
    function assertOptionalNode<T extends Node, U extends T>(node: T | undefined, test: (node: T) => node is U, message?: string, stackCrawlMark?: AnyFunction): asserts node is U | undefined;
    function assertOptionalNode(node: Node | undefined, test: ((node: Node) => boolean) | undefined, message?: string, stackCrawlMark?: AnyFunction): void;
}
//# sourceMappingURL=debug.d.ts.map