@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev3

package/dist/compiler/tir/expressions/TirNativeFunc.js

@@ -0,0 +1,805 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { IRNativeTag } from "../../../IR/IRNodes/IRNative/IRNativeTag.js";
+import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
+import { bool_t, bytes_t, data_t, int_t, void_t } from "../program/stdScope/stdScope.js";
+import { TirUnConstrDataResultT, TirPairDataT } from "../types/TirNativeType/index.js";
+import { TirFuncT } from "../types/TirNativeType/native/function.js";
+import { TirLinearMapT } from "../types/TirNativeType/native/linearMap.js";
+import { TirListT } from "../types/TirNativeType/native/list.js";
+import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
+export class TirNativeFunc {
+    tag;
+    type;
+    constructor(tag, type) {
+        this.tag = tag;
+        this.type = type;
+    }
+    toIR(ctx) {
+        return new IRNative(this.tag);
+    }
+    clone() {
+        return new TirNativeFunc(this.tag, this.type);
+    }
+    get range() { return SourceRange.unknown; }
+    deps() { return []; }
+    get isConstant() { return true; }
+    // Integer operations
+    static get addInteger() {
+        return new TirNativeFunc(IRNativeTag.addInteger, new TirFuncT([
+            // a
+            int_t,
+            // b
+            int_t
+        ], int_t));
+    }
+    static get subtractInteger() {
+        return new TirNativeFunc(IRNativeTag.subtractInteger, new TirFuncT([
+            // a
+            int_t,
+            // b
+            int_t
+        ], int_t));
+    }
+    static get multiplyInteger() {
+        return new TirNativeFunc(IRNativeTag.multiplyInteger, new TirFuncT([
+            // a
+            int_t,
+            // b
+            int_t
+        ], int_t));
+    }
+    static get divideInteger() {
+        return new TirNativeFunc(IRNativeTag.divideInteger, new TirFuncT([
+            // numerator
+            int_t,
+            // denominator
+            int_t
+        ], int_t));
+    }
+    static get quotientInteger() {
+        return new TirNativeFunc(IRNativeTag.quotientInteger, new TirFuncT([
+            // a
+            int_t,
+            // b
+            int_t
+        ], int_t));
+    }
+    static get remainderInteger() {
+        return new TirNativeFunc(IRNativeTag.remainderInteger, new TirFuncT([
+            // a
+            int_t,
+            // b
+            int_t
+        ], int_t));
+    }
+    static get modInteger() {
+        return new TirNativeFunc(IRNativeTag.modInteger, new TirFuncT([
+            // a
+            int_t,
+            // b
+            int_t
+        ], int_t));
+    }
+    static get equalsInteger() {
+        return new TirNativeFunc(IRNativeTag.equalsInteger, new TirFuncT([
+            // a
+            int_t,
+            // b
+            int_t
+        ], bool_t));
+    }
+    static get lessThanInteger() {
+        return new TirNativeFunc(IRNativeTag.lessThanInteger, new TirFuncT([
+            // a
+            int_t,
+            // b
+            int_t
+        ], bool_t));
+    }
+    static get lessThanEqualInteger() {
+        return new TirNativeFunc(IRNativeTag.lessThanEqualInteger, new TirFuncT([
+            // a
+            int_t,
+            // b
+            int_t
+        ], bool_t));
+    }
+    // ByteString operations
+    static get appendByteString() {
+        return new TirNativeFunc(IRNativeTag.appendByteString, new TirFuncT([
+            // left
+            bytes_t,
+            // right
+            bytes_t
+        ], bytes_t));
+    }
+    static get consByteString() {
+        return new TirNativeFunc(IRNativeTag.consByteString, new TirFuncT([
+            // byte
+            int_t,
+            // bytes
+            bytes_t
+        ], bytes_t));
+    }
+    static get sliceByteString() {
+        return new TirNativeFunc(IRNativeTag.sliceByteString, new TirFuncT([
+            // offset
+            int_t,
+            // length
+            int_t,
+            // bytes
+            bytes_t
+        ], bytes_t));
+    }
+    static get lengthOfByteString() {
+        return new TirNativeFunc(IRNativeTag.lengthOfByteString, new TirFuncT([
+            // bytes
+            bytes_t
+        ], int_t));
+    }
+    static get indexByteString() {
+        return new TirNativeFunc(IRNativeTag.indexByteString, new TirFuncT([
+            // bytes
+            bytes_t,
+            // index
+            int_t
+        ], int_t));
+    }
+    static get equalsByteString() {
+        return new TirNativeFunc(IRNativeTag.equalsByteString, new TirFuncT([
+            // a
+            bytes_t,
+            // b
+            bytes_t
+        ], bool_t));
+    }
+    static get lessThanByteString() {
+        return new TirNativeFunc(IRNativeTag.lessThanByteString, new TirFuncT([
+            // a
+            bytes_t,
+            // b
+            bytes_t
+        ], bool_t));
+    }
+    static get lessThanEqualsByteString() {
+        return new TirNativeFunc(IRNativeTag.lessThanEqualsByteString, new TirFuncT([
+            // a
+            bytes_t,
+            // b
+            bytes_t
+        ], bool_t));
+    }
+    // Hashing operations
+    static get sha2_256() {
+        return new TirNativeFunc(IRNativeTag.sha2_256, new TirFuncT([
+            // bytes
+            bytes_t
+        ], bytes_t));
+    }
+    static get sha3_256() {
+        return new TirNativeFunc(IRNativeTag.sha3_256, new TirFuncT([
+            // bytes
+            bytes_t
+        ], bytes_t));
+    }
+    static get blake2b_256() {
+        return new TirNativeFunc(IRNativeTag.blake2b_256, new TirFuncT([
+            // bytes
+            bytes_t
+        ], bytes_t));
+    }
+    static get verifyEd25519Signature() {
+        return new TirNativeFunc(IRNativeTag.verifyEd25519Signature, new TirFuncT([
+            // pubKey
+            bytes_t,
+            // message
+            bytes_t,
+            // signature
+            bytes_t
+        ], bool_t));
+    }
+    // Control flow functions that need type parameters
+    static strictIfThenElse(returnT) {
+        return new TirNativeFunc(IRNativeTag.strictIfThenElse, new TirFuncT([
+            // condition
+            bool_t,
+            // thenValue
+            returnT,
+            // elseValue
+            returnT
+        ], returnT));
+    }
+    static chooseUnit(returnT) {
+        return new TirNativeFunc(IRNativeTag.chooseUnit, new TirFuncT([
+            // unit
+            void_t
+        ], returnT));
+    }
+    static strictChooseList(elemT, returnT) {
+        return new TirNativeFunc(IRNativeTag.strictChooseList, new TirFuncT([
+            // list
+            new TirListT(elemT),
+            // caseNil
+            returnT,
+            // caseCons
+            returnT
+        ], returnT));
+    }
+    // List operations with type parameters
+    static mkCons(elemT) {
+        return new TirNativeFunc(IRNativeTag.mkCons, new TirFuncT([
+            // head
+            elemT,
+            // tail
+            new TirListT(elemT)
+        ], new TirListT(elemT)));
+    }
+    static headList(elemT) {
+        return new TirNativeFunc(IRNativeTag.headList, new TirFuncT([
+            // list
+            new TirListT(elemT)
+        ], elemT));
+    }
+    static tailList(elemT) {
+        return new TirNativeFunc(IRNativeTag.tailList, new TirFuncT([
+            // list
+            new TirListT(elemT)
+        ], new TirListT(elemT)));
+    }
+    static nullList(elemT) {
+        return new TirNativeFunc(IRNativeTag.nullList, new TirFuncT([
+            // list
+            new TirListT(elemT)
+        ], bool_t));
+    }
+    // Data operations with return type parameters
+    static chooseData(returnT) {
+        return new TirNativeFunc(IRNativeTag.chooseData, new TirFuncT([
+            // data
+            data_t,
+            // caseConstr
+            returnT,
+            // caseMap
+            returnT,
+            // caseList
+            returnT,
+            // caseIData
+            returnT,
+            // caseBData
+            returnT
+        ], returnT));
+    }
+    static get constrData() {
+        return new TirNativeFunc(IRNativeTag.constrData, new TirFuncT([
+            // tag
+            int_t,
+            // fields
+            new TirListT(data_t)
+        ], data_t));
+    }
+    static get mapData() {
+        return new TirNativeFunc(IRNativeTag.mapData, new TirFuncT([
+            // map
+            new TirLinearMapT(data_t, data_t)
+        ], data_t));
+    }
+    static get listData() {
+        return new TirNativeFunc(IRNativeTag.listData, new TirFuncT([
+            // list
+            new TirListT(data_t)
+        ], data_t));
+    }
+    static get iData() {
+        return new TirNativeFunc(IRNativeTag.iData, new TirFuncT([
+            // int
+            int_t
+        ], data_t));
+    }
+    static get bData() {
+        return new TirNativeFunc(IRNativeTag.bData, new TirFuncT([
+            // bytes
+            bytes_t
+        ], data_t));
+    }
+    // Data unwrapping operations
+    static get unConstrData() {
+        return new TirNativeFunc(IRNativeTag.unConstrData, new TirFuncT([
+            // data
+            data_t
+        ], new TirUnConstrDataResultT()));
+    }
+    static get unConstrDataResultFields() {
+        return new TirNativeFunc(IRNativeTag.sndPair, new TirFuncT([
+            new TirUnConstrDataResultT(),
+        ], new TirListT(data_t)));
+    }
+    static get unConstrDataResultIndex() {
+        return new TirNativeFunc(IRNativeTag.fstPair, new TirFuncT([
+            new TirUnConstrDataResultT(),
+        ], int_t));
+    }
+    static get unMapData() {
+        return new TirNativeFunc(IRNativeTag.unMapData, new TirFuncT([
+            // data
+            data_t
+        ], new TirLinearMapT(data_t, data_t)));
+    }
+    static get unListData() {
+        return new TirNativeFunc(IRNativeTag.unListData, new TirFuncT([
+            // data
+            data_t
+        ], new TirListT(data_t)));
+    }
+    static get unIData() {
+        return new TirNativeFunc(IRNativeTag.unIData, new TirFuncT([
+            // data
+            data_t
+        ], int_t));
+    }
+    static get unBData() {
+        return new TirNativeFunc(IRNativeTag.unBData, new TirFuncT([
+            // data
+            data_t
+        ], bytes_t));
+    }
+    // Data comparison
+    static get equalsData() {
+        return new TirNativeFunc(IRNativeTag.equalsData, new TirFuncT([
+            // a
+            data_t,
+            // b
+            data_t
+        ], bool_t));
+    }
+    static get mkNilData() {
+        return new TirNativeFunc(IRNativeTag.mkNilData, new TirFuncT([], new TirListT(data_t)));
+    }
+    static get serialiseData() {
+        return new TirNativeFunc(IRNativeTag.serialiseData, new TirFuncT([
+            // data
+            data_t
+        ], bytes_t));
+    }
+    // Cryptography functions
+    static get verifyEcdsaSecp256k1Signature() {
+        return new TirNativeFunc(IRNativeTag.verifyEcdsaSecp256k1Signature, new TirFuncT([
+            // pubKey
+            bytes_t,
+            // message
+            bytes_t,
+            // signature
+            bytes_t
+        ], bool_t));
+    }
+    static get verifySchnorrSecp256k1Signature() {
+        return new TirNativeFunc(IRNativeTag.verifySchnorrSecp256k1Signature, new TirFuncT([
+            // pubKey
+            bytes_t,
+            // message
+            bytes_t,
+            // signature
+            bytes_t
+        ], bool_t));
+    }
+    // BLS12-381 operations
+    /* TODO: add bls supprot
+    get bls12_381_G1_add(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G1_add,
+            new TirFuncT([bytes_t, bytes_t], bytes_t)
+        );
+    }
+    get bls12_381_G1_neg(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G1_neg,
+            new TirFuncT([bytes_t], bytes_t)
+        );
+    }
+    get bls12_381_G1_scalarMul(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G1_scalarMul,
+            new TirFuncT([bytes_t, int_t], bytes_t)
+        );
+    }
+    get bls12_381_G1_equal(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G1_equal,
+            new TirFuncT([bytes_t, bytes_t], bool_t)
+        );
+    }
+    get bls12_381_G1_hashToGroup(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G1_hashToGroup,
+            new TirFuncT([bytes_t], bytes_t)
+        );
+    }
+    get bls12_381_G1_compress(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G1_compress,
+            new TirFuncT([bytes_t], bytes_t)
+        );
+    }
+    get bls12_381_G1_uncompress(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G1_uncompress,
+            new TirFuncT([bytes_t], bytes_t)
+        );
+    }
+    get bls12_381_G2_add(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G2_add,
+            new TirFuncT([bytes_t, bytes_t], bytes_t)
+        );
+    }
+    get bls12_381_G2_neg(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G2_neg,
+            new TirFuncT([bytes_t], bytes_t)
+        );
+    }
+    get bls12_381_G2_scalarMul(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G2_scalarMul,
+            new TirFuncT([bytes_t, int_t], bytes_t)
+        );
+    }
+    get bls12_381_G2_equal(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G2_equal,
+            new TirFuncT([bytes_t, bytes_t], bool_t)
+        );
+    }
+    get bls12_381_G2_hashToGroup(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G2_hashToGroup,
+            new TirFuncT([bytes_t], bytes_t)
+        );
+    }
+    get bls12_381_G2_compress(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G2_compress,
+            new TirFuncT([bytes_t], bytes_t)
+        );
+    }
+    get bls12_381_G2_uncompress(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_G2_uncompress,
+            new TirFuncT([bytes_t], bytes_t)
+        );
+    }
+    get bls12_381_millerLoop(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_millerLoop,
+            new TirFuncT([bytes_t, bytes_t], bytes_t)
+        );
+    }
+    get bls12_381_mulMlResult(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_mulMlResult,
+            new TirFuncT([bytes_t, bytes_t], bytes_t)
+        );
+    }
+    get bls12_381_finalVerify(): TirNativeFunc {
+        return new TirNativeFunc(
+            IRNativeTag.bls12_381_finalVerify,
+            new TirFuncT([bytes_t, bytes_t], bool_t)
+        );
+    }
+    //*/
+    // Additional hashing functions
+    static get keccak_256() {
+        return new TirNativeFunc(IRNativeTag.keccak_256, new TirFuncT([
+            // bytes
+            bytes_t
+        ], bytes_t));
+    }
+    static get blake2b_224() {
+        return new TirNativeFunc(IRNativeTag.blake2b_224, new TirFuncT([
+            // bytes
+            bytes_t
+        ], bytes_t));
+    }
+    // ByteString manipulation
+    static get integerToByteString() {
+        return new TirNativeFunc(IRNativeTag.integerToByteString, new TirFuncT([
+            // flag
+            bool_t,
+            // value
+            int_t,
+            // size
+            int_t
+        ], bytes_t));
+    }
+    static get byteStringToInteger() {
+        return new TirNativeFunc(IRNativeTag.byteStringToInteger, new TirFuncT([
+            // flag
+            bool_t,
+            // bytes
+            bytes_t
+        ], int_t));
+    }
+    static get andByteString() {
+        return new TirNativeFunc(IRNativeTag.andByteString, new TirFuncT([
+            // flag
+            bool_t,
+            // a
+            bytes_t,
+            // b
+            bytes_t
+        ], bytes_t));
+    }
+    static get orByteString() {
+        return new TirNativeFunc(IRNativeTag.orByteString, new TirFuncT([
+            // flag
+            bool_t,
+            // a
+            bytes_t,
+            // b
+            bytes_t
+        ], bytes_t));
+    }
+    static get xorByteString() {
+        return new TirNativeFunc(IRNativeTag.xorByteString, new TirFuncT([
+            // flag
+            bool_t,
+            // a
+            bytes_t,
+            // b
+            bytes_t
+        ], bytes_t));
+    }
+    static get complementByteString() {
+        return new TirNativeFunc(IRNativeTag.complementByteString, new TirFuncT([
+            // bytes
+            bytes_t
+        ], bytes_t));
+    }
+    static get readBit() {
+        return new TirNativeFunc(IRNativeTag.readBit, new TirFuncT([
+            // bytes
+            bytes_t,
+            // index
+            int_t
+        ], bool_t));
+    }
+    static get writeBits() {
+        return new TirNativeFunc(IRNativeTag.writeBits, new TirFuncT([
+            // bytes
+            bytes_t,
+            // positions
+            new TirListT(int_t),
+            // value
+            bool_t
+        ], bytes_t));
+    }
+    // Additional ByteString operations
+    static get replicateByte() {
+        return new TirNativeFunc(IRNativeTag.replicateByte, new TirFuncT([
+            // count
+            int_t,
+            // byte
+            int_t
+        ], bytes_t));
+    }
+    static get shiftByteString() {
+        return new TirNativeFunc(IRNativeTag.shiftByteString, new TirFuncT([
+            // bytes
+            bytes_t,
+            // shift
+            int_t
+        ], bytes_t));
+    }
+    static get rotateByteString() {
+        return new TirNativeFunc(IRNativeTag.rotateByteString, new TirFuncT([
+            // bytes
+            bytes_t,
+            // amount
+            int_t
+        ], bytes_t));
+    }
+    static get countSetBits() {
+        return new TirNativeFunc(IRNativeTag.countSetBits, new TirFuncT([
+            // bytes
+            bytes_t
+        ], int_t));
+    }
+    static get findFirstSetBit() {
+        return new TirNativeFunc(IRNativeTag.findFirstSetBit, new TirFuncT([
+            // bytes
+            bytes_t
+        ], int_t));
+    }
+    static get ripemd_160() {
+        return new TirNativeFunc(IRNativeTag.ripemd_160, new TirFuncT([
+            // bytes
+            bytes_t
+        ], bytes_t));
+    }
+    // Custom utility functions
+    static _dropList(elemT) {
+        return new TirNativeFunc(IRNativeTag._dropList, new TirFuncT([
+            // n
+            int_t,
+            // list
+            new TirListT(elemT)
+        ], new TirListT(elemT)));
+    }
+    static _foldr(elemT, returnT) {
+        return new TirNativeFunc(IRNativeTag._foldr, new TirFuncT([
+            // reduce function
+            new TirFuncT([
+                elemT,
+                returnT
+            ], returnT),
+            // initial accumulator
+            returnT,
+            // list to fold
+            new TirListT(elemT)
+        ], returnT));
+    }
+    static _foldl(elemT, returnT) {
+        return new TirNativeFunc(IRNativeTag._foldl, new TirFuncT([
+            // reduce function
+            new TirFuncT([
+                returnT,
+                elemT
+            ], returnT),
+            // initial accumulator
+            returnT,
+            // list to fold
+            new TirListT(elemT)
+        ], returnT));
+    }
+    static _mkFindDataOptional(elems_t) {
+        return new TirNativeFunc(IRNativeTag._mkFindDataOptional, new TirFuncT([
+            // elem -> data
+            new TirFuncT([elems_t], data_t),
+            // elem -> bool (predicate)
+            new TirFuncT([elems_t], bool_t),
+            // List<elem>
+            new TirListT(elems_t)
+        ], new TirDataOptT(elems_t)));
+    }
+    static _length(elemT) {
+        return new TirNativeFunc(IRNativeTag._length, new TirFuncT([
+            // list
+            new TirListT(elemT)
+        ], int_t));
+    }
+    static _some(elemT) {
+        return new TirNativeFunc(IRNativeTag._some, new TirFuncT([
+            // predicate
+            new TirFuncT([
+                elemT
+            ], bool_t),
+            // list
+            new TirListT(elemT)
+        ], bool_t));
+    }
+    static _every(elemT) {
+        return new TirNativeFunc(IRNativeTag._every, new TirFuncT([
+            // predicate
+            new TirFuncT([
+                elemT
+            ], bool_t),
+            // list
+            new TirListT(elemT)
+        ], bool_t));
+    }
+    static _mkFilter(elemT) {
+        return new TirNativeFunc(IRNativeTag._mkFilter, new TirFuncT([
+            // pnilOfType: an empty list with the right element type
+            new TirListT(elemT),
+            // predicate
+            new TirFuncT([
+                elemT
+            ], bool_t),
+            // list to filter
+            new TirListT(elemT)
+        ], new TirListT(elemT)));
+    }
+    static _id(t) {
+        return new TirNativeFunc(IRNativeTag._id, new TirFuncT([t], t));
+    }
+    static get _not() {
+        return new TirNativeFunc(IRNativeTag._not, new TirFuncT([
+            // bool
+            bool_t
+        ], bool_t));
+    }
+    static get _strictAnd() {
+        return new TirNativeFunc(IRNativeTag._strictAnd, new TirFuncT([
+            bool_t,
+            bool_t
+        ], bool_t));
+    }
+    static get _and() {
+        return new TirNativeFunc(IRNativeTag._and, new TirFuncT([
+            bool_t,
+            bool_t
+        ], bool_t));
+    }
+    static get _strictOr() {
+        return new TirNativeFunc(IRNativeTag._strictOr, new TirFuncT([
+            bool_t,
+            bool_t
+        ], bool_t));
+    }
+    static get _or() {
+        return new TirNativeFunc(IRNativeTag._or, new TirFuncT([
+            bool_t,
+            bool_t
+        ], bool_t));
+    }
+    static get _gtBS() {
+        return new TirNativeFunc(IRNativeTag._gtBS, new TirFuncT([
+            bytes_t,
+            bytes_t
+        ], bool_t));
+    }
+    static get _gtEqBS() {
+        return new TirNativeFunc(IRNativeTag._gtEqBS, new TirFuncT([
+            bytes_t,
+            bytes_t
+        ], bool_t));
+    }
+    static get _gtInt() {
+        return new TirNativeFunc(IRNativeTag._gtInt, new TirFuncT([
+            int_t,
+            int_t
+        ], bool_t));
+    }
+    static get _gtEqInt() {
+        return new TirNativeFunc(IRNativeTag._gtEqInt, new TirFuncT([
+            int_t,
+            int_t
+        ], bool_t));
+    }
+    static get _pairDataToData() {
+        return new TirNativeFunc(IRNativeTag._pairDataToData, new TirFuncT([
+            // pair
+            new TirPairDataT()
+        ], data_t));
+    }
+    static get _pairDataFromData() {
+        return new TirNativeFunc(IRNativeTag._pairDataFromData, new TirFuncT([
+            // data
+            data_t
+        ], new TirPairDataT()));
+    }
+    static _mkEqualsList(elemT) {
+        return new TirNativeFunc(IRNativeTag._mkEqualsList, new TirFuncT([
+            // elem equality
+            new TirFuncT([
+                elemT,
+                elemT
+            ], bool_t),
+            // listA
+            new TirListT(elemT),
+            // listB
+            new TirListT(elemT)
+        ], bool_t));
+    }
+    static get _equalPairData() {
+        return new TirNativeFunc(IRNativeTag._equalPairData, new TirFuncT([
+            // pairA
+            new TirPairDataT(),
+            // pairB
+            new TirPairDataT()
+        ], bool_t));
+    }
+    static get _equalBoolean() {
+        return new TirNativeFunc(IRNativeTag._equalBoolean, new TirFuncT([
+            // a
+            bool_t,
+            // b
+            bool_t
+        ], bool_t));
+    }
+    static get _negateInt() {
+        return new TirNativeFunc(IRNativeTag._negateInt, new TirFuncT([
+            // n
+            int_t
+        ], int_t));
+    }
+}