@harmoniclabs/pebble 0.1.10 → 0.2.0

package/dist/compiler/AstCompiler/utils/getPropAccessReturnType.js

@@ -2,7 +2,7 @@ import { TirAliasType } from "../../tir/types/TirAliasType.js";
 import { isTirStructType } from "../../tir/types/TirStructType.js";
 import { TirTypeParam } from "../../tir/types/TirTypeParam.js";
 import { int_t, bytes_t, bool_t, string_t } from "../../tir/program/stdScope/stdScope.js";
-import { TirUnConstrDataResultT, TirPairDataT } from "../../tir/types/TirNativeType/index.js";
+import { TirBlsG1T, TirBlsG2T, TirMlResultT, TirUnConstrDataResultT, TirPairDataT } from "../../tir/types/TirNativeType/index.js";
 import { TirBoolT } from "../../tir/types/TirNativeType/native/bool.js";
 import { TirBytesT } from "../../tir/types/TirNativeType/native/bytes.js";
 import { TirDataT } from "../../tir/types/TirNativeType/native/data.js";
@@ -27,6 +27,24 @@ export function getPropAccessReturnType(ctx, objType, propId) {
         objType = objType.aliased;
     }
     // if( objType instanceof TirAliasType ) return findPropInImpls( objType.impls, propName ) ?? getPropAccessReturnType( objType.aliased, propId );
+    // Universal `.show()` — every (built-in) type implementing the Show
+    // interface has signature `(): bytes`. Struct types fall through to
+    // `getStructPropAccessReturnType`, which checks user-declared
+    // `type X implements Show { ... }` impls first; if absent, the
+    // expressify-time fallback emits a TirShowExpr that auto-derives via
+    // `_showIR` (e.g. for data-encoded structs).
+    if (propName === "show") {
+        if (objType instanceof TirVoidT
+            || objType instanceof TirBoolT
+            || objType instanceof TirIntT
+            || objType instanceof TirBytesT
+            || objType instanceof TirStringT
+            || objType instanceof TirDataT
+            || objType instanceof TirListT
+            || objType instanceof TirLinearMapT
+            || isTirOptType(objType))
+            return new TirFuncT([], bytes_t);
+    }
     if (isTirStructType(objType))
         return getStructPropAccessReturnType(ctx, objType, propName);
     if (objType instanceof TirVoidT)
@@ -60,6 +78,12 @@ export function getPropAccessReturnType(ctx, objType, propId) {
         return undefined;
     if (objType instanceof TirPairDataT)
         return undefined;
+    if (objType instanceof TirBlsG1T)
+        return undefined;
+    if (objType instanceof TirBlsG2T)
+        return undefined;
+    if (objType instanceof TirMlResultT)
+        return undefined;
     const tsEnsureExhaustiveCheck = objType;
     console.error(objType);
     throw new Error("unreachable::getPropAccessReturnType");

package/dist/compiler/AstCompiler/utils/monomorphizeGeneric.d.ts

@@ -0,0 +1,36 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { GenericTemplate } from "../../tir/program/TypedProgram.js";
+import { TirFuncT } from "../../tir/types/TirNativeType/native/function.js";
+import { TirType } from "../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../AstCompilationCtx.js";
+export interface MonomorphizationResult {
+    /** the canonical TIR function name registered in `program.functions` */
+    tirFuncName: string;
+    /** the substituted concrete TirFuncT (no remaining type params) */
+    concreteFuncType: TirFuncT;
+}
+/**
+ * Returns a deterministic instance key for memoization & function-table naming.
+ */
+export declare function buildMonomorphizationKey(templateCanonicalName: string, typeArgs: TirType[]): string;
+/**
+ * Instantiate a generic function template with the given concrete type
+ * arguments, producing (and caching) a fresh concrete TIR function.
+ *
+ * The strategy is "desugar to a concrete function during AST→TIR":
+ *
+ * 1. Build a child scope on the template's defining scope where each type
+ *    parameter name resolves as a type alias for its concrete type. When the
+ *    cloned FuncExpr is re-compiled, every `AstNamedTypeExpr` mentioning a
+ *    type parameter resolves to its concrete TIR type.
+ * 2. Construct a fresh `FuncExpr` reusing the template's body & signature but
+ *    with `typeParams = []` (so the "not implemented: generic functions"
+ *    guard in `_compileFuncExpr` does not trip) and a unique instance name.
+ * 3. Compile via `_compileFuncExpr` and register the resulting `TirFuncExpr`
+ *    in `program.functions` under the instance name.
+ *
+ * Results are memoized per `(template, type-args)` tuple — repeated calls
+ * with the same type arguments return the same instance and do not
+ * re-compile.
+ */
+export declare function monomorphizeGeneric(ctx: AstCompilationCtx, template: GenericTemplate, typeArgs: TirType[], callRange: SourceRange): MonomorphizationResult | undefined;

package/dist/compiler/AstCompiler/utils/monomorphizeGeneric.js

@@ -0,0 +1,123 @@
+import { FuncExpr } from "../../../ast/nodes/expr/functions/FuncExpr.js";
+import { Identifier } from "../../../ast/nodes/common/Identifier.js";
+import { ArrowKind } from "../../../ast/nodes/expr/functions/ArrowKind.js";
+import { DiagnosticCode } from "../../../diagnostics/diagnosticMessages.generated.js";
+import { substituteTypeParams } from "../../tir/types/utils/substituteTypeParams.js";
+import { AstCompilationCtx } from "../AstCompilationCtx.js";
+import { _compileFuncExpr } from "../internal/exprs/_compileFuncExpr.js";
+/**
+ * Returns a deterministic instance key for memoization & function-table naming.
+ */
+export function buildMonomorphizationKey(templateCanonicalName, typeArgs) {
+    return templateCanonicalName + "$$" + typeArgs.map(t => t.toConcreteTirTypeName()).join("$$");
+}
+/**
+ * Instantiate a generic function template with the given concrete type
+ * arguments, producing (and caching) a fresh concrete TIR function.
+ *
+ * The strategy is "desugar to a concrete function during AST→TIR":
+ *
+ * 1. Build a child scope on the template's defining scope where each type
+ *    parameter name resolves as a type alias for its concrete type. When the
+ *    cloned FuncExpr is re-compiled, every `AstNamedTypeExpr` mentioning a
+ *    type parameter resolves to its concrete TIR type.
+ * 2. Construct a fresh `FuncExpr` reusing the template's body & signature but
+ *    with `typeParams = []` (so the "not implemented: generic functions"
+ *    guard in `_compileFuncExpr` does not trip) and a unique instance name.
+ * 3. Compile via `_compileFuncExpr` and register the resulting `TirFuncExpr`
+ *    in `program.functions` under the instance name.
+ *
+ * Results are memoized per `(template, type-args)` tuple — repeated calls
+ * with the same type arguments return the same instance and do not
+ * re-compile.
+ */
+export function monomorphizeGeneric(ctx, template, typeArgs, callRange) {
+    const program = ctx.program;
+    if (typeArgs.length !== template.typeParams.length) {
+        ctx.error(DiagnosticCode.Expected_0_type_arguments_but_got_1, callRange, String(template.typeParams.length), String(typeArgs.length));
+        return undefined;
+    }
+    // Build the substitution env for substituteTypeParams
+    const subst = new Map();
+    for (let i = 0; i < template.typeParams.length; i++) {
+        subst.set(template.typeParams[i].symbol, typeArgs[i]);
+    }
+    // Compute concrete signature up-front (used by callers to type the call expr)
+    const concreteFuncType = substituteTypeParams(template.placeholderFuncType, subst);
+    // Memo key & cache hit
+    const instanceName = buildMonomorphizationKey(template.canonicalTirName, typeArgs);
+    const cached = program.monomorphizationCache.get(instanceName);
+    if (typeof cached === "string") {
+        return { tirFuncName: cached, concreteFuncType };
+    }
+    // Native template path: skip AST cloning entirely.
+    if (template.kind === "native") {
+        const tirFunc = template.instantiate(typeArgs);
+        program.functions.set(instanceName, tirFunc);
+        program.monomorphizationCache.set(instanceName, instanceName);
+        return { tirFuncName: instanceName, concreteFuncType };
+    }
+    // Cycle detection: polymorphic recursion (same template + same type args
+    // re-entering before the first compile finished) is impossible because
+    // recursion at the same type-args hits the memo cache below. Recursion at
+    // *different* type-args is allowed and produces a separate instance.
+    if (program.monomorphizationInFlight.has(instanceName)) {
+        // intentionally rare path; surface as a Not_implemented diagnostic
+        ctx.error(DiagnosticCode.Not_implemented_0, callRange, "mutually-recursive monomorphization for " + instanceName);
+        return undefined;
+    }
+    program.monomorphizationInFlight.add(instanceName);
+    // Pre-register memo so recursive same-args call resolves to the same name
+    program.monomorphizationCache.set(instanceName, instanceName);
+    try {
+        // Build child scope where each type-param name aliases its concrete type
+        const monoScope = template.definingScope.newChildScope({
+            ...template.definingScope.infos,
+            isFunctionDeclScope: false,
+            isMethodScope: false
+        });
+        for (let i = 0; i < template.typeParams.length; i++) {
+            const tparam = template.typeParams[i];
+            const concrete = typeArgs[i];
+            const concreteKey = concrete.toConcreteTirTypeName();
+            if (!program.types.has(concreteKey)) {
+                program.types.set(concreteKey, concrete);
+            }
+            monoScope.defineUnambigousType(tparam.name, concreteKey, concrete.hasDataEncoding(), new Map() // no methods on a bare type alias
+            );
+        }
+        // Register the instance in the parent (defining) scope under the
+        // instance name so the body's own recursive `id(...)` call (which
+        // resolves through the parent chain) sees a concrete value of the
+        // already-substituted type. Without this, recursive calls would
+        // re-trigger the generic placeholder path and infinite-loop the
+        // monomorphizer.
+        // Use the mono scope (not the defining scope) so the entry is local
+        // to this instantiation.
+        monoScope.defineValue({
+            name: instanceName,
+            type: concreteFuncType,
+            isConstant: true,
+        });
+        const cloneExpr = new FuncExpr(new Identifier(instanceName, template.astFuncExpr.name.range), template.astFuncExpr.flags, [], // intentionally empty: this clone is the monomorphized concrete fn
+        template.astFuncExpr.signature, template.astFuncExpr.body, template.astFuncExpr.arrowKind ?? ArrowKind.None, template.astFuncExpr.range);
+        // Pre-seed program.functions with the concrete signature so
+        // `_compileFuncExpr` picks it up via `program.functions.get(...).sig()`.
+        // We will replace this with the real TirFuncExpr after compile.
+        // (placeholder is not strictly required; _compileFuncExpr falls back to
+        //  inferring from the signature if not present — leaving this out for
+        //  simplicity)
+        const monoCtx = AstCompilationCtx.fromScope(program, monoScope);
+        const tirFuncExpr = _compileFuncExpr(monoCtx, cloneExpr, undefined, false // isMethod
+        );
+        if (!tirFuncExpr) {
+            program.monomorphizationCache.delete(instanceName);
+            return undefined;
+        }
+        program.functions.set(instanceName, tirFuncExpr);
+        return { tirFuncName: instanceName, concreteFuncType };
+    }
+    finally {
+        program.monomorphizationInFlight.delete(instanceName);
+    }
+}

package/dist/compiler/AstCompiler/utils/resolveNamespaceChain.d.ts

@@ -0,0 +1,28 @@
+import { PebbleExpr } from "../../../ast/nodes/expr/PebbleExpr.js";
+import { TirExpr } from "../../tir/expressions/TirExpr.js";
+import { AstCompilationCtx } from "../AstCompilationCtx.js";
+import { NamespaceSymbol } from "../scope/AstScope.js";
+export type NamespaceChainResolution = {
+    kind: "namespace";
+    namespace: NamespaceSymbol;
+} | {
+    kind: "value";
+    expr: TirExpr;
+}
+/** the chain points to a non-value (type / interface / nested ns
+ *  used in non-expression position). callers should typically error. */
+ | {
+    kind: "incomplete";
+} | undefined;
+/**
+ * if `expr` is `Identifier` or a chain of `DotPropAccessExpr` ending in an
+ * `Identifier`, AND the head identifier resolves to a namespace in scope,
+ * walks the chain through namespace `publicScope`s and returns the resolved
+ * member. otherwise returns `undefined` so the caller can fall back to
+ * normal value/property-access compilation.
+ *
+ * the resolution does NOT emit diagnostics on plain "not a namespace"
+ * outcomes — those are silent failures so the caller can choose another
+ * resolution strategy.
+ */
+export declare function tryResolveNamespaceChain(ctx: AstCompilationCtx, expr: PebbleExpr): NamespaceChainResolution;

package/dist/compiler/AstCompiler/utils/resolveNamespaceChain.js

@@ -0,0 +1,95 @@
+import { Identifier } from "../../../ast/nodes/common/Identifier.js";
+import { DotPropAccessExpr } from "../../../ast/nodes/expr/PropAccessExpr.js";
+import { DiagnosticCode } from "../../../diagnostics/diagnosticMessages.generated.js";
+import { TirVariableAccessExpr } from "../../tir/expressions/TirVariableAccessExpr.js";
+/**
+ * if `expr` is `Identifier` or a chain of `DotPropAccessExpr` ending in an
+ * `Identifier`, AND the head identifier resolves to a namespace in scope,
+ * walks the chain through namespace `publicScope`s and returns the resolved
+ * member. otherwise returns `undefined` so the caller can fall back to
+ * normal value/property-access compilation.
+ *
+ * the resolution does NOT emit diagnostics on plain "not a namespace"
+ * outcomes — those are silent failures so the caller can choose another
+ * resolution strategy.
+ */
+export function tryResolveNamespaceChain(ctx, expr) {
+    const segments = _collectChainSegments(expr);
+    if (!segments)
+        return undefined;
+    const head = ctx.scope.resolveNamespace(segments[0].text);
+    if (!head)
+        return undefined;
+    // head is a namespace; from here on, any failure emits a diagnostic
+    let current = head;
+    for (let i = 1; i < segments.length; i++) {
+        const seg = segments[i];
+        const name = seg.text;
+        const pub = current.publicScope;
+        const nested = pub.namespaces.get(name);
+        if (nested) {
+            current = nested;
+            continue;
+        }
+        const variable = pub.variables.get(name);
+        if (variable) {
+            // last segment must end here; if not, the chain is invalid
+            if (i !== segments.length - 1) {
+                ctx.error(DiagnosticCode.Property_0_does_not_exist_on_type_1, seg.range, segments[i + 1].text, variable.type.toString());
+                return { kind: "incomplete" };
+            }
+            return {
+                kind: "value",
+                expr: new TirVariableAccessExpr({ variableInfos: variable, isDefinedOutsideFuncScope: true }, seg.range)
+            };
+        }
+        const tirFuncName = pub.functions.get(name);
+        if (tirFuncName) {
+            if (i !== segments.length - 1) {
+                // function-typed member can't be further dotted
+                ctx.error(DiagnosticCode.Namespace_path_is_incomplete_expected_a_value_type_function_or_interface, seg.range);
+                return { kind: "incomplete" };
+            }
+            const funcExpr = pub.program.functions.get(tirFuncName);
+            if (!funcExpr) {
+                ctx.error(DiagnosticCode.Namespace_0_has_no_exported_member_1, seg.range, current.name, name);
+                return { kind: "incomplete" };
+            }
+            return {
+                kind: "value",
+                expr: new TirVariableAccessExpr({
+                    variableInfos: {
+                        isConstant: true,
+                        name: tirFuncName,
+                        type: funcExpr.type,
+                    },
+                    isDefinedOutsideFuncScope: true,
+                }, seg.range)
+            };
+        }
+        // not a namespace, not a value, not a function — likely a type or
+        // interface. either way it can't be used as a value here.
+        if (pub.types.has(name) || pub.interfaces.has(name)) {
+            ctx.error(DiagnosticCode.Namespace_path_is_incomplete_expected_a_value_type_function_or_interface, seg.range);
+            return { kind: "incomplete" };
+        }
+        ctx.error(DiagnosticCode.Namespace_0_has_no_exported_member_1, seg.range, current.name, name);
+        return { kind: "incomplete" };
+    }
+    // chain consumed entirely as namespaces (no leaf member)
+    return { kind: "namespace", namespace: current };
+}
+function _collectChainSegments(expr) {
+    if (expr instanceof Identifier)
+        return [expr];
+    if (expr instanceof DotPropAccessExpr) {
+        const inner = _collectChainSegments(expr.object);
+        if (!inner)
+            return undefined;
+        inner.push(expr.prop);
+        return inner;
+    }
+    // anything other than a plain dotted-identifier chain disqualifies
+    // namespace resolution.
+    return undefined;
+}

package/dist/compiler/AstCompiler/utils/resolveNamespacePath.d.ts

@@ -0,0 +1,37 @@
+import { Identifier } from "../../../ast/nodes/common/Identifier.js";
+import { UsingPath } from "../../../ast/nodes/statements/UsingStmt.js";
+import { AstScope, NamespaceSymbol } from "../scope/AstScope.js";
+import { AstCompilationCtx } from "../AstCompilationCtx.js";
+export interface ResolvedNamespacePath {
+    /** the namespace the path resolves to */
+    namespace: NamespaceSymbol;
+    /** the chain of resolved namespaces (one per segment of the path) */
+    chain: NamespaceSymbol[];
+}
+/**
+ * walks a dotted namespace path against the given scope.
+ *
+ * - returns the final `NamespaceSymbol` if every segment resolves to a namespace.
+ * - if the first segment is not a namespace, returns `undefined`
+ *   (no diagnostic emitted; the caller can fall back to a different
+ *   resolution strategy, e.g. struct lookup).
+ * - if a later segment is missing or is not a namespace, emits a
+ *   diagnostic and returns `undefined`.
+ */
+export declare function resolveNamespacePath(ctx: AstCompilationCtx, path: UsingPath): ResolvedNamespacePath | undefined;
+/**
+ * looks up a member name in a namespace's public scope.
+ *
+ * the member can be any of:
+ *   - a value (variable)
+ *   - a function
+ *   - a type
+ *   - an interface
+ *   - a nested namespace
+ *
+ * binds the resolved member into `target` (under either `originalName`
+ * or `aliasName` if provided). emits a diagnostic and returns `false`
+ * if no such member is exported, or if a conflicting binding already
+ * exists in `target`.
+ */
+export declare function bindNamespaceMember(ctx: AstCompilationCtx, ns: NamespaceSymbol, originalName: Identifier, aliasName: Identifier | undefined, target: AstScope): boolean;

package/dist/compiler/AstCompiler/utils/resolveNamespacePath.js

@@ -0,0 +1,93 @@
+import { DiagnosticCode } from "../../../diagnostics/diagnosticMessages.generated.js";
+/**
+ * walks a dotted namespace path against the given scope.
+ *
+ * - returns the final `NamespaceSymbol` if every segment resolves to a namespace.
+ * - if the first segment is not a namespace, returns `undefined`
+ *   (no diagnostic emitted; the caller can fall back to a different
+ *   resolution strategy, e.g. struct lookup).
+ * - if a later segment is missing or is not a namespace, emits a
+ *   diagnostic and returns `undefined`.
+ */
+export function resolveNamespacePath(ctx, path) {
+    const segments = path.segments;
+    if (segments.length === 0)
+        return undefined;
+    const head = segments[0];
+    const first = ctx.scope.resolveNamespace(head.text);
+    if (!first)
+        return undefined;
+    const chain = [first];
+    let current = first;
+    for (let i = 1; i < segments.length; i++) {
+        const seg = segments[i];
+        const inner = current.publicScope.namespaces.get(seg.text);
+        if (!inner) {
+            ctx.error(DiagnosticCode.Namespace_0_has_no_exported_member_1, seg.range, current.name, seg.text);
+            return undefined;
+        }
+        chain.push(inner);
+        current = inner;
+    }
+    return { namespace: current, chain };
+}
+/**
+ * looks up a member name in a namespace's public scope.
+ *
+ * the member can be any of:
+ *   - a value (variable)
+ *   - a function
+ *   - a type
+ *   - an interface
+ *   - a nested namespace
+ *
+ * binds the resolved member into `target` (under either `originalName`
+ * or `aliasName` if provided). emits a diagnostic and returns `false`
+ * if no such member is exported, or if a conflicting binding already
+ * exists in `target`.
+ */
+export function bindNamespaceMember(ctx, ns, originalName, aliasName, target) {
+    const pub = ns.publicScope;
+    const name = originalName.text;
+    const localName = aliasName?.text ?? name;
+    const variable = pub.variables.get(name);
+    const fn = pub.functions.get(name);
+    const tirFunc = fn ? pub.program.functions.get(fn) : undefined;
+    const ty = pub.types.get(name);
+    const iface = pub.interfaces.get(name);
+    const nested = pub.namespaces.get(name);
+    if (!variable && !fn && !ty && !iface && !nested) {
+        ctx.error(DiagnosticCode.Namespace_0_has_no_exported_member_1, originalName.range, ns.name, name);
+        return false;
+    }
+    let ok = true;
+    if (variable) {
+        ok = target.defineValue({ ...variable, name: localName }) && ok;
+    }
+    if (fn) {
+        target.functions.set(localName, fn);
+        if (tirFunc) {
+            target.defineValue({
+                isConstant: true,
+                name: localName,
+                type: tirFunc.type,
+            });
+        }
+    }
+    if (ty) {
+        ok = target.defineType(localName, ty) && ok;
+    }
+    if (iface) {
+        if (target.interfaces.has(localName))
+            ok = false;
+        else
+            target.interfaces.set(localName, iface);
+    }
+    if (nested) {
+        ok = target.defineNamespace({
+            name: localName,
+            publicScope: nested.publicScope
+        }) && ok;
+    }
+    return ok;
+}

package/dist/compiler/Compiler.d.ts

@@ -3,11 +3,13 @@ import { DiagnosticMessage } from "../diagnostics/DiagnosticMessage.js";
 import { CompilerOptions } from "../IR/toUPLC/CompilerOptions.js";
 import { CompilerIoApi } from "./io/CompilerIoApi.js";
 import { CheckResult } from "./SourceTypeMap.js";
+import { TestResult } from "./test/TestResult.js";
 export { CheckResult, SourceTypeMap, TypeEntry, MemberInfo } from "./SourceTypeMap.js";
+export { TestBudget, TestIterationResult, TestResult, TestKind, } from "./test/TestResult.js";
 export declare class Compiler extends DiagnosticEmitter {
     readonly io: CompilerIoApi;
     readonly cfg: CompilerOptions;
-    constructor(io?: CompilerIoApi, cfg?: CompilerOptions, diagnostics?: DiagnosticMessage[]);
+    constructor(io: CompilerIoApi, cfg: CompilerOptions, diagnostics?: DiagnosticMessage[]);
     check(config?: Partial<CompilerOptions>): Promise<CheckResult>;
     compile(config?: Partial<CompilerOptions>): Promise<Uint8Array>;
     export(config: Partial<ExportOptions> & HasFuncitonName): Promise<Uint8Array>;
@@ -16,6 +18,12 @@ export declare class Compiler extends DiagnosticEmitter {
         budgetSpent: import("@harmoniclabs/plutus-machine").ExBudget;
         logs: string[];
     }>;
+    test(config?: Partial<CompilerOptions> & {
+        nameFilter?: string | RegExp;
+        propertyIterations?: number;
+        seed?: number;
+    }): Promise<TestResult[]>;
+    private _runOneTest;
     runRepl(config?: Partial<CompilerOptions>): Promise<{
         result: import("@harmoniclabs/plutus-machine").CEKValueObj;
         budgetSpent: import("@harmoniclabs/plutus-machine").ExBudget;