@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev6

package/dist/ast/nodes/expr/CaseExpr.d.ts

@@ -3,20 +3,20 @@ import { VarDecl } from "../statements/declarations/VarDecl/VarDecl.js";
 import { HasSourceRange } from "../HasSourceRange.js";
 import { PebbleExpr } from "./PebbleExpr.js";
 export declare class CaseExpr implements HasSourceRange {
-    readonly matchExpr: PebbleExpr;
-    readonly cases: CaseExprMatcher[];
-    readonly wildcardCase: CaseWildcardMatcher | undefined;
+    matchExpr: PebbleExpr;
+    cases: CaseExprMatcher[];
+    wildcardCase: CaseWildcardMatcher | undefined;
     readonly range: SourceRange;
     constructor(matchExpr: PebbleExpr, cases: CaseExprMatcher[], wildcardCase: CaseWildcardMatcher | undefined, range: SourceRange);
 }
 export declare class CaseExprMatcher implements HasSourceRange {
     readonly pattern: VarDecl;
-    readonly body: PebbleExpr;
+    body: PebbleExpr;
     readonly range: SourceRange;
     constructor(pattern: VarDecl, body: PebbleExpr, range: SourceRange);
 }
 export declare class CaseWildcardMatcher implements HasSourceRange {
-    readonly body: PebbleExpr;
+    body: PebbleExpr;
     readonly range: SourceRange;
     constructor(body: PebbleExpr, range: SourceRange);
 }

package/dist/ast/nodes/expr/ElemAccessExpr.d.ts

@@ -5,8 +5,8 @@ import { PebbleExpr } from "./PebbleExpr.js";
  * `arrLikeExpr[ indexExpr ]`
  */
 export declare class ElemAccessExpr implements HasSourceRange {
-    readonly arrLikeExpr: PebbleExpr;
-    readonly indexExpr: PebbleExpr;
+    arrLikeExpr: PebbleExpr;
+    indexExpr: PebbleExpr;
     readonly range: SourceRange;
     constructor(arrLikeExpr: PebbleExpr, indexExpr: PebbleExpr, range: SourceRange);
 }

package/dist/ast/nodes/expr/ParentesizedExpr.d.ts

@@ -2,7 +2,7 @@ import { SourceRange } from "../../Source/SourceRange.js";
 import { HasSourceRange } from "../HasSourceRange.js";
 import { PebbleExpr } from "./PebbleExpr.js";
 export declare class ParentesizedExpr implements HasSourceRange {
-    readonly expr: PebbleExpr;
+    expr: PebbleExpr;
     readonly range: SourceRange;
     constructor(expr: PebbleExpr, range: SourceRange);
 }

package/dist/ast/nodes/expr/PebbleExpr.d.ts

@@ -5,6 +5,7 @@ import { FuncExpr } from "./functions/FuncExpr.js";
 import { LitteralExpr } from "./litteral/LitteralExpr.js";
 import { NonNullExpr } from "./unary/NonNullExpr.js";
 import { ParentesizedExpr } from "./ParentesizedExpr.js";
+import { PropAccessExpr } from "./PropAccessExpr.js";
 import { TernaryExpr } from "./TernaryExpr.js";
 import { TypeConversionExpr } from "./TypeConversionExpr.js";
 import { UnaryPrefixExpr } from "./unary/UnaryPrefixExpr.js";
@@ -14,5 +15,5 @@ import { BinaryExpr } from "./binary/BinaryExpr.js";
  * an expression is anything that can be evaluated to a value
  * it must therefore have a type
  */
-export type PebbleExpr = UnaryPrefixExpr | NonNullExpr | LitteralExpr | ParentesizedExpr | FuncExpr | CallExpr | CaseExpr | TypeConversionExpr | NonNullExpr | ElemAccessExpr | TernaryExpr | Identifier | BinaryExpr;
+export type PebbleExpr = UnaryPrefixExpr | NonNullExpr | LitteralExpr | ParentesizedExpr | FuncExpr | CallExpr | CaseExpr | TypeConversionExpr | NonNullExpr | ElemAccessExpr | TernaryExpr | Identifier | BinaryExpr | PropAccessExpr;
 export declare function isPebbleExpr(thing: any): thing is PebbleExpr;

package/dist/ast/nodes/expr/PropAccessExpr.d.ts

@@ -9,19 +9,19 @@ export type PropAccessTokenToExpr<T extends PropAccessToken> = T extends Token.Q
 export declare function makePropAccessExpr<T extends PropAccessToken>(token: T, object: PebbleExpr, prop: Identifier, range: SourceRange): PropAccessTokenToExpr<T>;
 export declare function isPropAccessExpr(thing: any): thing is PropAccessExpr;
 export declare class OptionalPropAccessExpr implements HasSourceRange {
-    readonly object: PebbleExpr;
+    object: PebbleExpr;
     readonly prop: Identifier;
     readonly range: SourceRange;
     constructor(object: PebbleExpr, prop: Identifier, range: SourceRange);
 }
 export declare class NonNullPropAccessExpr implements HasSourceRange {
-    readonly object: PebbleExpr;
+    object: PebbleExpr;
     readonly prop: Identifier;
     readonly range: SourceRange;
     constructor(object: PebbleExpr, prop: Identifier, range: SourceRange);
 }
 export declare class DotPropAccessExpr implements HasSourceRange {
-    readonly object: PebbleExpr;
+    object: PebbleExpr;
     readonly prop: Identifier;
     readonly range: SourceRange;
     constructor(object: PebbleExpr, prop: Identifier, range: SourceRange);

package/dist/ast/nodes/expr/TernaryExpr.d.ts

@@ -2,9 +2,9 @@ import { SourceRange } from "../../Source/SourceRange.js";
 import { HasSourceRange } from "../HasSourceRange.js";
 import { PebbleExpr } from "./PebbleExpr.js";
 export declare class TernaryExpr implements HasSourceRange {
-    readonly condition: PebbleExpr;
-    readonly ifTrue: PebbleExpr;
-    readonly ifFalse: PebbleExpr;
+    condition: PebbleExpr;
+    ifTrue: PebbleExpr;
+    ifFalse: PebbleExpr;
     readonly range: SourceRange;
     constructor(condition: PebbleExpr, ifTrue: PebbleExpr, ifFalse: PebbleExpr, range: SourceRange);
 }

package/dist/ast/nodes/expr/TypeConversionExpr.d.ts

@@ -3,8 +3,9 @@ import { HasSourceRange } from "../HasSourceRange.js";
 import { AstTypeExpr } from "../types/AstTypeExpr.js";
 import { PebbleExpr } from "./PebbleExpr.js";
 export declare class TypeConversionExpr implements HasSourceRange {
-    readonly expr: PebbleExpr;
+    expr: PebbleExpr;
     readonly asType: AstTypeExpr;
     readonly range: SourceRange;
+    private _creationStack;
     constructor(expr: PebbleExpr, asType: AstTypeExpr, range?: SourceRange);
 }

package/dist/ast/nodes/expr/TypeConversionExpr.js

@@ -3,9 +3,11 @@ export class TypeConversionExpr {
     expr;
     asType;
     range;
+    _creationStack;
     constructor(expr, asType, range = SourceRange.join(expr.range, asType.range)) {
         this.expr = expr;
         this.asType = asType;
         this.range = range;
+        this._creationStack = new Error().stack;
     }
 }

package/dist/ast/nodes/expr/binary/BinaryExpr.d.ts

@@ -8,126 +8,126 @@ export type BinaryTokenToExpr<T extends BinaryExprToken> = T extends Token.Aster
 export declare function makeBinaryExpr<T extends BinaryExprToken>(token: T, left: PebbleExpr, right: PebbleExpr, range: SourceRange): BinaryTokenToExpr<T>;
 export declare function isBinaryExpr(thing: any): thing is BinaryExpr;
 export interface IBinaryExpr extends HasSourceRange {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
 }
 export declare class ExponentiationExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class LessThanExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class GreaterThanExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class LessThanEqualExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class GreaterThanEqualExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class EqualExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class NotEqualExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class AddExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class SubExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class MultExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class DivExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class ModuloExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class ShiftLeftExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class ShiftRightExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class BitwiseAndExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class BitwiseXorExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class BitwiseOrExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class LogicalAndExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class LogicalOrExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }
 export declare class OptionalDefaultExpr implements IBinaryExpr {
-    readonly left: PebbleExpr;
-    readonly right: PebbleExpr;
+    left: PebbleExpr;
+    right: PebbleExpr;
     readonly range: SourceRange;
     constructor(left: PebbleExpr, right: PebbleExpr, range: SourceRange);
 }

package/dist/ast/nodes/expr/functions/CallExpr.d.ts

@@ -4,7 +4,7 @@ import { AstTypeExpr } from "../../types/AstTypeExpr.js";
 import { PebbleExpr } from "../PebbleExpr.js";
 export declare class CallExpr implements HasSourceRange {
     /** any expression that yeidls a function */
-    readonly funcExpr: PebbleExpr;
+    funcExpr: PebbleExpr;
     /** if the function is generic */
     readonly genericTypeArgs: AstTypeExpr[] | undefined;
     readonly args: PebbleExpr[];

package/dist/ast/nodes/expr/functions/FuncExpr.d.ts

@@ -14,8 +14,9 @@ export declare class FuncExpr implements HasSourceRange {
     readonly flags: CommonFlags;
     readonly typeParams: Identifier[];
     readonly signature: AstFuncType;
-    readonly body: BlockStmt | PebbleExpr;
+    body: BlockStmt | PebbleExpr;
     readonly arrowKind: ArrowKind;
     readonly range: SourceRange;
     constructor(name: Identifier, flags: CommonFlags, typeParams: Identifier[], signature: AstFuncType, body: BlockStmt | PebbleExpr, arrowKind: ArrowKind, range: SourceRange);
+    bodyBlockStmt(): BlockStmt;
 }

package/dist/ast/nodes/expr/functions/FuncExpr.js

@@ -1,3 +1,5 @@
+import { BlockStmt } from "../../statements/BlockStmt.js";
+import { ReturnStmt } from "../../statements/ReturnStmt.js";
 /**
  * a litteral function value
 **/
@@ -18,4 +20,8 @@ export class FuncExpr {
         this.arrowKind = arrowKind;
         this.range = range;
     }
+    bodyBlockStmt() {
+        return (this.body instanceof BlockStmt ? this.body :
+            new BlockStmt([new ReturnStmt(this.body, this.body.range)], this.body.range));
+    }
 }

package/dist/ast/nodes/expr/litteral/LitContextExpr.d.ts

@@ -0,0 +1,6 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+export declare class LitContextExpr implements HasSourceRange {
+    readonly range: SourceRange;
+    constructor(range: SourceRange);
+}

package/dist/ast/nodes/expr/litteral/LitContextExpr.js

@@ -0,0 +1,6 @@
+export class LitContextExpr {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitFailExpr.d.ts

@@ -0,0 +1,6 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+export declare class LitFailExpr implements HasSourceRange {
+    readonly range: SourceRange;
+    constructor(range: SourceRange);
+}

package/dist/ast/nodes/expr/litteral/LitFailExpr.js

@@ -0,0 +1,6 @@
+export class LitFailExpr {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitteralExpr.d.ts

@@ -1,4 +1,6 @@
 import { LitArrExpr } from "./LitArrExpr.js";
+import { LitContextExpr } from "./LitContextExpr.js";
+import { LitFailExpr } from "./LitFailExpr.js";
 import { LitFalseExpr } from "./LitFalseExpr.js";
 import { LitHexBytesExpr } from "./LitHexBytesExpr.js";
 import { LitIntExpr } from "./LitIntExpr.js";
@@ -9,5 +11,5 @@ import { LitThisExpr } from "./LitThisExpr.js";
 import { LitTrueExpr } from "./LitTrueExpr.js";
 import { LitUndefExpr } from "./LitUndefExpr.js";
 import { LitVoidExpr } from "./LitVoidExpr.js";
-export type LitteralExpr = LitVoidExpr | LitUndefExpr | LitTrueExpr | LitFalseExpr | LitThisExpr | LitArrExpr | LitObjExpr | LitNamedObjExpr | LitStrExpr | LitIntExpr | LitHexBytesExpr;
+export type LitteralExpr = LitVoidExpr | LitUndefExpr | LitTrueExpr | LitFalseExpr | LitThisExpr | LitContextExpr | LitArrExpr | LitObjExpr | LitNamedObjExpr | LitStrExpr | LitIntExpr | LitHexBytesExpr | LitFailExpr;
 export declare function isLitteralExpr(thing: any): thing is LitteralExpr;

package/dist/ast/nodes/expr/litteral/LitteralExpr.js

@@ -1,4 +1,6 @@
 import { LitArrExpr } from "./LitArrExpr.js";
+import { LitContextExpr } from "./LitContextExpr.js";
+import { LitFailExpr } from "./LitFailExpr.js";
 import { LitFalseExpr } from "./LitFalseExpr.js";
 import { LitHexBytesExpr } from "./LitHexBytesExpr.js";
 import { LitIntExpr } from "./LitIntExpr.js";
@@ -15,10 +17,12 @@ export function isLitteralExpr(thing) {
         || thing instanceof LitTrueExpr
         || thing instanceof LitFalseExpr
         || thing instanceof LitThisExpr
+        || thing instanceof LitContextExpr
         || thing instanceof LitArrExpr
         || thing instanceof LitObjExpr
         || thing instanceof LitNamedObjExpr
         || thing instanceof LitStrExpr
         || thing instanceof LitIntExpr
-        || thing instanceof LitHexBytesExpr);
+        || thing instanceof LitHexBytesExpr
+        || thing instanceof LitFailExpr);
 }

package/dist/ast/nodes/statements/AssertStmt.d.ts

@@ -3,9 +3,9 @@ import { PebbleExpr } from "../expr/PebbleExpr.js";
 import { HasSourceRange } from "../HasSourceRange.js";
 export declare class AssertStmt implements HasSourceRange {
     /** must be boolean or Optional */
-    readonly condition: PebbleExpr;
+    condition: PebbleExpr;
     /** must be string */
-    readonly elseExpr: PebbleExpr | undefined;
+    elseExpr: PebbleExpr | undefined;
     readonly range: SourceRange;
     constructor(
     /** must be boolean or Optional */

package/dist/ast/nodes/statements/AssignmentStmt.d.ts

@@ -39,7 +39,7 @@ export declare class SubAssignmentStmt implements IAssignmentStmt {
 }
 export declare class ExpAssignmentStmt implements IAssignmentStmt {
     readonly varIdentifier: Identifier;
-    readonly assignedExpr: PebbleExpr;
+    assignedExpr: PebbleExpr;
     readonly range: SourceRange;
     constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
 }

package/dist/ast/nodes/statements/BlockStmt.d.ts

@@ -2,7 +2,7 @@ import { SourceRange } from "../../Source/SourceRange.js";
 import { HasSourceRange } from "../HasSourceRange.js";
 import { BodyStmt } from "./PebbleStmt.js";
 export declare class BlockStmt implements HasSourceRange {
-    readonly stmts: BodyStmt[];
+    stmts: BodyStmt[];
     readonly range: SourceRange;
     constructor(stmts: BodyStmt[], range: SourceRange);
 }

package/dist/ast/nodes/statements/FailStmt.d.ts

@@ -3,7 +3,7 @@ import { PebbleExpr } from "../expr/PebbleExpr.js";
 import { HasSourceRange } from "../HasSourceRange.js";
 export declare class FailStmt implements HasSourceRange {
     /** must be string (or utf8 bytes) */
-    readonly value: PebbleExpr | undefined;
+    value: PebbleExpr | undefined;
     readonly range: SourceRange;
     constructor(
     /** must be string (or utf8 bytes) */

package/dist/ast/nodes/statements/ForOfStmt.d.ts

@@ -2,6 +2,7 @@ import { PebbleAst } from "../../PebbleAst.js";
 import { SourceRange } from "../../Source/SourceRange.js";
 import { PebbleExpr } from "../expr/PebbleExpr.js";
 import { HasSourceRange } from "../HasSourceRange.js";
+import { BlockStmt } from "./BlockStmt.js";
 import { VarDecl } from "./declarations/VarDecl/VarDecl.js";
 import { VarStmt } from "./VarStmt.js";
 /**
@@ -9,8 +10,9 @@ import { VarStmt } from "./VarStmt.js";
  */
 export declare class ForOfStmt implements HasSourceRange {
     readonly elemDeclaration: VarStmt<[VarDecl]>;
-    readonly iterable: PebbleExpr;
-    readonly body: PebbleAst;
+    iterable: PebbleExpr;
+    body: PebbleAst;
     readonly range: SourceRange;
     constructor(elemDeclaration: VarStmt<[VarDecl]>, iterable: PebbleExpr, body: PebbleAst, range: SourceRange);
+    bodyBlock(): BlockStmt;
 }

package/dist/ast/nodes/statements/ForOfStmt.js

@@ -1,3 +1,4 @@
+import { BlockStmt } from "./BlockStmt.js";
 /**
  * for( `elemDeclaration` of iterable ) body
  */
@@ -12,4 +13,9 @@ export class ForOfStmt {
         this.body = body;
         this.range = range;
     }
+    bodyBlock() {
+        if (this.body instanceof BlockStmt)
+            return this.body;
+        return new BlockStmt([this.body], this.body.range);
+    }
 }

package/dist/ast/nodes/statements/ForStmt.d.ts

@@ -2,6 +2,7 @@ import { SourceRange } from "../../Source/SourceRange.js";
 import { PebbleExpr } from "../expr/PebbleExpr.js";
 import { HasSourceRange } from "../HasSourceRange.js";
 import { AssignmentStmt } from "./AssignmentStmt.js";
+import { BlockStmt } from "./BlockStmt.js";
 import { BodyStmt } from "./PebbleStmt.js";
 import { VarStmt } from "./VarStmt.js";
 /**
@@ -10,10 +11,11 @@ import { VarStmt } from "./VarStmt.js";
  * for( init; condition; update ) body
  */
 export declare class ForStmt implements HasSourceRange {
-    readonly init: VarStmt | undefined;
-    readonly condition: PebbleExpr | undefined;
-    readonly updates: AssignmentStmt[];
-    readonly body: BodyStmt;
+    init: VarStmt | undefined;
+    condition: PebbleExpr | undefined;
+    updates: AssignmentStmt[];
+    body: BodyStmt;
     readonly range: SourceRange;
     constructor(init: VarStmt | undefined, condition: PebbleExpr | undefined, updates: AssignmentStmt[], body: BodyStmt, range: SourceRange);
+    bodyBlock(): BlockStmt;
 }

package/dist/ast/nodes/statements/ForStmt.js

@@ -1,3 +1,4 @@
+import { BlockStmt } from "./BlockStmt.js";
 /**
  * ***NOT*** for...of loop
  *
@@ -16,4 +17,9 @@ export class ForStmt {
         this.body = body;
         this.range = range;
     }
+    bodyBlock() {
+        if (this.body instanceof BlockStmt)
+            return this.body;
+        return new BlockStmt([this.body], this.body.range);
+    }
 }

package/dist/ast/nodes/statements/IfStmt.d.ts

@@ -1,11 +1,14 @@
-import { PebbleAst } from "../../PebbleAst.js";
 import { SourceRange } from "../../Source/SourceRange.js";
 import { PebbleExpr } from "../expr/PebbleExpr.js";
 import { HasSourceRange } from "../HasSourceRange.js";
+import { BlockStmt } from "./BlockStmt.js";
+import { BodyStmt } from "./PebbleStmt.js";
 export declare class IfStmt implements HasSourceRange {
-    readonly condition: PebbleExpr;
-    readonly thenBranch: PebbleAst;
-    readonly elseBranch: PebbleAst | undefined;
+    condition: PebbleExpr;
+    thenBranch: BodyStmt;
+    elseBranch: BodyStmt | undefined;
     readonly range: SourceRange;
-    constructor(condition: PebbleExpr, thenBranch: PebbleAst, elseBranch: PebbleAst | undefined, range: SourceRange);
+    constructor(condition: PebbleExpr, thenBranch: BodyStmt, elseBranch: BodyStmt | undefined, range: SourceRange);
+    thenBranchBlock(): BlockStmt;
+    elseBranchBlock(): BlockStmt | undefined;
 }

package/dist/ast/nodes/statements/IfStmt.js

@@ -1,3 +1,4 @@
+import { BlockStmt } from "./BlockStmt.js";
 export class IfStmt {
     condition;
     thenBranch;
@@ -9,4 +10,16 @@ export class IfStmt {
         this.elseBranch = elseBranch;
         this.range = range;
     }
+    thenBranchBlock() {
+        if (this.thenBranch instanceof BlockStmt)
+            return this.thenBranch;
+        return new BlockStmt([this.thenBranch], this.thenBranch.range);
+    }
+    elseBranchBlock() {
+        if (!this.elseBranch)
+            return undefined;
+        if (this.elseBranch instanceof BlockStmt)
+            return this.elseBranch;
+        return new BlockStmt([this.elseBranch], this.elseBranch.range);
+    }
 }

package/dist/ast/nodes/statements/MatchStmt.d.ts

@@ -3,15 +3,24 @@ import { VarDecl } from "./declarations/VarDecl/VarDecl.js";
 import { PebbleExpr } from "../expr/PebbleExpr.js";
 import { HasSourceRange } from "../HasSourceRange.js";
 import { BodyStmt } from "./PebbleStmt.js";
+import { BlockStmt } from "./BlockStmt.js";
 export declare class MatchStmt implements HasSourceRange {
-    readonly matchExpr: PebbleExpr;
-    readonly cases: MatchStmtCase[];
+    matchExpr: PebbleExpr;
+    cases: MatchStmtCase[];
+    elseCase: MatchStmtElseCase | undefined;
     readonly range: SourceRange;
-    constructor(matchExpr: PebbleExpr, cases: MatchStmtCase[], range: SourceRange);
+    constructor(matchExpr: PebbleExpr, cases: MatchStmtCase[], elseCase: MatchStmtElseCase | undefined, range: SourceRange);
 }
 export declare class MatchStmtCase implements HasSourceRange {
     readonly pattern: VarDecl;
-    readonly body: BodyStmt;
+    body: BodyStmt;
     readonly range: SourceRange;
     constructor(pattern: VarDecl, body: BodyStmt, range: SourceRange);
+    bodyBlockStmt(): BlockStmt;
+}
+export declare class MatchStmtElseCase implements HasSourceRange {
+    body: BodyStmt;
+    readonly range: SourceRange;
+    constructor(body: BodyStmt, range: SourceRange);
+    bodyBlockStmt(): BlockStmt;
 }

package/dist/ast/nodes/statements/MatchStmt.js

@@ -1,10 +1,13 @@
+import { BlockStmt } from "./BlockStmt.js";
 export class MatchStmt {
     matchExpr;
     cases;
+    elseCase;
     range;
-    constructor(matchExpr, cases, range) {
+    constructor(matchExpr, cases, elseCase, range) {
         this.matchExpr = matchExpr;
         this.cases = cases;
+        this.elseCase = elseCase;
         this.range = range;
     }
 }
@@ -17,4 +20,22 @@ export class MatchStmtCase {
         this.body = body;
         this.range = range;
     }
+    bodyBlockStmt() {
+        if (this.body instanceof BlockStmt)
+            return this.body;
+        return new BlockStmt([this.body], this.body.range);
+    }
+}
+export class MatchStmtElseCase {
+    body;
+    range;
+    constructor(body, range) {
+        this.body = body;
+        this.range = range;
+    }
+    bodyBlockStmt() {
+        if (this.body instanceof BlockStmt)
+            return this.body;
+        return new BlockStmt([this.body], this.body.range);
+    }
 }

package/dist/ast/nodes/statements/PebbleStmt.d.ts

@@ -23,7 +23,8 @@ import { UsingStmt } from "./UsingStmt.js";
 import { FuncDecl } from "./declarations/FuncDecl.js";
 import { ExportStmt } from "./ExportStmt.js";
 import { InterfaceDecl } from "./declarations/InterfaceDecl.js";
-export type TopLevelStmt = EmptyStmt | VarStmt | PebbleTypeDecl | InterfaceDecl | FuncDecl | TestStmt | ExportStmt | ExportStarStmt | ExportImportStmt | ImportStmt | ImportStarStmt | TypeImplementsStmt | UsingStmt;
+import { ContractDecl } from "./declarations/ContractDecl.js";
+export type TopLevelStmt = EmptyStmt | VarStmt | PebbleTypeDecl | InterfaceDecl | FuncDecl | TestStmt | ExportStmt | ExportStarStmt | ExportImportStmt | ImportStmt | ImportStarStmt | TypeImplementsStmt | UsingStmt | ContractDecl;
 export declare function isTopLevelStmt(stmt: any): stmt is TopLevelStmt;
 export type BodyStmt = IfStmt | VarStmt | ForStmt | ForOfStmt | WhileStmt | ReturnStmt | BlockStmt | BreakStmt | ContinueStmt | EmptyStmt | FailStmt | AssertStmt | MatchStmt | AssignmentStmt | UsingStmt;
 export declare function isBodyStmt(stmt: any): stmt is BodyStmt;