@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev3

package/dist/compiler/tir/expressions/unary/TirUnaryTilde.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 TirUnaryTilde implements ITirExpr, ITirUnaryExpression {
+    operand: TirExpr;
+    readonly type: TirType;
+    readonly range: SourceRange;
+    constructor(operand: TirExpr, type: TirType, range: SourceRange);
+    clone(): TirUnaryTilde;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

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

@@ -0,0 +1,22 @@
+import { _ir_apps } from "../../../../IR/tree_utils/_ir_apps.js";
+import { IRNative } from "../../../../IR/index.js";
+export class TirUnaryTilde {
+    operand;
+    type;
+    range;
+    constructor(operand, type, range) {
+        this.operand = operand;
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirUnaryTilde(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.complementByteString, this.operand.toIR(ctx));
+    }
+}

package/dist/compiler/tir/expressions/utils/NamedExpr.d.ts

@@ -0,0 +1,5 @@
+import { TirExpr } from "../TirExpr.js";
+export interface NamedExpr {
+    name: string;
+    expr: TirExpr;
+}

package/dist/compiler/tir/expressions/utils/NamedExpr.js

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

package/dist/compiler/tir/program/TypedProgram.d.ts

@@ -0,0 +1,44 @@
+import { DiagnosticEmitter } from "../../../diagnostics/DiagnosticEmitter.js";
+import { DiagnosticMessage } from "../../../diagnostics/DiagnosticMessage.js";
+import { AstScope } from "../../AstCompiler/scope/AstScope.js";
+import { UidGenerator } from "../../internalVar.js";
+import { TirExpr } from "../expressions/TirExpr.js";
+import { TirFuncExpr } from "../expressions/TirFuncExpr.js";
+import { TirInlineClosedIR } from "../expressions/TirInlineClosedIR.js";
+import { TirType } from "../types/TirType.js";
+import { StdTypes } from "./stdScope/StdTypes.js";
+export interface IGenericType {
+    arity: number;
+    apply: (argsTirNames: string[]) => (TirType | undefined);
+}
+/**
+ * for now we only care about "executables"
+ *
+ * TODO: support libraries
+ */
+export declare class TypedProgram extends DiagnosticEmitter {
+    readonly constants: Map<string, TirExpr>;
+    readonly functions: Map<string, TirFuncExpr | TirInlineClosedIR>;
+    readonly types: Map<string, TirType>;
+    private readonly genericTypes;
+    /** main */
+    contractTirFuncName: string;
+    readonly stdTypes: StdTypes;
+    /** to every file is assigned a unique string used to prefix exported value,
+     * to guarantee we have unique keys in the `this.constants` map
+    **/
+    readonly filePrefix: Map<string, string>;
+    readonly uid: UidGenerator;
+    readonly stdScope: AstScope;
+    readonly preludeScope: AstScope;
+    constructor(diagnostics?: DiagnosticMessage[]);
+    getMainOrThrow(): TirFuncExpr;
+    getFilePrefix(path: string): string;
+    defineGenericType(tirKey: string, arity: number, mkApplied: (tyArgs: TirType[]) => TirType): boolean;
+    getAppliedGeneric(genericTirKey: string, concreteArgsNames: (string | TirType)[]): TirType | undefined;
+    private _mkGenericInfos;
+    private _fileExports;
+    getExportedSymbols(srcAbsPathsrcAbsPath: string): AstScope | undefined;
+    setExportedSymbols(srcAbsPathsrcAbsPath: string, scope: AstScope): void;
+}
+export declare function getAppliedTirTypeName(baseName: string, args: string[]): string;

package/dist/compiler/tir/program/TypedProgram.js

@@ -0,0 +1,126 @@
+import { DiagnosticEmitter } from "../../../diagnostics/DiagnosticEmitter.js";
+import { AstScope } from "../../AstCompiler/scope/AstScope.js";
+import { UidGenerator } from "../../internalVar.js";
+import { TirFuncExpr } from "../expressions/TirFuncExpr.js";
+import { isTirType } from "../types/TirType.js";
+import { populatePreludeScope, populateStdScope } from "./stdScope/stdScope.js";
+import { StdTypes } from "./stdScope/StdTypes.js";
+/**
+ * for now we only care about "executables"
+ *
+ * TODO: support libraries
+ */
+export class TypedProgram extends DiagnosticEmitter {
+    constants;
+    functions;
+    types;
+    genericTypes;
+    /** main */
+    contractTirFuncName = "";
+    stdTypes;
+    /** to every file is assigned a unique string used to prefix exported value,
+     * to guarantee we have unique keys in the `this.constants` map
+    **/
+    filePrefix;
+    uid;
+    stdScope;
+    preludeScope;
+    constructor(diagnostics = []) {
+        super(diagnostics);
+        this.uid = new UidGenerator();
+        this.constants = new Map();
+        this.functions = new Map();
+        this.types = new Map();
+        this.genericTypes = new Map();
+        this.filePrefix = new Map();
+        this.stdScope = new AstScope(undefined, this, { isFunctionDeclScope: false, isMethodScope: false });
+        populateStdScope(this);
+        this.stdTypes = new StdTypes(this);
+        this.preludeScope = new AstScope(this.stdScope, this, { isFunctionDeclScope: false, isMethodScope: false });
+        populatePreludeScope(this);
+    }
+    getMainOrThrow() {
+        if (this.contractTirFuncName === "")
+            throw new Error("TypedProgram: main function name not set");
+        const mainFuncExpr = this.functions.get(this.contractTirFuncName);
+        if (!(mainFuncExpr instanceof TirFuncExpr))
+            throw new Error(`TypedProgram: main function '${this.contractTirFuncName}' not found or not a function`);
+        return mainFuncExpr;
+    }
+    getFilePrefix(path) {
+        if (!this.filePrefix.has(path)) {
+            const prefix = this.uid.getUid();
+            this.filePrefix.set(path, prefix);
+        }
+        return this.filePrefix.get(path);
+    }
+    defineGenericType(tirKey, arity, mkApplied) {
+        if (!(typeof tirKey === "string" && tirKey.length > 0
+            && Number.isSafeInteger(arity) && arity > 0
+            && typeof mkApplied === "function"))
+            return false;
+        if (this.genericTypes.has(tirKey))
+            return false;
+        this.genericTypes.set(tirKey, this._mkGenericInfos(tirKey, arity, mkApplied));
+        return true;
+    }
+    getAppliedGeneric(genericTirKey, concreteArgsNames) {
+        const genericInfos = this.genericTypes.get(genericTirKey);
+        if (typeof genericInfos !== "object")
+            return undefined;
+        const { arity, apply } = genericInfos;
+        if (concreteArgsNames.length < arity)
+            return undefined;
+        concreteArgsNames = concreteArgsNames.slice(0, arity);
+        // `apply` also defines the applied concrete type
+        const applied = apply(concreteArgsNames.map(t => typeof t === "string" ? t : t.toConcreteTirTypeName()));
+        if (!applied)
+            return undefined;
+        return applied;
+    }
+    _mkGenericInfos(tirKey, arity, mkApplied) {
+        return {
+            arity,
+            apply: _genericInfosApply.bind({
+                program: this,
+                tirKey,
+                arity,
+                mkApplied
+            })
+        };
+    }
+    _fileExports = new Map();
+    getExportedSymbols(srcAbsPathsrcAbsPath) {
+        return this._fileExports.get(srcAbsPathsrcAbsPath);
+    }
+    setExportedSymbols(srcAbsPathsrcAbsPath, scope) {
+        this._fileExports.set(srcAbsPathsrcAbsPath, scope);
+    }
+}
+// if htis is causing problems
+// (such as not resulting in the same name for the same type)
+// it can be removed,
+// and in `_genericInfosApply` the method `.toConcreteTirTypeName()`
+// should be used to save the type in the program
+export function getAppliedTirTypeName(baseName, args) {
+    return `${baseName}<${args.join(",")}>`;
+}
+function _genericInfosApply(argsTirNames) {
+    const { program, tirKey, arity, mkApplied } = this;
+    if (argsTirNames.length < arity)
+        return undefined;
+    argsTirNames = argsTirNames.slice(0, arity);
+    const appliedConcreteName = getAppliedTirTypeName(tirKey, argsTirNames);
+    if (program.types.has(appliedConcreteName))
+        return program.types.get(appliedConcreteName);
+    const args = argsTirNames.map(t => program.types.get(t));
+    if (args.some(t => !(t && t.isConcrete())))
+        return undefined;
+    const applied = mkApplied(args);
+    if (!(isTirType(applied)
+        && applied.isConcrete()))
+        return undefined;
+    // !!! DO NOT REMOVE !!!
+    program.types.set(appliedConcreteName, applied);
+    return applied;
+}

package/dist/compiler/tir/program/stdScope/StdTypes.d.ts

@@ -0,0 +1,34 @@
+import { TirBoolT } from "../../types/TirNativeType/native/bool.js";
+import { TirBytesT } from "../../types/TirNativeType/native/bytes.js";
+import { TirDataT } from "../../types/TirNativeType/native/data.js";
+import { TirIntT } from "../../types/TirNativeType/native/int.js";
+import { TirStringT } from "../../types/TirNativeType/native/string.js";
+import { TirVoidT } from "../../types/TirNativeType/native/void.js";
+import { TirType } from "../../types/TirType.js";
+import { TypedProgram } from "../TypedProgram.js";
+export interface IStdTypes {
+    readonly void: TirVoidT;
+    readonly bool: TirBoolT;
+    readonly int: TirIntT;
+    readonly bytes: TirBytesT;
+    readonly string: TirStringT;
+    readonly data: TirDataT;
+    dataOptional: (arg: TirType) => (TirType | undefined);
+    sopOptional: (arg: TirType) => (TirType | undefined);
+    list: (arg: TirType) => (TirType | undefined);
+    linearMap: (keyT: TirType, valT: TirType) => (TirType | undefined);
+}
+export declare class StdTypes implements IStdTypes {
+    readonly program: TypedProgram;
+    readonly void: TirVoidT;
+    readonly bool: TirBoolT;
+    readonly int: TirIntT;
+    readonly bytes: TirBytesT;
+    readonly string: TirStringT;
+    readonly data: TirDataT;
+    constructor(program: TypedProgram);
+    dataOptional(arg: TirType): TirType | undefined;
+    sopOptional(arg: TirType): TirType | undefined;
+    list(arg: TirType): TirType | undefined;
+    linearMap(keyT: TirType, valT: TirType): TirType | undefined;
+}

package/dist/compiler/tir/program/stdScope/StdTypes.js

@@ -0,0 +1,40 @@
+import { TirBoolT } from "../../types/TirNativeType/native/bool.js";
+import { TirBytesT } from "../../types/TirNativeType/native/bytes.js";
+import { TirDataT } from "../../types/TirNativeType/native/data.js";
+import { TirIntT } from "../../types/TirNativeType/native/int.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";
+import { TirSopOptT } from "../../types/TirNativeType/native/Optional/sop.js";
+import { TirStringT } from "../../types/TirNativeType/native/string.js";
+import { TirVoidT } from "../../types/TirNativeType/native/void.js";
+export class StdTypes {
+    program;
+    void;
+    bool;
+    int;
+    bytes;
+    string;
+    data;
+    constructor(program) {
+        this.program = program;
+        this.void = program.types.get(TirVoidT.toTirTypeKey());
+        this.bool = program.types.get(TirBoolT.toTirTypeKey());
+        this.int = program.types.get(TirIntT.toTirTypeKey());
+        this.bytes = program.types.get(TirBytesT.toTirTypeKey());
+        this.string = program.types.get(TirStringT.toTirTypeKey());
+        this.data = program.types.get(TirDataT.toTirTypeKey());
+    }
+    dataOptional(arg) {
+        return this.program.getAppliedGeneric(TirDataOptT.toTirTypeKey(), [arg]);
+    }
+    sopOptional(arg) {
+        return this.program.getAppliedGeneric(TirSopOptT.toTirTypeKey(), [arg]);
+    }
+    list(arg) {
+        return this.program.getAppliedGeneric(TirListT.toTirTypeKey(), [arg]);
+    }
+    linearMap(keyT, valT) {
+        return this.program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [keyT, valT]);
+    }
+}

package/dist/compiler/tir/program/stdScope/prelude/preludeTypesSrc.js

@@ -0,0 +1,288 @@
+/*
+export const preludeTypesSrc =
+`export type Hash32 = bytes;
+export type Hash28 = bytes;
+export type PolicyId = Hash28;
+export type TokenName = bytes;
+export type PubKeyHash = Hash28;
+export type ScriptHash = Hash28;
+export type TxHash = Hash32;
+
+export struct TxOutRef {
+    id: TxHash,
+    index: int,
+}
+
+export struct Credential {
+    PubKey { hash: PubKeyHash }
+    Script { hash: ScriptHash }
+}
+
+type Credential implements {
+    hash(): bytes
+    {
+        // return case this
+        //     is PubKey{ hash } => hash
+        //     is Script{ hash } => hash;
+        return builtin.unBData(
+            builtin.unConstrData( this ).snd.head
+        );
+    }
+}
+
+export type ChangedParameters = LinearMap<int,data>;
+
+export struct Rational {
+    numerator: int,
+    denominator: int
+}
+
+export struct ProtocolVersion {
+    major: int,
+    minor: int
+}
+
+export struct ConstitutionInfo {
+    consitutionScriptHash: Optional<ScriptHash>
+}
+
+export struct GovAction {
+    ParameterChange {
+        govActionId: Optional<TxOutRef>,
+        changedParameters: ChangedParameters,
+        constitutionScriptHash: Optional<ScriptHash>
+    }
+    HardForkInitiation {
+        govActionId: Optional<TxOutRef>,
+        nextProtocolVersion: ProtocolVersion
+    }
+    TreasuryWithdrawals {
+        withdrawals: LinearMap<Credential, int>
+        constitutionScriptHash: Optional<ScriptHash>
+    }
+    NoConfidence {
+        govActionId: Optional<TxOutRef>
+    }
+    UpdateCommittee {
+        govActionId: Optional<TxOutRef>,
+        removed: List<Credential>,
+        newMembers: LinearMap<Credential, int>,
+        newQuorum: Rational
+    }
+    NewConstitution {
+        govActionId: Optional<TxOutRef>,
+        info: ConstitutionInfo
+    }
+    InfoAction {}
+}
+
+export struct ProposalProcedure {
+    deposit: int,
+    credential: Credential,
+    action: GovAction
+}
+
+export struct Voter {
+    Committee {
+        credential: Credential
+    }
+    DRep {
+        credential: Credential
+    }
+    StakePool {
+        pubKeyHash: PubKeyHash
+    }
+}
+
+export struct ScriptPurpose {
+    Mint { policy: PolicyId }
+    Spend {
+        ref: TxOutRef,
+        optionalDatum: Optional<data>
+    }
+    Withdraw {
+        credential: Credential
+    }
+    Certificate {
+        index: int,
+        certificate: Certificate
+    }
+    Vote {
+        voter: Voter
+    }
+    Propose {
+        index: int,
+        proposal: ProposalProcedure
+    }
+}
+
+export struct ScriptInfo {
+    Mint { policy: PolicyId }
+    Spend {
+        ref: TxOutRef,
+        datum: Optional<data>
+    }
+    Withdraw {
+        credential: Credential
+    }
+    Certificate {
+        index: int,
+        certificate: Certificate
+    }
+    Vote {
+        voter: Voter
+    }
+    Propose {
+        index: int,
+        proposal: ProposalProcedure
+    }
+}
+
+export struct StakeCredential {
+    Credential { credential: Credential }
+    Ptr {
+        a: int,
+        b: int,
+        c: int
+    }
+}
+
+export struct Address {
+    payment: Credential,
+    stake: Optional<Credential>
+}
+
+export type Value = LinearMap<PolicyId, LinearMap<TokenName, int>>
+
+type Value implements {
+    amountOf( policy: PolicyId, name: bytes ): int
+    {
+        // todo
+        fail;
+    }
+    lovelaces(): int
+    {
+        return this.amountOf( #, # );
+    }
+}
+
+export struct OutputDatum {
+    NoDatum {}
+    DatumHash { hash: Hash32 }
+    InlineDatum { datum: data }
+}
+
+export struct TxOut {
+    address: Address,
+    value: Value,
+    datum: OutputDatum,
+    referenceScript: Optional<ScriptHash>
+}
+
+export struct TxIn {
+    ref: TxOutRef,
+    resolved: TxOut
+}
+
+export struct ExtendedInteger {
+    NegInf {}
+    Finite { n: int }
+    PosInf {}
+}
+
+export struct IntervalBoundary {
+    boundary: ExtendedInteger,
+    isInclusive: boolean
+}
+
+export struct Interval {
+    from: IntervalBoundary,
+    to: IntervalBoundary,
+}
+
+export struct Vote {
+    No {}
+    Yes {}
+    Abstain {}
+}
+
+export struct Delegatee {
+    StakePool { poolKeyHash: PubKeyHash }
+    DRep { drep: Credential }
+    PoolAndDRep {
+        poolKeyHash: PubKeyHash,
+        drep: Credential
+    }
+}
+
+export struct Certificate {
+    StakeRegistration {
+        stakeKey: Credential,
+        deposit: Optional<int>
+    }
+    StakeDeRegistration {
+        stakeKey: Credential,
+        refund: Optional<int>
+    }
+    Delegation {
+        delegator: Credential,
+        delegatee: Delegatee
+    }
+    RegistrationAndDelegation {
+        delegator: Credential,
+        delegatee: Delegatee,
+        lovelacesDeposit: int
+    }
+    DRepRegistration {
+        drep: Credential,
+        lovelacesDeposit: int
+    }
+    DRepUpdate {
+        drep: Credential
+    }
+    DRepDeRegistration {
+        drep: Credential,
+        refund: int
+    }
+    PoolRegistration {
+        poolId: PubKeyHash,
+        poolVRF: bytes
+    }
+    PoolRetire {
+        poolId: PubKeyHash,
+        epoch: int
+    }
+    CommitteeHotAuthorization {
+        cold: Credential,
+        hot: Credential
+    }
+    CommitteeResignation {
+        cold: Credential
+    }
+}
+
+export struct Tx {
+    inputs: List<TxIn>,
+    refInputs: List<TxIn>,
+    outputs: List<TxOut>,
+    fee: int,
+    mint: Value,
+    certificates: List<Certificate>,
+    withdrawals: LinearMap<Credential, int>,
+    validityInterval: Interval,
+    requiredSigners: List<PubKeyHash>,
+    redeemers: LinearMap<ScriptPurpose, data>,
+    datums: LinearMap<Hash32, data>,
+    hash: TxHash,
+    votes: LinearMap<Voter, LinearMap<TxOutRef, Vote>>,
+    proposals: List<ProposalProcedure>,
+    currentTreasury: Optional<int>,
+    treasuryDonation: Optional<int>
+}
+
+export struct ScriptContext {
+    tx: Tx,
+    redeemer: data,
+    purpose: ScriptInfo
+}`;
+//*/ 

package/dist/compiler/tir/program/stdScope/stdScope.d.ts

@@ -0,0 +1,15 @@
+import { TypedProgram } from "../TypedProgram.js";
+import { TirBoolT } from "../../types/TirNativeType/native/bool.js";
+import { TirBytesT } from "../../types/TirNativeType/native/bytes.js";
+import { TirDataT } from "../../types/TirNativeType/native/data.js";
+import { TirIntT } from "../../types/TirNativeType/native/int.js";
+import { TirStringT } from "../../types/TirNativeType/native/string.js";
+import { TirVoidT } from "../../types/TirNativeType/native/void.js";
+export declare const void_t: TirVoidT;
+export declare const int_t: TirIntT;
+export declare const string_t: TirStringT;
+export declare const bytes_t: TirBytesT;
+export declare const bool_t: TirBoolT;
+export declare const data_t: TirDataT;
+export declare function populateStdScope(program: TypedProgram): void;
+export declare function populatePreludeScope(program: TypedProgram): void;