@harmoniclabs/pebble 0.3.3 → 0.3.5

package/dist/IR/toUPLC/ctx/ToUplcCtx.js

@@ -32,8 +32,30 @@ export class ToUplcCtx {
         return ctx._parentDbn + idx + 1;
     }
     getVarAccessDbn(sym) {
-        const declDbn = this.getVarDeclDbn(sym);
-        return this.dbn - declDbn;
+        // Resolve the de Bruijn index LEXICALLY, against this access's own
+        // scope chain — i.e. the number of binders between the access and the
+        // NEAREST (innermost) enclosing binder of `sym`.
+        //
+        // The previous implementation looked `sym` up in a single tree-wide
+        // `ctxMap` (last writer wins). That is incorrect whenever the same
+        // binder symbol appears in sibling scopes — which happens routinely
+        // because cloned IR reuses its binder symbols (e.g. the shared
+        // `const { tx } = context` destructuring duplicated across a
+        // contract's purpose-match cases). An access in one branch would then
+        // resolve against another branch's binder, yielding a wrong and
+        // sometimes NEGATIVE index ("invalid deBruijn index").
+        let offset = 0;
+        let ctx = this;
+        while (ctx) {
+            const vars = ctx._variables;
+            for (let i = vars.length - 1; i >= 0; i--) {
+                if (vars[i] === sym)
+                    return offset + (vars.length - 1 - i);
+            }
+            offset += vars.length;
+            ctx = ctx.parent;
+        }
+        throw new Error("Variable not found in scope chain: " + String(sym.description));
     }
     toJson() {
         let obj = {};

package/dist/compiler/AstCompiler/internal/_deriveContractBody/_deriveContractBody.js

@@ -428,7 +428,7 @@ function _getMatchedRedeemerBlockStatements(compiler, stmts, paramsInternalNames
                 }
                 const realVarName = contextVarsMapping[fieldIdentifier.text];
                 if (!realVarName && typeof realVarName !== "string") {
-                    return compiler.error(DiagnosticCode._0_is_not_aviable_in_this_contract_method_context, fieldIdentifier.range, fieldIdentifier.text);
+                    return compiler.error(DiagnosticCode._0_is_not_available_in_this_contract_method_context, fieldIdentifier.range, fieldIdentifier.text);
                 }
                 if (destructuredFieldsIds.includes(fieldIdentifier.text)) {
                     return compiler.error(DiagnosticCode.Duplicate_identifier_0, fieldVarDecl.range, fieldIdentifier.text);

package/dist/compiler/TirCompiler/expressify/expressifyVars.js

@@ -165,7 +165,12 @@ export function expressifyVars(ctx, expr) {
             if (c.pattern instanceof TirArrayLikeDeconstr)
                 throw new Error("case expression not yet supported for array-like deconstruction");
             const pattern = toNamedDeconstructVarDecl(c.pattern);
-            const branchBodyStmts = flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(pattern, branchCtx);
+            const branchBodyStmts = flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(pattern, branchCtx, 
+            // user case-arm pattern: the body references each binding by its
+            // OWN name (`is P{ field: alias } => …` uses `alias`), so the
+            // rename must NOT be keyed by the struct field name (which could
+            // shadow an outer variable of that name).
+            false);
             branchBodyStmts.push(new TirReturnStmt(c.body, c.body.range));
             c.body = expressifyFuncBody(branchCtx, branchBodyStmts, undefined);
         }

package/dist/compiler/TirCompiler/expressify/flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct.d.ts

@@ -6,4 +6,19 @@ import { ExpressifyCtx } from "./ExpressifyCtx.js";
  *
  * @returns the extracted nested deconstructions
  */
-export declare function flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(decl: TirNamedDeconstructVarDecl | TirSingleDeconstructVarDecl, ctx: ExpressifyCtx): TirVarDecl[];
+export declare function flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(decl: TirNamedDeconstructVarDecl | TirSingleDeconstructVarDecl, ctx: ExpressifyCtx, 
+/**
+ * The field-name → binding rename below is a REMAP device used by
+ * synthesized destructures (e.g. loop state `State{ a: §a_fresh }`, where
+ * the original body references the source name `a` and must be redirected
+ * to the fresh threaded binding). For those, key the rename by the field
+ * name (`fName`).
+ *
+ * A USER case-arm / destructure pattern (`P{ field: alias }`) is different:
+ * it INTRODUCES a fresh binding the body references by its own name
+ * (`alias` = `varDecl.name`); the field name is NOT a name the body uses.
+ * Keying by `fName` there shadows any outer variable that happens to share
+ * the struct field's name (a silent miscompilation). Such callers pass
+ * `false` so the rename is keyed by the binding's own name instead.
+ */
+fieldNameIsBodyReference?: boolean): TirVarDecl[];

package/dist/compiler/TirCompiler/expressify/flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct.js

@@ -8,14 +8,32 @@ import { isSingleConstrStruct } from "./isSingleConstrStruct.js";
  *
  * @returns the extracted nested deconstructions
  */
-export function flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(decl, ctx) {
+export function flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(decl, ctx, 
+/**
+ * The field-name → binding rename below is a REMAP device used by
+ * synthesized destructures (e.g. loop state `State{ a: §a_fresh }`, where
+ * the original body references the source name `a` and must be redirected
+ * to the fresh threaded binding). For those, key the rename by the field
+ * name (`fName`).
+ *
+ * A USER case-arm / destructure pattern (`P{ field: alias }`) is different:
+ * it INTRODUCES a fresh binding the body references by its own name
+ * (`alias` = `varDecl.name`); the field name is NOT a name the body uses.
+ * Keying by `fName` there shadows any outer variable that happens to share
+ * the struct field's name (a silent miscompilation). Such callers pass
+ * `false` so the rename is keyed by the binding's own name instead.
+ */
+fieldNameIsBodyReference = true) {
     const extracted = [];
     const restFields = new Map();
     for (const [fName, varDecl] of decl.fields) {
         if (varDecl instanceof TirSimpleVarDecl) {
             restFields.set(fName, varDecl.name);
             ctx.introduceFuncParams([varDecl]);
-            ctx.setNewVariableName(fName, varDecl.name); // added to fix reassigned variables on non-terminating statements
+            // register the rename so reassigned bindings thread on
+            // non-terminating statements; key by the name the body references
+            // (see `fieldNameIsBodyReference`).
+            ctx.setNewVariableName(fieldNameIsBodyReference ? fName : varDecl.name, varDecl.name);
             if (isSingleConstrStruct(varDecl.type)) {
                 const structType = getUnaliased(varDecl.type);
                 const constr = structType.constructors[0];

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

@@ -191,6 +191,9 @@ export function populateStdNamespace(program) {
     defineBuiltin(blsNsScope, "g1Uncompress", IRNativeTag.bls12_381_G1_uncompress, new TirFuncT([bytes_t], g1_t), blsNs);
     // CIP-0381 multi-scalar multiplication: Σ scalars[i] · points[i]
     defineBuiltin(blsNsScope, "g1MultiScalarMul", IRNativeTag.bls12_381_G1_multiScalarMul, new TirFuncT([new TirListT(int_t), new TirListT(g1_t)], g1_t), blsNs);
+    // `multiScalarMul` is a convenience alias for the G1 variant (the usual
+    // group for commitments); the explicit `g1`/`g2` names remain available.
+    defineBuiltin(blsNsScope, "multiScalarMul", IRNativeTag.bls12_381_G1_multiScalarMul, new TirFuncT([new TirListT(int_t), new TirListT(g1_t)], g1_t), blsNs);
     defineBuiltin(blsNsScope, "g2Add", IRNativeTag.bls12_381_G2_add, new TirFuncT([g2_t, g2_t], g2_t), blsNs);
     defineBuiltin(blsNsScope, "g2Neg", IRNativeTag.bls12_381_G2_neg, new TirFuncT([g2_t], g2_t), blsNs);
     defineBuiltin(blsNsScope, "g2ScalarMul", IRNativeTag.bls12_381_G2_scalarMul, new TirFuncT([int_t, g2_t], g2_t), blsNs);

package/dist/diagnostics/diagnosticMessages.generated.d.ts

@@ -98,7 +98,7 @@ export declare enum DiagnosticCode {
     _context_can_only_be_destructured_in_a_constant_declaration = 292,
     _context_can_only_be_accessed_in_a_contract_method = 293,
     _this_in_a_contract_context_can_only_be_used_to_read_parameters_in_a_contract_method = 293,
-    _0_is_not_aviable_in_this_contract_method_context = 294,
+    _0_is_not_available_in_this_contract_method_context = 294,
     _context_can_only_be_destructured_as_an_unnamed_object = 295,
     _0_is_not_a_contract_parameter = 296,
     Importing_the_table_disables_some_indirect_call_optimizations = 901,

package/dist/diagnostics/diagnosticMessages.generated.js

@@ -100,7 +100,7 @@ export var DiagnosticCode;
     DiagnosticCode[DiagnosticCode["_context_can_only_be_destructured_in_a_constant_declaration"] = 292] = "_context_can_only_be_destructured_in_a_constant_declaration";
     DiagnosticCode[DiagnosticCode["_context_can_only_be_accessed_in_a_contract_method"] = 293] = "_context_can_only_be_accessed_in_a_contract_method";
     DiagnosticCode[DiagnosticCode["_this_in_a_contract_context_can_only_be_used_to_read_parameters_in_a_contract_method"] = 293] = "_this_in_a_contract_context_can_only_be_used_to_read_parameters_in_a_contract_method";
-    DiagnosticCode[DiagnosticCode["_0_is_not_aviable_in_this_contract_method_context"] = 294] = "_0_is_not_aviable_in_this_contract_method_context";
+    DiagnosticCode[DiagnosticCode["_0_is_not_available_in_this_contract_method_context"] = 294] = "_0_is_not_available_in_this_contract_method_context";
     DiagnosticCode[DiagnosticCode["_context_can_only_be_destructured_as_an_unnamed_object"] = 295] = "_context_can_only_be_destructured_as_an_unnamed_object";
     DiagnosticCode[DiagnosticCode["_0_is_not_a_contract_parameter"] = 296] = "_0_is_not_a_contract_parameter";
     DiagnosticCode[DiagnosticCode["Importing_the_table_disables_some_indirect_call_optimizations"] = 901] = "Importing_the_table_disables_some_indirect_call_optimizations";
@@ -393,7 +393,7 @@ export function diagnosticCodeToString(code) {
         case 292: return "`context` can only be destructured in a constant declaration.";
         case 293: return "`context` can only be accessed in a contract method.";
         case 293: return "`this`, in a contract context, can only be used to read parameters in a contract method.";
-        case 294: return "`{0}` is not aviable in this contract method `context`.";
+        case 294: return "`{0}` is not available in this contract method `context`.";
         case 295: return "`context` can only be destructured as an unnamed object.";
         case 296: return "'{0}' is not a contract parameter.";
         case 901: return "Importing the table disables some indirect call optimizations.";

package/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const COMPILER_VERSION = "0.3.3";
+export declare const COMPILER_VERSION = "0.3.5";

package/dist/version.generated.js

@@ -1,2 +1,2 @@
 // This file is auto-generated by scripts/genVersion.js. Do not edit.
-export const COMPILER_VERSION = "0.3.3";
+export const COMPILER_VERSION = "0.3.5";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",