npm - @harmoniclabs/pebble - Versions diffs - 0.1.0-dev5 → 0.1.0-dev6 - Mend

@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (307) hide show

package/dist/compiler/tir/program/stdScope/stdScope.js CHANGED Viewed

@@ -354,6 +354,127 @@ export function populatePreludeScope(program) {
             proposal: proposalProcedure_t
         }
     }, onlyData);
+    // struct Vote {
+    //     No {}
+    //     Yes {}
+    //     Abstain {}
+    // }
+    const { data: vote_t } = defineMultiConstructorStruct("Vote", {
+        No: {},
+        Yes: {},
+        Abstain: {}
+    }, onlyData);
+    // struct Delegatee {
+    //     StakePool { poolKeyHash: PubKeyHash }
+    //     DRep { drep: Credential }
+    //     PoolAndDRep {
+    //         poolKeyHash: PubKeyHash,
+    //         drep: Credential
+    //     }
+    // }
+    const { data: delegatee_t } = defineMultiConstructorStruct("Delegatee", {
+        StakePool: {
+            poolKeyHash: pubKeyHash_t
+        },
+        DRep: {
+            drep: credential_t
+        },
+        PoolAndDRep: {
+            poolKeyHash: pubKeyHash_t,
+            drep: credential_t
+        }
+    }, onlyData);
+    // struct Certificate {
+    //     StakeRegistration {
+    //         stakeKey: Credential,
+    //         deposit: Optional<int>
+    //     }
+    //     StakeDeRegistration {
+    //         stakeKey: Credential,
+    //         refund: Optional<int>
+    //     }
+    //     Delegation {
+    //         delegator: Credential,
+    //         delegatee: Delegatee
+    //     }
+    //     RegistrationAndDelegation {
+    //         delegator: Credential,
+    //         delegatee: Delegatee,
+    //         lovelacesDeposit: int
+    //     }
+    //     DRepRegistration {
+    //         drep: Credential,
+    //         lovelacesDeposit: int
+    //     }
+    //     DRepUpdate {
+    //         drep: Credential
+    //     }
+    //     DRepDeRegistration {
+    //         drep: Credential,
+    //         refund: int
+    //     }
+    //     PoolRegistration {
+    //         poolId: PubKeyHash,
+    //         poolVRF: PubKeyHash
+    //     }
+    //     PoolRetire {
+    //         poolId: PubKeyHash,
+    //         epoch: int
+    //     }
+    //     CommitteeHotAuthorization {
+    //         cold: Credential,
+    //         hot: Credential
+    //     }
+    //     CommitteeResignation {
+    //         cold: Credential
+    //     }
+    // }
+    const opt_int_t = program.getAppliedGeneric(TirDataOptT.toTirTypeKey(), [int_t]);
+    if (!opt_int_t)
+        throw new Error("expected opt_int_t");
+    const { data: certificate_t } = defineMultiConstructorStruct("Certificate", {
+        StakeRegistration: {
+            stakeKey: credential_t,
+            deposit: opt_int_t
+        },
+        StakeDeRegistration: {
+            stakeKey: credential_t,
+            refund: opt_int_t
+        },
+        Delegation: {
+            delegator: credential_t,
+            delegatee: delegatee_t
+        },
+        RegistrationAndDelegation: {
+            delegator: credential_t,
+            delegatee: delegatee_t,
+            lovelacesDeposit: int_t
+        },
+        DRepRegistration: {
+            drep: credential_t,
+            lovelacesDeposit: int_t
+        },
+        DRepUpdate: {
+            drep: credential_t
+        },
+        DRepDeRegistration: {
+            drep: credential_t,
+            refund: int_t
+        },
+        PoolRegistration: {
+            poolId: pubKeyHash_t,
+            poolVRF: bytes_t
+        },
+        PoolRetire: {
+            poolId: pubKeyHash_t,
+            epoch: int_t
+        },
+        CommitteeHotAuthorization: {
+            cold: credential_t,
+            hot: credential_t
+        },
+        CommitteeResignation: { cold: credential_t }
+    }, onlyData);
     // struct ScriptInfo {
     //     Mint { policy: PolicyId }
     //     Spend {
@@ -390,14 +511,14 @@ export function populatePreludeScope(program) {
             credential: credential_t
         },
         Certificate: {
-            index: int_t,
-            certificate: credential_t
+            certificateIndex: int_t,
+            certificate: certificate_t
         },
         Vote: {
             voter: voter_t
         },
         Propose: {
-            index: int_t,
+            proposalIndex: int_t,
             proposal: proposalProcedure_t
         }
     }, onlyData);
@@ -501,7 +622,7 @@ export function populatePreludeScope(program) {
     //     resolved: TxOut
     // }
     const { data: txIn_t } = defineSingleConstructorStruct("TxIn", {
-        txOutRef: txOutRef_t,
+        ref: txOutRef_t,
         resolved: txOut_t
     }, onlyData);
     // struct ExtendedInteger {
@@ -532,127 +653,6 @@ export function populatePreludeScope(program) {
         from: intervalBoundary_t,
         to: intervalBoundary_t
     }, onlyData);
-    // struct Vote {
-    //     No {}
-    //     Yes {}
-    //     Abstain {}
-    // }
-    const { data: vote_t } = defineMultiConstructorStruct("Vote", {
-        No: {},
-        Yes: {},
-        Abstain: {}
-    }, onlyData);
-    // struct Delegatee {
-    //     StakePool { poolKeyHash: PubKeyHash }
-    //     DRep { drep: Credential }
-    //     PoolAndDRep {
-    //         poolKeyHash: PubKeyHash,
-    //         drep: Credential
-    //     }
-    // }
-    const { data: delegatee_t } = defineMultiConstructorStruct("Delegatee", {
-        StakePool: {
-            poolKeyHash: pubKeyHash_t
-        },
-        DRep: {
-            drep: credential_t
-        },
-        PoolAndDRep: {
-            poolKeyHash: pubKeyHash_t,
-            drep: credential_t
-        }
-    }, onlyData);
-    // struct Certificate {
-    //     StakeRegistration {
-    //         stakeKey: Credential,
-    //         deposit: Optional<int>
-    //     }
-    //     StakeDeRegistration {
-    //         stakeKey: Credential,
-    //         refund: Optional<int>
-    //     }
-    //     Delegation {
-    //         delegator: Credential,
-    //         delegatee: Delegatee
-    //     }
-    //     RegistrationAndDelegation {
-    //         delegator: Credential,
-    //         delegatee: Delegatee,
-    //         lovelacesDeposit: int
-    //     }
-    //     DRepRegistration {
-    //         drep: Credential,
-    //         lovelacesDeposit: int
-    //     }
-    //     DRepUpdate {
-    //         drep: Credential
-    //     }
-    //     DRepDeRegistration {
-    //         drep: Credential,
-    //         refund: int
-    //     }
-    //     PoolRegistration {
-    //         poolId: PubKeyHash,
-    //         poolVRF: PubKeyHash
-    //     }
-    //     PoolRetire {
-    //         poolId: PubKeyHash,
-    //         epoch: int
-    //     }
-    //     CommitteeHotAuthorization {
-    //         cold: Credential,
-    //         hot: Credential
-    //     }
-    //     CommitteeResignation {
-    //         cold: Credential
-    //     }
-    // }
-    const opt_int_t = program.getAppliedGeneric(TirDataOptT.toTirTypeKey(), [int_t]);
-    if (!opt_int_t)
-        throw new Error("expected opt_int_t");
-    const { data: certificate_t } = defineMultiConstructorStruct("Certificate", {
-        StakeRegistration: {
-            stakeKey: credential_t,
-            deposit: opt_int_t
-        },
-        StakeDeRegistration: {
-            stakeKey: credential_t,
-            refund: opt_int_t
-        },
-        Delegation: {
-            delegator: credential_t,
-            delegatee: delegatee_t
-        },
-        RegistrationAndDelegation: {
-            delegator: credential_t,
-            delegatee: delegatee_t,
-            lovelacesDeposit: int_t
-        },
-        DRepRegistration: {
-            drep: credential_t,
-            lovelacesDeposit: int_t
-        },
-        DRepUpdate: {
-            drep: credential_t
-        },
-        DRepDeRegistration: {
-            drep: credential_t,
-            refund: int_t
-        },
-        PoolRegistration: {
-            poolId: pubKeyHash_t,
-            poolVRF: bytes_t
-        },
-        PoolRetire: {
-            poolId: pubKeyHash_t,
-            epoch: int_t
-        },
-        CommitteeHotAuthorization: {
-            cold: credential_t,
-            hot: credential_t
-        },
-        CommitteeResignation: { cold: credential_t }
-    }, onlyData);
     // struct Tx {
     //     inputs: List<TxIn>,
     //     refInputs: List<TxIn>,
@@ -726,5 +726,5 @@ export function populatePreludeScope(program) {
         redeemer: data_t,
         purpose: scriptInfo_t
     }, onlyData);
-    preludeScope.readonly();
+    // preludeScope.readonly();
 }

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

@@ -12,6 +12,8 @@ export declare class TirAssertStmt implements ITirStmt {
     condition: TirExpr,
     /** must be string */
     elseExpr: TirExpr | undefined, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
     toSafeCondition(): TirExpr;

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

@@ -13,6 +13,16 @@ export class TirAssertStmt {
         this.elseExpr = elseExpr;
         this.range = range;
     }
+    toString() {
+        return (`assert ${this.condition.toString()}` +
+            (this.elseExpr ? ` else ${this.elseExpr.toString()}` : ""));
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return (`assert ${this.condition.pretty(indent)}` +
+            (this.elseExpr ? ` else ${this.elseExpr.pretty(indent)}` : ""));
+    }
     definitelyTerminates() { return false; }
     deps() {
         const deps = this.condition.deps();

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

@@ -7,6 +7,8 @@ export declare class TirAssignmentStmt implements ITirStmt {
     readonly assignedExpr: TirExpr;
     readonly range: SourceRange;
     constructor(varIdentifier: TirVariableAccessExpr, assignedExpr: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

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

@@ -7,6 +7,14 @@ export class TirAssignmentStmt {
         this.assignedExpr = assignedExpr;
         this.range = range;
     }
+    toString() {
+        return `${this.varIdentifier.toString()} = ${this.assignedExpr.toString()};`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `${this.varIdentifier.pretty(indent)} = ${this.assignedExpr.pretty(indent)}`;
+    }
     definitelyTerminates() { return false; }
     deps() {
         return this.varIdentifier.deps();

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

@@ -4,6 +4,8 @@ export declare class TirBlockStmt implements ITirStmt {
     stmts: TirStmt[];
     readonly range: SourceRange;
     constructor(stmts: TirStmt[], range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

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

@@ -8,6 +8,22 @@ export class TirBlockStmt {
         this.stmts = stmts;
         this.range = range;
     }
+    toString() {
+        return (`{ ` +
+            this.stmts.map(s => s.toString()).join("; ") +
+            `}`);
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        if (this.stmts.length === 0)
+            return `${indent_0}{ }`;
+        return (`{` +
+            "\n" + indent_1 + this.stmts.map(s => s.pretty(indent + 1)).join(`;${indent_1}`) +
+            `${indent_0}}`);
+    }
     definitelyTerminates() {
         return this.stmts.some(stmt => stmt.definitelyTerminates());
     }

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

@@ -3,6 +3,8 @@ import { ITirStmt } from "./TirStmt.js";
 export declare class TirBreakStmt implements ITirStmt {
     readonly range: SourceRange;
     constructor(range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

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

@@ -3,6 +3,14 @@ export class TirBreakStmt {
     constructor(range) {
         this.range = range;
     }
+    toString() {
+        return `break`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `break`;
+    }
     // loops are transoformed into recursive functions
     // and break statements are transformed into return statements
     // so this statement does terminate the function

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

@@ -3,6 +3,8 @@ import { ITirStmt } from "./TirStmt.js";
 export declare class TirContinueStmt implements ITirStmt {
     readonly range: SourceRange;
     constructor(range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

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

@@ -3,6 +3,14 @@ export class TirContinueStmt {
     constructor(range) {
         this.range = range;
     }
+    toString() {
+        return `continue`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `continue`;
+    }
     // loops are transoformed into recursive functions
     // and continue statements are transformed into return statements
     // so this statement does terminate the function

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

@@ -8,6 +8,8 @@ export declare class TirFailStmt implements ITirStmt {
     constructor(
     /** must be string (or utf8 bytes) */
     failMsgExpr: TirExpr | undefined, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

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

@@ -7,6 +7,14 @@ export class TirFailStmt {
         this.failMsgExpr = failMsgExpr;
         this.range = range;
     }
+    toString() {
+        return `fail${this.failMsgExpr ? ` ${this.failMsgExpr.toString()}` : ""}`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `fail${this.failMsgExpr ? ` ${this.failMsgExpr.pretty(indent)}` : ""}`;
+    }
     definitelyTerminates() { return true; }
     deps() {
         return this.failMsgExpr?.deps() ?? [];

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

@@ -11,6 +11,8 @@ export declare class TirForOfStmt implements ITirStmt {
     body: TirStmt;
     readonly range: SourceRange;
     constructor(elemDeclaration: TirVarDecl, iterable: TirExpr, body: TirStmt, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

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

@@ -14,6 +14,20 @@ export class TirForOfStmt {
         this.body = body;
         this.range = range;
     }
+    toString() {
+        return (`for( ${this.elemDeclaration.toString()} of ${this.iterable.toString()} ) ` +
+            this.body.toString());
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        return (`for(` +
+            indent_1 + this.elemDeclaration.pretty(indent + 1) + ` of ` + this.iterable.pretty(indent + 1) +
+            `${indent_0}) ` +
+            this.body.pretty(indent));
+    }
     definitelyTerminates() {
         return this.body.definitelyTerminates();
     }

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

@@ -14,6 +14,8 @@ export declare class TirForStmt implements ITirStmt {
     body: TirStmt;
     readonly range: SourceRange;
     constructor(init: TirSimpleVarDecl[], condition: TirExpr | undefined, update: TirStmt[] | undefined, body: TirStmt, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

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

@@ -18,6 +18,27 @@ export class TirForStmt {
         this.body = body;
         this.range = range;
     }
+    toString() {
+        return (`for( ${this.init.map(v => v.toString()).join(", ")}; ` +
+            `${this.condition?.toString() ?? ""}; ` +
+            `${this.update?.map(s => s.toString()).join(", ") ?? ""} ) ` +
+            `${this.body.toString()}`);
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        const initPart = this.init.map(v => v.pretty(indent + 1)).join(`,${indent_1}`);
+        const condPart = this.condition ? this.condition.pretty(indent + 1) : "";
+        const updatePart = (this.update ?? []).map(s => s.pretty(indent + 1)).join(`,${indent_1}`);
+        return (`for(` +
+            indent_1 + initPart + `;` +
+            indent_1 + condPart + `;` +
+            indent_1 + updatePart +
+            `${indent_0}) ` +
+            this.body.pretty(indent));
+    }
     definitelyTerminates() {
         return this.body.definitelyTerminates() || (this.update?.some(stmt => stmt.definitelyTerminates()) ?? false);
     }

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

@@ -6,7 +6,10 @@ export declare class TirIfStmt implements ITirStmt {
     thenBranch: TirStmt;
     elseBranch: TirStmt | undefined;
     readonly range: SourceRange;
+    private _creationStack?;
     constructor(condition: TirExpr, thenBranch: TirStmt, elseBranch: TirStmt | undefined, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

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

@@ -4,13 +4,32 @@ export class TirIfStmt {
     thenBranch;
     elseBranch;
     range;
+    _creationStack;
     constructor(condition, thenBranch, elseBranch, range) {
         this.condition = condition;
         this.thenBranch = thenBranch;
         this.elseBranch = elseBranch;
         this.range = range;
+        this._creationStack = new Error().stack;
+    }
+    toString() {
+        return (`if( ${this.condition.toString()} ) ` +
+            this.thenBranch.toString() +
+            (this.elseBranch ? ` else ${this.elseBranch.toString()}` : ``));
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        return (`if(` +
+            indent_1 + this.condition.pretty(indent + 1) +
+            `${indent_0}) ` +
+            this.thenBranch.pretty(indent) +
+            (this.elseBranch ? ` else ${this.elseBranch.pretty(indent)}` : ""));
     }
     definitelyTerminates() {
+        console.log(this._creationStack);
         return (this.thenBranch.definitelyTerminates()
             && (this.elseBranch?.definitelyTerminates() ?? false));
     }

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

@@ -9,6 +9,8 @@ export declare class TirMatchStmt implements ITirStmt {
     wildcardCase: TirMatchStmtWildcardCase | undefined;
     readonly range: SourceRange;
     constructor(matchExpr: TirExpr, cases: TirMatchStmtCase[], wildcardCase: TirMatchStmtWildcardCase | undefined, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

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

@@ -11,6 +11,36 @@ export class TirMatchStmt {
         this.wildcardCase = wildcardCase;
         this.range = range;
     }
+    toString() {
+        return (`match ( ${this.matchExpr.toString()} ) { ` +
+            this.cases.map(c => `when ${c.pattern.toString()}: ${c.body.toString()};`).join(" ") +
+            (this.wildcardCase ? ` else ${this.wildcardCase.body.toString()};` : "") +
+            ` }`);
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        const caseParts = this.cases.map(c => `when ${c.pattern.pretty(indent + 1)}: ${c.body.pretty(indent + 1)}`);
+        const casesPart = caseParts.length > 0
+            ? indent_1 + caseParts.join(`;${indent_1}`) + ";"
+            : "";
+        const wildcardPart = this.wildcardCase
+            ? indent_1 + `else ${this.wildcardCase.body.pretty(indent + 1)};`
+            : "";
+        if (caseParts.length === 0 && !this.wildcardCase) {
+            return (`match (` +
+                indent_1 + this.matchExpr.pretty(indent + 1) +
+                `${indent_0}) { }`);
+        }
+        return (`match (` +
+            indent_1 + this.matchExpr.pretty(indent + 1) +
+            `${indent_0}) {` +
+            casesPart +
+            wildcardPart +
+            `${indent_0}}`);
+    }
     definitelyTerminates() {
         return this.cases.every(({ body }) => body.definitelyTerminates());
     }

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

@@ -5,6 +5,8 @@ export declare class TirReturnStmt implements ITirStmt {
     value: TirExpr;
     readonly range: SourceRange;
     constructor(value: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

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

@@ -5,6 +5,14 @@ export class TirReturnStmt {
         this.value = value;
         this.range = range;
     }
+    toString() {
+        return `return ${this.value?.toString() ?? ""}`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `return ${this.value.pretty(indent)}`;
+    }
     definitelyTerminates() { return true; }
     deps() {
         return this.value?.deps() ?? [];

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

@@ -27,6 +27,8 @@ export interface ITirStmt extends HasSourceRange {
      * or a non-conditional fail statement (which terminates the entire program)
      */
     definitelyTerminates: () => boolean;
+    toString: () => string;
+    pretty: (indent: number) => string;
 }
 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/TirVarDecl/TirArrayLikeDeconstr.d.ts CHANGED Viewed

@@ -11,6 +11,8 @@ export declare class TirArrayLikeDeconstr implements ITirStmt {
     isConst: boolean;
     readonly range: SourceRange;
     constructor(elements: TirVarDecl[], rest: string | undefined, type: TirType, initExpr: TirExpr | undefined, isConst: boolean, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     deps(): string[];
     definitelyTerminates(): boolean;
     introducedVars(): string[];