@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev4

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLessThanEqualExpr.js

@@ -0,0 +1,25 @@
+import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirLessThanEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
+import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { int_t, bytes_t } from "../../../../tir/program/stdScope/stdScope.js";
+import { _compileExpr } from "../_compileExpr.js";
+export function _compileLessThanEqualExpr(ctx, expr, typeHint) {
+    const left = _compileExpr(ctx, expr.left, typeHint);
+    if (!left)
+        return undefined;
+    if (!canAssignTo(left.type, int_t)
+        && !canAssignTo(left.type, bytes_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
+    let leftType = left.type;
+    while (leftType instanceof TirAliasType)
+        leftType = leftType.aliased;
+    const right = _compileExpr(ctx, expr.right, leftType);
+    if (!right)
+        return undefined;
+    if (!canAssignTo(right.type, leftType))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), leftType.toString());
+    return new TirLessThanEqualExpr(left, right, 
+    // implicit bool type,
+    expr.range);
+}

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLessThanExpr.d.ts

@@ -0,0 +1,5 @@
+import { LessThanExpr } from "../../../../../ast/nodes/expr/binary/BinaryExpr.js";
+import { TirLessThanExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirType } from "../../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../../AstCompilationCtx.js";
+export declare function _compileLessThanExpr(ctx: AstCompilationCtx, expr: LessThanExpr, typeHint: TirType | undefined): TirLessThanExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLessThanExpr.js

@@ -0,0 +1,26 @@
+import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirLessThanExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
+import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../_compileExpr.js";
+export function _compileLessThanExpr(ctx, expr, typeHint) {
+    const int_t = ctx.program.stdTypes.int;
+    const bytes_t = ctx.program.stdTypes.bytes;
+    const left = _compileExpr(ctx, expr.left, typeHint);
+    if (!left)
+        return undefined;
+    if (!canAssignTo(left.type, int_t)
+        && !canAssignTo(left.type, bytes_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
+    let leftType = left.type;
+    while (leftType instanceof TirAliasType)
+        leftType = leftType.aliased;
+    const right = _compileExpr(ctx, expr.right, leftType);
+    if (!right)
+        return undefined;
+    if (!canAssignTo(right.type, leftType))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), leftType.toString());
+    return new TirLessThanExpr(left, right, 
+    // implicit bool type,
+    expr.range);
+}

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLogicalAndExpr.d.ts

@@ -0,0 +1,5 @@
+import { LogicalAndExpr } from "../../../../../ast/nodes/expr/binary/BinaryExpr.js";
+import { TirLogicalAndExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirType } from "../../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../../AstCompilationCtx.js";
+export declare function _compileLogicalAndExpr(ctx: AstCompilationCtx, expr: LogicalAndExpr, _typeHint: TirType | undefined): TirLogicalAndExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLogicalAndExpr.js

@@ -0,0 +1,22 @@
+import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirLogicalAndExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../_compileExpr.js";
+export function _compileLogicalAndExpr(ctx, expr, _typeHint) {
+    const bool_t = ctx.program.stdTypes.bool;
+    const left = _compileExpr(ctx, expr.left, bool_t);
+    if (!left)
+        return undefined;
+    // TODO: accept optionals
+    if (!canAssignTo(left.type, bool_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), bool_t.toString());
+    const right = _compileExpr(ctx, expr.right, bool_t);
+    if (!right)
+        return undefined;
+    // TODO: accept optionals
+    if (!canAssignTo(right.type, bool_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), bool_t.toString());
+    return new TirLogicalAndExpr(left, right, 
+    // implicit bool type,
+    expr.range);
+}

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLogicalOrExpr.d.ts

@@ -0,0 +1,5 @@
+import { LogicalOrExpr } from "../../../../../ast/nodes/expr/binary/BinaryExpr.js";
+import { TirLogicalOrExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirType } from "../../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../../AstCompilationCtx.js";
+export declare function _compileLogicalOrExpr(ctx: AstCompilationCtx, expr: LogicalOrExpr, _typeHint: TirType | undefined): TirLogicalOrExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLogicalOrExpr.js

@@ -0,0 +1,22 @@
+import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirLogicalOrExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../_compileExpr.js";
+export function _compileLogicalOrExpr(ctx, expr, _typeHint) {
+    const bool_t = ctx.program.stdTypes.bool;
+    const left = _compileExpr(ctx, expr.left, bool_t);
+    if (!left)
+        return undefined;
+    // TODO: accept optionals
+    if (!canAssignTo(left.type, bool_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), bool_t.toString());
+    const right = _compileExpr(ctx, expr.right, bool_t);
+    if (!right)
+        return undefined;
+    // TODO: accept optionals
+    if (!canAssignTo(right.type, bool_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), bool_t.toString());
+    return new TirLogicalOrExpr(left, right, 
+    // implicit bool type,
+    expr.range);
+}

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileModuloExpr.d.ts

@@ -0,0 +1,5 @@
+import { ModuloExpr } from "../../../../../ast/nodes/expr/binary/BinaryExpr.js";
+import { TirModuloExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirType } from "../../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../../AstCompilationCtx.js";
+export declare function _compileModuloExpr(ctx: AstCompilationCtx, expr: ModuloExpr, _typeHint: TirType | undefined): TirModuloExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileModuloExpr.js

@@ -0,0 +1,20 @@
+import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirModuloExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../_compileExpr.js";
+export function _compileModuloExpr(ctx, expr, _typeHint) {
+    const int_t = ctx.program.stdTypes.int;
+    const left = _compileExpr(ctx, expr.left, int_t);
+    if (!left)
+        return undefined;
+    if (!canAssignTo(left.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
+    const right = _compileExpr(ctx, expr.right, int_t);
+    if (!right)
+        return undefined;
+    if (!canAssignTo(right.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
+    return new TirModuloExpr(left, right, 
+    // implicit int type,
+    expr.range);
+}

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileMultExpr.d.ts

@@ -0,0 +1,5 @@
+import { MultExpr } from "../../../../../ast/nodes/expr/binary/BinaryExpr.js";
+import { TirMultExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirType } from "../../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../../AstCompilationCtx.js";
+export declare function _compileMultExpr(ctx: AstCompilationCtx, expr: MultExpr, _typeHint: TirType | undefined): TirMultExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileMultExpr.js

@@ -0,0 +1,20 @@
+import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirMultExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../_compileExpr.js";
+export function _compileMultExpr(ctx, expr, _typeHint) {
+    const int_t = ctx.program.stdTypes.int;
+    const left = _compileExpr(ctx, expr.left, int_t);
+    if (!left)
+        return undefined;
+    if (!canAssignTo(left.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
+    const right = _compileExpr(ctx, expr.right, int_t);
+    if (!right)
+        return undefined;
+    if (!canAssignTo(right.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
+    return new TirMultExpr(left, right, 
+    // implicit int type,
+    expr.range);
+}

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileNotEqualExpr.d.ts

@@ -0,0 +1,5 @@
+import { NotEqualExpr } from "../../../../../ast/nodes/expr/binary/BinaryExpr.js";
+import { TirNotEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirType } from "../../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../../AstCompilationCtx.js";
+export declare function _compileNotEqualExpr(ctx: AstCompilationCtx, expr: NotEqualExpr, typeHint: TirType | undefined): TirNotEqualExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileNotEqualExpr.js

@@ -0,0 +1,18 @@
+import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirNotEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../_compileExpr.js";
+export function _compileNotEqualExpr(ctx, expr, typeHint) {
+    const left = _compileExpr(ctx, expr.left, typeHint);
+    if (!left)
+        return undefined;
+    const leftType = left.type;
+    const right = _compileExpr(ctx, expr.right, leftType);
+    if (!right)
+        return undefined;
+    if (!canAssignTo(right.type, leftType))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), leftType.toString());
+    return new TirNotEqualExpr(left, right, 
+    // implicit bool type,
+    expr.range);
+}

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileOptionalDefaultExpr.d.ts

@@ -0,0 +1,5 @@
+import { OptionalDefaultExpr } from "../../../../../ast/nodes/expr/binary/BinaryExpr.js";
+import { TirExpr } from "../../../../tir/expressions/TirExpr.js";
+import { TirType } from "../../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../../AstCompilationCtx.js";
+export declare function _compileOptionalDefaultExpr(ctx: AstCompilationCtx, expr: OptionalDefaultExpr, typeHint: TirType | undefined): TirExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileOptionalDefaultExpr.js

@@ -0,0 +1,60 @@
+import { Identifier } from "../../../../../ast/nodes/common/Identifier.js";
+import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirLitNamedObjExpr } from "../../../../tir/expressions/litteral/TirLitNamedObjExpr.js";
+import { TirCaseExpr, TirCaseMatcher } from "../../../../tir/expressions/TirCaseExpr.js";
+import { TirFromDataExpr } from "../../../../tir/expressions/TirFromDataExpr.js";
+import { TirVariableAccessExpr } from "../../../../tir/expressions/TirVariableAccessExpr.js";
+import { TirNamedDeconstructVarDecl } from "../../../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
+import { TirSimpleVarDecl } from "../../../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
+import { TirSopOptT } from "../../../../tir/types/TirNativeType/native/Optional/sop.js";
+import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { getOptTypeArg } from "../../../../tir/types/utils/getOptTypeArg.js";
+import { _compileExpr } from "../_compileExpr.js";
+export function _compileOptionalDefaultExpr(ctx, expr, typeHint) {
+    const left = _compileExpr(ctx, expr.left, typeHint ? new TirSopOptT(typeHint) : undefined);
+    if (!left)
+        return undefined;
+    const leftType = left.type;
+    const unwrappedType = getOptTypeArg(leftType);
+    if (!unwrappedType) {
+        ctx.warning(DiagnosticCode.Left_side_of_opeartor_is_not_optional_right_side_is_unused, expr.right.range);
+        return left;
+    }
+    const optType = new TirSopOptT(unwrappedType);
+    const right = _compileExpr(ctx, expr.right, unwrappedType);
+    if (!right)
+        return undefined;
+    const isUnwrappedReturn = canAssignTo(right.type, unwrappedType);
+    if (!isUnwrappedReturn && !canAssignTo(right.type, optType))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), unwrappedType.toString());
+    const returnType = isUnwrappedReturn ? unwrappedType : optType;
+    const accessSomeValueExpr = new TirVariableAccessExpr({
+        variableInfos: {
+            name: "value",
+            type: unwrappedType,
+            isConstant: true
+        },
+        isDefinedOutsideFuncScope: false,
+    }, expr.range);
+    return new TirCaseExpr(left, [
+        new TirCaseMatcher(new TirNamedDeconstructVarDecl("Some", new Map([
+            ["value", new TirSimpleVarDecl("value", unwrappedType, undefined, // no init expr
+                true, // isConst
+                expr.range)]
+        ]), undefined, // no rest
+        leftType, undefined, // no init expr
+        true, // isConst
+        expr.range), isUnwrappedReturn ?
+            accessSomeValueExpr :
+            new TirLitNamedObjExpr(new Identifier("Some", expr.range), [new Identifier("value", left.range)], [accessSomeValueExpr], optType, expr.range), expr.range),
+        new TirCaseMatcher(new TirNamedDeconstructVarDecl("None", new Map(), // no fields extracted
+        undefined, // no rest
+        leftType, undefined, // no init expr
+        true, // isConst
+        expr.range), isUnwrappedReturn ? right : (
+        // ensure we have a sop encoded optional
+        right.type instanceof TirSopOptT ? right :
+            new TirFromDataExpr(right, optType, expr.range)), expr.range)
+    ], undefined, // no wildcard case
+    returnType, expr.range);
+}

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileShiftLeftExpr.d.ts

@@ -0,0 +1,5 @@
+import { ShiftLeftExpr } from "../../../../../ast/nodes/expr/binary/BinaryExpr.js";
+import { TirShiftLeftExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirType } from "../../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../../AstCompilationCtx.js";
+export declare function _compileShiftLeftExpr(ctx: AstCompilationCtx, expr: ShiftLeftExpr, _typeHint: TirType | undefined): TirShiftLeftExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileShiftLeftExpr.js

@@ -0,0 +1,21 @@
+import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirShiftLeftExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../_compileExpr.js";
+export function _compileShiftLeftExpr(ctx, expr, _typeHint) {
+    const int_t = ctx.program.stdTypes.int;
+    const bytes_t = ctx.program.stdTypes.bytes;
+    const left = _compileExpr(ctx, expr.left, bytes_t);
+    if (!left)
+        return undefined;
+    if (!canAssignTo(left.type, bytes_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), bytes_t.toString());
+    const right = _compileExpr(ctx, expr.right, int_t);
+    if (!right)
+        return undefined;
+    if (!canAssignTo(right.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
+    return new TirShiftLeftExpr(left, right, 
+    // implicit bytes type,
+    expr.range);
+}

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileShiftRightExpr.d.ts

@@ -0,0 +1,5 @@
+import { ShiftRightExpr } from "../../../../../ast/nodes/expr/binary/BinaryExpr.js";
+import { TirShiftRightExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirType } from "../../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../../AstCompilationCtx.js";
+export declare function _compileShiftRightExpr(ctx: AstCompilationCtx, expr: ShiftRightExpr, _typeHint: TirType | undefined): TirShiftRightExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileShiftRightExpr.js

@@ -0,0 +1,21 @@
+import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirShiftRightExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../_compileExpr.js";
+export function _compileShiftRightExpr(ctx, expr, _typeHint) {
+    const bytes_t = ctx.program.stdTypes.bytes;
+    const int_t = ctx.program.stdTypes.int;
+    const left = _compileExpr(ctx, expr.left, bytes_t);
+    if (!left)
+        return undefined;
+    if (!canAssignTo(left.type, bytes_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), bytes_t.toString());
+    const right = _compileExpr(ctx, expr.right, int_t);
+    if (!right)
+        return undefined;
+    if (!canAssignTo(right.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
+    return new TirShiftRightExpr(left, right, 
+    // implicit bytes type,
+    expr.range);
+}

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileSubExpr.d.ts

@@ -0,0 +1,5 @@
+import { SubExpr } from "../../../../../ast/nodes/expr/binary/BinaryExpr.js";
+import { TirSubExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirType } from "../../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../../AstCompilationCtx.js";
+export declare function _compileSubExpr(ctx: AstCompilationCtx, expr: SubExpr, _typeHint: TirType | undefined): TirSubExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileSubExpr.js

@@ -0,0 +1,20 @@
+import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirSubExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../_compileExpr.js";
+export function _compileSubExpr(ctx, expr, _typeHint) {
+    const int_t = ctx.program.stdTypes.int;
+    const left = _compileExpr(ctx, expr.left, int_t);
+    if (!left)
+        return undefined;
+    if (!canAssignTo(left.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
+    const right = _compileExpr(ctx, expr.right, int_t);
+    if (!right)
+        return undefined;
+    if (!canAssignTo(right.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
+    return new TirSubExpr(left, right, 
+    // implicit int type,
+    expr.range);
+}

package/dist/compiler/AstCompiler/internal/statements/_compileAssertStmt.d.ts

@@ -0,0 +1,4 @@
+import { AssertStmt } from "../../../../ast/nodes/statements/AssertStmt.js";
+import { TirAssertStmt } from "../../../tir/statements/TirAssertStmt.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+export declare function _compileAssertStmt(ctx: AstCompilationCtx, stmt: AssertStmt): [TirAssertStmt] | undefined;

package/dist/compiler/AstCompiler/internal/statements/_compileAssertStmt.js

@@ -0,0 +1,30 @@
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirTypeConversionExpr } from "../../../tir/expressions/TirTypeConversionExpr.js";
+import { TirAssertStmt } from "../../../tir/statements/TirAssertStmt.js";
+import { canAssignTo, canAssignToOptional } from "../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../exprs/_compileExpr.js";
+export function _compileAssertStmt(ctx, stmt) {
+    const bool_t = ctx.program.stdTypes.bool;
+    const string_t = ctx.program.stdTypes.string;
+    const bytes_t = ctx.program.stdTypes.bytes;
+    const tirCond = _compileExpr(ctx, stmt.condition, bool_t);
+    if (!tirCond)
+        return undefined;
+    if (!canAssignTo(tirCond.type, bool_t)
+        && !canAssignToOptional(tirCond.type)) {
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.condition.range, tirCond.type.toString(), bool_t.toString());
+    }
+    let failMsgExpr = undefined;
+    if (stmt.elseExpr) {
+        failMsgExpr = _compileExpr(ctx, stmt.elseExpr, string_t);
+        if (!failMsgExpr)
+            return undefined;
+        if (canAssignTo(failMsgExpr.type, bytes_t)) {
+            // auto cast to string
+            failMsgExpr = new TirTypeConversionExpr(failMsgExpr, string_t, failMsgExpr.range);
+        }
+        if (!canAssignTo(failMsgExpr.type, string_t))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.elseExpr.range, failMsgExpr.type.toString(), string_t.toString());
+    }
+    return [new TirAssertStmt(tirCond, failMsgExpr, stmt.range)];
+}

package/dist/compiler/AstCompiler/internal/statements/_compileAssignmentStmt.d.ts

@@ -0,0 +1,8 @@
+import { AssignmentStmt, ExplicitAssignmentStmt } from "../../../../ast/nodes/statements/AssignmentStmt.js";
+import { TirExpr } from "../../../tir/expressions/TirExpr.js";
+import { TirAssignmentStmt } from "../../../tir/statements/TirAssignmentStmt.js";
+import { TirType } from "../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+export declare function _compileAssignmentStmt(ctx: AstCompilationCtx, stmt: AssignmentStmt): [TirAssignmentStmt] | undefined;
+export declare function _compileExplicitAssignmentStmt(ctx: AstCompilationCtx, stmt: ExplicitAssignmentStmt): TirAssignmentStmt | undefined;
+export declare function __getBinOpAssignmentLeftArg(ctx: AstCompilationCtx, stmt: ExplicitAssignmentStmt, varType: TirType, exprType: TirType): TirExpr | undefined;

package/dist/compiler/AstCompiler/internal/statements/_compileAssignmentStmt.js

@@ -0,0 +1,154 @@
+import { isExplicitAssignmentStmt, SimpleAssignmentStmt, AddAssignmentStmt, SubAssignmentStmt, ExpAssignmentStmt, MultAssignmentStmt, DivAssignmentStmt, ModuloAssignmentStmt, ShiftLeftAssignmentStmt, ShiftRightAssignmentStmt, BitwiseAndAssignmentStmt, BitwiseXorAssignmentStmt, BitwiseOrAssignmentStmt, LogicalAndAssignmentStmt, LogicalOrAssignmentStmt } from "../../../../ast/nodes/statements/AssignmentStmt.js";
+import { DecrStmt } from "../../../../ast/nodes/statements/DecrStmt.js";
+import { IncrStmt } from "../../../../ast/nodes/statements/IncrStmt.js";
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirAddExpr, TirSubExpr, TirExponentiationExpr, TirMultExpr, TirDivExpr, TirModuloExpr, TirShiftLeftExpr, TirShiftRightExpr, TirBitwiseAndExpr, TirBitwiseXorExpr, TirBitwiseOrExpr, TirLogicalAndExpr, TirLogicalOrExpr } from "../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirLitIntExpr } from "../../../tir/expressions/litteral/TirLitIntExpr.js";
+import { TirVariableAccessExpr } from "../../../tir/expressions/TirVariableAccessExpr.js";
+import { TirAssignmentStmt } from "../../../tir/statements/TirAssignmentStmt.js";
+import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../exprs/_compileExpr.js";
+export function _compileAssignmentStmt(ctx, stmt) {
+    const int_t = ctx.program.stdTypes.int;
+    if (stmt instanceof IncrStmt
+        || stmt instanceof DecrStmt) {
+        const resolvedValue = ctx.scope.resolveValue(stmt.varIdentifier.text);
+        if (!resolvedValue)
+            return ctx.error(DiagnosticCode._0_is_not_defined, stmt.varIdentifier.range, stmt.varIdentifier.text);
+        const { variableInfos, isDefinedOutsideFuncScope } = resolvedValue;
+        const varType = variableInfos.type;
+        if (!canAssignTo(varType, int_t))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.varIdentifier.range, varType.toString(), int_t.toString());
+        const varAccessExpr = new TirVariableAccessExpr(resolvedValue, stmt.varIdentifier.range);
+        return ([new TirAssignmentStmt(varAccessExpr, stmt instanceof IncrStmt ?
+                new TirAddExpr(varAccessExpr, new TirLitIntExpr(BigInt(1), stmt.range), stmt.range) :
+                new TirSubExpr(varAccessExpr, new TirLitIntExpr(BigInt(1), stmt.range), stmt.range), stmt.range)]);
+    }
+    if (isExplicitAssignmentStmt(stmt)) {
+        const tirStmt = _compileExplicitAssignmentStmt(ctx, stmt);
+        if (!tirStmt)
+            return undefined;
+        return [tirStmt];
+    }
+    else {
+        const tsEnsureExsautstiveCheck = stmt;
+        console.error(stmt);
+        throw new Error("unreachable::AstCompiler::_compileForUpdateStmts");
+    }
+}
+export function _compileExplicitAssignmentStmt(ctx, stmt) {
+    const int_t = ctx.program.stdTypes.int;
+    const bytes_t = ctx.program.stdTypes.bytes;
+    const bool_t = ctx.program.stdTypes.bool;
+    const scope = ctx.scope;
+    const resovleResult = scope.resolveValue(stmt.varIdentifier.text);
+    if (!resovleResult)
+        return ctx.error(DiagnosticCode._0_is_not_defined, stmt.range, stmt.varIdentifier.text);
+    const { variableInfos, isDefinedOutsideFuncScope } = resovleResult;
+    if (variableInfos.isConstant)
+        return ctx.error(DiagnosticCode.Cannot_assign_to_0_because_it_is_a_constant, stmt.varIdentifier.range, stmt.varIdentifier.text);
+    const varType = variableInfos.type;
+    const varAccessExpr = new TirVariableAccessExpr(resovleResult, stmt.varIdentifier.range);
+    let expr = undefined;
+    if (stmt instanceof SimpleAssignmentStmt) {
+        expr = _compileExpr(ctx, stmt.assignedExpr, varType);
+        if (!expr)
+            return undefined;
+        if (!canAssignTo(expr.type, varType))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.range, expr.type.toString(), varType.toString());
+    }
+    else if (stmt instanceof AddAssignmentStmt) {
+        expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, int_t);
+        if (!expr)
+            return undefined;
+        expr = new TirAddExpr(varAccessExpr, expr, stmt.range);
+    }
+    else if (stmt instanceof SubAssignmentStmt) {
+        expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, int_t);
+        if (!expr)
+            return undefined;
+        expr = new TirSubExpr(varAccessExpr, expr, stmt.range);
+    }
+    else if (stmt instanceof ExpAssignmentStmt) {
+        expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, int_t);
+        if (!expr)
+            return undefined;
+        expr = new TirExponentiationExpr(varAccessExpr, expr, stmt.range);
+    }
+    else if (stmt instanceof MultAssignmentStmt) {
+        expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, int_t);
+        if (!expr)
+            return undefined;
+        expr = new TirMultExpr(varAccessExpr, expr, stmt.range);
+    }
+    else if (stmt instanceof DivAssignmentStmt) {
+        expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, int_t);
+        if (!expr)
+            return undefined;
+        expr = new TirDivExpr(varAccessExpr, expr, stmt.range);
+    }
+    else if (stmt instanceof ModuloAssignmentStmt) {
+        expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, int_t);
+        if (!expr)
+            return undefined;
+        expr = new TirModuloExpr(varAccessExpr, expr, stmt.range);
+    }
+    else if (stmt instanceof ShiftLeftAssignmentStmt) {
+        expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, bytes_t);
+        if (!expr)
+            return undefined;
+        expr = new TirShiftLeftExpr(varAccessExpr, expr, stmt.range);
+    }
+    else if (stmt instanceof ShiftRightAssignmentStmt) {
+        expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, bytes_t);
+        if (!expr)
+            return undefined;
+        expr = new TirShiftRightExpr(varAccessExpr, expr, stmt.range);
+    }
+    else if (stmt instanceof BitwiseAndAssignmentStmt) {
+        expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, bytes_t);
+        if (!expr)
+            return undefined;
+        expr = new TirBitwiseAndExpr(varAccessExpr, expr, stmt.range);
+    }
+    else if (stmt instanceof BitwiseXorAssignmentStmt) {
+        expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, bytes_t);
+        if (!expr)
+            return undefined;
+        expr = new TirBitwiseXorExpr(varAccessExpr, expr, stmt.range);
+    }
+    else if (stmt instanceof BitwiseOrAssignmentStmt) {
+        expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, bytes_t);
+        if (!expr)
+            return undefined;
+        expr = new TirBitwiseOrExpr(varAccessExpr, expr, stmt.range);
+    }
+    else if (stmt instanceof LogicalAndAssignmentStmt) {
+        expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, bool_t);
+        if (!expr)
+            return undefined;
+        expr = new TirLogicalAndExpr(varAccessExpr, expr, stmt.range);
+    }
+    else if (stmt instanceof LogicalOrAssignmentStmt) {
+        expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, bool_t);
+        if (!expr)
+            return undefined;
+        expr = new TirLogicalOrExpr(varAccessExpr, expr, stmt.range);
+    }
+    else {
+        const tsEnsureExsautstiveCheck = stmt;
+        console.error(stmt);
+        throw new Error("unreachable::AstCompiler::_compileExplicitAssignmentStmt");
+    }
+    return new TirAssignmentStmt(varAccessExpr, expr, stmt.range);
+}
+export function __getBinOpAssignmentLeftArg(ctx, stmt, varType, exprType) {
+    if (!canAssignTo(varType, exprType))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.varIdentifier.range, varType.toString(), exprType.toString());
+    const expr = _compileExpr(ctx, stmt.assignedExpr, exprType);
+    if (!expr)
+        return undefined;
+    if (!canAssignTo(expr.type, exprType))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.range, expr.type.toString(), exprType.toString());
+    return expr;
+}

package/dist/compiler/AstCompiler/internal/statements/_compileBlockStmt.d.ts

@@ -0,0 +1,4 @@
+import { BlockStmt } from "../../../../ast/nodes/statements/BlockStmt.js";
+import { TirBlockStmt } from "../../../tir/statements/TirBlockStmt.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+export declare function _compileBlockStmt(ctx: AstCompilationCtx, stmt: BlockStmt): [TirBlockStmt] | undefined;

package/dist/compiler/AstCompiler/internal/statements/_compileBlockStmt.js

@@ -0,0 +1,14 @@
+import { TirBlockStmt } from "../../../tir/statements/TirBlockStmt.js";
+import { _compileStatement } from "./_compileStatement.js";
+export function _compileBlockStmt(ctx, stmt) {
+    const blockCtx = ctx.newBranchChildScope();
+    // stmt.stmts;
+    const tirStmts = [];
+    for (const blockStmt of stmt.stmts) {
+        const tirStmt = _compileStatement(blockCtx, blockStmt);
+        if (!Array.isArray(tirStmt))
+            return undefined;
+        tirStmts.push(...tirStmt);
+    }
+    return [new TirBlockStmt(tirStmts, stmt.range)];
+}

package/dist/compiler/AstCompiler/internal/statements/_compileBreakStmt.d.ts

@@ -0,0 +1,4 @@
+import { BreakStmt } from "../../../../ast/nodes/statements/BreakStmt.js";
+import { TirBreakStmt } from "../../../tir/statements/TirBreakStmt.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+export declare function _compileBreakStmt(ctx: AstCompilationCtx, stmt: BreakStmt): [TirBreakStmt] | undefined;

package/dist/compiler/AstCompiler/internal/statements/_compileBreakStmt.js

@@ -0,0 +1,7 @@
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirBreakStmt } from "../../../tir/statements/TirBreakStmt.js";
+export function _compileBreakStmt(ctx, stmt) {
+    if (!ctx.isLoop)
+        return ctx.error(DiagnosticCode.A_break_statement_can_only_be_used_within_a_loop, stmt.range);
+    return [new TirBreakStmt(stmt.range)];
+}

package/dist/compiler/AstCompiler/internal/statements/_compileContinueStmt.d.ts

@@ -0,0 +1,4 @@
+import { ContinueStmt } from "../../../../ast/nodes/statements/ContinueStmt.js";
+import { TirContinueStmt } from "../../../tir/statements/TirContinueStmt.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+export declare function _compileContinueStmt(ctx: AstCompilationCtx, stmt: ContinueStmt): [TirContinueStmt] | undefined;

package/dist/compiler/AstCompiler/internal/statements/_compileContinueStmt.js

@@ -0,0 +1,7 @@
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirContinueStmt } from "../../../tir/statements/TirContinueStmt.js";
+export function _compileContinueStmt(ctx, stmt) {
+    if (!ctx.isLoop)
+        return ctx.error(DiagnosticCode.A_continue_statement_can_only_be_used_within_a_loop, stmt.range);
+    return [new TirContinueStmt(stmt.range)];
+}

package/dist/compiler/AstCompiler/internal/statements/_compileExprStmt.d.ts

@@ -0,0 +1 @@
+export {};