@harmoniclabs/pebble 0.1.0-dev0 → 0.1.0-dev2

package/dist/compiler/AstCompiler/internal/exprs/_compileNonNullExpr.js

@@ -1,43 +0,0 @@
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirCaseExpr, TirCaseMatcher } from "../../../tir/expressions/TirCaseExpr.js";
-import { TirFailExpr } from "../../../tir/expressions/TirFailExpr.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 { getOptTypeArg } from "../../../tir/types/utils/getOptTypeArg.js";
-import { _compileExpr } from "./_compileExpr.js";
-export function _compileNonNullExpr(ctx, expr, typeHint) {
-    const operand = _compileExpr(ctx, expr.operand, typeHint);
-    if (!operand)
-        return undefined;
-    const optionalType = operand.type;
-    const nonNullType = getOptTypeArg(optionalType);
-    if (!nonNullType) {
-        ctx.warning(DiagnosticCode.Non_null_opeartor_used_on_expression_of_type_0_which_is_not_optional_this_will_be_omitted_during_compilation, expr.operand.range, optionalType.toString());
-        return operand;
-    }
-    return new TirCaseExpr(operand, [
-        new TirCaseMatcher(new TirNamedDeconstructVarDecl("Some", new Map([
-            ["value", new TirSimpleVarDecl("value", nonNullType, undefined, // no init expr
-                true, // isConst
-                expr.range)]
-        ]), undefined, // no rest
-        optionalType, undefined, // no init expr
-        true, // isConst
-        expr.range), new TirVariableAccessExpr({
-            variableInfos: {
-                name: "value",
-                type: nonNullType,
-                isConstant: true
-            },
-            isDefinedOutsideFuncScope: false,
-        }, expr.range), expr.range),
-        new TirCaseMatcher(new TirNamedDeconstructVarDecl("None", new Map(), // no fields extracted
-        undefined, // no rest
-        optionalType, undefined, // no init expr
-        true, // isConst
-        expr.range), new TirFailExpr(undefined, // no message
-        nonNullType, expr.range), expr.range)
-    ], undefined, // no wildcard case
-    nonNullType, expr.range);
-}

package/dist/compiler/AstCompiler/internal/exprs/_compilePropAccessExpr.d.ts

@@ -1,9 +0,0 @@
-import { PropAccessExpr, OptionalPropAccessExpr, NonNullPropAccessExpr, DotPropAccessExpr } from "../../../../ast/nodes/expr/PropAccessExpr.js";
-import { TirExpr } from "../../../tir/expressions/TirExpr.js";
-import { TirPropAccessExpr } from "../../../tir/expressions/TirPropAccessExpr.js";
-import { TirType } from "../../../tir/types/TirType.js";
-import { AstCompilationCtx } from "../../AstCompilationCtx.js";
-export declare function _compilePropAccessExpr(ctx: AstCompilationCtx, expr: PropAccessExpr, typeHint: TirType | undefined): TirExpr | undefined;
-export declare function _compileOptionalPropAccessExpr(ctx: AstCompilationCtx, expr: OptionalPropAccessExpr, _typeHint: TirType | undefined): TirExpr | undefined;
-export declare function _compileNonNullPropAccessExpr(ctx: AstCompilationCtx, expr: NonNullPropAccessExpr, _typeHint: TirType | undefined): TirPropAccessExpr | undefined;
-export declare function _compileDotPropAccessExpr(ctx: AstCompilationCtx, expr: DotPropAccessExpr, _typeHint: TirType | undefined): TirPropAccessExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/_compilePropAccessExpr.js

@@ -1,102 +0,0 @@
-import { OptionalPropAccessExpr, NonNullPropAccessExpr, DotPropAccessExpr } from "../../../../ast/nodes/expr/PropAccessExpr.js";
-import { NonNullExpr } from "../../../../ast/nodes/expr/unary/NonNullExpr.js";
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirCaseExpr, TirCaseMatcher } from "../../../tir/expressions/TirCaseExpr.js";
-import { TirPropAccessExpr } from "../../../tir/expressions/TirPropAccessExpr.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 { getOptTypeArg } from "../../../tir/types/utils/getOptTypeArg.js";
-import { getPropAccessReturnType } from "../../utils/getPropAccessReturnType.js";
-import { _compileExpr } from "./_compileExpr.js";
-import { _compileNonNullExpr } from "./_compileNonNullExpr.js";
-import { TirLitNamedObjExpr } from "../../../tir/expressions/litteral/TirLitNamedObjExpr.js";
-import { Identifier } from "../../../../ast/nodes/common/Identifier.js";
-import { TirSopOptT } from "../../../tir/types/TirNativeType/native/Optional/sop.js";
-export function _compilePropAccessExpr(ctx, expr, typeHint) {
-    if (expr instanceof OptionalPropAccessExpr)
-        return _compileOptionalPropAccessExpr(ctx, expr, typeHint);
-    if (expr instanceof NonNullPropAccessExpr)
-        return _compileNonNullPropAccessExpr(ctx, expr, typeHint);
-    if (expr instanceof DotPropAccessExpr)
-        return _compileDotPropAccessExpr(ctx, expr, typeHint);
-    const tsEnsureExsautstiveCheck = expr;
-    console.error(expr);
-    throw new Error("unreachable::AstCompiler::_compilePropAccessExpr");
-}
-export function _compileOptionalPropAccessExpr(ctx, expr, _typeHint) {
-    const optionalObjExpr = _compileExpr(ctx, expr.object, undefined);
-    if (!optionalObjExpr)
-        return undefined;
-    const optionalObjType = optionalObjExpr.type;
-    const objType = getOptTypeArg(optionalObjType);
-    if (!objType) {
-        // object type is not optional, compile as a normal prop access
-        const returnType = getPropAccessReturnType(ctx, optionalObjType, expr.prop);
-        if (!returnType)
-            return ctx.error(DiagnosticCode.Property_0_does_not_exist_on_type_1, expr.prop.range, expr.prop.text, optionalObjType.toString());
-        return new TirPropAccessExpr(optionalObjExpr, expr.prop, returnType, expr.range);
-    }
-    const returnType = getPropAccessReturnType(ctx, objType, expr.prop);
-    if (!returnType)
-        return ctx.error(DiagnosticCode.Property_0_does_not_exist_on_type_1, expr.prop.range, expr.prop.text, objType.toString());
-    const optionalReturnType = new TirSopOptT(returnType);
-    /*
-    `obj?.prop` is compiled as:
-    ```
-    case obj
-    is Some{ value } => value.prop
-    is None => None
-    ```
-    */
-    return new TirCaseExpr(optionalObjExpr, [
-        // is Some{ value } => value.prop
-        new TirCaseMatcher(
-        // Some{ value }
-        new TirNamedDeconstructVarDecl("Some", new Map([
-            ["value", new TirSimpleVarDecl("value", objType, undefined, true, optionalObjExpr.range)]
-        ]), undefined, // rest
-        optionalObjType, undefined, // no init expr
-        true, // constant
-        expr.range.atEnd()), 
-        // value.prop
-        new TirPropAccessExpr(
-        // value
-        new TirVariableAccessExpr({
-            variableInfos: {
-                isConstant: true,
-                name: "value",
-                type: objType,
-            },
-            isDefinedOutsideFuncScope: false,
-        }, optionalObjExpr.range), 
-        // .prop
-        expr.prop, returnType, expr.range), expr.range),
-        // is None => None
-        new TirCaseMatcher(
-        // is None
-        new TirNamedDeconstructVarDecl("None", new Map(), undefined, // rest
-        optionalObjType, undefined, // no init expr
-        true, // constant
-        expr.range), 
-        // => None
-        new TirLitNamedObjExpr(new Identifier("None", optionalObjExpr.range.atEnd()), [], [], optionalObjType, optionalObjExpr.range.atEnd()), optionalObjExpr.range.atEnd())
-    ], undefined, // no wildcard case
-    optionalReturnType, expr.range);
-}
-export function _compileNonNullPropAccessExpr(ctx, expr, _typeHint) {
-    const nonNullObjExpr = _compileNonNullExpr(ctx, new NonNullExpr(expr.object, expr.object.range), undefined);
-    if (!nonNullObjExpr)
-        return undefined;
-    return _compileDotPropAccessExpr(ctx, new DotPropAccessExpr(nonNullObjExpr, expr.prop, expr.range), _typeHint);
-}
-export function _compileDotPropAccessExpr(ctx, expr, _typeHint) {
-    const objExpr = _compileExpr(ctx, expr.object, undefined);
-    if (!objExpr)
-        return undefined;
-    const objType = objExpr.type;
-    const returnType = getPropAccessReturnType(ctx, objType, expr.prop);
-    if (!returnType)
-        return ctx.error(DiagnosticCode.Property_0_does_not_exist_on_type_1, expr.prop.range, expr.prop.text, objType.toString());
-    return new TirPropAccessExpr(objExpr, expr.prop, returnType, expr.range);
-}

package/dist/compiler/AstCompiler/internal/exprs/_compileTernaryExpr.d.ts

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

package/dist/compiler/AstCompiler/internal/exprs/_compileTernaryExpr.js

@@ -1,22 +0,0 @@
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirTernaryExpr } from "../../../tir/expressions/TirTernaryExpr.js";
-import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
-import { _compileExpr } from "./_compileExpr.js";
-export function _compileTernaryExpr(ctx, expr, typeHint) {
-    const bool_t = ctx.program.stdTypes.bool;
-    const cond = _compileExpr(ctx, expr.condition, bool_t);
-    if (!cond)
-        return undefined;
-    if (!canAssignTo(cond.type, bool_t))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.condition.range, cond.type.toString(), bool_t.toString());
-    const thenExpr = _compileExpr(ctx, expr.ifTrue, typeHint);
-    if (!thenExpr)
-        return undefined;
-    const returnType = thenExpr.type;
-    const elseExpr = _compileExpr(ctx, expr.ifFalse, returnType);
-    if (!elseExpr)
-        return undefined;
-    if (!canAssignTo(elseExpr.type, returnType))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.ifFalse.range, elseExpr.type.toString(), returnType.toString());
-    return new TirTernaryExpr(cond, thenExpr, elseExpr, returnType, expr.range);
-}

package/dist/compiler/AstCompiler/internal/exprs/_compileTypeConversionExpr.d.ts

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

package/dist/compiler/AstCompiler/internal/exprs/_compileTypeConversionExpr.js

@@ -1,25 +0,0 @@
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirTypeConversionExpr } from "../../../tir/expressions/TirTypeConversionExpr.js";
-import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
-import { canCastTo } from "../../../tir/types/utils/canCastTo.js";
-import { _compileExpr } from "./_compileExpr.js";
-export function _compileTypeConversionExpr(ctx, ast, typeHint) {
-    const data_t = ctx.program.stdTypes.data;
-    const possibleTargetTypeTirNames = ctx.scope.resolveType(ast.asType.toAstName());
-    if (!possibleTargetTypeTirNames)
-        return ctx.error(DiagnosticCode._0_is_not_defined, ast.asType.range, ast.asType.toAstName());
-    const sopTargetType = ctx.program.types.get(possibleTargetTypeTirNames.sopTirName);
-    if (!sopTargetType)
-        return ctx.error(DiagnosticCode._0_is_not_defined, ast.asType.range, ast.asType.toAstName());
-    const dataTargetType = typeof possibleTargetTypeTirNames.dataTirName === "string" ?
-        ctx.program.types.get(possibleTargetTypeTirNames.dataTirName) :
-        undefined;
-    const expr = _compileExpr(ctx, ast.expr, dataTargetType);
-    if (!expr)
-        return undefined;
-    const targetType = (dataTargetType
-        && canAssignTo(expr.type, data_t)) ? dataTargetType : sopTargetType;
-    if (!canCastTo(expr.type, targetType))
-        return ctx.error(DiagnosticCode.Type_0_cannot_be_converted_to_type_1, ast.expr.range, expr.type.toString(), targetType.toString());
-    return new TirTypeConversionExpr(expr, targetType, ast.range);
-}

package/dist/compiler/AstCompiler/internal/exprs/_compileUnaryPrefixExpr.d.ts

@@ -1,5 +0,0 @@
-import { UnaryPrefixExpr } from "../../../../ast/nodes/expr/unary/UnaryPrefixExpr.js";
-import { TirUnaryPrefixExpr } from "../../../tir/expressions/unary/TirUnaryPrefixExpr.js";
-import { TirType } from "../../../tir/types/TirType.js";
-import { AstCompilationCtx } from "../../AstCompilationCtx.js";
-export declare function _compileUnaryPrefixExpr(ctx: AstCompilationCtx, expr: UnaryPrefixExpr, _typeHint: TirType | undefined): TirUnaryPrefixExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/_compileUnaryPrefixExpr.js

@@ -1,54 +0,0 @@
-import { UnaryExclamation } from "../../../../ast/nodes/expr/unary/UnaryExclamation.js";
-import { UnaryMinus } from "../../../../ast/nodes/expr/unary/UnaryMinus.js";
-import { UnaryPlus } from "../../../../ast/nodes/expr/unary/UnaryPlus.js";
-import { UnaryTilde } from "../../../../ast/nodes/expr/unary/UnaryTilde.js";
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirUnaryExclamation } from "../../../tir/expressions/unary/TirUnaryExclamation.js";
-import { TirUnaryMinus } from "../../../tir/expressions/unary/TirUnaryMinus.js";
-import { TirUnaryPlus } from "../../../tir/expressions/unary/TirUnaryPlus.js";
-import { TirUnaryTilde } from "../../../tir/expressions/unary/TirUnaryTilde.js";
-import { canAssignTo, canAssignToOptional } from "../../../tir/types/utils/canAssignTo.js";
-import { _compileExpr } from "./_compileExpr.js";
-export function _compileUnaryPrefixExpr(ctx, expr, _typeHint) {
-    const bool_t = ctx.program.stdTypes.bool;
-    const int_t = ctx.program.stdTypes.int;
-    const bytes_t = ctx.program.stdTypes.bytes;
-    if (expr instanceof UnaryExclamation) {
-        const operand = _compileExpr(ctx, expr.operand, bool_t);
-        if (!operand)
-            return undefined;
-        const operandType = operand.type;
-        if (!(canAssignTo(operandType, bool_t)
-            || canAssignToOptional(operandType))) {
-            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.operand.range, operand.type.toString(), "boolean | Optional<T>");
-        }
-        return new TirUnaryExclamation(operand, bool_t, expr.range);
-    }
-    else if (expr instanceof UnaryPlus
-        || expr instanceof UnaryMinus) {
-        const operand = _compileExpr(ctx, expr.operand, int_t);
-        if (!operand)
-            return undefined;
-        const operandType = operand.type;
-        if (!canAssignTo(operandType, int_t)) {
-            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.operand.range, operand.type.toString(), "int");
-        }
-        if (expr instanceof UnaryPlus)
-            return new TirUnaryPlus(operand, int_t, expr.range);
-        if (expr instanceof UnaryMinus)
-            return new TirUnaryMinus(operand, int_t, expr.range);
-    }
-    else if (expr instanceof UnaryTilde) {
-        const operand = _compileExpr(ctx, expr.operand, bytes_t);
-        if (!operand)
-            return undefined;
-        const operandType = operand.type;
-        if (!canAssignTo(operandType, bytes_t)) {
-            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.operand.range, operand.type.toString(), "bytes");
-        }
-        return new TirUnaryTilde(operand, int_t, expr.range);
-    }
-    const tsEnsureExsautstiveCheck = expr;
-    console.error(expr);
-    throw new Error("unreachable::AstCompiler::_compileUnaryPrefixExpr");
-}

package/dist/compiler/AstCompiler/internal/exprs/_compileVarAccessExpr.d.ts

@@ -1,5 +0,0 @@
-import { Identifier } from "../../../../ast/nodes/common/Identifier.js";
-import { TirVariableAccessExpr } from "../../../tir/expressions/TirVariableAccessExpr.js";
-import { TirType } from "../../../tir/types/TirType.js";
-import { AstCompilationCtx } from "../../AstCompilationCtx.js";
-export declare function _compileVarAccessExpr(ctx: AstCompilationCtx, expr: Identifier, typeHint: TirType | undefined): TirVariableAccessExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/_compileVarAccessExpr.js

@@ -1,9 +0,0 @@
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirVariableAccessExpr } from "../../../tir/expressions/TirVariableAccessExpr.js";
-export function _compileVarAccessExpr(ctx, expr, typeHint) {
-    const resolvedValue = ctx.scope.resolveValue(expr.text);
-    if (!resolvedValue)
-        return ctx.error(DiagnosticCode._0_is_not_defined, expr.range, expr.text);
-    // const { variableInfos, isDefinedOutsideFuncScope } = resolvedValue;
-    return new TirVariableAccessExpr(resolvedValue, expr.range);
-}

package/dist/compiler/AstCompiler/internal/exprs/_hasDuplicateTypeParams.d.ts

@@ -1,3 +0,0 @@
-import { Identifier } from "../../../../ast/nodes/common/Identifier.js";
-import { AstCompilationCtx } from "../../AstCompilationCtx.js";
-export declare function _hasDuplicateTypeParams(ctx: AstCompilationCtx, typeParams: Identifier[]): boolean;

package/dist/compiler/AstCompiler/internal/exprs/_hasDuplicateTypeParams.js

@@ -1,13 +0,0 @@
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-export function _hasDuplicateTypeParams(ctx, typeParams) {
-    const typeParamNames = new Set();
-    let result = false;
-    for (const tp of typeParams) {
-        if (typeParamNames.has(tp.text)) {
-            ctx.error(DiagnosticCode.Duplicate_identifier_0, tp.range, tp.text);
-            result = true;
-        }
-        typeParamNames.add(tp.text);
-    }
-    return result;
-}

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

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

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

@@ -1,20 +0,0 @@
-import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirAddExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
-import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
-import { _compileExpr } from "../_compileExpr.js";
-export function _compileAddExpr(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 TirAddExpr(left, right, 
-    // implicit int type,
-    expr.range);
-}

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

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

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

@@ -1,20 +0,0 @@
-import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirBitwiseAndExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
-import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
-import { _compileExpr } from "../_compileExpr.js";
-export function _compileBitwiseAndExpr(ctx, expr, _typeHint) {
-    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, bytes_t);
-    if (!right)
-        return undefined;
-    if (!canAssignTo(right.type, bytes_t))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), bytes_t.toString());
-    return new TirBitwiseAndExpr(left, right, 
-    // implicit bytes type,
-    expr.range);
-}

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

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

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

@@ -1,20 +0,0 @@
-import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirBitwiseOrExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
-import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
-import { _compileExpr } from "../_compileExpr.js";
-export function _compileBitwiseOrExpr(ctx, expr, _typeHint) {
-    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, bytes_t);
-    if (!right)
-        return undefined;
-    if (!canAssignTo(right.type, bytes_t))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), bytes_t.toString());
-    return new TirBitwiseOrExpr(left, right, 
-    // implicit bytes type,
-    expr.range);
-}

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

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

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

@@ -1,20 +0,0 @@
-import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirBitwiseXorExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
-import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
-import { _compileExpr } from "../_compileExpr.js";
-export function _compileBitwiseXorExpr(ctx, expr, _typeHint) {
-    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, bytes_t);
-    if (!right)
-        return undefined;
-    if (!canAssignTo(right.type, bytes_t))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), bytes_t.toString());
-    return new TirBitwiseXorExpr(left, right, 
-    // implicit bytes type,
-    expr.range);
-}

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

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

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

@@ -1,20 +0,0 @@
-import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirDivExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
-import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
-import { _compileExpr } from "../_compileExpr.js";
-export function _compileDivExpr(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 TirDivExpr(left, right, 
-    // implicit int type,
-    expr.range);
-}

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

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

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

@@ -1,18 +0,0 @@
-import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
-import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
-import { _compileExpr } from "../_compileExpr.js";
-export function _compileEqualExpr(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 TirEqualExpr(left, right, 
-    // implicit bool type,
-    expr.range);
-}

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

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

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

@@ -1,20 +0,0 @@
-import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirExponentiationExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
-import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
-import { _compileExpr } from "../_compileExpr.js";
-export function _compileExponentiationExpr(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 TirExponentiationExpr(left, right, 
-    // implicit int type
-    expr.range);
-}

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

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

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

@@ -1,27 +0,0 @@
-import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirGreaterThanEqualExpr } 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";
-// only aviable for ints and bytes
-export function _compileGreaterThanEqualExpr(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 TirGreaterThanEqualExpr(left, right, 
-    // implicit bool type,
-    expr.range);
-}

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

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

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

@@ -1,26 +0,0 @@
-import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirGreaterThanExpr } 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 _compileGreaterThanExpr(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 TirGreaterThanExpr(left, right, 
-    // implicit bool type,
-    expr.range);
-}

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

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