@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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