@harmoniclabs/pebble 0.1.10 → 0.2.0

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;