@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev3

package/dist/compiler/tir/expressions/litteral/TirLitIntExpr.js

@@ -0,0 +1,19 @@
+import { int_t } from "../../program/stdScope/stdScope.js";
+import { IRConst } from "../../../../IR/index.js";
+export class TirLitIntExpr {
+    integer;
+    range;
+    type = int_t;
+    isConstant = true;
+    constructor(integer, range) {
+        this.integer = integer;
+        this.range = range;
+    }
+    clone() {
+        return new TirLitIntExpr(this.integer, this.range.clone());
+    }
+    deps() { return []; }
+    toIR(ctx) {
+        return IRConst.int(this.integer);
+    }
+}

package/dist/compiler/tir/expressions/litteral/TirLitNamedObjExpr.d.ts

@@ -0,0 +1,22 @@
+import { Identifier } from "../../../../ast/nodes/common/Identifier.js";
+import { ITirExpr } from "../ITirExpr.js";
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../TirExpr.js";
+import { ITirLitObjExpr } from "./TirLitObjExpr.js";
+import { IRTerm } from "../../../../IR/index.js";
+import { TirDataStructType, TirSoPStructType } from "../../types/TirStructType.js";
+import { ToIRTermCtx } from "../ToIRTermCtx.js";
+import { TirDataOptT } from "../../types/TirNativeType/native/Optional/data.js";
+import { TirSopOptT } from "../../types/TirNativeType/native/Optional/sop.js";
+export declare class TirLitNamedObjExpr implements ITirExpr, ITirLitObjExpr {
+    readonly name: Identifier;
+    readonly fieldNames: Identifier[];
+    readonly values: TirExpr[];
+    readonly type: TirSoPStructType | TirDataStructType | TirSopOptT | TirDataOptT;
+    readonly range: SourceRange;
+    get isConstant(): boolean;
+    constructor(name: Identifier, fieldNames: Identifier[], values: TirExpr[], type: TirSoPStructType | TirDataStructType | TirSopOptT | TirDataOptT, range: SourceRange);
+    clone(): TirLitNamedObjExpr;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/litteral/TirLitNamedObjExpr.js

@@ -0,0 +1,105 @@
+import { mergeSortedStrArrInplace } from "../../../../utils/array/mergeSortedStrArrInplace.js";
+import { IRConstr } from "../../../../IR/index.js";
+import { data_t } from "../../program/stdScope/stdScope.js";
+import { TirAliasType } from "../../types/TirAliasType.js";
+import { TirSoPStructType } from "../../types/TirStructType.js";
+import { TirTypeParam } from "../../types/TirTypeParam.js";
+import { getUnaliased } from "../../types/utils/getUnaliased.js";
+import { TirCallExpr } from "../TirCallExpr.js";
+import { TirToDataExpr } from "../TirToDataExpr.js";
+import { TirLitArrExpr } from "./TirLitArrExpr.js";
+import { TirLitIntExpr } from "./TirLitIntExpr.js";
+import { TirNativeFunc } from "../TirNativeFunc.js";
+import { isObject } from "@harmoniclabs/obj-utils";
+import { TirPairDataT } from "../../types/TirNativeType/index.js";
+import { TirFuncT } from "../../types/TirNativeType/native/function.js";
+import { TirListT } from "../../types/TirNativeType/native/list.js";
+import { TirSopOptT } from "../../types/TirNativeType/native/Optional/sop.js";
+export class TirLitNamedObjExpr {
+    name;
+    fieldNames;
+    values;
+    type;
+    range;
+    get isConstant() {
+        return this.values.every(value => value.isConstant);
+    }
+    constructor(name, fieldNames, values, type, range) {
+        this.name = name;
+        this.fieldNames = fieldNames;
+        this.values = values;
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirLitNamedObjExpr(this.name, this.fieldNames.map(f => f), this.values.map(v => v.clone()), this.type.clone(), this.range.clone());
+    }
+    deps() {
+        return this.values.reduce((deps, value) => {
+            const valueDeps = value.deps();
+            mergeSortedStrArrInplace(deps, valueDeps);
+            return deps;
+        }, []);
+    }
+    toIR(ctx) {
+        const type = this.type;
+        const ctorIdx = type.constructors.findIndex(c => c.name === this.name.text);
+        if (ctorIdx < 0)
+            throw new Error("invalid constructor name in named object literal.");
+        const ctor = type.constructors[ctorIdx];
+        const fields = ctor.fields;
+        const fNames = fields.map(f => f.name);
+        if (fields.length !== this.fieldNames.length
+            || this.fieldNames.length !== this.values.length)
+            throw new Error("incorrect number of fields in object literal");
+        const len = fNames.length;
+        const _namedFields = new Array(len);
+        for (let i = 0; i < len; i++) {
+            _namedFields[i] = {
+                name: fNames[i],
+                expr: this.values[i]
+            };
+        }
+        // sort according to definition order
+        const namedFields = fNames.map(f => _namedFields.find(n => n.name === f));
+        if (namedFields.some(thing => !isObject(thing))) {
+            throw new Error("missing field in object literal");
+        }
+        if (type instanceof TirSoPStructType) {
+            return new IRConstr(0, namedFields.map(({ expr }) => expr.toIR(ctx)));
+        }
+        // else data
+        const exprsAsData = namedFields.map(({ expr }) => {
+            const exprType = getUnaliased(expr.type) ?? expr.type;
+            if (exprType instanceof TirSoPStructType
+                || exprType instanceof TirSopOptT
+                || exprType instanceof TirFuncT
+                || exprType instanceof TirPairDataT
+                // we have no way to describe it to typescript if not this way
+                || exprType instanceof TirAliasType
+                || exprType instanceof TirTypeParam)
+                throw new Error("filed cannot be encoded as data");
+            /*
+            const returnType = (
+                exprType instanceof TirVoidT
+                || exprType instanceof TirBoolT
+                || exprType instanceof TirIntT
+                || exprType instanceof TirBytesT
+                || exprType instanceof TirStringT
+                || exprType instanceof TirDataT
+                || exprType instanceof TirListT
+                || exprType instanceof TirLinearMapT
+                || exprType instanceof TirUnConstrDataResultT
+            ) ? data_t : exprType;
+            //*/
+            return new TirToDataExpr(expr, expr.range);
+        });
+        const fieldsAsListOfData = new TirLitArrExpr(exprsAsData, new TirListT(data_t), this.range);
+        return (type.untagged ?
+            new TirCallExpr(TirNativeFunc.listData, [fieldsAsListOfData], data_t, this.range).toIR(ctx) :
+            new TirCallExpr(TirNativeFunc.constrData, [
+                new TirLitIntExpr(BigInt(ctorIdx), this.range),
+                fieldsAsListOfData
+            ], data_t, this.range).toIR(ctx));
+    }
+}

package/dist/compiler/tir/expressions/litteral/TirLitObjExpr.d.ts

@@ -0,0 +1,22 @@
+import { Identifier } from "../../../../ast/nodes/common/Identifier.js";
+import { ITirExpr } from "../ITirExpr.js";
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../TirExpr.js";
+import { TirDataStructType, TirSoPStructType } from "../../types/TirStructType.js";
+import { ToIRTermCtx } from "../ToIRTermCtx.js";
+import { IRTerm } from "../../../../IR/index.js";
+export interface ITirLitObjExpr {
+    fieldNames: Identifier[];
+    values: TirExpr[];
+}
+export declare class TirLitObjExpr implements ITirExpr, ITirLitObjExpr {
+    readonly fieldNames: Identifier[];
+    readonly values: TirExpr[];
+    readonly type: TirSoPStructType | TirDataStructType;
+    readonly range: SourceRange;
+    get isConstant(): boolean;
+    constructor(fieldNames: Identifier[], values: TirExpr[], type: TirSoPStructType | TirDataStructType, range: SourceRange);
+    clone(): TirLitObjExpr;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/litteral/TirLitObjExpr.js

@@ -0,0 +1,102 @@
+import { mergeSortedStrArrInplace } from "../../../../utils/array/mergeSortedStrArrInplace.js";
+import { TirSoPStructType } from "../../types/TirStructType.js";
+import { IRConstr } from "../../../../IR/index.js";
+import { isObject } from "@harmoniclabs/obj-utils";
+import { TirToDataExpr } from "../TirToDataExpr.js";
+import { getUnaliased } from "../../types/utils/getUnaliased.js";
+import { data_t } from "../../program/stdScope/stdScope.js";
+import { TirAliasType } from "../../types/TirAliasType.js";
+import { TirTypeParam } from "../../types/TirTypeParam.js";
+import { TirLitArrExpr } from "./TirLitArrExpr.js";
+import { TirCallExpr } from "../TirCallExpr.js";
+import { TirLitIntExpr } from "./TirLitIntExpr.js";
+import { TirNativeFunc } from "../TirNativeFunc.js";
+import { TirPairDataT } from "../../types/TirNativeType/index.js";
+import { TirFuncT } from "../../types/TirNativeType/native/function.js";
+import { TirListT } from "../../types/TirNativeType/native/list.js";
+import { TirSopOptT } from "../../types/TirNativeType/native/Optional/sop.js";
+export class TirLitObjExpr {
+    fieldNames;
+    values;
+    type;
+    range;
+    get isConstant() {
+        return this.values.every(value => value.isConstant);
+    }
+    constructor(fieldNames, values, type, range) {
+        this.fieldNames = fieldNames;
+        this.values = values;
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirLitObjExpr(this.fieldNames.map(f => f), this.values.map(v => v.clone()), this.type.clone(), this.range.clone());
+    }
+    deps() {
+        return this.values.reduce((deps, value) => {
+            const valueDeps = value.deps();
+            mergeSortedStrArrInplace(deps, valueDeps);
+            return deps;
+        }, []);
+    }
+    toIR(ctx) {
+        const type = this.type;
+        if (type.constructors.length !== 1)
+            throw new Error("multiple constructors for unnamed object literal");
+        const ctor = type.constructors[0];
+        const fields = ctor.fields;
+        const fNames = fields.map(f => f.name);
+        if (fields.length !== this.fieldNames.length
+            || this.fieldNames.length !== this.values.length)
+            throw new Error("incorrect number of fields in object literal");
+        const len = fNames.length;
+        const _namedFields = new Array(len);
+        for (let i = 0; i < len; i++) {
+            _namedFields[i] = {
+                name: fNames[i],
+                expr: this.values[i]
+            };
+        }
+        // sort according to definition order
+        const namedFields = fNames.map(f => _namedFields.find(n => n.name === f));
+        if (namedFields.some(thing => !isObject(thing))) {
+            throw new Error("missing field in object literal");
+        }
+        if (type instanceof TirSoPStructType) {
+            return new IRConstr(0, namedFields.map(({ expr }) => expr.toIR(ctx)));
+        }
+        // else data
+        const exprsAsData = namedFields.map(({ expr }) => {
+            const exprType = getUnaliased(expr.type) ?? expr.type;
+            if (exprType instanceof TirSoPStructType
+                || exprType instanceof TirSopOptT
+                || exprType instanceof TirFuncT
+                || exprType instanceof TirPairDataT
+                // we have no way to describe it to typescript if not this way
+                || exprType instanceof TirAliasType
+                || exprType instanceof TirTypeParam)
+                throw new Error("filed cannot be encoded as data");
+            /*
+            const returnType = (
+                exprType instanceof TirVoidT
+                || exprType instanceof TirBoolT
+                || exprType instanceof TirIntT
+                || exprType instanceof TirBytesT
+                || exprType instanceof TirStringT
+                || exprType instanceof TirDataT
+                || exprType instanceof TirListT
+                || exprType instanceof TirLinearMapT
+                || exprType instanceof TirUnConstrDataResultT
+            ) ? data_t : exprType;
+            //*/
+            return new TirToDataExpr(expr, expr.range);
+        });
+        const fieldsAsListOfData = new TirLitArrExpr(exprsAsData, new TirListT(data_t), this.range);
+        return (type.untagged ?
+            new TirCallExpr(TirNativeFunc.listData, [fieldsAsListOfData], data_t, this.range).toIR(ctx) :
+            new TirCallExpr(TirNativeFunc.constrData, [
+                new TirLitIntExpr(BigInt(0), this.range),
+                new TirLitArrExpr(exprsAsData, new TirListT(data_t), this.range)
+            ], data_t, this.range).toIR(ctx));
+    }
+}

package/dist/compiler/tir/expressions/litteral/TirLitStrExpr.d.ts

@@ -0,0 +1,15 @@
+import { ITirExpr } from "../ITirExpr.js";
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirType } from "../../types/TirType.js";
+import { ToIRTermCtx } from "../ToIRTermCtx.js";
+import { IRTerm } from "../../../../IR/index.js";
+export declare class TirLitStrExpr implements ITirExpr {
+    readonly string: string;
+    readonly range: SourceRange;
+    readonly type: TirType;
+    readonly isConstant: boolean;
+    constructor(string: string, range: SourceRange);
+    clone(): TirLitStrExpr;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/litteral/TirLitStrExpr.js

@@ -0,0 +1,20 @@
+import { bytes_t } from "../../program/stdScope/stdScope.js";
+import { IRConst } from "../../../../IR/index.js";
+import { fromUtf8 } from "@harmoniclabs/uint8array-utils";
+export class TirLitStrExpr {
+    string;
+    range;
+    type = bytes_t;
+    isConstant = true;
+    constructor(string, range) {
+        this.string = string;
+        this.range = range;
+    }
+    clone() {
+        return new TirLitStrExpr(this.string, this.range.clone());
+    }
+    deps() { return []; }
+    toIR(ctx) {
+        return IRConst.bytes(fromUtf8(this.string));
+    }
+}

package/dist/compiler/tir/expressions/litteral/TirLitThisExpr.d.ts

@@ -0,0 +1,14 @@
+import { ITirExpr } from "../ITirExpr.js";
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirType } from "../../types/TirType.js";
+import { ToIRTermCtx } from "../ToIRTermCtx.js";
+import { IRTerm } from "../../../../IR/index.js";
+export declare class TirLitThisExpr implements ITirExpr {
+    readonly type: TirType;
+    readonly range: SourceRange;
+    readonly isConstant: boolean;
+    constructor(type: TirType, range: SourceRange);
+    clone(): TirLitThisExpr;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/litteral/TirLitThisExpr.js

@@ -0,0 +1,20 @@
+import { IRVar } from "../../../../IR/index.js";
+export class TirLitThisExpr {
+    type;
+    range;
+    isConstant = false;
+    constructor(type, range) {
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirLitThisExpr(this.type.clone(), this.range.clone());
+    }
+    deps() { return []; }
+    toIR(ctx) {
+        const dbn = ctx.getVarAccessDbn("this");
+        if (typeof dbn !== "bigint")
+            throw new Error("Missing 'this' variable declaration in context");
+        return new IRVar(dbn);
+    }
+}

package/dist/compiler/tir/expressions/litteral/TirLitTrueExpr.d.ts

@@ -0,0 +1,14 @@
+import { ITirExpr } from "../ITirExpr.js";
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirType } from "../../types/TirType.js";
+import { IRTerm } from "../../../../IR/index.js";
+import { ToIRTermCtx } from "../ToIRTermCtx.js";
+export declare class TirLitTrueExpr implements ITirExpr {
+    readonly range: SourceRange;
+    readonly type: TirType;
+    readonly isConstant: boolean;
+    constructor(range: SourceRange);
+    clone(): TirLitTrueExpr;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/litteral/TirLitTrueExpr.js

@@ -0,0 +1,17 @@
+import { bool_t } from "../../program/stdScope/stdScope.js";
+import { IRConst } from "../../../../IR/index.js";
+export class TirLitTrueExpr {
+    range;
+    type = bool_t;
+    isConstant = true;
+    constructor(range) {
+        this.range = range;
+    }
+    clone() {
+        return new TirLitTrueExpr(this.range.clone());
+    }
+    deps() { return []; }
+    toIR(ctx) {
+        return IRConst.bool(true);
+    }
+}

package/dist/compiler/tir/expressions/litteral/TirLitUndefExpr.d.ts

@@ -0,0 +1,18 @@
+import { ITirExpr } from "../ITirExpr.js";
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { IRTerm } from "../../../../IR/index.js";
+import { ToIRTermCtx } from "../ToIRTermCtx.js";
+import { TirDataOptT } from "../../types/TirNativeType/native/Optional/data.js";
+import { TirSopOptT } from "../../types/TirNativeType/native/Optional/sop.js";
+export declare class TirLitUndefExpr implements ITirExpr {
+    /** must be an optional */
+    readonly type: TirSopOptT | TirDataOptT;
+    readonly range: SourceRange;
+    readonly isConstant: boolean;
+    constructor(
+    /** must be an optional */
+    type: TirSopOptT | TirDataOptT, range: SourceRange);
+    clone(): TirLitUndefExpr;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/litteral/TirLitUndefExpr.js

@@ -0,0 +1,23 @@
+import { IRConst, IRConstr } from "../../../../IR/index.js";
+import { DataConstr } from "@harmoniclabs/plutus-data";
+import { TirSopOptT } from "../../types/TirNativeType/native/Optional/sop.js";
+export class TirLitUndefExpr {
+    type;
+    range;
+    isConstant = true;
+    constructor(
+    /** must be an optional */
+    type, range) {
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirLitUndefExpr(this.type.clone(), this.range.clone());
+    }
+    deps() { return []; }
+    toIR(ctx) {
+        return this.type instanceof TirSopOptT ?
+            new IRConstr(1, []) :
+            IRConst.data(new DataConstr(1, []));
+    }
+}

package/dist/compiler/tir/expressions/litteral/TirLitVoidExpr.d.ts

@@ -0,0 +1,14 @@
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { IRTerm } from "../../../../IR/index.js";
+import { TirType } from "../../types/TirType.js";
+import { ITirExpr } from "../ITirExpr.js";
+import { ToIRTermCtx } from "../ToIRTermCtx.js";
+export declare class TirLitVoidExpr implements ITirExpr {
+    readonly range: SourceRange;
+    readonly type: TirType;
+    readonly isConstant: boolean;
+    constructor(range: SourceRange);
+    clone(): TirLitVoidExpr;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/litteral/TirLitVoidExpr.js

@@ -0,0 +1,17 @@
+import { IRConst } from "../../../../IR/index.js";
+import { void_t } from "../../program/stdScope/stdScope.js";
+export class TirLitVoidExpr {
+    range;
+    type = void_t;
+    isConstant = true;
+    constructor(range) {
+        this.range = range;
+    }
+    clone() {
+        return new TirLitVoidExpr(this.range.clone());
+    }
+    deps() { return []; }
+    toIR(ctx) {
+        return IRConst.unit;
+    }
+}

package/dist/compiler/tir/expressions/litteral/TirLitteralExpr.d.ts

@@ -0,0 +1,13 @@
+import { TirLitArrExpr } from "./TirLitArrExpr.js";
+import { TirLitFalseExpr } from "./TirLitFalseExpr.js";
+import { TirLitHexBytesExpr } from "./TirLitHexBytesExpr.js";
+import { TirLitIntExpr } from "./TirLitIntExpr.js";
+import { TirLitNamedObjExpr } from "./TirLitNamedObjExpr.js";
+import { TirLitObjExpr } from "./TirLitObjExpr.js";
+import { TirLitStrExpr } from "./TirLitStrExpr.js";
+import { TirLitThisExpr } from "./TirLitThisExpr.js";
+import { TirLitTrueExpr } from "./TirLitTrueExpr.js";
+import { TirLitUndefExpr } from "./TirLitUndefExpr.js";
+import { TirLitVoidExpr } from "./TirLitVoidExpr.js";
+export type TirLitteralExpr = TirLitVoidExpr | TirLitUndefExpr | TirLitTrueExpr | TirLitFalseExpr | TirLitStrExpr | TirLitIntExpr | TirLitHexBytesExpr | TirLitThisExpr | TirLitArrExpr | TirLitObjExpr | TirLitNamedObjExpr;
+export declare function isTirLitteralExpr(thing: any): thing is TirLitteralExpr;

package/dist/compiler/tir/expressions/litteral/TirLitteralExpr.js

@@ -0,0 +1,24 @@
+import { TirLitArrExpr } from "./TirLitArrExpr.js";
+import { TirLitFalseExpr } from "./TirLitFalseExpr.js";
+import { TirLitHexBytesExpr } from "./TirLitHexBytesExpr.js";
+import { TirLitIntExpr } from "./TirLitIntExpr.js";
+import { TirLitNamedObjExpr } from "./TirLitNamedObjExpr.js";
+import { TirLitObjExpr } from "./TirLitObjExpr.js";
+import { TirLitStrExpr } from "./TirLitStrExpr.js";
+import { TirLitThisExpr } from "./TirLitThisExpr.js";
+import { TirLitTrueExpr } from "./TirLitTrueExpr.js";
+import { TirLitUndefExpr } from "./TirLitUndefExpr.js";
+import { TirLitVoidExpr } from "./TirLitVoidExpr.js";
+export function isTirLitteralExpr(thing) {
+    return (thing instanceof TirLitVoidExpr
+        || thing instanceof TirLitUndefExpr
+        || thing instanceof TirLitTrueExpr
+        || thing instanceof TirLitFalseExpr
+        || thing instanceof TirLitThisExpr
+        || thing instanceof TirLitArrExpr
+        || thing instanceof TirLitObjExpr
+        || thing instanceof TirLitNamedObjExpr
+        || thing instanceof TirLitStrExpr
+        || thing instanceof TirLitIntExpr
+        || thing instanceof TirLitHexBytesExpr);
+}

package/dist/compiler/tir/expressions/unary/ITirUnaryExpression.d.ts

@@ -0,0 +1,4 @@
+import { TirExpr } from "../TirExpr.js";
+export interface ITirUnaryExpression {
+    operand: TirExpr;
+}

package/dist/compiler/tir/expressions/unary/ITirUnaryExpression.js

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

package/dist/compiler/tir/expressions/unary/TirUnaryExclamation.d.ts

@@ -0,0 +1,17 @@
+import { ITirExpr } from "../ITirExpr.js";
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../TirExpr.js";
+import { ITirUnaryExpression } from "./ITirUnaryExpression.js";
+import { TirType } from "../../types/TirType.js";
+import { IRTerm } from "../../../../IR/index.js";
+import { ToIRTermCtx } from "../ToIRTermCtx.js";
+export declare class TirUnaryExclamation implements ITirExpr, ITirUnaryExpression {
+    operand: TirExpr;
+    readonly type: TirType;
+    readonly range: SourceRange;
+    constructor(operand: TirExpr, type: TirType, range: SourceRange);
+    clone(): TirUnaryExclamation;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/unary/TirUnaryExclamation.js

@@ -0,0 +1,23 @@
+import { IRNative } from "../../../../IR/index.js";
+import { _ir_apps } from "../../../../IR/tree_utils/_ir_apps.js";
+export class TirUnaryExclamation {
+    operand;
+    type;
+    range;
+    constructor(operand, type, range) {
+        this.operand = operand;
+        this.type = type;
+        this.range = range;
+    }
+    /// @ts-ignore Return type annotation circularly references itself
+    clone() {
+        return new TirUnaryExclamation(this.operand.clone(), this.type.clone(), this.range.clone());
+    }
+    deps() {
+        return this.operand.deps();
+    }
+    get isConstant() { return this.operand.isConstant; }
+    toIR(ctx) {
+        return _ir_apps(IRNative._not, this.operand.toIR(ctx));
+    }
+}

package/dist/compiler/tir/expressions/unary/TirUnaryMinus.d.ts

@@ -0,0 +1,17 @@
+import { ITirExpr } from "../ITirExpr.js";
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../TirExpr.js";
+import { ITirUnaryExpression } from "./ITirUnaryExpression.js";
+import { TirType } from "../../types/TirType.js";
+import { ToIRTermCtx } from "../ToIRTermCtx.js";
+import { IRTerm } from "../../../../IR/index.js";
+export declare class TirUnaryMinus implements ITirExpr, ITirUnaryExpression {
+    operand: TirExpr;
+    readonly type: TirType;
+    readonly range: SourceRange;
+    constructor(operand: TirExpr, type: TirType, range: SourceRange);
+    clone(): TirUnaryMinus;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/unary/TirUnaryMinus.js

@@ -0,0 +1,22 @@
+import { IRNative } from "../../../../IR/index.js";
+import { _ir_apps } from "../../../../IR/tree_utils/_ir_apps.js";
+export class TirUnaryMinus {
+    operand;
+    type;
+    range;
+    constructor(operand, type, range) {
+        this.operand = operand;
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirUnaryMinus(this.operand.clone(), this.type.clone(), this.range.clone());
+    }
+    deps() {
+        return this.operand.deps();
+    }
+    get isConstant() { return this.operand.isConstant; }
+    toIR(ctx) {
+        return _ir_apps(IRNative._negateInt, this.operand.toIR(ctx));
+    }
+}

package/dist/compiler/tir/expressions/unary/TirUnaryPlus.d.ts

@@ -0,0 +1,15 @@
+import { ITirExpr } from "../ITirExpr.js";
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../TirExpr.js";
+import { ITirUnaryExpression } from "./ITirUnaryExpression.js";
+import { TirType } from "../../types/TirType.js";
+export declare class TirUnaryPlus implements ITirExpr, ITirUnaryExpression {
+    operand: TirExpr;
+    readonly type: TirType;
+    readonly range: SourceRange;
+    constructor(operand: TirExpr, type: TirType, range: SourceRange);
+    clone(): TirUnaryPlus;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: any): any;
+}

package/dist/compiler/tir/expressions/unary/TirUnaryPlus.js

@@ -0,0 +1,20 @@
+export class TirUnaryPlus {
+    operand;
+    type;
+    range;
+    constructor(operand, type, range) {
+        this.operand = operand;
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirUnaryPlus(this.operand.clone(), this.type.clone(), this.range.clone());
+    }
+    deps() {
+        return this.operand.deps();
+    }
+    get isConstant() { return this.operand.isConstant; }
+    toIR(ctx) {
+        return this.operand.toIR(ctx);
+    }
+}

package/dist/compiler/tir/expressions/unary/TirUnaryPrefixExpr.d.ts

@@ -0,0 +1,6 @@
+import { TirUnaryExclamation } from "./TirUnaryExclamation.js";
+import { TirUnaryMinus } from "./TirUnaryMinus.js";
+import { TirUnaryPlus } from "./TirUnaryPlus.js";
+import { TirUnaryTilde } from "./TirUnaryTilde.js";
+export type TirUnaryPrefixExpr = TirUnaryExclamation | TirUnaryPlus | TirUnaryMinus | TirUnaryTilde;
+export declare function isTirUnaryPrefixExpr(thing: any): thing is TirUnaryPrefixExpr;

package/dist/compiler/tir/expressions/unary/TirUnaryPrefixExpr.js

@@ -0,0 +1,10 @@
+import { TirUnaryExclamation } from "./TirUnaryExclamation.js";
+import { TirUnaryMinus } from "./TirUnaryMinus.js";
+import { TirUnaryPlus } from "./TirUnaryPlus.js";
+import { TirUnaryTilde } from "./TirUnaryTilde.js";
+export function isTirUnaryPrefixExpr(thing) {
+    return (thing instanceof TirUnaryExclamation ||
+        thing instanceof TirUnaryPlus ||
+        thing instanceof TirUnaryMinus ||
+        thing instanceof TirUnaryTilde);
+}