@harmoniclabs/pebble 0.1.10 → 0.3.0

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

@@ -1,3 +1,5 @@
+import { TirValueT } from "../../types/TirNativeType/native/value.js";
+import { getUnaliased } from "../../types/utils/getUnaliased.js";
 import { _ir_apps } from "../../../../IR/IRNodes/IRApp.js";
 import { IRNative } from "../../../../IR/IRNodes/IRNative/index.js";
 export class TirUnaryMinus {
@@ -23,6 +25,7 @@ export class TirUnaryMinus {
     }
     get isConstant() { return this.operand.isConstant; }
     toIR(ctx) {
-        return _ir_apps(IRNative._negateInt, this.operand.toIR(ctx));
+        const operandTy = getUnaliased(this.operand.type);
+        return _ir_apps(operandTy instanceof TirValueT ? IRNative._negateValue : IRNative._negateInt, this.operand.toIR(ctx));
     }
 }

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

@@ -1,16 +1,85 @@
 import { DiagnosticEmitter } from "../../../diagnostics/DiagnosticEmitter.js";
 import { DiagnosticMessage } from "../../../diagnostics/DiagnosticMessage.js";
+import { FuncExpr } from "../../../ast/nodes/expr/functions/FuncExpr.js";
 import { AstScope } from "../../AstCompiler/scope/AstScope.js";
 import { UidGenerator } from "../../internalVar.js";
 import { TirFuncExpr } from "../expressions/TirFuncExpr.js";
 import { TirInlineClosedIR } from "../expressions/TirInlineClosedIR.js";
 import { TirSimpleVarDecl } from "../statements/TirVarDecl/TirSimpleVarDecl.js";
+import { TirTestStmt } from "../statements/TirTestStmt.js";
+import { TirTypeParam } from "../types/TirTypeParam.js";
 import { TirType } from "../types/TirType.js";
 import { StdTypes } from "./stdScope/StdTypes.js";
 export interface IGenericType {
     arity: number;
     apply: (argsTirNames: string[]) => (TirType | undefined);
 }
+/**
+ * A pending generic function template registered at AST→TIR collection time.
+ *
+ * Two flavors are supported:
+ * - "user" templates wrap a Pebble `function f<T>(...) { body }` AST node.
+ *   `monomorphizeGeneric` instantiates one by re-compiling a clone of the
+ *   AST in a scope where each type-param name aliases its concrete type.
+ * - "native" templates wrap a polymorphic UPLC builtin (e.g. `mkCons<T>`).
+ *   Each instantiation produces a fresh `TirInlineClosedIR` directly; there
+ *   is no AST involved.
+ *
+ * Both flavors share the same monomorphization memoization on
+ * `program.monomorphizationCache`.
+ */
+/**
+ * An interface-constraint on a type parameter of a generic function.
+ * Captured at template-registration time so `monomorphizeGeneric` doesn't
+ * have to re-resolve the interface at each call site.
+ */
+export interface TypeParamConstraint {
+    /** e.g. "ToData" */
+    interfaceName: string;
+    /** method-name -> AstFuncType signature (as registered in `scope.interfaces`) */
+    methods: Map<string, import("../../../ast/nodes/types/AstNativeTypeExpr.js").AstFuncType>;
+}
+export interface BaseGenericTemplate {
+    /** the AST function name (e.g. "id") or the canonical synthetic name (e.g. "mkCons") */
+    astFuncName: string;
+    /** the type-param symbols in declaration order */
+    typeParams: TirTypeParam[];
+    /** the canonical (pre-monomorphization) tir-name registered on the placeholder value */
+    canonicalTirName: string;
+    /** the placeholder TirFuncT (with TirTypeParams) used to type the generic identifier in scope */
+    placeholderFuncType: import("../types/TirNativeType/native/function.js").TirFuncT;
+    /**
+     * One slot per type param, aligned by index with `typeParams`.
+     * `undefined` for unconstrained params.
+     */
+    constraints: (TypeParamConstraint | undefined)[];
+}
+export interface UserGenericTemplate extends BaseGenericTemplate {
+    kind: "user";
+    /** the FuncExpr AST node — cloned and re-compiled per instantiation */
+    astFuncExpr: FuncExpr;
+    /** the lexical scope where this template was declared */
+    definingScope: AstScope;
+}
+export interface NativeGenericTemplate extends BaseGenericTemplate {
+    kind: "native";
+    /** produces a fresh closed-IR for a given type-arg vector */
+    instantiate: (typeArgs: TirType[]) => TirInlineClosedIR;
+}
+export type GenericTemplate = UserGenericTemplate | NativeGenericTemplate;
+/**
+ * Factory for one method of an interface, evaluated against a concrete type
+ * at monomorphization time. Returns the raw `IRTerm` callable as the method
+ * dictionary — a closed IR closure `(self: ConcreteT, ...) -> ReturnT`.
+ *
+ * For the built-in `ToData` interface this is `_toDataUplcFunc(t)` from
+ * `TirToDataExpr.ts` — a hoisted `IRFunc` that converts its argument to data
+ * using the right per-type encoding (iData / bData / inline-struct-encoder / etc).
+ *
+ * Returning `undefined` signals "this type doesn't implement the interface",
+ * which the caller turns into a diagnostic.
+ */
+export type BuiltinInterfaceImplFactory = (concreteType: TirType) => (import("../../../IR/IRTerm.js").IRTerm | undefined);
 /**
  * for now we only care about "executables"
  *
@@ -19,8 +88,40 @@ export interface IGenericType {
 export declare class TypedProgram extends DiagnosticEmitter {
     readonly constants: Map<string, TirSimpleVarDecl>;
     readonly functions: Map<string, TirFuncExpr | TirInlineClosedIR>;
+    /**
+     * Generic function templates awaiting monomorphization. Keyed by the
+     * canonical AST function name (e.g. "id" for `function id<T>(...)`).
+     */
+    readonly genericTemplates: Map<string, GenericTemplate>;
+    /**
+     * Monomorphization memo: `templateName + "$$" + concreteArgs.join("$$")`
+     * → the TIR function name of the previously-compiled instance.
+     */
+    readonly monomorphizationCache: Map<string, string>;
+    /**
+     * Stack of monomorphizations currently in-flight, used to detect
+     * polymorphic recursion (a generic instantiating itself with different
+     * type arguments mid-compile).
+     */
+    readonly monomorphizationInFlight: Set<string>;
+    /**
+     * Built-in interface implementations.
+     *
+     *   builtinInterfaceImpls[interfaceName][methodName] = factory
+     *
+     * The factory, given a concrete TIR type, returns a `TirExpr` callable
+     * as the method's dictionary entry (typed `(self: T, ...) -> ReturnT`).
+     *
+     * Populated by `populateBuiltinInterfaces` for `ToData` and any other
+     * compiler-supplied interface that user types can implicitly satisfy.
+     * User-declared `type Foo implements I { ... }` impls live on the
+     * struct's `methodNamesPtr` instead.
+     */
+    readonly builtinInterfaceImpls: Map<string, Map<string, BuiltinInterfaceImplFactory>>;
     readonly types: Map<string, TirType>;
     private readonly genericTypes;
+    /** Top-level `test name() { ... }` declarations collected from the entry file. */
+    readonly tests: TirTestStmt[];
     /** main */
     contractTirFuncName: string;
     readonly stdTypes: StdTypes;

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

@@ -4,6 +4,8 @@ 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 { populateStdNamespace } from "./stdScope/populateStdNamespace.js";
+import { populateBuiltinInterfaces } from "./stdScope/populateBuiltinInterfaces.js";
 import { StdTypes } from "./stdScope/StdTypes.js";
 /**
  * for now we only care about "executables"
@@ -13,8 +15,40 @@ import { StdTypes } from "./stdScope/StdTypes.js";
 export class TypedProgram extends DiagnosticEmitter {
     constants;
     functions;
+    /**
+     * Generic function templates awaiting monomorphization. Keyed by the
+     * canonical AST function name (e.g. "id" for `function id<T>(...)`).
+     */
+    genericTemplates = new Map();
+    /**
+     * Monomorphization memo: `templateName + "$$" + concreteArgs.join("$$")`
+     * → the TIR function name of the previously-compiled instance.
+     */
+    monomorphizationCache = new Map();
+    /**
+     * Stack of monomorphizations currently in-flight, used to detect
+     * polymorphic recursion (a generic instantiating itself with different
+     * type arguments mid-compile).
+     */
+    monomorphizationInFlight = new Set();
+    /**
+     * Built-in interface implementations.
+     *
+     *   builtinInterfaceImpls[interfaceName][methodName] = factory
+     *
+     * The factory, given a concrete TIR type, returns a `TirExpr` callable
+     * as the method's dictionary entry (typed `(self: T, ...) -> ReturnT`).
+     *
+     * Populated by `populateBuiltinInterfaces` for `ToData` and any other
+     * compiler-supplied interface that user types can implicitly satisfy.
+     * User-declared `type Foo implements I { ... }` impls live on the
+     * struct's `methodNamesPtr` instead.
+     */
+    builtinInterfaceImpls = new Map();
     types;
     genericTypes;
+    /** Top-level `test name() { ... }` declarations collected from the entry file. */
+    tests;
     /** main */
     contractTirFuncName = "";
     stdTypes;
@@ -32,12 +66,21 @@ export class TypedProgram extends DiagnosticEmitter {
         this.functions = new Map();
         this.types = new Map();
         this.genericTypes = new Map();
+        this.tests = [];
         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);
+        // Register built-in interfaces (currently: `ToData`) and their
+        // compiler-supplied impl factories. Must precede `populateStdNamespace`
+        // so constrained native templates (`std.linearMap.prepend`) can
+        // reference `ToData` at registration time.
+        populateBuiltinInterfaces(this);
+        // The `std`, `std.crypto`, `std.crypto.bls12_381`, `std.builtins`
+        // namespaces and all their members live on the prelude scope.
+        populateStdNamespace(this);
     }
     registerType(tirType) {
         if (!isTirType(tirType))

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

@@ -0,0 +1,17 @@
+import { TypedProgram } from "../TypedProgram.js";
+/**
+ * Register compiler-built interfaces and their built-in implementation
+ * factories.
+ *
+ * - `ToData`: every type that supports a `data` encoding (which is most
+ *   Pebble types) automatically satisfies it. The factory returns
+ *   `_toDataUplcFunc(T)` — a closed IR closure `(T) -> data` produced by
+ *   the same compile-time dispatch that `TirToDataExpr` uses.
+ *
+ * User types may also implement these interfaces explicitly via
+ * `type Foo implements ToData { toData(self): data { ... } }`. When a
+ * constraint is resolved at call time, the user-impl path is checked first
+ * (via the type's `methodNamesPtr`); only if no user impl exists does the
+ * compiler fall back to the built-in factory registered here.
+ */
+export declare function populateBuiltinInterfaces(program: TypedProgram): void;

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

@@ -0,0 +1,70 @@
+import { Identifier } from "../../../../ast/nodes/common/Identifier.js";
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { AstFuncType } from "../../../../ast/nodes/types/AstNativeTypeExpr.js";
+import { AstNamedTypeExpr } from "../../../../ast/nodes/types/AstNamedTypeExpr.js";
+import { SimpleVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
+import { CommonFlags } from "../../../../common.js";
+// NOTE: `TirToDataExpr` transitively imports `common_hoisted`, which calls
+// `IRConst.data(...)` at module-load time. Loading this at the top would
+// cycle with `TypedProgram` during early compiler bootstrap and trip
+// "Cannot read properties of undefined (reading 'data')" in tests that load
+// the IR layer in isolation. Require it lazily inside the factory instead.
+/**
+ * Register compiler-built interfaces and their built-in implementation
+ * factories.
+ *
+ * - `ToData`: every type that supports a `data` encoding (which is most
+ *   Pebble types) automatically satisfies it. The factory returns
+ *   `_toDataUplcFunc(T)` — a closed IR closure `(T) -> data` produced by
+ *   the same compile-time dispatch that `TirToDataExpr` uses.
+ *
+ * User types may also implement these interfaces explicitly via
+ * `type Foo implements ToData { toData(self): data { ... } }`. When a
+ * constraint is resolved at call time, the user-impl path is checked first
+ * (via the type's `methodNamesPtr`); only if no user impl exists does the
+ * compiler fall back to the built-in factory registered here.
+ */
+export function populateBuiltinInterfaces(program) {
+    const unkRange = SourceRange.unknown;
+    // ---- interface ToData { toData(self): data } ----
+    const selfParam = new SimpleVarDecl(new Identifier("self", unkRange), 
+    // self has no annotated type; the implementer's type fills the slot
+    undefined, undefined, CommonFlags.None, unkRange);
+    const toDataSig = new AstFuncType([selfParam], new AstNamedTypeExpr(new Identifier("data", unkRange), [], unkRange), unkRange);
+    const toDataMethods = new Map([
+        ["toData", toDataSig],
+    ]);
+    // Register the interface in the prelude scope so users can write
+    // `<T implements ToData>`. The scope walker (`resolveInterface`) finds
+    // it via the parent chain.
+    program.preludeScope.interfaces.set("ToData", toDataMethods);
+    // Built-in impl factory: given a concrete TIR type, return a
+    // closed `IRTerm` of type `(T) -> data`. `_toDataUplcFunc` already
+    // dispatches compile-time per concrete type — return its hoisted
+    // closure directly. Loaded lazily to avoid the bootstrap cycle.
+    program.builtinInterfaceImpls.set("ToData", new Map([
+        ["toData", (concreteType) => {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const { _toDataUplcFunc } = require("../../expressions/TirToDataExpr.js");
+                return _toDataUplcFunc(concreteType);
+            }],
+    ]));
+    // ---- interface Show { show(self): bytes } ----
+    // Returns a UTF-8 textual representation suitable for human reading
+    // and for passing through `trace`. Built-in primitives auto-implement
+    // it (int -> decimal, bytes -> lowercase hex, bool -> "true"/"false",
+    // data -> serialiseData -> hex, List<T>/LinearMap<K,V> -> recursive,
+    // data-encoded structs -> serialiseData -> hex). User types may
+    // override with `type X implements Show { show(self): bytes { ... } }`.
+    const showSig = new AstFuncType([selfParam], new AstNamedTypeExpr(new Identifier("bytes", unkRange), [], unkRange), unkRange);
+    program.preludeScope.interfaces.set("Show", new Map([
+        ["show", showSig],
+    ]));
+    program.builtinInterfaceImpls.set("Show", new Map([
+        ["show", (concreteType) => {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const { _showUplcFunc } = require("../../expressions/TirShowExpr.js");
+                return _showUplcFunc(concreteType);
+            }],
+    ]));
+}

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

@@ -0,0 +1,22 @@
+import { TypedProgram } from "../TypedProgram.js";
+/**
+ * Populate the top-level `std` namespace and its sub-namespaces:
+ *
+ *   std
+ *   ├── crypto
+ *   │   ├── hashing & signatures (sha2_256, blake2b_256, verifyEd25519Signature, ...)
+ *   │   └── bls12_381
+ *   │       ├── types: G1, G2, MlResult
+ *   │       └── g1Add, g1Neg, g2Add, ..., millerLoop, finalVerify
+ *   └── builtins
+ *       ├── types: RawConstr
+ *       ├── arithmetic, byte-string, bitwise, data, string, trace, conversion ops
+ *       └── (polymorphic intrinsics like mkCons<T> are registered as native
+ *           generic templates and dispatched through the same monomorphizer
+ *           as user generic functions — see `populateNativeGenericTemplates`)
+ *
+ * Identifiers like `std.crypto.sha2_256(b)` resolve through the existing
+ * namespace-chain walker; the function is registered on the program as a
+ * `TirInlineClosedIR` whose IR is the corresponding `IRNative` tag.
+ */
+export declare function populateStdNamespace(program: TypedProgram): void;