@harmoniclabs/pebble 0.1.0-dev4 → 0.1.0-dev6

package/dist/IR/toUPLC/subRoutines/handleLetted/index.js

@@ -4,23 +4,19 @@ import { getSortedLettedSet, getLettedTerms, IRLetted } from "../../../IRNodes/I
 import { IRVar } from "../../../IRNodes/IRVar.js";
 import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
 import { findAllNoHoisted } from "../../_internal/findAll.js";
-import { getDebruijnInTerm } from "../../_internal/getDebruijnInTerm.js";
-import { _getMinUnboundDbn } from "./groupByScope.js";
+import { getMaxScope } from "./groupByScope.js";
 import { IRDelayed } from "../../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../../IRNodes/IRForced.js";
 import { lowestCommonAncestor } from "../../_internal/lowestCommonAncestor.js";
 import { isIRTerm } from "../../../utils/isIRTerm.js";
 import { markRecursiveHoistsAsForced } from "../markRecursiveHoistsAsForced.js";
 import { IRConst } from "../../../IRNodes/IRConst.js";
-import { incrementUnboundDbns } from "./incrementUnboundDbns.js";
 import { equalIrHash, irHashToHex } from "../../../IRHash.js";
 import { sanifyTree } from "../sanifyTree.js";
-import { mapArrayLike } from "../../../IRNodes/utils/mapArrayLike.js";
-import { IRCase } from "../../../IRNodes/IRCase.js";
-import { IRConstr } from "../../../IRNodes/IRConstr.js";
 import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
 import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
 import { findHighestRecursiveParent } from "./findHighestRecursiveParent.js";
+import { IRNative } from "../../../IRNodes/IRNative/index.js";
+import { isForcedNativeTag } from "../../../IRNodes/IRNative/isForcedNative.js";
 export function handleLettedAndReturnRoot(term) {
     // console.log(" ------------------------------------------- handleLetted ------------------------------------------- ");
     // console.log( prettyIRText( term ))
@@ -28,52 +24,60 @@ export function handleLettedAndReturnRoot(term) {
     // pre-execuded terms (hence constants)
     if (term instanceof IRConst)
         return term;
+    sanifyTree(term);
     // TODO: should probably merge `markRecursiveHoistsAsForced` inside `getLettedTerms` to iter once
     markRecursiveHoistsAsForced(term);
     // in case there are no letted terms there is no work to do
     while (true) {
+        // console.log(` ------------------ letted loop ------------------ `);
         const allDirectLetted = getLettedTerms(term, { all: false, includeHoisted: false });
         if (allDirectLetted.length === 0)
             return term;
+        // // console.log("allDirectLetted", allDirectLetted.map( expandedJsonLettedSetEntry ) );
         const sortedLettedSet = getSortedLettedSet(allDirectLetted);
+        // console.log("sortedLettedSet", sortedLettedSet.map( expandedJsonLettedSetEntry ) );
+        // `sortedLettedSet` is sorted from least to most dependencies
+        // so we'll have "0 dependencies" letted terms at the start of the array
+        // and "n dependencies" letted terms at the end of the array
+        // 
+        // we process the "most dependent" terms first
+        // so their values are inlined
+        // and later, its dependencies will be replaced with `IRVar`
+        // whereever these dependent are inlined
+        //
+        // hence why `pop` (and not `shift`)
         const { letted, nReferences } = sortedLettedSet.pop();
-        /*
-        const _lettedValue_ = letted.value;
-        const shouldLog = (
-            _lettedValue_ instanceof IRApp &&
-            _lettedValue_.fn instanceof IRFunc &&
-            _lettedValue_.fn.arity === 1 &&
-            _lettedValue_.fn.body instanceof IRLetted &&
-            equalIrHash( _lettedValue_.fn.body.hash, new Uint32Array( fromHex("71030a2d7560e563fe25fd782edd847f").buffer ) as IRHash ) &&
-            _lettedValue_.arg instanceof IRLetted &&
-            equalIrHash( _lettedValue_.arg.hash, new Uint32Array( fromHex("82dfb8a2f2703fe59fb25f8372e5e958").buffer ) as IRHash )
-        );
-        //*/
-        // shouldLog && console.log("nReferences", nReferences);
+        // shouldLog && // console.log("nReferences", nReferences);
         // console.log(` ------------------ working with ${lettedToStr(letted)} ------------------ `);
         if (nReferences === 1) {
             // console.log("inlining letted (single reference) with value", prettyIRText( letted.value ) )
             _modifyChildFromTo(letted.parent, letted, letted.value);
             continue;
         }
-        const maxScope = findLettedMaxScope(letted) ?? (() => {
-            if (letted.meta.isClosed || letted.isClosedAtDbn(0)) {
-                // value is closed (hoisted),
-                // so the max scope is the entire script
-                return term;
-            }
-            else
-                throw new Error(`could not find a max scope for letted value with hash ${irHashToHex(letted.hash)}`);
-        })();
+        // console.log("--------- not inilning ("+ nReferences +" references)");
+        const maxScope = getMaxScope(letted) ?? term;
+        // const maxScope = getMaxScope( letted ) ?? ((): IRTerm => {
+        //     if( letted.meta.isClosed || isClosedTerm( letted.value ) )
+        //     {
+        //         // value is closed (hoisted),
+        //         // so the max scope is the entire script
+        //         return term;
+        //     }
+        //     else throw new Error(
+        //         `could not find a max scope for letted value with hash ${irHashToHex(letted.hash)}`
+        //     );
+        // })();
         const lettedTermCanBeHoisted = maxScope === term;
         const minScope = findHighestRecursiveParent(letted, maxScope);
         sanifyTree(maxScope);
         const lettedHash = letted.hash;
         const sameLettedRefs = findAllNoHoisted(maxScope, node => node instanceof IRLetted &&
             equalIrHash(node.hash, lettedHash));
+        // console.log("sameLettedRefs", sameLettedRefs.length );
         if (sameLettedRefs.length <= 0) {
-            console.warn("how did you get here? 0 references found for letted term;\n\n" +
-                "!!! PLEASE OPEN AN ISSUE ON GITHUB (https://github.com/HarmonicLabs/plu-ts/issues) !!!\n\n");
+            console.warn("how did you get here? 0 references found for letted term;\n" +
+                "the compiler can easly recover this edge case, but something funny is going on with this contract.\n\n" +
+                "!!! PLEASE OPEN AN ISSUE ON GITHUB (https://github.com/HarmonicLabs/plu-ts/issues) !!!\n");
             continue;
         }
         // just in case
@@ -83,8 +87,10 @@ export function handleLettedAndReturnRoot(term) {
             continue;
         }
         // always inline letted vars
-        if (letted.value instanceof IRVar ||
-            letted.value instanceof IRSelfCall) {
+        if (letted.value instanceof IRVar
+            || letted.value instanceof IRSelfCall
+            || (letted.value instanceof IRNative
+                && !isForcedNativeTag(letted.value.tag))) {
             // console.log("inlining letted (value is var) with value", prettyIRText( letted.value ) )
             for (const elem of sameLettedRefs) {
                 // inline
@@ -126,25 +132,16 @@ export function handleLettedAndReturnRoot(term) {
         const parentNode = lca;
         const parentNodeDirectChild = (parentNode instanceof IRFunc ||
             parentNode instanceof IRRecursive) ? parentNode.body : parentNode.delayed;
-        // add 1 to every var's DeBruijn that accesses stuff outside the parent node
-        // not including the `parentNode` node
-        // since the new function introdcued substituting the letted term
-        // is added inside the `parentNode` node
-        incrementUnboundDbns(parentNodeDirectChild, 
-        // `shouldNotModifyLetted` arg (given the hash returns `true` if it should NOT modify the term)
-        // this callback is ONLY called on LETTED terms
-        ({ hash }) => equalIrHash(hash, lettedHash));
         // now we replace
         const lettedValue = letted.value.clone();
-        modifyValueToLetDbns(lettedValue, getDiffDbn(letted, parentNode));
-        const newNode = new IRApp(new IRFunc(1, parentNodeDirectChild), lettedValue, { __src__: letted.meta.__src__ });
+        const newNode = new IRApp(new IRFunc([letted.name], parentNodeDirectChild), lettedValue, { __src__: letted.meta.__src__ });
         // replace child with new node
         if (parentNode instanceof IRFunc || parentNode instanceof IRRecursive)
             parentNode.body = newNode;
         else
             parentNode.delayed = newNode;
         for (const ref of sameLettedRefs) {
-            _modifyChildFromTo(ref.parent, ref, new IRVar(getDebruijnInTerm(parentNodeDirectChild, ref)));
+            _modifyChildFromTo(ref.parent, ref, new IRVar(ref.name));
         }
         // const delayed = parentNode instanceof IRDelayed;
         // let finalMaxScope: IRFunc | IRDelayed = parentNode;
@@ -155,141 +152,18 @@ export function handleLettedAndReturnRoot(term) {
         // {
         //     finalMaxScope = (finalMaxScope as any).parent as any
         // }
-        // console.log("final max scope (delayed: " + delayed + ")" , prettyIRText( finalMaxScope ) )
-    }
-}
-/**
- *
- * @param letted
- * @returns {IRFunc} the lowest `IRFunc` in the tree that defines all the variables needed for the
- */
-function findLettedMaxScope(letted) {
-    let minUnboundDbn = _getMinUnboundDbn(letted.value);
-    if (minUnboundDbn === undefined) {
-        let tmp = letted;
-        let maxScope = undefined;
-        while (tmp.parent) {
-            tmp = tmp.parent;
-            if (tmp instanceof IRFunc || tmp instanceof IRDelayed)
-                maxScope = tmp;
-        }
-        ;
-        return maxScope;
-    }
-    let tmp = letted;
-    let maxScope = undefined;
-    while (minUnboundDbn >= 0) {
-        if (!tmp.parent) {
-            throw new Error(`could not find a max scope for letted value with hash ${irHashToHex(letted.hash)}; ` +
-                `the max parent found leaves the term open (reached root)`);
-        }
-        tmp = tmp.parent;
-        if (tmp instanceof IRRecursive) {
-            minUnboundDbn -= tmp.arity;
-            // maxScope = tmp; // recursive cannot be a max scope
-        }
-        else if (tmp instanceof IRFunc) {
-            minUnboundDbn -= tmp.arity;
-            maxScope = tmp;
-        }
-    }
-    // just ts sillyness here
-    if (!maxScope) {
-        throw new Error(`could not find a max scope for letted value with hash ${irHashToHex(letted.hash)}; ` +
-            `no IRFunc found`);
-    }
-    return maxScope;
-}
-function modifyValueToLetDbns(lettedValue, diffDbn) {
-    if (diffDbn <= 0)
-        return;
-    // if there is any actual difference between the letted term
-    // and the position where it will be finally placed
-    // the value needs to be modified accoridingly
-    const stack = [{ term: lettedValue, dbn: 0 }];
-    while (stack.length > 0) {
-        const { term: t, dbn } = stack.pop();
-        if ((t instanceof IRVar ||
-            t instanceof IRSelfCall) &&
-            t.dbn > dbn) {
-            t.dbn -= diffDbn;
-        }
-        if (t instanceof IRLetted) {
-            t.dbn -= diffDbn;
-            // reduce dbn in letted value too
-            stack.push({ term: t.value, dbn });
-            continue;
-        }
-        if (t instanceof IRApp) {
-            stack.push({ term: t.arg, dbn }, { term: t.fn, dbn });
-            continue;
-        }
-        if (t instanceof IRCase) {
-            stack.push({ term: t.constrTerm, dbn }, ...mapArrayLike(t.continuations, continuation => ({ term: continuation, dbn })));
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            stack.push(...mapArrayLike(t.fields, field => ({ term: field, dbn })));
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push({ term: t.delayed, dbn });
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push({ term: t.forced, dbn });
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push({ term: t.body, dbn: dbn + t.arity });
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push({ term: t.body, dbn: dbn + t.arity });
-            continue;
-        }
-        // no hoisted
-    }
-}
-/**
- * @returns the difference in DeBruijn
- * between the maxScope and the letted term
- */
-function getDiffDbn(letted, parentNode) {
-    // get the difference in DeBruijn
-    // between the maxScope and the letted term
-    let diffDbn = 0;
-    //*
-    let tmpNode = letted;
-    while (tmpNode !== parentNode) {
-        tmpNode = tmpNode.parent;
-        if ( // is an intermediate `IRFunc`
-        (tmpNode instanceof IRFunc ||
-            tmpNode instanceof IRRecursive) &&
-            tmpNode !== parentNode // avoid counting parent node arity if IRFunc 
-        ) {
-            // increment differential in DeBruijn by n vars indroduced here
-            diffDbn += tmpNode.arity;
-        }
+        // // // console.log("final max scope (delayed: " + delayed + ")" , prettyIRText( finalMaxScope ) )
     }
-    return diffDbn;
 }
 function handleLettedAsHoistedAndReturnRoot(letted, lca, sameLettedRefs, currentRoot) {
     const lettedHash = letted.hash;
     let parentNode = lca.parent;
     const parentNodeDirectChild = lca;
-    // add 1 to every var's DeBruijn that accesses stuff outside the parent node
-    // not including the `parentNode` node
-    // since the new function introdcued substituting the letted term
-    // is added inside the `parentNode` node
-    incrementUnboundDbns(parentNodeDirectChild, 
-    // `shouldNotModifyLetted` arg (given the hash returns `true` if it should NOT modify the term)
-    ({ hash }) => equalIrHash(hash, lettedHash));
     // now we replace
     const lettedValue = letted.value; //.clone();
     // no need to modify letted value dbns, since closed
     // modifyValueToLetDbns( lettedValue, getDiffDbn( letted, parentNode ) );
-    const newNode = new IRApp(new IRFunc(1, parentNodeDirectChild), lettedValue, { __src__: letted.meta.__src__ });
+    const newNode = new IRApp(new IRFunc([letted.name], parentNodeDirectChild), lettedValue, { __src__: letted.meta.__src__ });
     // replace child with new node
     if (parentNode) {
         _modifyChildFromTo(parentNode, parentNodeDirectChild, newNode);
@@ -298,7 +172,7 @@ function handleLettedAsHoistedAndReturnRoot(letted, lca, sameLettedRefs, current
         currentRoot = newNode;
     }
     for (const ref of sameLettedRefs) {
-        _modifyChildFromTo(ref.parent, ref, new IRVar(getDebruijnInTerm(parentNodeDirectChild, ref)));
+        _modifyChildFromTo(ref.parent, ref, new IRVar(ref.name));
     }
     return currentRoot;
 }

package/dist/IR/toUPLC/subRoutines/handleRecursiveTerms.js

@@ -9,12 +9,14 @@ import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
 export function handleRecursiveTerms(term) {
     if (term instanceof IRRecursive) {
         const bodyPtr = term.body;
-        _modifyChildFromTo(term.parent, term, new IRApp(new IRHoisted(new IRFunc(1, new IRApp(new IRVar(0), new IRVar(0)))), new IRFunc(1, bodyPtr)));
+        const recBody = Symbol("recBody");
+        const self = term.name;
+        _modifyChildFromTo(term.parent, term, new IRApp(new IRHoisted(new IRFunc([recBody], new IRApp(new IRVar(recBody), new IRVar(recBody)))), new IRFunc([self], bodyPtr)));
         handleRecursiveTerms(bodyPtr);
         return;
     }
     if (term instanceof IRSelfCall) {
-        _modifyChildFromTo(term.parent, term, new IRApp(new IRVar(term.dbn), new IRVar(term.dbn)));
+        _modifyChildFromTo(term.parent, term, new IRApp(new IRVar(term.name), new IRVar(term.name)));
         return;
     }
     getChildren(term).forEach(handleRecursiveTerms);
@@ -22,7 +24,9 @@ export function handleRecursiveTerms(term) {
 export function handleRootRecursiveTerm(term) {
     if (term instanceof IRRecursive) {
         const bodyPtr = term.body;
-        const newRoot = new IRApp(new IRHoisted(new IRFunc(1, new IRApp(new IRVar(0), new IRVar(0)))), new IRFunc(1, bodyPtr));
+        const recBody = Symbol("recBody");
+        const self = term.name;
+        const newRoot = new IRApp(new IRHoisted(new IRFunc([recBody], new IRApp(new IRVar(recBody), new IRVar(recBody)))), new IRFunc([self], bodyPtr));
         handleRecursiveTerms(bodyPtr);
         return newRoot;
     }

package/dist/IR/toUPLC/subRoutines/hoistForcedNatives.js

@@ -38,10 +38,11 @@ export function hoistForcedNatives(term) {
         const nodes = toHoist[tag];
         if (nodes.length <= 0)
             continue; // also single use (might be inside loop)
+        const varSym = Symbol(tagStr);
         for (const node of nodes) {
-            _modifyChildFromTo(node.parent, node, new IRVar(getDbnToRoot(node)));
+            _modifyChildFromTo(node.parent, node, new IRVar(varSym));
         }
-        term = new IRApp(new IRFunc(1, term), new IRNative(tag));
+        term = new IRApp(new IRFunc([varSym], term), new IRNative(tag));
     }
     return term;
 }

package/dist/IR/toUPLC/subRoutines/inlineSingleUseAndReturnRoot/InlineSingleUseCtx.d.ts

@@ -0,0 +1,22 @@
+export declare enum InlineSingleUseVarsFlags {
+    none = 0,
+    isRecursiveFunction = 1
+}
+interface InlineSingleUseCtxMeta {
+    readonly isRecursiveContext: boolean;
+}
+export declare class InlineSingleUseCtx {
+    readonly params: symbol[];
+    readonly parent: InlineSingleUseCtx | undefined;
+    readonly localVarsUses: Record<symbol, number>;
+    readonly localVarsFlags: Record<symbol, InlineSingleUseVarsFlags>;
+    readonly meta: InlineSingleUseCtxMeta;
+    constructor(params: symbol[], parent: InlineSingleUseCtx | undefined, meta: InlineSingleUseCtxMeta);
+    static root(params?: symbol[]): InlineSingleUseCtx;
+    newChild(params: symbol[], meta?: InlineSingleUseCtxMeta): InlineSingleUseCtx;
+    private keys;
+    private getIncrement;
+    incrementVarUse(sym: symbol): void;
+    getSingleUseVars(): symbol[];
+}
+export {};

package/dist/IR/toUPLC/subRoutines/inlineSingleUseAndReturnRoot/InlineSingleUseCtx.js

@@ -0,0 +1,59 @@
+export var InlineSingleUseVarsFlags;
+(function (InlineSingleUseVarsFlags) {
+    InlineSingleUseVarsFlags[InlineSingleUseVarsFlags["none"] = 0] = "none";
+    InlineSingleUseVarsFlags[InlineSingleUseVarsFlags["isRecursiveFunction"] = 1] = "isRecursiveFunction";
+})(InlineSingleUseVarsFlags || (InlineSingleUseVarsFlags = {}));
+const defaultInlineMeta = Object.freeze({
+    isRecursiveContext: false
+});
+export class InlineSingleUseCtx {
+    params;
+    parent;
+    localVarsUses;
+    localVarsFlags;
+    meta;
+    constructor(params, parent, meta) {
+        this.params = params;
+        this.parent = parent;
+        params = params.slice();
+        this.localVarsUses = {};
+        this.localVarsFlags = {};
+        for (const p of params) {
+            this.localVarsUses[p] = 0;
+            this.localVarsFlags[p] = InlineSingleUseVarsFlags.none;
+        }
+        meta = {
+            ...meta,
+            isRecursiveContext: parent?.meta.isRecursiveContext ?? defaultInlineMeta.isRecursiveContext
+        };
+        this.meta = meta;
+    }
+    static root(params = []) {
+        return new InlineSingleUseCtx(params, undefined, defaultInlineMeta);
+    }
+    newChild(params, meta = defaultInlineMeta) {
+        return new InlineSingleUseCtx(params, this, meta);
+    }
+    keys() {
+        return Object.getOwnPropertySymbols(this.localVarsUses);
+    }
+    getIncrement() {
+        return this.meta.isRecursiveContext ? 10 : 1;
+    }
+    incrementVarUse(sym) {
+        if (typeof this.localVarsUses[sym] !== "number") {
+            if (this.parent)
+                this.parent.incrementVarUse(sym);
+            else {
+                console.error(sym);
+                throw new Error("trying to increment use of variable not in context");
+            }
+        }
+        else
+            this.localVarsUses[sym] += this.getIncrement();
+    }
+    getSingleUseVars() {
+        const keys = this.keys();
+        return keys.filter(k => this.localVarsUses[k] === 1);
+    }
+}

package/dist/IR/toUPLC/subRoutines/inlineSingleUseAndReturnRoot/inlineSingleUseAndReturnRoot.js

@@ -0,0 +1,217 @@
+/*
+import { IRFunc, IRHoisted, IRLetted } from "../../../IRNodes/index.js";
+import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
+import { IRVar } from "../../../IRNodes/IRVar.js";
+import { IRTerm } from "../../../IRTerm.js";
+import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
+import { getApplicationTerms } from "../../utils/getApplicationTerms.js";
+import { InlineSingleUseCtx } from "./InlineSingleUseCtx.js";
+
+export interface InlineSingleResult {
+    term: IRTerm;
+    somethingWasInlined: boolean;
+}
+
+// DOES NOT WORK AS IS
+// TODO: FIND BUG (use onlySpend contract)
+export function inlineSingleUseAndReturnRoot( term: IRTerm ): InlineSingleResult
+{
+    // we need to go bottom up
+    // ONLY REMOVE UNUSED VARS IF NOT UNIT
+    // (in which case we need to keep it for eventual side effects (asserts and traces))
+
+    return _inlineSingleUse( term, InlineSingleUseCtx.root( 0 ) );
+}
+
+// DOES NOT WORK AS IS
+// TODO: FIND BUG (use onlySpend contract)
+function _inlineSingleUse( term: IRTerm, ctx: InlineSingleUseCtx ): InlineSingleResult
+{
+    let somethingWasInlined = false;
+    
+    if( term instanceof IRVar ) {
+        // increment used
+        ctx.incrementVarUse( term.dbn );
+        return { term: term, somethingWasInlined: false };
+    }
+
+    const applicationTerms = getApplicationTerms( term );
+    
+    if( !applicationTerms )
+    {
+        const childrens = term.children();
+        const nextCtx = term instanceof IRFunc
+            ? ctx.newChild( term.arity )
+            : ctx;
+        for( const c of childrens ) {
+            const inlineResult = _inlineSingleUse( c, nextCtx );
+            somethingWasInlined ||= inlineResult.somethingWasInlined;
+        }
+        return { term, somethingWasInlined };
+    }
+
+    const { func, args } = applicationTerms;
+
+    if(!( func instanceof IRFunc )) {
+        for( const child of term.children() ) {
+            // same as parent ctx
+            const inlineResult = _inlineSingleUse( child, ctx );
+            somethingWasInlined ||= inlineResult.somethingWasInlined;
+        }
+        return { term, somethingWasInlined };
+    }
+
+    const funcCtx = ctx.newChild( func.arity );
+    const inlineResult = _inlineSingleUse( func.body, funcCtx );
+    func.body = inlineResult.term;
+    somethingWasInlined ||= inlineResult.somethingWasInlined;
+
+    // if all variables are either not used at all, or used more than once, keep as is
+    if( !funcCtx.localVarsUseCount.some( nUses => nUses === 1 ) )
+    {
+        for( const funcArg of args ) {
+            // arguments passed have the same context of the function called
+            const inlineResult = _inlineSingleUse( funcArg, ctx );
+            somethingWasInlined ||= inlineResult.somethingWasInlined;
+        }
+        return { term, somethingWasInlined };
+    }
+
+    // if we get here, at least one variable is used exactly once
+    somethingWasInlined = true;
+
+    // removed dbns are relative indices (0-based) of the function parameters
+    const removedDbns: bigint[] = funcCtx.localVarsUseCount
+        .map( (varCount, idx) => varCount === 1 ? BigInt(idx) : undefined )
+        .filter( (v): v is bigint => typeof v === "bigint" );
+    
+    // remove vars here
+    const inlinedTerms: { [dbn: number]: IRTerm } = {};
+    const remainingArgs: IRTerm[] = [];
+    args.forEach( ( arg, idx ) => {
+        const nUses = funcCtx.localVarsUseCount[ idx ];
+        if( nUses === 1 ) {
+            // map using relative parameter index
+            inlinedTerms[ idx ] = arg;
+        } else remainingArgs.push( arg );
+    } );
+
+    func.arity -= removedDbns.length;
+    const decrementedFuncBody = _decrementAndInline(
+        func.body,
+        removedDbns,
+        inlinedTerms,
+        0
+    );
+    func.body = decrementedFuncBody;
+
+    for( const funcArg of remainingArgs ) {
+        // arguments passed have the same context of the function called
+        _inlineSingleUse( funcArg, ctx );
+    }
+
+    const someArgsWereUsed = remainingArgs.length > 0;
+    const newTerm = someArgsWereUsed
+        ? _ir_apps( func, ...(remainingArgs as [IRTerm, ...IRTerm[]]) )
+        : decrementedFuncBody;
+
+    const parent = term.parent;
+    if( parent ) _modifyChildFromTo( parent, term, newTerm );
+    
+    return { term: newTerm, somethingWasInlined };
+}
+
+function _getDbnDecrement( termDbn: number, removedDbns: bigint[], paramOffset: number ): number
+{
+    // termDbn is absolute inside current function. removedDbns are relative indices (0..arity-1)
+    // A variable corresponds to a parameter if termDbn - paramOffset is within removed list
+    const rel = termDbn - paramOffset;
+    if( rel < 0 ) return 0;
+    // number of removed parameters with index < rel
+    return removedDbns.filter( dbn => Number(dbn) < rel ).length;
+}
+
+function _decrementAndInline(
+    term: IRTerm,
+    removedDbns: bigint[],
+    inlineDbns: { [dbn: number]: IRTerm },
+    paramOffset: number // absolute dbn of parameter 0 for current function scope
+): IRTerm
+{
+    if( removedDbns.length <= 0 ) return term;
+
+    if( term instanceof IRVar ) {
+        const relIdx = term.dbn - paramOffset;
+        if( relIdx >= 0 ) {
+            let inlineTerm = inlineDbns[ relIdx ];
+            if( inlineTerm ) {
+                // clone to avoid sharing and adjust dbns relative to current paramOffset
+                inlineTerm = inlineTerm.clone();
+                inlineTerm = _incrementTermDbns( inlineTerm, paramOffset );
+                if( term.parent ) _modifyChildFromTo( term.parent, term, inlineTerm );
+                return inlineTerm;
+            }
+            const decrement = _getDbnDecrement( term.dbn, removedDbns, paramOffset );
+            if( decrement > 0 ) term.dbn -= decrement;
+        }
+        return term;
+    }
+    if( term instanceof IRSelfCall ) {
+        const decrement = _getDbnDecrement( term.dbn, removedDbns, paramOffset );
+        if( decrement > 0 ) term.dbn -= decrement;
+        return term;
+    }
+    if( term instanceof IRLetted ) {
+        const decrement = _getDbnDecrement( term.dbn, removedDbns, paramOffset );
+        if( decrement > 0 ) term.dbn -= decrement;
+        for( const child of term.children() ) {
+            _decrementAndInline( child, removedDbns, inlineDbns, paramOffset );
+        }
+        return term;
+    }
+    if( term instanceof IRHoisted ) return term; // closed
+
+    if( term instanceof IRFunc ) {
+        // entering new function: its parameters start at current paramOffset
+        // increment paramOffset by its arity for body children
+        for( const child of term.children() ) {
+            _decrementAndInline( child, removedDbns, inlineDbns, paramOffset + term.arity );
+        }
+        return term;
+    }
+
+    for( const child of term.children() ) {
+        _decrementAndInline( child, removedDbns, inlineDbns, paramOffset );
+    }
+    return term;
+}
+
+function _incrementTermDbns( term: IRTerm, dbnDiff: number ): IRTerm
+{
+    if( dbnDiff === 0 ) return term;
+
+    if( term instanceof IRVar ) {
+        term.dbn += dbnDiff;
+        // _modifyChildFromTo( term.parent, term, term );
+        return term;
+    }
+    if( term instanceof IRSelfCall ) {
+        term.dbn += dbnDiff;
+        // _modifyChildFromTo( term.parent, term, term );
+        return term;
+    }
+    if( term instanceof IRLetted ) {
+        term.dbn += dbnDiff;
+        for( const c of term.children() ) {
+            _incrementTermDbns( c, dbnDiff );
+        }
+        return term;
+    }
+    if( term instanceof IRHoisted ) return term; // hoisted terms are closed
+
+    for( const child of term.children() ) {
+        _incrementTermDbns( child, dbnDiff );
+    }
+    return term;
+}
+//*/