@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

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

@@ -1,25 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

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