@harmoniclabs/pebble 0.1.0-dev0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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