@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

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

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

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

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

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

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

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

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

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

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

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

@@ -1,288 +0,0 @@
-/*
-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

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