@tsvm/ir 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,238 @@
+import { IRFunction, IRGlobal, IRImport, IRExport, ConstantKind, IRModule, OpCode, Operand, Register, TerminatorInstruction, BasicBlock, IRType, FunctionAttribute, Instruction, Diagnostic, ModuleInfo, ProjectSemanticGraph, FunctionCapabilityReport } from '@tsvm/shared';
+import ts from 'typescript';
+
+declare class IRModuleBuilder {
+    readonly sourceFile: string;
+    private functions;
+    private globals;
+    private imports;
+    private exports;
+    private constantPool;
+    private constantMap;
+    private nextFunctionId;
+    constructor(sourceFile: string);
+    addFunction(fn: IRFunction): void;
+    addGlobal(g: IRGlobal): void;
+    addImport(imp: IRImport): void;
+    addExport(exp: IRExport): void;
+    addConstant(kind: ConstantKind, value: string | number | boolean | null): number;
+    build(): IRModule;
+    getNextFunctionId(): string;
+}
+declare class IRFunctionBuilder {
+    readonly id: string;
+    readonly name: string;
+    readonly returnType: IRType;
+    private blocks;
+    private params;
+    private locals;
+    private attributes;
+    private capturedVariables;
+    private nextRegId;
+    private nextBlockId;
+    constructor(id: string, name: string, returnType: IRType);
+    addParam(name: string, type: IRType, isRest?: boolean, defaultValue?: number): Register;
+    addLocal(name: string, type: IRType, isCaptured?: boolean): Register;
+    addAttribute(attr: FunctionAttribute): void;
+    addCapturedVariable(name: string): void;
+    allocRegister(): Register;
+    createBlock(label: string): BasicBlockBuilder;
+    addBlock(block: BasicBlock): void;
+    getBlockCount(): number;
+    build(isVirtualized?: boolean, isExported?: boolean): IRFunction;
+}
+declare class BasicBlockBuilder {
+    readonly id: string;
+    readonly label: string;
+    private instructions;
+    private terminator?;
+    private predecessors;
+    private successors;
+    constructor(id: string, label: string);
+    addInstruction(opcode: OpCode, operands: Operand[], result?: Register): void;
+    setTerminator(term: TerminatorInstruction): void;
+    addPredecessor(id: string): void;
+    getInstructionCount(): number;
+    getPredecessorCount(): number;
+    getTerminatorKind(): TerminatorInstruction['kind'] | undefined;
+    build(): BasicBlock;
+}
+declare function createInstruction(opcode: OpCode, operands: Operand[], result?: Register): Instruction;
+declare function createTerminator(kind: TerminatorInstruction['kind'], targets: string[], condition?: Register, returnValue?: Register): TerminatorInstruction;
+
+type SupportedFunctionNode = ts.FunctionDeclaration | ts.FunctionExpression | ts.ArrowFunction | ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.ConstructorDeclaration;
+interface LowerToIROptions {
+    readonly forceVirtualizeAll?: boolean;
+    readonly forceVirtualizeFunctionNames?: ReadonlySet<string>;
+    readonly skipTopLevelFunctionNames?: ReadonlySet<string>;
+    readonly compatibilityFallback?: boolean;
+    readonly diagnostics?: Diagnostic[];
+}
+interface ClosureAnalysis {
+    readonly localNames: ReadonlySet<string>;
+    readonly capturedFromOuter: readonly string[];
+    readonly capturedByDescendants: ReadonlySet<string>;
+}
+interface NormalizedClassFieldElement {
+    readonly kind: 'field';
+    readonly node: ts.PropertyDeclaration;
+    readonly isStatic: boolean;
+    readonly keyName?: string;
+    readonly computedBindingName?: string;
+    readonly privateBindingName?: string;
+}
+
+interface LoweringOptions {
+    readonly name: string;
+    readonly isExported: boolean;
+    readonly isVirtualized: boolean;
+    readonly analysis: ClosureAnalysis;
+    readonly attributes?: readonly FunctionAttribute[];
+    readonly isNested?: boolean;
+    readonly prologueEmitter?: ((lowering: ASTLowering) => void) | undefined;
+    readonly privateIdentifierBindings?: ReadonlyMap<string, string>;
+    readonly instanceFieldsToInitialize?: readonly NormalizedClassFieldElement[];
+}
+interface IASTLowering {
+    node: ts.Node;
+    fnBuilder: any;
+    currentBlock: any;
+    modBuilder: any;
+    scope: Map<string, any>;
+    outerCaptureBindings: Set<string>;
+    isAsyncFunction: boolean;
+    isGenerator: boolean;
+    instanceFieldsToInitialize: readonly any[] | undefined;
+    createTempLocal(name: string): any;
+    emitConstant(kind: any, value: unknown): any;
+    loadFromLocal(reg: any): any;
+    storeToLocal(reg1: any, reg2: any): void;
+    normalizeExpression(expr: ts.Expression): ts.Expression;
+    lowerNestedFunctionLike(expr: ts.FunctionLikeDeclaration, name?: string, options?: any): any;
+    resolveLexicalCapture(name: string, node: ts.Node, detail: string): any;
+    failUnsupported(node: ts.Node, msg?: string): never;
+    resolveVar(name: string): any;
+    storeValue(target: ts.Expression, valueReg: any): void;
+    readValue(target: ts.Expression): any;
+    resolvePrivateIdentifierRegister(identifier: ts.PrivateIdentifier): any;
+    emitObjectPropertyAssignment(objReg: any, keyReg: any, valueReg: any, computed?: boolean): void;
+    getPropertyNameText(name: ts.PropertyName): string;
+    materializeArgumentArray(args: readonly ts.Expression[]): any;
+    emitSpreadInto(targetReg: any, sourceReg: any): void;
+    emitSpreadIntoArray(targetReg: any, sourceReg: any, startIndexReg: any, destIndexLocal: any): void;
+    lowerClassLike(node: ts.ClassDeclaration | ts.ClassExpression, name?: string): any;
+    emitInstanceFieldInitializers(fields: readonly any[]): void;
+}
+declare class ASTLowering {
+    readonly modBuilder: IRModuleBuilder;
+    private readonly node;
+    private fnBuilder;
+    private currentBlock;
+    private scope;
+    readonly functionId: string;
+    private nestedFunctionCount;
+    private tempLocalCount;
+    private readonly sourceFile;
+    private readonly capturedLocals;
+    private readonly outerCaptureBindings;
+    private readonly breakTargets;
+    private readonly continueTargets;
+    private readonly finallyContexts;
+    private throwPassthroughFinallyDepth;
+    private readonly pendingParameterBindings;
+    private readonly isAsyncFunction;
+    private readonly isGenerator;
+    private readonly privateIdentifierBindings;
+    private readonly instanceFieldsToInitialize?;
+    constructor(modBuilder: IRModuleBuilder, node: SupportedFunctionNode, options: LoweringOptions);
+    private failUnsupported;
+    private isSyntheticDeadBlock;
+    private shouldEmitFallthroughReturn;
+    private enterBreakTarget;
+    private leaveBreakTarget;
+    private enterContinueTarget;
+    private leaveContinueTarget;
+    private emitJumpAndAdvance;
+    private emitConstant;
+    private storeToLocal;
+    private boxCapturedParameters;
+    private lowerPendingParameterBindings;
+    private loadOuterCaptureCell;
+    private resolveVar;
+    private findIdentifierNode;
+    private createNestedFunctionName;
+    private getAvailableOuterCaptureNames;
+    private canProvideLexicalThis;
+    private canProvideLexicalNewTarget;
+    private initializeLexicalSemanticCaptures;
+    private initializeLexicalCapture;
+    private resolveLexicalCapture;
+    private collectReferencedOuterNames;
+    private getFunctionAttributes;
+    private normalizeClassLike;
+    private lowerClassConstructor;
+    private lowerNestedFunctionLike;
+    private emitClassMethodOrAccessorDescriptor;
+    private lowerClassLike;
+    private emitClassConstructorGuard;
+    private emitInstanceFieldInitializers;
+    private resolvePrivateIdentifierRegister;
+    private lowerNestedFunction;
+    private buildClosureEnvironment;
+    private getCellForCapture;
+    private storeValue;
+    private readValue;
+    private emitObjectPropertyAssignment;
+    private normalizeExpression;
+    private createTempLocal;
+    private createSyntheticBindingName;
+    private declareScopedIdentifier;
+    private declareForcedBoxedIdentifier;
+    private withTemporaryBinding;
+    private getPropertyKeyRegister;
+    private buildAccessorDescriptorSource;
+    private emitObjectPropertyWrite;
+    private emitDefineProperty;
+    private initializeDeclaredIdentifier;
+    private applyDefaultValue;
+    private materializeBindingElementValue;
+    private emitRestArgs;
+    private emitArraySlice;
+    private emitSpreadInto;
+    private emitSpreadIntoArray;
+    private bindPattern;
+    private initializeVariableDeclaration;
+    private assignLoopBinding;
+    private loadFromLocal;
+    private getActiveFinallyContext;
+    private withFinallyContext;
+    private withPassthroughThrow;
+    private createFinallyContext;
+    private getCompletionTargetCode;
+    private setFinallyCompletion;
+    private routeAbruptCompletionThroughFinally;
+    private emitCompletionTargetDispatch;
+    private emitCompletionDispatch;
+    private bindCatchVariable;
+    private lowerTryCatchStatement;
+    private lowerTryFinallyStatement;
+    private lowerConditionalExpression;
+    private lowerNullishCoalesce;
+    private lowerTemplateExpression;
+    private lowerNestedFunctionNode;
+    private visitExpression;
+    private getPropertyNameText;
+    private materializeArgumentArray;
+    private parseAssignmentTargetWithDefault;
+    private storeArrayPattern;
+    private storeObjectPattern;
+    private visitStatement;
+}
+declare function lowerToIR(moduleInfo: ModuleInfo, graph: ProjectSemanticGraph, filePath: string, options?: LowerToIROptions): IRModule;
+
+declare function analyzeFunctionCapabilities(filePath: string, sourceText?: string): FunctionCapabilityReport[];
+declare function analyzeTopLevelFunctionCapabilities(filePath: string, sourceText?: string): FunctionCapabilityReport[];
+
+declare function printIRModule(module: IRModule): string;
+
+export { ASTLowering, BasicBlockBuilder, type IASTLowering, IRFunctionBuilder, IRModuleBuilder, type LowerToIROptions, analyzeFunctionCapabilities, analyzeTopLevelFunctionCapabilities, createInstruction, createTerminator, lowerToIR, printIRModule };