@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev3

package/dist/compiler/tir/statements/TirAssertStmt.d.ts

@@ -0,0 +1,18 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../expressions/TirExpr.js";
+import { ITirStmt } from "./TirStmt.js";
+export declare class TirAssertStmt implements ITirStmt {
+    /** must be boolean or Optional */
+    condition: TirExpr;
+    /** must be string */
+    elseExpr: TirExpr | undefined;
+    readonly range: SourceRange;
+    constructor(
+    /** must be boolean or Optional */
+    condition: TirExpr, 
+    /** must be string */
+    elseExpr: TirExpr | undefined, range: SourceRange);
+    definitelyTerminates(): boolean;
+    deps(): string[];
+    toSafeCondition(): TirExpr;
+}

package/dist/compiler/tir/statements/TirAssertStmt.js

@@ -0,0 +1,29 @@
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+import { TirTraceIfFalseExpr } from "../expressions/TirTraceIfFalseExpr.js";
+export class TirAssertStmt {
+    condition;
+    elseExpr;
+    range;
+    constructor(
+    /** must be boolean or Optional */
+    condition, 
+    /** must be string */
+    elseExpr, range) {
+        this.condition = condition;
+        this.elseExpr = elseExpr;
+        this.range = range;
+    }
+    definitelyTerminates() { return false; }
+    deps() {
+        const deps = this.condition.deps();
+        if (this.elseExpr) {
+            mergeSortedStrArrInplace(deps, this.elseExpr.deps());
+        }
+        return deps;
+    }
+    toSafeCondition() {
+        if (!this.elseExpr)
+            return this.condition;
+        return new TirTraceIfFalseExpr(this.condition, this.elseExpr, this.range);
+    }
+}

package/dist/compiler/tir/statements/TirAssignmentStmt.d.ts

@@ -0,0 +1,12 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../expressions/TirExpr.js";
+import { TirVariableAccessExpr } from "../expressions/TirVariableAccessExpr.js";
+import { ITirStmt } from "./TirStmt.js";
+export declare class TirAssignmentStmt implements ITirStmt {
+    readonly varIdentifier: TirVariableAccessExpr;
+    readonly assignedExpr: TirExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: TirVariableAccessExpr, assignedExpr: TirExpr, range: SourceRange);
+    definitelyTerminates(): boolean;
+    deps(): string[];
+}

package/dist/compiler/tir/statements/TirAssignmentStmt.js

@@ -0,0 +1,14 @@
+export class TirAssignmentStmt {
+    varIdentifier;
+    assignedExpr;
+    range;
+    constructor(varIdentifier, assignedExpr, range) {
+        this.varIdentifier = varIdentifier;
+        this.assignedExpr = assignedExpr;
+        this.range = range;
+    }
+    definitelyTerminates() { return false; }
+    deps() {
+        return this.varIdentifier.deps();
+    }
+}

package/dist/compiler/tir/statements/TirBlockStmt.d.ts

@@ -0,0 +1,9 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { ITirStmt, TirStmt } from "./TirStmt.js";
+export declare class TirBlockStmt implements ITirStmt {
+    stmts: TirStmt[];
+    readonly range: SourceRange;
+    constructor(stmts: TirStmt[], range: SourceRange);
+    definitelyTerminates(): boolean;
+    deps(): string[];
+}

package/dist/compiler/tir/statements/TirBlockStmt.js

@@ -0,0 +1,25 @@
+import { filterSortedStrArrInplace } from "../../../utils/array/filterSortedStrArrInplace.js";
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+import { isTirVarDecl } from "./TirVarDecl/TirVarDecl.js";
+export class TirBlockStmt {
+    stmts;
+    range;
+    constructor(stmts, range) {
+        this.stmts = stmts;
+        this.range = range;
+    }
+    definitelyTerminates() {
+        return this.stmts.some(stmt => stmt.definitelyTerminates());
+    }
+    deps() {
+        const deps = [];
+        const introducedVars = [];
+        for (const stmt of this.stmts) {
+            mergeSortedStrArrInplace(deps, filterSortedStrArrInplace(stmt.deps(), introducedVars));
+            if (isTirVarDecl(stmt)) {
+                mergeSortedStrArrInplace(introducedVars, stmt.introducedVars());
+            }
+        }
+        return deps;
+    }
+}

package/dist/compiler/tir/statements/TirBreakStmt.d.ts

@@ -0,0 +1,8 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { ITirStmt } from "./TirStmt.js";
+export declare class TirBreakStmt implements ITirStmt {
+    readonly range: SourceRange;
+    constructor(range: SourceRange);
+    definitelyTerminates(): boolean;
+    deps(): string[];
+}

package/dist/compiler/tir/statements/TirBreakStmt.js

@@ -0,0 +1,11 @@
+export class TirBreakStmt {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+    // loops are transoformed into recursive functions
+    // and break statements are transformed into return statements
+    // so this statement does terminate the function
+    definitelyTerminates() { return true; }
+    deps() { return []; }
+}

package/dist/compiler/tir/statements/TirContinueStmt.d.ts

@@ -0,0 +1,8 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { ITirStmt } from "./TirStmt.js";
+export declare class TirContinueStmt implements ITirStmt {
+    readonly range: SourceRange;
+    constructor(range: SourceRange);
+    definitelyTerminates(): boolean;
+    deps(): string[];
+}

package/dist/compiler/tir/statements/TirContinueStmt.js

@@ -0,0 +1,13 @@
+export class TirContinueStmt {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+    // loops are transoformed into recursive functions
+    // and continue statements are transformed into return statements
+    // so this statement does terminate the function
+    definitelyTerminates() { return true; }
+    deps() {
+        return [];
+    }
+}

package/dist/compiler/tir/statements/TirFailStmt.d.ts

@@ -0,0 +1,13 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../expressions/TirExpr.js";
+import { ITirStmt } from "./TirStmt.js";
+export declare class TirFailStmt implements ITirStmt {
+    /** must be string (or utf8 bytes) */
+    failMsgExpr: TirExpr | undefined;
+    readonly range: SourceRange;
+    constructor(
+    /** must be string (or utf8 bytes) */
+    failMsgExpr: TirExpr | undefined, range: SourceRange);
+    definitelyTerminates(): boolean;
+    deps(): string[];
+}

package/dist/compiler/tir/statements/TirFailStmt.js

@@ -0,0 +1,14 @@
+export class TirFailStmt {
+    failMsgExpr;
+    range;
+    constructor(
+    /** must be string (or utf8 bytes) */
+    failMsgExpr, range) {
+        this.failMsgExpr = failMsgExpr;
+        this.range = range;
+    }
+    definitelyTerminates() { return true; }
+    deps() {
+        return this.failMsgExpr?.deps() ?? [];
+    }
+}

package/dist/compiler/tir/statements/TirForOfStmt.d.ts

@@ -0,0 +1,16 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../expressions/TirExpr.js";
+import { ITirStmt, TirStmt } from "./TirStmt.js";
+import { TirVarDecl } from "./TirVarDecl/TirVarDecl.js";
+/**
+ * for( `elemDeclaration` of iterable ) body
+ */
+export declare class TirForOfStmt implements ITirStmt {
+    readonly elemDeclaration: TirVarDecl;
+    readonly iterable: TirExpr;
+    body: TirStmt;
+    readonly range: SourceRange;
+    constructor(elemDeclaration: TirVarDecl, iterable: TirExpr, body: TirStmt, range: SourceRange);
+    definitelyTerminates(): boolean;
+    deps(): string[];
+}

package/dist/compiler/tir/statements/TirForOfStmt.js

@@ -0,0 +1,25 @@
+import { filterSortedStrArrInplace } from "../../../utils/array/filterSortedStrArrInplace.js";
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+/**
+ * for( `elemDeclaration` of iterable ) body
+ */
+export class TirForOfStmt {
+    elemDeclaration;
+    iterable;
+    body;
+    range;
+    constructor(elemDeclaration, iterable, body, range) {
+        this.elemDeclaration = elemDeclaration;
+        this.iterable = iterable;
+        this.body = body;
+        this.range = range;
+    }
+    definitelyTerminates() {
+        return this.body.definitelyTerminates();
+    }
+    deps() {
+        const deps = this.iterable.deps();
+        const introducedVars = this.elemDeclaration.introducedVars();
+        return mergeSortedStrArrInplace(deps, filterSortedStrArrInplace(this.body.deps(), introducedVars));
+    }
+}

package/dist/compiler/tir/statements/TirForStmt.d.ts

@@ -0,0 +1,19 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../expressions/TirExpr.js";
+import { ITirStmt, TirStmt } from "./TirStmt.js";
+import { TirSimpleVarDecl } from "./TirVarDecl/TirSimpleVarDecl.js";
+/**
+ * ***NOT*** for...of loop
+ *
+ * for( init; condition; update ) body
+ */
+export declare class TirForStmt implements ITirStmt {
+    readonly init: TirSimpleVarDecl[];
+    readonly condition: TirExpr | undefined;
+    readonly update: TirStmt[] | undefined;
+    body: TirStmt;
+    readonly range: SourceRange;
+    constructor(init: TirSimpleVarDecl[], condition: TirExpr | undefined, update: TirStmt[] | undefined, body: TirStmt, range: SourceRange);
+    definitelyTerminates(): boolean;
+    deps(): string[];
+}

package/dist/compiler/tir/statements/TirForStmt.js

@@ -0,0 +1,39 @@
+import { filterSortedStrArrInplace } from "../../../utils/array/filterSortedStrArrInplace.js";
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+/**
+ * ***NOT*** for...of loop
+ *
+ * for( init; condition; update ) body
+ */
+export class TirForStmt {
+    init;
+    condition;
+    update;
+    body;
+    range;
+    constructor(init, condition, update, body, range) {
+        this.init = init;
+        this.condition = condition;
+        this.update = update;
+        this.body = body;
+        this.range = range;
+    }
+    definitelyTerminates() {
+        return this.body.definitelyTerminates() || (this.update?.some(stmt => stmt.definitelyTerminates()) ?? false);
+    }
+    deps() {
+        const { deps, introducedVars } = this.init.reduce((acc, decl) => {
+            mergeSortedStrArrInplace(acc.deps, filterSortedStrArrInplace(decl.deps(), acc.introducedVars));
+            mergeSortedStrArrInplace(acc.introducedVars, decl.introducedVars());
+            return acc;
+        }, { deps: [], introducedVars: [] });
+        function addDeps(otherDeps) {
+            mergeSortedStrArrInplace(deps, filterSortedStrArrInplace(otherDeps, introducedVars));
+        }
+        addDeps(this.condition?.deps() ?? []);
+        for (const stmt of this.update ?? [])
+            addDeps(stmt.deps());
+        addDeps(this.body.deps());
+        return deps;
+    }
+}

package/dist/compiler/tir/statements/TirIfStmt.d.ts

@@ -0,0 +1,12 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../expressions/TirExpr.js";
+import { ITirStmt, TirStmt } from "./TirStmt.js";
+export declare class TirIfStmt implements ITirStmt {
+    readonly condition: TirExpr;
+    thenBranch: TirStmt;
+    elseBranch: TirStmt | undefined;
+    readonly range: SourceRange;
+    constructor(condition: TirExpr, thenBranch: TirStmt, elseBranch: TirStmt | undefined, range: SourceRange);
+    definitelyTerminates(): boolean;
+    deps(): string[];
+}

package/dist/compiler/tir/statements/TirIfStmt.js

@@ -0,0 +1,23 @@
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+export class TirIfStmt {
+    condition;
+    thenBranch;
+    elseBranch;
+    range;
+    constructor(condition, thenBranch, elseBranch, range) {
+        this.condition = condition;
+        this.thenBranch = thenBranch;
+        this.elseBranch = elseBranch;
+        this.range = range;
+    }
+    definitelyTerminates() {
+        return (this.thenBranch.definitelyTerminates()
+            && (this.elseBranch?.definitelyTerminates() ?? false));
+    }
+    deps() {
+        const deps = this.condition.deps();
+        mergeSortedStrArrInplace(deps, this.thenBranch.deps());
+        this.elseBranch && mergeSortedStrArrInplace(deps, this.elseBranch.deps());
+        return deps;
+    }
+}

package/dist/compiler/tir/statements/TirMatchStmt.d.ts

@@ -0,0 +1,27 @@
+import { HasSourceRange } from "../../../ast/nodes/HasSourceRange.js";
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../expressions/TirExpr.js";
+import { ITirStmt, TirStmt } from "./TirStmt.js";
+import { TirNamedDeconstructVarDecl } from "./TirVarDecl/TirNamedDeconstructVarDecl.js";
+export declare class TirMatchStmt implements ITirStmt {
+    readonly matchExpr: TirExpr;
+    readonly cases: TirMatchStmtCase[];
+    wildcardCase: TirMatchStmtWildcardCase | undefined;
+    readonly range: SourceRange;
+    constructor(matchExpr: TirExpr, cases: TirMatchStmtCase[], wildcardCase: TirMatchStmtWildcardCase | undefined, range: SourceRange);
+    definitelyTerminates(): boolean;
+    deps(): string[];
+}
+export declare class TirMatchStmtCase implements HasSourceRange {
+    pattern: TirNamedDeconstructVarDecl;
+    body: TirStmt;
+    readonly range: SourceRange;
+    constructor(pattern: TirNamedDeconstructVarDecl, body: TirStmt, range: SourceRange);
+    deps(): string[];
+}
+export declare class TirMatchStmtWildcardCase implements HasSourceRange {
+    body: TirStmt;
+    readonly range: SourceRange;
+    constructor(body: TirStmt, range: SourceRange);
+    deps(): string[];
+}

package/dist/compiler/tir/statements/TirMatchStmt.js

@@ -0,0 +1,51 @@
+import { filterSortedStrArrInplace } from "../../../utils/array/filterSortedStrArrInplace.js";
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+export class TirMatchStmt {
+    matchExpr;
+    cases;
+    wildcardCase;
+    range;
+    constructor(matchExpr, cases, wildcardCase, range) {
+        this.matchExpr = matchExpr;
+        this.cases = cases;
+        this.wildcardCase = wildcardCase;
+        this.range = range;
+    }
+    definitelyTerminates() {
+        return this.cases.every(({ body }) => body.definitelyTerminates());
+    }
+    deps() {
+        const deps = this.matchExpr.deps();
+        for (const caseStmt of this.cases) {
+            mergeSortedStrArrInplace(deps, caseStmt.deps());
+        }
+        if (this.wildcardCase)
+            mergeSortedStrArrInplace(deps, this.wildcardCase.deps());
+        return deps;
+    }
+}
+export class TirMatchStmtCase {
+    pattern;
+    body;
+    range;
+    constructor(pattern, body, range) {
+        this.pattern = pattern;
+        this.body = body;
+        this.range = range;
+    }
+    deps() {
+        const introducedVars = this.pattern.introducedVars();
+        return filterSortedStrArrInplace(this.body.deps(), introducedVars);
+    }
+}
+export class TirMatchStmtWildcardCase {
+    body;
+    range;
+    constructor(body, range) {
+        this.body = body;
+        this.range = range;
+    }
+    deps() {
+        return this.body.deps();
+    }
+}

package/dist/compiler/tir/statements/TirReturnStmt.d.ts

@@ -0,0 +1,10 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../expressions/TirExpr.js";
+import { ITirStmt } from "./TirStmt.js";
+export declare class TirReturnStmt implements ITirStmt {
+    value: TirExpr;
+    readonly range: SourceRange;
+    constructor(value: TirExpr, range: SourceRange);
+    definitelyTerminates(): boolean;
+    deps(): string[];
+}

package/dist/compiler/tir/statements/TirReturnStmt.js

@@ -0,0 +1,12 @@
+export class TirReturnStmt {
+    value;
+    range;
+    constructor(value, range) {
+        this.value = value;
+        this.range = range;
+    }
+    definitelyTerminates() { return true; }
+    deps() {
+        return this.value?.deps() ?? [];
+    }
+}

package/dist/compiler/tir/statements/TirStmt.d.ts

@@ -0,0 +1,32 @@
+import { TirAssertStmt } from "./TirAssertStmt.js";
+import { TirAssignmentStmt } from "./TirAssignmentStmt.js";
+import { TirBlockStmt } from "./TirBlockStmt.js";
+import { TirBreakStmt } from "./TirBreakStmt.js";
+import { TirContinueStmt } from "./TirContinueStmt.js";
+import { TirFailStmt } from "./TirFailStmt.js";
+import { TirForOfStmt } from "./TirForOfStmt.js";
+import { TirForStmt } from "./TirForStmt.js";
+import { TirIfStmt } from "./TirIfStmt.js";
+import { TirMatchStmt } from "./TirMatchStmt.js";
+import { TirReturnStmt } from "./TirReturnStmt.js";
+import { TirWhileStmt } from "./TirWhileStmt.js";
+import { TirVarDecl } from "./TirVarDecl/TirVarDecl.js";
+import { HasSourceRange } from "../../../ast/nodes/HasSourceRange.js";
+export declare enum Termination {
+    Conditinal = -1,
+    NoTermination = 0,
+    Return = 1,
+    Fail = 2
+}
+export interface ITirStmt extends HasSourceRange {
+    deps: () => string[];
+    /**
+     * @returns true if the statement is guaranteed to terminate the function
+     *
+     * that implies there is a non-conditional return statement
+     * or a non-conditional fail statement (which terminates the entire program)
+     */
+    definitelyTerminates: () => boolean;
+}
+export type TirStmt = TirVarDecl | TirIfStmt | TirForStmt | TirForOfStmt | TirWhileStmt | TirReturnStmt | TirBlockStmt | TirBreakStmt | TirContinueStmt | TirFailStmt | TirAssertStmt | TirMatchStmt | TirAssignmentStmt;
+export declare function isTirStmt(thing: any): thing is TirStmt;

package/dist/compiler/tir/statements/TirStmt.js

@@ -0,0 +1,40 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { TirAssertStmt } from "./TirAssertStmt.js";
+import { TirAssignmentStmt } from "./TirAssignmentStmt.js";
+import { TirBlockStmt } from "./TirBlockStmt.js";
+import { TirBreakStmt } from "./TirBreakStmt.js";
+import { TirContinueStmt } from "./TirContinueStmt.js";
+import { TirFailStmt } from "./TirFailStmt.js";
+import { TirForOfStmt } from "./TirForOfStmt.js";
+import { TirForStmt } from "./TirForStmt.js";
+import { TirIfStmt } from "./TirIfStmt.js";
+import { TirMatchStmt } from "./TirMatchStmt.js";
+import { TirReturnStmt } from "./TirReturnStmt.js";
+import { TirWhileStmt } from "./TirWhileStmt.js";
+import { isTirVarDecl } from "./TirVarDecl/TirVarDecl.js";
+export var Termination;
+(function (Termination) {
+    Termination[Termination["Conditinal"] = -1] = "Conditinal";
+    Termination[Termination["NoTermination"] = 0] = "NoTermination";
+    Termination[Termination["Return"] = 1] = "Return";
+    Termination[Termination["Fail"] = 2] = "Fail";
+})(Termination || (Termination = {}));
+Object.freeze(Termination);
+export function isTirStmt(thing) {
+    return isObject(thing) && (thing instanceof TirIfStmt
+        || isTirVarDecl(thing)
+        || thing instanceof TirForStmt
+        || thing instanceof TirForOfStmt
+        || thing instanceof TirWhileStmt
+        || thing instanceof TirReturnStmt
+        || thing instanceof TirBlockStmt
+        || thing instanceof TirBreakStmt
+        || thing instanceof TirContinueStmt
+        || thing instanceof TirFailStmt
+        || thing instanceof TirAssertStmt
+        // || thing instanceof TirTestStmt
+        || thing instanceof TirMatchStmt
+        || thing instanceof TirAssignmentStmt
+    // || thing instanceof TirExprStmt
+    );
+}

package/dist/compiler/tir/statements/TirVarDecl/TirArrayLikeDeconstr.d.ts

@@ -0,0 +1,17 @@
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../../expressions/TirExpr.js";
+import { TirType } from "../../types/TirType.js";
+import { ITirStmt } from "../TirStmt.js";
+import { TirVarDecl } from "./TirVarDecl.js";
+export declare class TirArrayLikeDeconstr implements ITirStmt {
+    readonly elements: TirVarDecl[];
+    readonly rest: string | undefined;
+    type: TirType;
+    initExpr: TirExpr | undefined;
+    isConst: boolean;
+    readonly range: SourceRange;
+    constructor(elements: TirVarDecl[], rest: string | undefined, type: TirType, initExpr: TirExpr | undefined, isConst: boolean, range: SourceRange);
+    deps(): string[];
+    definitelyTerminates(): boolean;
+    introducedVars(): string[];
+}

package/dist/compiler/tir/statements/TirVarDecl/TirArrayLikeDeconstr.js

@@ -0,0 +1,30 @@
+import { mergeSortedStrArrInplace } from "../../../../utils/array/mergeSortedStrArrInplace.js";
+export class TirArrayLikeDeconstr {
+    elements;
+    rest;
+    type;
+    initExpr;
+    isConst;
+    range;
+    constructor(elements, rest, type, initExpr, isConst, range) {
+        this.elements = elements;
+        this.rest = rest;
+        this.type = type;
+        this.initExpr = initExpr;
+        this.isConst = isConst;
+        this.range = range;
+    }
+    deps() {
+        return this.initExpr?.deps() ?? [];
+    }
+    definitelyTerminates() { return false; }
+    introducedVars() {
+        const introducedVars = [];
+        for (const element of this.elements) {
+            mergeSortedStrArrInplace(introducedVars, element.introducedVars());
+        }
+        if (this.rest)
+            mergeSortedStrArrInplace(introducedVars, [this.rest]);
+        return introducedVars;
+    }
+}

package/dist/compiler/tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.d.ts

@@ -0,0 +1,21 @@
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../../expressions/TirExpr.js";
+import { TirType } from "../../types/TirType.js";
+import { ITirStmt } from "../TirStmt.js";
+import { ITirVarDecl, TirVarDecl } from "./TirVarDecl.js";
+export declare class TirNamedDeconstructVarDecl implements ITirStmt, ITirVarDecl {
+    /** only original (not aliased) constr name used in destructuring */
+    readonly constrName: string;
+    readonly fields: Map<string, TirVarDecl>;
+    readonly rest: string | undefined;
+    readonly type: TirType;
+    initExpr: TirExpr | undefined;
+    isConst: boolean;
+    readonly range: SourceRange;
+    constructor(
+    /** only original (not aliased) constr name used in destructuring */
+    constrName: string, fields: Map<string, TirVarDecl>, rest: string | undefined, type: TirType, initExpr: TirExpr | undefined, isConst: boolean, range: SourceRange);
+    deps(): string[];
+    definitelyTerminates(): boolean;
+    introducedVars(): string[];
+}

package/dist/compiler/tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js

@@ -0,0 +1,34 @@
+import { mergeSortedStrArrInplace } from "../../../../utils/array/mergeSortedStrArrInplace.js";
+export class TirNamedDeconstructVarDecl {
+    constrName;
+    fields;
+    rest;
+    type;
+    initExpr;
+    isConst;
+    range;
+    constructor(
+    /** only original (not aliased) constr name used in destructuring */
+    constrName, fields, rest, type, initExpr, isConst, range) {
+        this.constrName = constrName;
+        this.fields = fields;
+        this.rest = rest;
+        this.type = type;
+        this.initExpr = initExpr;
+        this.isConst = isConst;
+        this.range = range;
+    }
+    deps() {
+        return this.initExpr?.deps() ?? [];
+    }
+    definitelyTerminates() { return false; }
+    introducedVars() {
+        const introducedVars = [];
+        for (const field of this.fields.values()) {
+            mergeSortedStrArrInplace(introducedVars, field.introducedVars());
+        }
+        if (this.rest)
+            mergeSortedStrArrInplace(introducedVars, [this.rest]);
+        return introducedVars;
+    }
+}

package/dist/compiler/tir/statements/TirVarDecl/TirSimpleVarDecl.d.ts

@@ -0,0 +1,17 @@
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../../expressions/TirExpr.js";
+import { TirType } from "../../types/TirType.js";
+import { ITirStmt } from "../TirStmt.js";
+import { ITirVarDecl } from "./TirVarDecl.js";
+export declare class TirSimpleVarDecl implements ITirStmt, ITirVarDecl {
+    readonly name: string;
+    readonly type: TirType;
+    initExpr: TirExpr | undefined;
+    isConst: boolean;
+    readonly range: SourceRange;
+    constructor(name: string, type: TirType, initExpr: TirExpr | undefined, // deconstructed OR function param
+    isConst: boolean, range: SourceRange);
+    deps(): string[];
+    definitelyTerminates(): boolean;
+    introducedVars(): string[];
+}

package/dist/compiler/tir/statements/TirVarDecl/TirSimpleVarDecl.js

@@ -0,0 +1,22 @@
+export class TirSimpleVarDecl {
+    name;
+    type;
+    initExpr;
+    isConst;
+    range;
+    constructor(name, type, initExpr, // deconstructed OR function param
+    isConst, range) {
+        this.name = name;
+        this.type = type;
+        this.initExpr = initExpr;
+        this.isConst = isConst;
+        this.range = range;
+    }
+    deps() {
+        return this.initExpr?.deps() ?? [];
+    }
+    definitelyTerminates() { return false; }
+    introducedVars() {
+        return [this.name];
+    }
+}