@harmoniclabs/pebble 0.1.0-dev0

package/dist/compiler/tir/statements/TirVarDecl/TirSingleDeconstructVarDecl.d.ts

@@ -0,0 +1,17 @@
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../../expressions/TirExpr.js";
+import { TirType } from "../../types/TirType.js";
+import { ITirStmt } from "../TirStmt.js";
+import { TirVarDecl } from "./TirVarDecl.js";
+export declare class TirSingleDeconstructVarDecl implements ITirStmt {
+    readonly fields: Map<string, TirVarDecl>;
+    readonly rest: string | undefined;
+    readonly type: TirType;
+    initExpr: TirExpr | undefined;
+    isConst: boolean;
+    readonly range: SourceRange;
+    constructor(fields: Map<string, TirVarDecl>, rest: string | undefined, type: TirType, initExpr: TirExpr | undefined, isConst: boolean, range: SourceRange);
+    deps(): string[];
+    definitelyTerminates(): boolean;
+    introducedVars(): string[];
+}

package/dist/compiler/tir/statements/TirVarDecl/TirSingleDeconstructVarDecl.js

@@ -0,0 +1,30 @@
+import { mergeSortedStrArrInplace } from "../../../../utils/array/mergeSortedStrArrInplace.js";
+export class TirSingleDeconstructVarDecl {
+    fields;
+    rest;
+    type;
+    initExpr;
+    isConst;
+    range;
+    constructor(fields, rest, type, initExpr, isConst, range) {
+        this.fields = fields;
+        this.rest = rest;
+        this.type = type;
+        this.initExpr = initExpr;
+        this.isConst = isConst;
+        this.range = range;
+    }
+    deps() {
+        return this.initExpr?.deps() ?? [];
+    }
+    definitelyTerminates() { return false; }
+    introducedVars() {
+        const introducedVars = [];
+        for (const field of this.fields.values()) {
+            mergeSortedStrArrInplace(introducedVars, field.introducedVars());
+        }
+        if (this.rest)
+            mergeSortedStrArrInplace(introducedVars, [this.rest]);
+        return introducedVars;
+    }
+}

package/dist/compiler/tir/statements/TirVarDecl/TirVarDecl.d.ts

@@ -0,0 +1,10 @@
+import { TirNamedDeconstructVarDecl } from "./TirNamedDeconstructVarDecl.js";
+import { TirSimpleVarDecl } from "./TirSimpleVarDecl.js";
+import { TirSingleDeconstructVarDecl } from "./TirSingleDeconstructVarDecl.js";
+import { TirArrayLikeDeconstr } from "./TirArrayLikeDeconstr.js";
+export interface ITirVarDecl {
+    introducedVars: () => string[];
+    readonly isConst: boolean;
+}
+export type TirVarDecl = TirSimpleVarDecl | TirNamedDeconstructVarDecl | TirSingleDeconstructVarDecl | TirArrayLikeDeconstr;
+export declare function isTirVarDecl(thing: any): thing is TirVarDecl;

package/dist/compiler/tir/statements/TirVarDecl/TirVarDecl.js

@@ -0,0 +1,11 @@
+import { TirNamedDeconstructVarDecl } from "./TirNamedDeconstructVarDecl.js";
+import { TirSimpleVarDecl } from "./TirSimpleVarDecl.js";
+import { TirSingleDeconstructVarDecl } from "./TirSingleDeconstructVarDecl.js";
+import { TirArrayLikeDeconstr } from "./TirArrayLikeDeconstr.js";
+import { isObject } from "@harmoniclabs/obj-utils";
+export function isTirVarDecl(thing) {
+    return isObject(thing) && (thing instanceof TirSimpleVarDecl
+        || thing instanceof TirNamedDeconstructVarDecl
+        || thing instanceof TirSingleDeconstructVarDecl
+        || thing instanceof TirArrayLikeDeconstr);
+}

package/dist/compiler/tir/statements/TirWhileStmt.d.ts

@@ -0,0 +1,11 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../expressions/TirExpr.js";
+import { ITirStmt, TirStmt } from "./TirStmt.js";
+export declare class TirWhileStmt implements ITirStmt {
+    readonly condition: TirExpr;
+    body: TirStmt;
+    readonly range: SourceRange;
+    constructor(condition: TirExpr, body: TirStmt, range: SourceRange);
+    definitelyTerminates(): boolean;
+    deps(): string[];
+}

package/dist/compiler/tir/statements/TirWhileStmt.js

@@ -0,0 +1,19 @@
+export class TirWhileStmt {
+    condition;
+    body;
+    range;
+    constructor(condition, body, range) {
+        this.condition = condition;
+        this.body = body;
+        this.range = range;
+    }
+    definitelyTerminates() {
+        return this.body.definitelyTerminates();
+    }
+    deps() {
+        return [
+            ...new Set(this.condition.deps()
+                .concat(this.body.deps()))
+        ];
+    }
+}

package/dist/compiler/tir/statements/utils/definitelyFails.d.ts

@@ -0,0 +1,3 @@
+import { TirBlockStmt } from "../TirBlockStmt.js";
+import { TirStmt } from "../TirStmt.js";
+export declare function definitelyFails(stmt: TirStmt | TirBlockStmt): boolean;

package/dist/compiler/tir/statements/utils/definitelyFails.js

@@ -0,0 +1,52 @@
+import { TirAssertStmt } from "../TirAssertStmt.js";
+import { TirAssignmentStmt } from "../TirAssignmentStmt.js";
+import { TirBlockStmt } from "../TirBlockStmt.js";
+import { TirBreakStmt } from "../TirBreakStmt.js";
+import { TirContinueStmt } from "../TirContinueStmt.js";
+import { TirFailStmt } from "../TirFailStmt.js";
+import { TirForOfStmt } from "../TirForOfStmt.js";
+import { TirForStmt } from "../TirForStmt.js";
+import { TirIfStmt } from "../TirIfStmt.js";
+import { TirMatchStmt } from "../TirMatchStmt.js";
+import { TirReturnStmt } from "../TirReturnStmt.js";
+import { isTirVarDecl } from "../TirVarDecl/TirVarDecl.js";
+import { TirWhileStmt } from "../TirWhileStmt.js";
+export function definitelyFails(stmt) {
+    const stack = [stmt];
+    while (stmt = stack.pop()) {
+        if (stmt instanceof TirFailStmt)
+            return true;
+        if (stmt instanceof TirBlockStmt) {
+            stack.push(...stmt.stmts);
+            continue;
+        }
+        if (isTirVarDecl(stmt))
+            continue;
+        if (stmt instanceof TirIfStmt) {
+            stack.push(stmt.thenBranch);
+            if (stmt.elseBranch)
+                stack.push(stmt.elseBranch);
+            continue;
+        }
+        if (stmt instanceof TirMatchStmt) {
+            if (stmt.cases.every(({ body }) => definitelyFails(body)))
+                return true;
+            continue;
+        }
+        if (stmt instanceof TirForStmt
+            || stmt instanceof TirForOfStmt
+            || stmt instanceof TirWhileStmt) {
+            stack.push(stmt.body);
+            continue;
+        }
+        if (stmt instanceof TirReturnStmt
+            || stmt instanceof TirBlockStmt
+            || stmt instanceof TirBreakStmt
+            || stmt instanceof TirContinueStmt
+            || stmt instanceof TirAssertStmt
+            || stmt instanceof TirAssignmentStmt)
+            continue;
+        // const tsEnsureExsaustiveCheck: never = stmt;
+    }
+    return false;
+}

package/dist/compiler/tir/types/TirAliasType.d.ts

@@ -0,0 +1,32 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { AstFuncName, TirFuncName } from "../../AstCompiler/scope/AstScope.js";
+import { ITirType, TirType } from "./TirType.js";
+export declare class TirAliasType<AliasedT extends TirType = TirType> implements ITirType {
+    readonly name: string;
+    readonly fileUid: string;
+    readonly aliased: AliasedT;
+    /**
+     * Maps AstFuncName to TirFuncName for methods defined in this alias type.
+     * This is used to resolve method calls on the aliased type.
+     *
+     * @type {Map<AstFuncName, TirFuncName>}
+     */
+    readonly methodsNamesPtr: Map<AstFuncName, TirFuncName>;
+    constructor(name: string, fileUid: string, aliased: AliasedT, 
+    /**
+     * Maps AstFuncName to TirFuncName for methods defined in this alias type.
+     * This is used to resolve method calls on the aliased type.
+     *
+     * @type {Map<AstFuncName, TirFuncName>}
+     */
+    methodsNamesPtr: Map<AstFuncName, TirFuncName>);
+    hasDataEncoding(): boolean;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    toString(): string;
+    toAstName(): string;
+    private _isConcrete;
+    isConcrete(): boolean;
+    clone(): TirAliasType<AliasedT>;
+    toUplcConstType(): ConstType;
+}

package/dist/compiler/tir/types/TirAliasType.js

@@ -0,0 +1,49 @@
+export class TirAliasType {
+    name;
+    fileUid;
+    aliased;
+    methodsNamesPtr;
+    constructor(name, fileUid, aliased, 
+    /**
+     * Maps AstFuncName to TirFuncName for methods defined in this alias type.
+     * This is used to resolve method calls on the aliased type.
+     *
+     * @type {Map<AstFuncName, TirFuncName>}
+     */
+    methodsNamesPtr) {
+        this.name = name;
+        this.fileUid = fileUid;
+        this.aliased = aliased;
+        this.methodsNamesPtr = methodsNamesPtr;
+    }
+    hasDataEncoding() {
+        return this.aliased.hasDataEncoding();
+    }
+    toTirTypeKey() {
+        return this.name + "_" + this.fileUid;
+    }
+    toConcreteTirTypeName() {
+        return this.toTirTypeKey();
+    }
+    toString() {
+        return this.name;
+    }
+    toAstName() {
+        return this.toString();
+    }
+    _isConcrete = undefined;
+    isConcrete() {
+        if (typeof this._isConcrete !== "boolean")
+            this._isConcrete = this.aliased.isConcrete();
+        return this._isConcrete;
+    }
+    clone() {
+        return new TirAliasType(this.name, this.fileUid, this.aliased.clone(), this.methodsNamesPtr);
+    }
+    toUplcConstType() {
+        let t = this.aliased;
+        while (t instanceof TirAliasType)
+            t = t.aliased;
+        return t.toUplcConstType();
+    }
+}

package/dist/compiler/tir/types/TirInterfaceImpl.d.ts

@@ -0,0 +1,44 @@
+import { TirInterfaceType } from "./TirInterfaceType.js";
+import { TirCustomType } from "./TirType.js";
+export declare class TirInterfaceImpl {
+    /**
+     * type that implements the interface
+     */
+    readonly thisType: TirCustomType;
+    /**
+     * interface type being implemented
+     *
+     * `undefined` for anonymous interfaces
+     * eg. `type MyType implements { ... }`
+     */
+    readonly interfaceType: TirInterfaceType | undefined;
+    /**
+     * method implementations are
+     * compiled as functions external to the type being implemented
+     *
+     * here we map the `frontendName`
+     * to the external function ast name stored in the scope
+     */
+    readonly methodImplExternalFunctionName: Map<string, string>;
+    constructor(
+    /**
+     * type that implements the interface
+     */
+    thisType: TirCustomType, 
+    /**
+     * interface type being implemented
+     *
+     * `undefined` for anonymous interfaces
+     * eg. `type MyType implements { ... }`
+     */
+    interfaceType: TirInterfaceType | undefined, 
+    /**
+     * method implementations are
+     * compiled as functions external to the type being implemented
+     *
+     * here we map the `frontendName`
+     * to the external function ast name stored in the scope
+     */
+    methodImplExternalFunctionName: Map<string, string>);
+    clone(): TirInterfaceImpl;
+}

package/dist/compiler/tir/types/TirInterfaceImpl.js

@@ -0,0 +1,32 @@
+export class TirInterfaceImpl {
+    thisType;
+    interfaceType;
+    methodImplExternalFunctionName;
+    constructor(
+    /**
+     * type that implements the interface
+     */
+    thisType, 
+    /**
+     * interface type being implemented
+     *
+     * `undefined` for anonymous interfaces
+     * eg. `type MyType implements { ... }`
+     */
+    interfaceType, 
+    /**
+     * method implementations are
+     * compiled as functions external to the type being implemented
+     *
+     * here we map the `frontendName`
+     * to the external function ast name stored in the scope
+     */
+    methodImplExternalFunctionName) {
+        this.thisType = thisType;
+        this.interfaceType = interfaceType;
+        this.methodImplExternalFunctionName = methodImplExternalFunctionName;
+    }
+    clone() {
+        return new TirInterfaceImpl(this.thisType, this.interfaceType?.clone(), new Map(this.methodImplExternalFunctionName));
+    }
+}

package/dist/compiler/tir/types/TirInterfaceType.d.ts

@@ -0,0 +1,28 @@
+import { TirFuncT } from "./TirNativeType/native/function.js";
+/**
+ * represents interface declaraions
+ */
+export declare class TirInterfaceType {
+    readonly name: string;
+    readonly methods: TirInterfaceMethod[];
+    constructor(name: string, methods: TirInterfaceMethod[]);
+    clone(): TirInterfaceType;
+}
+/**
+ * only represents the method signature declared in the interface
+ *
+ * this is not the method implementation
+ */
+export declare class TirInterfaceMethod {
+    /**
+     * method name used by the developer
+     */
+    readonly frontendName: string;
+    readonly funcSingature: TirFuncT;
+    constructor(
+    /**
+     * method name used by the developer
+     */
+    frontendName: string, funcSingature: TirFuncT);
+    clone(): TirInterfaceMethod;
+}

package/dist/compiler/tir/types/TirInterfaceType.js

@@ -0,0 +1,36 @@
+/**
+ * represents interface declaraions
+ */
+export class TirInterfaceType {
+    name;
+    methods;
+    constructor(
+    // anonymous interface for custom type methods
+    name, methods) {
+        this.name = name;
+        this.methods = methods;
+    }
+    clone() {
+        return new TirInterfaceType(this.name, this.methods.map(m => m.clone()));
+    }
+}
+/**
+ * only represents the method signature declared in the interface
+ *
+ * this is not the method implementation
+ */
+export class TirInterfaceMethod {
+    frontendName;
+    funcSingature;
+    constructor(
+    /**
+     * method name used by the developer
+     */
+    frontendName, funcSingature) {
+        this.frontendName = frontendName;
+        this.funcSingature = funcSingature;
+    }
+    clone() {
+        return new TirInterfaceMethod(this.frontendName, this.funcSingature.clone());
+    }
+}

package/dist/compiler/tir/types/TirNativeType/TirNativeType.d.ts

@@ -0,0 +1,41 @@
+import type { ITirType, TirType } from "../TirType.js";
+import { ConstType } from "@harmoniclabs/uplc";
+import { TirBoolT } from "./native/bool.js";
+import { TirBytesT } from "./native/bytes.js";
+import { TirDataT } from "./native/data.js";
+import { TirFuncT } from "./native/function.js";
+import { TirIntT } from "./native/int.js";
+import { TirLinearMapT } from "./native/linearMap.js";
+import { TirListT } from "./native/list.js";
+import { TirDataOptT } from "./native/Optional/data.js";
+import { TirSopOptT } from "./native/Optional/sop.js";
+import { TirStringT } from "./native/string.js";
+import { TirVoidT } from "./native/void.js";
+export type TirNamedDestructableNativeType = TirDataT | TirDataOptT<TirType> | TirSopOptT<TirType> | TirListT<TirType> | TirLinearMapT<TirType, TirType>;
+export declare function isTirNamedDestructableNativeType(t: any): t is TirNamedDestructableNativeType;
+export type TirNativeType = TirVoidT | TirBoolT | TirIntT | TirBytesT | TirStringT | TirDataT | TirDataOptT<TirType> | TirSopOptT<TirType> | TirListT<TirType> | TirLinearMapT<TirType, TirType> | TirFuncT | TirUnConstrDataResultT | TirPairDataT;
+export declare function isTirNativeType(t: any): t is TirNativeType;
+export declare class TirUnConstrDataResultT implements ITirType {
+    constructor();
+    hasDataEncoding(): boolean;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    toString(): string;
+    toAstName(): string;
+    isConcrete(): boolean;
+    clone(): TirUnConstrDataResultT;
+    toUplcConstType(): ConstType;
+}
+export declare class TirPairDataT implements ITirType {
+    constructor();
+    hasDataEncoding(): boolean;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    toString(): string;
+    toAstName(): string;
+    isConcrete(): boolean;
+    clone(): TirPairDataT;
+    toUplcConstType(): ConstType;
+}

package/dist/compiler/tir/types/TirNativeType/TirNativeType.js

@@ -0,0 +1,86 @@
+import { constT } from "@harmoniclabs/uplc";
+import { TirBoolT } from "./native/bool.js";
+import { TirBytesT } from "./native/bytes.js";
+import { TirDataT } from "./native/data.js";
+import { TirFuncT } from "./native/function.js";
+import { TirIntT } from "./native/int.js";
+import { TirLinearMapT } from "./native/linearMap.js";
+import { TirListT } from "./native/list.js";
+import { TirDataOptT } from "./native/Optional/data.js";
+import { TirSopOptT } from "./native/Optional/sop.js";
+import { TirStringT } from "./native/string.js";
+import { TirVoidT } from "./native/void.js";
+export function isTirNamedDestructableNativeType(t) {
+    return (t instanceof TirDataT
+        || t instanceof TirDataOptT
+        || t instanceof TirSopOptT
+        || t instanceof TirListT
+        || t instanceof TirLinearMapT);
+}
+export function isTirNativeType(t) {
+    return (t instanceof TirVoidT
+        || t instanceof TirBoolT
+        || t instanceof TirIntT
+        || t instanceof TirBytesT
+        || t instanceof TirStringT
+        || t instanceof TirDataT
+        || t instanceof TirDataOptT
+        || t instanceof TirSopOptT
+        || t instanceof TirListT
+        || t instanceof TirLinearMapT
+        || t instanceof TirFuncT // =>
+        || t instanceof TirUnConstrDataResultT
+        || t instanceof TirPairDataT);
+}
+export class TirUnConstrDataResultT {
+    constructor() { }
+    hasDataEncoding() { return false; }
+    static toTirTypeKey() {
+        return "#un_constr_data_result#";
+    }
+    toTirTypeKey() {
+        return TirUnConstrDataResultT.toTirTypeKey();
+    }
+    toConcreteTirTypeName() {
+        return this.toTirTypeKey();
+    }
+    toString() {
+        return this.toTirTypeKey();
+    }
+    toAstName() {
+        return this.toTirTypeKey();
+    }
+    isConcrete() { return true; }
+    clone() {
+        return new TirUnConstrDataResultT();
+    }
+    toUplcConstType() {
+        return constT.pairOf(constT.int, constT.listOf(constT.data));
+    }
+}
+export class TirPairDataT {
+    constructor() { }
+    hasDataEncoding() { return false; }
+    static toTirTypeKey() {
+        return "#pair_data";
+    }
+    toTirTypeKey() {
+        return TirPairDataT.toTirTypeKey();
+    }
+    toConcreteTirTypeName() {
+        return this.toTirTypeKey();
+    }
+    toString() {
+        return this.toTirTypeKey();
+    }
+    toAstName() {
+        return this.toTirTypeKey();
+    }
+    isConcrete() { return true; }
+    clone() {
+        return new TirPairDataT();
+    }
+    toUplcConstType() {
+        return constT.pairOf(constT.data, constT.data);
+    }
+}

package/dist/compiler/tir/types/TirNativeType/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./TirNativeType.js";
+export * from "./native/index.js";

package/dist/compiler/tir/types/TirNativeType/index.js

@@ -0,0 +1,2 @@
+export * from "./TirNativeType.js";
+export * from "./native/index.js";

package/dist/compiler/tir/types/TirNativeType/native/Optional/data.d.ts

@@ -0,0 +1,17 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { TirDataStructType } from "../../../TirStructType.js";
+import { TirType, ITirType } from "../../../TirType.js";
+export declare class TirDataOptT<T extends TirType = TirType> extends TirDataStructType implements ITirType {
+    readonly typeArg: T;
+    constructor(typeArg: T);
+    hasDataEncoding(): boolean;
+    toAstName(): string;
+    toString(): string;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    protected _isConcrete: boolean | undefined;
+    isConcrete(): boolean;
+    clone(): TirDataOptT<T>;
+    toUplcConstType(): ConstType;
+}

package/dist/compiler/tir/types/TirNativeType/native/Optional/data.js

@@ -0,0 +1,47 @@
+import { constT } from "@harmoniclabs/uplc";
+import { getAppliedTirTypeName } from "../../../../program/TypedProgram.js";
+import { TirDataStructType, TirStructConstr, TirStructField } from "../../../TirStructType.js";
+export class TirDataOptT extends TirDataStructType {
+    typeArg;
+    constructor(typeArg) {
+        super("Optional", // name
+        "", // fileUid
+        [
+            new TirStructConstr("Some", // name
+            [
+                new TirStructField("value", typeArg)
+            ]),
+            new TirStructConstr("None", []) // name, fields
+        ], new Map() // methodNamesPtr
+        );
+        this.typeArg = typeArg;
+    }
+    hasDataEncoding() { return this.typeArg.hasDataEncoding(); }
+    toAstName() {
+        return "Optional";
+    }
+    toString() {
+        return `${this.toAstName()}<${this.typeArg.toString()}>`;
+    }
+    static toTirTypeKey() {
+        return "data_opt";
+    }
+    toTirTypeKey() {
+        return TirDataOptT.toTirTypeKey();
+    }
+    toConcreteTirTypeName() {
+        return getAppliedTirTypeName(this.toTirTypeKey(), [this.typeArg.toConcreteTirTypeName()]);
+    }
+    _isConcrete = undefined;
+    isConcrete() {
+        if (typeof this._isConcrete !== "boolean")
+            this._isConcrete = this.typeArg.isConcrete();
+        return this._isConcrete;
+    }
+    clone() {
+        const result = new TirDataOptT(this.typeArg.clone());
+        result._isConcrete = this._isConcrete;
+        return result;
+    }
+    toUplcConstType() { return constT.data; }
+}

package/dist/compiler/tir/types/TirNativeType/native/Optional/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./data.js";
+export * from "./sop.js";
+export * from "./isTirOptType.js";

package/dist/compiler/tir/types/TirNativeType/native/Optional/index.js

@@ -0,0 +1,3 @@
+export * from "./data.js";
+export * from "./sop.js";
+export * from "./isTirOptType.js";

package/dist/compiler/tir/types/TirNativeType/native/Optional/isTirOptType.d.ts

@@ -0,0 +1,4 @@
+import { TirType } from "../../../TirType.js";
+import { TirDataOptT } from "./data.js";
+import { TirSopOptT } from "./sop.js";
+export declare function isTirOptType(t: any): t is TirDataOptT<TirType> | TirSopOptT<TirType>;

package/dist/compiler/tir/types/TirNativeType/native/Optional/isTirOptType.js

@@ -0,0 +1,6 @@
+import { TirDataOptT } from "./data.js";
+import { TirSopOptT } from "./sop.js";
+export function isTirOptType(t) {
+    return (t instanceof TirDataOptT
+        || t instanceof TirSopOptT);
+}

package/dist/compiler/tir/types/TirNativeType/native/Optional/sop.d.ts

@@ -0,0 +1,17 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { TirSoPStructType } from "../../../TirStructType.js";
+import { TirType, ITirType } from "../../../TirType.js";
+export declare class TirSopOptT<T extends TirType = TirType> extends TirSoPStructType implements ITirType {
+    readonly typeArg: T;
+    constructor(typeArg: T);
+    hasDataEncoding(): boolean;
+    toAstName(): string;
+    toString(): string;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    protected _isConcrete: boolean | undefined;
+    isConcrete(): boolean;
+    clone(): TirSopOptT<T>;
+    toUplcConstType(): ConstType;
+}