@harmoniclabs/pebble 0.1.0-dev0

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

@@ -0,0 +1,12 @@
+export {};
+/*
+export function _compileExprStmt(
+    ctx: AstCompilationCtx,
+    stmt: ExprStmt
+): [ TirExprStmt ] | undefined
+{
+    const expr = _compileExpr( ctx, stmt.expr, void_t );
+    if( !expr ) return undefined;
+    return [ new TirExprStmt( expr, stmt.range ) ];
+}
+    //*/ 

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

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

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

@@ -0,0 +1,18 @@
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirFailStmt } from "../../../tir/statements/TirFailStmt.js";
+import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
+import { string_t } from "../../../tir/program/stdScope/stdScope.js";
+import { _compileExpr } from "../exprs/_compileExpr.js";
+export function _compileFailStmt(ctx, stmt) {
+    if (!ctx.functionCtx)
+        return ctx.error(DiagnosticCode.A_fail_statement_can_only_be_used_within_a_function_body, stmt.range);
+    let failMsgExpr = undefined;
+    if (stmt.value) {
+        failMsgExpr = _compileExpr(ctx, stmt.value, string_t);
+        if (!failMsgExpr)
+            return undefined;
+        if (!canAssignTo(failMsgExpr.type, string_t))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.value.range, failMsgExpr.type.toString(), string_t.toString());
+    }
+    return [new TirFailStmt(failMsgExpr, stmt.range)];
+}

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

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

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

@@ -0,0 +1,30 @@
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirForOfStmt } from "../../../tir/statements/TirForOfStmt.js";
+import { TirListT } from "../../../tir/types/TirNativeType/index.js";
+import { TirTypeParam } from "../../../tir/types/TirTypeParam.js";
+import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
+import { getListTypeArg } from "../../../tir/types/utils/getListTypeArg.js";
+import { wrapManyStatements } from "../../utils/wrapManyStatementsOrReturnSame.js";
+import { _compileExpr } from "../exprs/_compileExpr.js";
+import { _compileStatement } from "./_compileStatement.js";
+import { _compileVarDecl } from "./_compileVarStmt.js";
+export function _compileForOfStmt(ctx, stmt) {
+    const any_list_t = new TirListT(new TirTypeParam("T"));
+    const iterableExpr = _compileExpr(ctx, stmt.iterable, any_list_t);
+    if (!iterableExpr)
+        return undefined;
+    const elemsType = getListTypeArg(iterableExpr.type);
+    if (!elemsType)
+        return ctx.error(DiagnosticCode.The_argument_of_a_for_of_statement_must_be_an_iterable, stmt.iterable.range);
+    const loopCtx = ctx.newLoopChildScope();
+    const varDecl = stmt.elemDeclaration.declarations[0];
+    const tirVarDecl = _compileVarDecl(loopCtx, varDecl, elemsType);
+    if (!tirVarDecl)
+        return undefined;
+    if (!canAssignTo(tirVarDecl.type, elemsType))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, varDecl.range, tirVarDecl.type.toString(), elemsType.toString());
+    const tirBody = wrapManyStatements(_compileStatement(loopCtx, stmt.body), stmt.body.range);
+    if (!tirBody)
+        return undefined;
+    return [new TirForOfStmt(tirVarDecl, iterableExpr, tirBody, stmt.range)];
+}

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

@@ -0,0 +1,7 @@
+import { AssignmentStmt } from "../../../../ast/nodes/statements/AssignmentStmt.js";
+import { ForStmt } from "../../../../ast/nodes/statements/ForStmt.js";
+import { TirAssignmentStmt } from "../../../tir/statements/TirAssignmentStmt.js";
+import { TirForStmt } from "../../../tir/statements/TirForStmt.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+export declare function _compileForStmt(ctx: AstCompilationCtx, stmt: ForStmt): [TirForStmt] | undefined;
+export declare function _compileForUpdateStmts(ctx: AstCompilationCtx, stmts: AssignmentStmt[]): TirAssignmentStmt[] | undefined;

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

@@ -0,0 +1,46 @@
+import { TirForStmt } from "../../../tir/statements/TirForStmt.js";
+import { bool_t } from "../../../tir/program/stdScope/stdScope.js";
+import { wrapManyStatements } from "../../utils/wrapManyStatementsOrReturnSame.js";
+import { _compileExpr } from "../exprs/_compileExpr.js";
+import { _compileAssignmentStmt } from "./_compileAssignmentStmt.js";
+import { _compileStatement } from "./_compileStatement.js";
+import { _compileVarStmt } from "./_compileVarStmt.js";
+import { TirSimpleVarDecl } from "../../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+export function _compileForStmt(ctx, stmt) {
+    const loopScope = ctx.newLoopChildScope();
+    const _tirInit = stmt.init ? _compileVarStmt(loopScope, stmt.init) : undefined;
+    if (!_tirInit)
+        return undefined;
+    const nonSimpleDecl = _tirInit.filter(s => !(s instanceof TirSimpleVarDecl));
+    if (nonSimpleDecl.length > 0) {
+        for (const decl of nonSimpleDecl) {
+            ctx.error(DiagnosticCode.for_loop_initialization_variables_cannot_be_destructured_Declare_it_as_a_simple_variable_and_move_the_destructuring_in_the_loop_body, decl.range);
+        }
+        return undefined;
+    }
+    const tirInit = _tirInit;
+    const tirCond = stmt.condition ? _compileExpr(loopScope, stmt.condition, bool_t) : undefined;
+    if (!tirCond)
+        return undefined;
+    const tirUpdates = _compileForUpdateStmts(loopScope, stmt.updates);
+    if (!tirUpdates)
+        return undefined;
+    const tirBody = wrapManyStatements(_compileStatement(loopScope.newBranchChildScope(), stmt.body), stmt.body.range);
+    if (!tirBody)
+        return undefined;
+    return [new TirForStmt(tirInit, tirCond, tirUpdates, tirBody, stmt.range)];
+}
+export function _compileForUpdateStmts(ctx, stmts) {
+    const tirStmts = [];
+    for (let stmt of stmts) {
+        const tirStmt = _compileAssignmentStmt(ctx, stmt);
+        // empty array here returns undefined
+        // that is fine, because an empty array of assignments
+        // is not a valid statement
+        if (!tirStmt)
+            return undefined;
+        tirStmts.push(...tirStmt);
+    }
+    return tirStmts;
+}

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

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

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

@@ -0,0 +1,27 @@
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirIfStmt } from "../../../tir/statements/TirIfStmt.js";
+import { canAssignTo, canAssignToOptional } from "../../../tir/types/utils/canAssignTo.js";
+import { bool_t } from "../../../tir/program/stdScope/stdScope.js";
+import { wrapManyStatements } from "../../utils/wrapManyStatementsOrReturnSame.js";
+import { _compileExpr } from "../exprs/_compileExpr.js";
+import { _compileStatement } from "./_compileStatement.js";
+export function _compileIfStmt(ctx, stmt) {
+    const coditionExpr = _compileExpr(ctx, stmt.condition, bool_t);
+    if (!coditionExpr)
+        return undefined;
+    if (!canAssignTo(coditionExpr.type, bool_t)
+        && !canAssignToOptional(coditionExpr.type))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.condition.range, coditionExpr.type.toString(), "boolean | Optional<T>");
+    const thenBranch = wrapManyStatements(_compileStatement(ctx.newBranchChildScope(), stmt.thenBranch), stmt.thenBranch.range);
+    if (!thenBranch)
+        return undefined;
+    let elseBranch = undefined;
+    if (stmt.elseBranch) {
+        elseBranch = wrapManyStatements(_compileStatement(ctx.newBranchChildScope(), stmt.elseBranch), stmt.elseBranch.range);
+        if (!elseBranch)
+            return undefined;
+    }
+    return [
+        new TirIfStmt(coditionExpr, thenBranch, elseBranch, stmt.range)
+    ];
+}

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

@@ -0,0 +1,6 @@
+import { MatchStmt, MatchStmtCase } from "../../../../ast/nodes/statements/MatchStmt.js";
+import { TirMatchStmt, TirMatchStmtCase, TirMatchStmtWildcardCase } from "../../../tir/statements/TirMatchStmt.js";
+import { DeconstructableTirType } from "../../../tir/types/utils/getDeconstructableType.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+export declare function _compileMatchStmt(ctx: AstCompilationCtx, stmt: MatchStmt): [TirMatchStmt] | undefined;
+export declare function _compileTirMatchStmtCase(ctx: AstCompilationCtx, matchCase: MatchStmtCase, deconstructableType: DeconstructableTirType, constrNamesAlreadySpecified: string[]): TirMatchStmtCase | TirMatchStmtWildcardCase | undefined;

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

@@ -0,0 +1,182 @@
+import { ArrayLikeDeconstr } from "../../../../ast/nodes/statements/declarations/VarDecl/ArrayLikeDeconstr.js";
+import { NamedDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/NamedDeconstructVarDecl.js";
+import { SimpleVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
+import { SingleDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SingleDeconstructVarDecl.js";
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirMatchStmt, TirMatchStmtCase, TirMatchStmtWildcardCase } from "../../../tir/statements/TirMatchStmt.js";
+import { TirNamedDeconstructVarDecl } from "../../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
+import { TirDataT } from "../../../tir/types/TirNativeType/native/data.js";
+import { TirDataOptT } from "../../../tir/types/TirNativeType/native/Optional/data.js";
+import { TirSopOptT } from "../../../tir/types/TirNativeType/native/Optional/sop.js";
+import { isTirStructType, TirDataStructType, TirSoPStructType } from "../../../tir/types/TirStructType.js";
+import { getDeconstructableType } from "../../../tir/types/utils/getDeconstructableType.js";
+import { wrapManyStatements } from "../../utils/wrapManyStatementsOrReturnSame.js";
+import { _compileExpr } from "../exprs/_compileExpr.js";
+import { _compileStatement } from "./_compileStatement.js";
+import { _compileNamedDeconstructVarDecl, _compileSingleDeconstructVarDecl, _compileVarDecl } from "./_compileVarStmt.js";
+export function _compileMatchStmt(ctx, stmt) {
+    if (!ctx.functionCtx)
+        return ctx.error(DiagnosticCode.A_match_statement_can_only_be_used_within_a_function_body, stmt.range);
+    const matchExpr = _compileExpr(ctx, stmt.matchExpr, undefined);
+    if (!matchExpr)
+        return undefined;
+    const matchExprType = matchExpr.type;
+    const deconstructableType = getDeconstructableType(matchExprType);
+    if (!deconstructableType)
+        return ctx.error(DiagnosticCode.A_value_of_type_0_cannot_be_deconstructed, stmt.matchExpr.range, matchExprType.toString());
+    // TODO: add support for all deconstructable types
+    if (!isTirStructType(deconstructableType)) {
+        return ctx.error(DiagnosticCode.Not_implemented_0, stmt.matchExpr.range, "only structs supported for now, sorry!");
+    }
+    const ctors = deconstructableType.constructors;
+    const ctorNames = ctors.map(c => c.name);
+    const missingCtors = ctorNames.slice();
+    if (stmt.cases.length === 0)
+        return ctx.error(DiagnosticCode.A_match_statement_must_have_at_least_one_case, stmt.range);
+    const cases = [];
+    let wildcardCase = undefined;
+    const constrNamesAlreadySpecified = [];
+    for (const matchCase of stmt.cases) {
+        const branch = _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, constrNamesAlreadySpecified);
+        if (!branch)
+            return undefined;
+        if (branch instanceof TirMatchStmtWildcardCase) {
+            wildcardCase = branch;
+            break; // wildcard case catches any branch specified after it
+        }
+        const indexOfCtor = missingCtors.indexOf(branch.pattern.constrName);
+        if (indexOfCtor === -1) {
+            return ctx.error(DiagnosticCode.Unknown_0_constructor_1, branch.pattern.range, deconstructableType.toString(), branch.pattern.constrName);
+        }
+        missingCtors.splice(indexOfCtor, 1);
+        cases.push(branch);
+    }
+    if (!wildcardCase && cases.length < ctors.length) {
+        return ctx.error(DiagnosticCode.Match_cases_are_not_exhaustive, stmt.range);
+    }
+    return [new TirMatchStmt(matchExpr, cases, wildcardCase, stmt.range)];
+}
+export function _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, constrNamesAlreadySpecified) {
+    const pattern = _compileVarDecl(ctx, matchCase.pattern, deconstructableType);
+    if (!pattern)
+        return undefined;
+    if (pattern instanceof SimpleVarDecl) {
+        if (pattern.name.text === "_") {
+            const branchCtx = ctx.newBranchChildScope();
+            const branchBody = wrapManyStatements(_compileStatement(branchCtx, matchCase.body), matchCase.body.range);
+            if (!branchBody)
+                return undefined;
+            return new TirMatchStmtWildcardCase(branchBody, matchCase.range);
+        }
+        return ctx.error(DiagnosticCode.The_argument_of_a_match_statement_branch_must_be_deconstructed, matchCase.pattern.range);
+    }
+    else if (pattern instanceof NamedDeconstructVarDecl) {
+        const deconstructedCtorIdentifier = pattern.name;
+        const deconstructedCtorName = deconstructedCtorIdentifier.text;
+        if (constrNamesAlreadySpecified.includes(deconstructedCtorName))
+            return ctx.error(DiagnosticCode.Constructor_0_was_already_specified, deconstructedCtorIdentifier.range, deconstructedCtorName);
+        constrNamesAlreadySpecified.push(deconstructedCtorName);
+        if (deconstructableType instanceof TirDataT) {
+            if (!(deconstructedCtorName === "Constr" // { index, fields, ...rest }
+                || deconstructedCtorName === "Map" // { map, ...rest }
+                || deconstructedCtorName === "List" // { list, ...rest }
+                || deconstructedCtorName === "B" // { bytes, ...rest }
+                || deconstructedCtorName === "I" // { int, ...rest }
+            ))
+                return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, "data", deconstructedCtorName);
+            const branchCtx = ctx.newBranchChildScope();
+            const branchArg = _compileNamedDeconstructVarDecl(branchCtx, pattern, deconstructableType);
+            if (!branchArg)
+                return undefined;
+            const branchBody = wrapManyStatements(_compileStatement(branchCtx, matchCase.body), matchCase.body.range);
+            if (!branchBody)
+                return undefined;
+            return new TirMatchStmtCase(branchArg, branchBody, matchCase.range);
+        }
+        else if (deconstructableType instanceof TirSopOptT
+            || deconstructableType instanceof TirDataOptT) {
+            if (!(deconstructedCtorName === "Some" // { value, ...rest }
+                || deconstructedCtorName === "None" // { ...rest }
+            ))
+                return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, "Optional", deconstructedCtorName);
+            const branchCtx = ctx.newBranchChildScope();
+            const branchArg = _compileNamedDeconstructVarDecl(branchCtx, pattern, deconstructableType);
+            if (!branchArg)
+                return undefined;
+            const branchBody = wrapManyStatements(_compileStatement(branchCtx, matchCase.body), matchCase.body.range);
+            if (!branchBody)
+                return undefined;
+            return new TirMatchStmtCase(branchArg, branchBody, matchCase.range);
+        }
+        else if (deconstructableType instanceof TirSoPStructType
+            || deconstructableType instanceof TirDataStructType) {
+            const ctorDef = deconstructableType.constructors.find(c => c.name === deconstructedCtorName);
+            if (!ctorDef)
+                return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, deconstructableType.toString(), deconstructedCtorName);
+            const branchCtx = ctx.newBranchChildScope();
+            const branchArg = _compileNamedDeconstructVarDecl(branchCtx, pattern, deconstructableType);
+            if (!branchArg)
+                return undefined;
+            const branchBody = wrapManyStatements(_compileStatement(branchCtx, matchCase.body), matchCase.body.range);
+            if (!branchBody)
+                return undefined;
+            return new TirMatchStmtCase(branchArg, branchBody, matchCase.range);
+        }
+        // else if( deconstructableType instanceof TirListT )
+        // else if( deconstructableType instanceof TirLinearMapT )
+        else
+            return ctx.error(DiagnosticCode.A_value_of_type_0_cannot_be_deconstructed_by_named_object, matchCase.pattern.range, deconstructableType.toString());
+    }
+    else if (pattern instanceof SingleDeconstructVarDecl) {
+        if (!isTirStructType(deconstructableType))
+            return ctx.error(DiagnosticCode.A_value_of_type_0_cannot_be_deconstructed_as_unnamed_object, matchCase.pattern.range, deconstructableType.toString());
+        if (deconstructableType.constructors.length !== 1)
+            return ctx.error(DiagnosticCode.A_value_of_type_0_has_multiple_constructors, matchCase.pattern.range, deconstructableType.toString());
+        const branchCtx = ctx.newBranchChildScope();
+        const branchArg = _compileSingleDeconstructVarDecl(branchCtx, pattern, deconstructableType);
+        if (!branchArg)
+            return undefined;
+        if (!(branchArg instanceof TirNamedDeconstructVarDecl)) {
+            return ctx.error(DiagnosticCode.Not_implemented_0, matchCase.pattern.range, "only structs supported for now, sorry!");
+        }
+        const branchBody = wrapManyStatements(_compileStatement(branchCtx, matchCase.body), matchCase.body.range);
+        if (!branchBody)
+            return undefined;
+        return new TirMatchStmtCase(branchArg, branchBody, matchCase.range);
+    }
+    else if (pattern instanceof ArrayLikeDeconstr) {
+        return ctx.error(DiagnosticCode.Not_implemented_0, pattern.range, "only structs supported for now, sorry!");
+        /*
+        if(!(
+            deconstructableType instanceof TirListT
+            || deconstructableType instanceof TirLinearMapT
+        )) return ctx.error(
+            DiagnosticCode.A_value_of_type_0_cannot_be_deconstructed_as_an_array,
+            matchCase.pattern.range, deconstructableType.toString()
+        );
+
+        const branchCtx = ctx.newBranchChildScope();
+
+        const branchArg = _compileArrayLikeDeconstr(
+            branchCtx,
+            pattern,
+            deconstructableType
+        );
+        if( !branchArg ) return undefined;
+        const branchBody = wrapManyStatements(
+            _compileStatement(
+                branchCtx,
+                matchCase.body
+            ),
+            matchCase.body.range
+        );
+        if( !branchBody ) return undefined;
+
+        return new TirMatchStmtCase(
+            branchArg,
+            branchBody,
+            matchCase.range
+        );
+        //*/
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirLitVoidExpr } from "../../../tir/expressions/litteral/TirLitVoidExpr.js";
+import { TirReturnStmt } from "../../../tir/statements/TirReturnStmt.js";
+import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../exprs/_compileExpr.js";
+export function _compileReturnStmt(ctx, stmt) {
+    if (!ctx.functionCtx)
+        return ctx.error(DiagnosticCode.A_return_statement_can_only_be_used_within_a_function_body, stmt.range);
+    const hintReturn = ctx.functionCtx.returnType;
+    const expr = stmt.value ?
+        _compileExpr(ctx, stmt.value, hintReturn) : new TirLitVoidExpr(stmt.range);
+    if (!expr)
+        return undefined;
+    if (!canAssignTo(expr.type, hintReturn))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.value?.range ?? stmt.range, expr.type.toString(), hintReturn.toString());
+    return [new TirReturnStmt(expr, stmt.range)];
+}

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

@@ -0,0 +1,11 @@
+import { BodyStmt } from "../../../../ast/nodes/statements/PebbleStmt.js";
+import { TirStmt } from "../../../tir/statements/TirStmt.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+/**
+ * here we just translate to TIR
+ *
+ * WE DO NOT OPTIMIZE
+ *
+ * optimizaitons are part of the TIR -> TermIR compilation
+**/
+export declare function _compileStatement(ctx: AstCompilationCtx, stmt: BodyStmt): TirStmt[] | undefined;

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

@@ -0,0 +1,73 @@
+import { AssertStmt } from "../../../../ast/nodes/statements/AssertStmt.js";
+import { isAssignmentStmt } from "../../../../ast/nodes/statements/AssignmentStmt.js";
+import { BlockStmt } from "../../../../ast/nodes/statements/BlockStmt.js";
+import { BreakStmt } from "../../../../ast/nodes/statements/BreakStmt.js";
+import { ContinueStmt } from "../../../../ast/nodes/statements/ContinueStmt.js";
+import { EmptyStmt } from "../../../../ast/nodes/statements/EmptyStmt.js";
+import { FailStmt } from "../../../../ast/nodes/statements/FailStmt.js";
+import { ForOfStmt } from "../../../../ast/nodes/statements/ForOfStmt.js";
+import { ForStmt } from "../../../../ast/nodes/statements/ForStmt.js";
+import { IfStmt } from "../../../../ast/nodes/statements/IfStmt.js";
+import { MatchStmt } from "../../../../ast/nodes/statements/MatchStmt.js";
+import { ReturnStmt } from "../../../../ast/nodes/statements/ReturnStmt.js";
+import { UsingStmt } from "../../../../ast/nodes/statements/UsingStmt.js";
+import { VarStmt } from "../../../../ast/nodes/statements/VarStmt.js";
+import { WhileStmt } from "../../../../ast/nodes/statements/WhileStmt.js";
+import { _compileAssertStmt } from "./_compileAssertStmt.js";
+import { _compileAssignmentStmt } from "./_compileAssignmentStmt.js";
+import { _compileBlockStmt } from "./_compileBlockStmt.js";
+import { _compileBreakStmt } from "./_compileBreakStmt.js";
+import { _compileContinueStmt } from "./_compileContinueStmt.js";
+import { _compileFailStmt } from "./_compileFailStmt.js";
+import { _compileForOfStmt } from "./_compileForOfStmt.js";
+import { _compileForStmt } from "./_compileForStmt.js";
+import { _compileIfStmt } from "./_compileIfStmt.js";
+import { _compileMatchStmt } from "./_compileMatchStmt.js";
+import { _compileReturnStmt } from "./_compileReturnStmt.js";
+import { _compileUsingStmt } from "./_compileUsingStmt.js";
+import { _compileVarStmt } from "./_compileVarStmt.js";
+import { _compileWhileStmt } from "./_compileWhileStmt.js";
+/**
+ * here we just translate to TIR
+ *
+ * WE DO NOT OPTIMIZE
+ *
+ * optimizaitons are part of the TIR -> TermIR compilation
+**/
+export function _compileStatement(ctx, stmt) {
+    if (stmt instanceof IfStmt)
+        return _compileIfStmt(ctx, stmt);
+    if (stmt instanceof VarStmt)
+        return _compileVarStmt(ctx, stmt);
+    if (stmt instanceof ForStmt)
+        return _compileForStmt(ctx, stmt);
+    if (stmt instanceof ForOfStmt)
+        return _compileForOfStmt(ctx, stmt);
+    if (stmt instanceof WhileStmt)
+        return _compileWhileStmt(ctx, stmt);
+    if (stmt instanceof ReturnStmt)
+        return _compileReturnStmt(ctx, stmt);
+    if (stmt instanceof BlockStmt)
+        return _compileBlockStmt(ctx, stmt);
+    if (stmt instanceof BreakStmt)
+        return _compileBreakStmt(ctx, stmt);
+    if (stmt instanceof ContinueStmt)
+        return _compileContinueStmt(ctx, stmt);
+    if (stmt instanceof EmptyStmt)
+        return [];
+    if (stmt instanceof FailStmt)
+        return _compileFailStmt(ctx, stmt);
+    if (stmt instanceof AssertStmt)
+        return _compileAssertStmt(ctx, stmt);
+    // if( stmt instanceof TestStmt ) return _compileTestStmt( ctx, stmt );
+    if (stmt instanceof MatchStmt)
+        return _compileMatchStmt(ctx, stmt);
+    if (isAssignmentStmt(stmt))
+        return _compileAssignmentStmt(ctx, stmt);
+    // if( stmt instanceof ExprStmt ) return _compileExprStmt( ctx, stmt );
+    if (stmt instanceof UsingStmt)
+        return _compileUsingStmt(ctx, stmt);
+    const tsEnsureExsautstiveCheck = stmt;
+    console.error(stmt);
+    throw new Error("unreachable::AstCompiler::_compileStatement");
+}

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

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

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

@@ -0,0 +1,32 @@
+export {};
+/*
+export function _compileTestStmt(
+    ctx: AstCompilationCtx,
+    stmt: TestStmt
+): [ TirTestStmt ] | undefined
+{
+    if( ctx.functionCtx ) return ctx.error(
+        DiagnosticCode.A_test_statement_can_only_be_used_outside_a_function,
+        stmt.range
+    );
+
+    let tirBody = wrapManyStatements(
+        _compileStatement(
+            ctx.newBranchChildScope(),
+            stmt.body
+        ),
+        stmt.body.range
+    );
+    if( !tirBody ) return undefined;
+    if(!( tirBody instanceof TirBlockStmt))
+    {
+        tirBody = new TirBlockStmt( [ tirBody ], stmt.body.range );
+    }
+
+    return [ new TirTestStmt(
+        stmt.testName?.string,
+        tirBody as TirBlockStmt,
+        stmt.range
+    ) ];
+}
+//*/ 

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

@@ -0,0 +1,11 @@
+import { UsingStmt } from "../../../../ast/nodes/statements/UsingStmt.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+/**
+ * `using` only introduces symbols in scope
+ *
+ * we don't represent `using` statements in the TIR
+ *
+ * @returns {[]} an empty array if successful compilation
+ * @returns {undefined} `undefined` if compilation failed
+**/
+export declare function _compileUsingStmt(ctx: AstCompilationCtx, stmt: UsingStmt): [] | undefined;

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

@@ -0,0 +1,41 @@
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { getStructType } from "../../../tir/types/utils/canAssignTo.js";
+import { _compileDataEncodedConcreteType } from "../types/_compileDataEncodedConcreteType.js";
+import { _compileSopEncodedConcreteType } from "../types/_compileSopEncodedConcreteType.js";
+/**
+ * `using` only introduces symbols in scope
+ *
+ * we don't represent `using` statements in the TIR
+ *
+ * @returns {[]} an empty array if successful compilation
+ * @returns {undefined} `undefined` if compilation failed
+**/
+export function _compileUsingStmt(ctx, stmt) {
+    stmt.constructorNames;
+    stmt.structTypeExpr;
+    stmt.range;
+    const structOrAliasType = (_compileSopEncodedConcreteType(ctx, stmt.structTypeExpr)
+        ?? _compileDataEncodedConcreteType(ctx, stmt.structTypeExpr));
+    if (!structOrAliasType)
+        return undefined;
+    // un-alias
+    const structType = getStructType(structOrAliasType);
+    if (!structType || !structType.isConcrete())
+        return ctx.error(DiagnosticCode.Type_0_does_not_have_constructors, stmt.structTypeExpr.range, structOrAliasType.toString());
+    const defCtorNames = structType.constructors.map(c => c.name);
+    const sameStmtCtorNames = [];
+    for (const stmtCtor of stmt.constructorNames) {
+        const stmtCtorNameId = stmtCtor.constructorName;
+        const stmtCtorName = stmtCtorNameId.text;
+        const stmtReassignedCtorName = stmtCtor.renamedConstructorName;
+        if (!defCtorNames.includes(stmtCtorName))
+            return ctx.error(DiagnosticCode.Constructor_0_is_not_part_of_the_definition_of_1, stmtCtorNameId.range, stmtCtorName, structType.toString());
+        if (sameStmtCtorNames.includes(stmtCtorName))
+            return ctx.error(DiagnosticCode.Constructor_0_was_already_specified, stmtCtorNameId.range, stmtCtorName);
+        sameStmtCtorNames.push(stmtCtorName);
+        const valid = ctx.scope.defineAviableConstructorIfValid(stmtReassignedCtorName?.text ?? stmtCtorName, stmtCtorName, structOrAliasType);
+        if (!valid)
+            return ctx.error(DiagnosticCode.Constructor_name_0_is_already_declared_in_this_scope, stmtCtorNameId.range, stmtCtorName);
+    }
+    return [];
+}

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

@@ -0,0 +1,34 @@
+import { PebbleExpr } from "../../../../ast/nodes/expr/PebbleExpr.js";
+import { ArrayLikeDeconstr } from "../../../../ast/nodes/statements/declarations/VarDecl/ArrayLikeDeconstr.js";
+import { NamedDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/NamedDeconstructVarDecl.js";
+import { SimpleVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
+import { SingleDeconstructVarDecl, ISingleDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SingleDeconstructVarDecl.js";
+import { VarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/VarDecl.js";
+import { VarStmt } from "../../../../ast/nodes/statements/VarStmt.js";
+import { AstTypeExpr } from "../../../../ast/nodes/types/AstTypeExpr.js";
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../../../tir/expressions/TirExpr.js";
+import { TirArrayLikeDeconstr } from "../../../tir/statements/TirVarDecl/TirArrayLikeDeconstr.js";
+import { TirNamedDeconstructVarDecl } from "../../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
+import { TirVarDecl } from "../../../tir/statements/TirVarDecl/TirVarDecl.js";
+import { TirStructConstr } from "../../../tir/types/TirStructType.js";
+import { TirType } from "../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+export declare function _compileVarStmt(ctx: AstCompilationCtx, stmt: VarStmt): TirVarDecl[] | undefined;
+export declare function _compileVarDecl(ctx: AstCompilationCtx, decl: VarDecl, typeHint: TirType | undefined): TirVarDecl | undefined;
+export declare function _compileSimpleVarDecl(ctx: AstCompilationCtx, decl: SimpleVarDecl, typeHint: TirType | undefined): TirVarDecl | undefined;
+export declare function _compileNamedDeconstructVarDecl(ctx: AstCompilationCtx, decl: NamedDeconstructVarDecl, typeHint: TirType | undefined): TirNamedDeconstructVarDecl | undefined;
+export declare function _compileSingleDeconstructVarDecl(ctx: AstCompilationCtx, decl: SingleDeconstructVarDecl, typeHint: TirType | undefined): TirVarDecl | undefined;
+export declare function _compileArrayLikeDeconstr(ctx: AstCompilationCtx, decl: ArrayLikeDeconstr, typeHint: TirType | undefined): TirArrayLikeDeconstr | undefined;
+export declare function _getDeconstructedFields(ctx: AstCompilationCtx, astDeconstruct: ISingleDeconstructVarDecl, ctorDef: TirStructConstr): [
+    fields: Map<string, TirVarDecl>,
+    rest: string | undefined
+] | undefined;
+export declare function _getVarDeclTypeAndExpr(ctx: AstCompilationCtx, decl: {
+    type: AstTypeExpr | undefined;
+    initExpr: PebbleExpr | undefined;
+    range: SourceRange;
+}, deconstructTypeHint: TirType | undefined): [
+    varType: TirType,
+    varInitExpr: TirExpr | undefined
+] | undefined;