@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

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;
+}
+//*/ 

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

@@ -1,36 +1,33 @@
 import { IRApp } from "../../IRNodes/IRApp.js";
 import { IRCase } from "../../IRNodes/IRCase.js";
 import { IRConstr } from "../../IRNodes/IRConstr.js";
-import { IRDelayed } from "../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../IRNodes/IRForced.js";
-import { IRFunc } from "../../IRNodes/IRFunc.js";
 import { IRHoisted } from "../../IRNodes/IRHoisted.js";
 import { IRLetted } from "../../IRNodes/IRLetted.js";
-import { IRRecursive } from "../../IRNodes/IRRecursive.js";
 export function markRecursiveHoistsAsForced(_term) {
     const stack = [{ term: _term, isInRecursiveTerm: false }];
     while (stack.length > 0) {
         const { term: t, isInRecursiveTerm, isIRAppArg } = stack.pop();
+        if (isInRecursiveTerm && (t instanceof IRHoisted
+            || t instanceof IRLetted)) {
+            t.meta.forceHoist = true;
+            // don't push anything to the stack
+            // hoisted values are handled normally
+            continue;
+        }
         if (t instanceof IRApp) {
-            // must push the arg first and then the fucntion
-            // so that we can check if the function is the Z combinator before the arg is processed
-            stack.push({ term: t.arg, isIRAppArg: true, isInRecursiveTerm }, { term: t.fn, isInRecursiveTerm });
+            stack.push({ term: t.fn, isInRecursiveTerm }, { term: t.arg, isIRAppArg: true, isInRecursiveTerm });
             continue;
         }
         if (t instanceof IRConstr) {
-            // must push the arg first and then the fucntion
-            // so that we can check if the function is the Z combinator before the arg is processed
             stack.push(...Array.from(t.fields)
-                .map((f, i) => ({
+                .map(f => ({
                 term: f,
-                isIRAppArg: i > 0,
+                isIRAppArg: true,
                 isInRecursiveTerm
             })));
             continue;
         }
         if (t instanceof IRCase) {
-            // must push the arg first and then the fucntion
-            // so that we can check if the function is the Z combinator before the arg is processed
             stack.push({
                 term: t.constrTerm,
                 isIRAppArg: false,
@@ -38,45 +35,11 @@ export function markRecursiveHoistsAsForced(_term) {
             }, ...Array.from(t.continuations)
                 .map(cont => ({
                 term: cont,
-                isIRAppArg: true,
+                isIRAppArg: false,
                 isInRecursiveTerm
             })));
             continue;
         }
-        if (t instanceof IRHoisted ||
-            t instanceof IRLetted) {
-            if (isInRecursiveTerm) {
-                t.meta.forceHoist = true;
-                // don't push anything to the stack
-                // hoisted values are handled normally
-                continue;
-            }
-            // otherwhise check in values too
-            else if (t instanceof IRLetted) {
-                stack.push({ term: t.value, isInRecursiveTerm });
-                continue;
-            }
-            else if (t instanceof IRHoisted) {
-                stack.push({ term: t.hoisted, isInRecursiveTerm });
-                continue;
-            }
-        }
-        if (t instanceof IRDelayed) {
-            stack.push({ term: t.delayed, isInRecursiveTerm });
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push({ term: t.forced, isInRecursiveTerm });
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push({ term: t.body, isInRecursiveTerm });
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push({ term: t.body, isInRecursiveTerm: true });
-            continue;
-        }
-        const tsEnsureExsaustiveCheck = t;
+        stack.push(...(t.children?.().map(c => ({ term: c, isInRecursiveTerm })) ?? []));
     }
 }

package/dist/IR/toUPLC/subRoutines/performUplcOptimizationsAndReturnRoot/expandFuncsAndReturnRoot.d.ts

@@ -1,4 +1,4 @@
 import { IRFunc } from "../../../IRNodes/IRFunc.js";
 import { IRTerm } from "../../../IRTerm.js";
-export declare function getExpandedIRFunc(body: IRTerm, arity: number): IRFunc;
+export declare function getExpandedIRFunc(body: IRTerm, params: symbol[]): IRFunc;
 export declare function expandFuncsAndReturnRoot(root: IRTerm): IRTerm;

package/dist/IR/toUPLC/subRoutines/performUplcOptimizationsAndReturnRoot/expandFuncsAndReturnRoot.js

@@ -9,10 +9,10 @@ import { IRLetted } from "../../../IRNodes/IRLetted.js";
 import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
 import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
 import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
-export function getExpandedIRFunc(body, arity) {
-    body = new IRFunc(1, body);
-    while (--arity > 0) {
-        body = new IRFunc(1, body);
+export function getExpandedIRFunc(body, params) {
+    let introducedParam;
+    while (introducedParam = params.pop()) {
+        body = new IRFunc([introducedParam], body);
     }
     return body;
     // if( arity === 1 ) return new IRFunc( 1, body );
@@ -28,13 +28,11 @@ export function expandFuncsAndReturnRoot(root) {
             // all good
             if (t.arity <= 1)
                 continue;
-            const expanded = getExpandedIRFunc(t.body, t.arity);
-            if (t.parent) {
+            const expanded = getExpandedIRFunc(t.body, t.params);
+            if (t.parent)
                 _modifyChildFromTo(t.parent, t, expanded);
-            }
-            else {
+            else
                 root = expanded;
-            }
             continue;
         }
         if (t instanceof IRApp) {
@@ -57,12 +55,11 @@ export function expandFuncsAndReturnRoot(root) {
             stack.push(t.forced);
             continue;
         }
-        if (t instanceof IRRecursive ||
-            t instanceof IRHoisted ||
-            t instanceof IRLetted ||
-            t instanceof IRSelfCall) {
+        if (t instanceof IRRecursive
+            || t instanceof IRHoisted
+            || t instanceof IRLetted
+            || t instanceof IRSelfCall)
             throw new Error("Unexpected term while performing uplc optimizations");
-        }
     }
     return root;
 }

package/dist/IR/toUPLC/subRoutines/performUplcOptimizationsAndReturnRoot/{index.d.ts → performUplcOptimizationsAndReturnRoot.d.ts}

@@ -1,5 +1,3 @@
 import { IRTerm } from "../../../IRTerm.js";
 import { CompilerOptions } from "../../CompilerOptions.js";
 export declare function performUplcOptimizationsAndReturnRoot(root: IRTerm, options: CompilerOptions): IRTerm;
-/** @experimental still can't figure how to make it work */
-export declare function groupIndipendentLets(term: IRTerm, dbn: number): [args: IRTerm[], body: IRTerm];

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

@@ -0,0 +1,151 @@
+import { IRConstr } from "../../../IRNodes/index.js";
+import { IRApp } from "../../../IRNodes/IRApp.js";
+import { IRCase } from "../../../IRNodes/IRCase.js";
+import { IRFunc } from "../../../IRNodes/IRFunc.js";
+import { IRHoisted } from "../../../IRNodes/IRHoisted.js";
+import { IRLetted } from "../../../IRNodes/IRLetted.js";
+import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
+import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
+import { IRVar } from "../../../IRNodes/IRVar.js";
+import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
+import { isDebugUplcOptimizations } from "../../CompilerOptions.js";
+import { expandFuncsAndReturnRoot } from "./expandFuncsAndReturnRoot.js";
+import { getApplicationTerms } from "../../utils/getApplicationTerms.js";
+import { getUnboundedVars } from "../handleLetted/groupByScope.js";
+export function performUplcOptimizationsAndReturnRoot(root, options) {
+    const opts = options.uplcOptimizations;
+    if (isDebugUplcOptimizations(opts))
+        return root;
+    const { groupApplications, inlineSingleUse: shouldInlineSingleUse, simplifyWrappedPartialFuncApps, removeForceDelay } = opts;
+    root = expandFuncsAndReturnRoot(root);
+    const stack = [root];
+    let t = root;
+    while (t = stack.pop()) {
+        if (t instanceof IRApp
+            && isIdLike(t.fn)) {
+            const arg = t.arg;
+            if (t.parent)
+                _modifyChildFromTo(t.parent, t, arg);
+            else
+                root = arg;
+            stack.push(arg);
+            continue;
+        }
+        const indepApps = groupIndependentApplications(t);
+        if (indepApps) {
+            const { newRoot, args, nextBody } = indepApps;
+            if (newRoot)
+                root = newRoot;
+            stack.push(...args);
+            stack.push(nextBody);
+            continue;
+        }
+        if (t instanceof IRRecursive ||
+            t instanceof IRHoisted ||
+            t instanceof IRLetted ||
+            t instanceof IRSelfCall)
+            throw new Error("Unexpected term while performing uplc optimizations");
+        stack.push(...t.children());
+    }
+    return root;
+}
+function isIdLike(term) {
+    return (term instanceof IRFunc &&
+        term.params.length === 1 &&
+        term.body instanceof IRVar &&
+        term.body.name === term.params[0]);
+}
+/**
+ *
+ * @returns either an object containing the new root, sorted args and next body
+ *          or undefined if grouping wasnt possible (root is the same)
+ */
+function groupIndependentApplications(root) {
+    const parent = root.parent;
+    let applicaitonTerms = getApplicationTerms(root);
+    if (!applicaitonTerms)
+        return undefined;
+    let { func, args } = applicaitonTerms;
+    if (!(func instanceof IRFunc))
+        return undefined;
+    const params = func.params.slice();
+    while (true) {
+        applicaitonTerms = getApplicationTerms(func.body);
+        if (!applicaitonTerms)
+            break;
+        if (!(applicaitonTerms.func instanceof IRFunc))
+            break;
+        func = applicaitonTerms.func;
+        params.push(...func.params);
+        args.push(...applicaitonTerms.args);
+        if (params.length !== args.length)
+            break;
+    }
+    const len = Math.min(params.length, args.length);
+    const finalParams = params.slice(len);
+    const finalArgs = args.slice(len);
+    params.length = len;
+    args.length = len;
+    const paramToArg = {};
+    for (let i = 0; i < len; i++) {
+        const p = params[i];
+        paramToArg[p] = args[i];
+    }
+    const globalUnbound = getUnboundedVars(root);
+    const groups = [[]];
+    for (let i = 0; i < len; i++) {
+        const p = params[i];
+        const arg = args[i];
+        const unbound = getUnboundedVars(arg, globalUnbound);
+        let highestIdx = -1;
+        for (let j = groups.length - 1; j >= 0; j--) {
+            const group = groups[j];
+            if (group.some(sym => unbound.has(sym))) {
+                highestIdx = j;
+                break;
+            }
+        }
+        if (highestIdx === groups.length - 1) {
+            groups.push([p]);
+            continue;
+        }
+        groups[highestIdx + 1].push(p);
+    }
+    groups[groups.length - 1].push(...finalParams);
+    const sortedArgs = new Array(len);
+    const soretedParams = groups.flat();
+    for (let i = 0; i < len; i++) {
+        const p = soretedParams[i];
+        sortedArgs[i] = paramToArg[p];
+    }
+    let nextBody = func.body;
+    if (finalArgs.length > 0) {
+        if (finalArgs.length === 1) {
+            nextBody = new IRApp(nextBody, finalArgs[0]);
+        }
+        else {
+            nextBody = new IRCase(new IRConstr(0, finalArgs), [nextBody]);
+        }
+    }
+    let newTerm = nextBody;
+    for (let i = groups.length - 1; i >= 0; i--) {
+        const group = groups[i];
+        if (group.length === 1) {
+            newTerm = new IRApp(new IRFunc(group, newTerm), paramToArg[group[0]]);
+        }
+        else if (group.length <= 0)
+            continue;
+        else {
+            newTerm = new IRCase(new IRConstr(0, group.map(p => paramToArg[p])), [new IRFunc(group, newTerm)]);
+        }
+    }
+    if (parent)
+        _modifyChildFromTo(parent, root, newTerm);
+    else
+        root = newTerm;
+    return {
+        newRoot: !parent ? root : undefined,
+        args: sortedArgs,
+        nextBody
+    };
+}

package/dist/IR/toUPLC/subRoutines/removeUnusuedVarsAndReturnRoot/RemoveUnusedVarsCtx.d.ts

@@ -0,0 +1,11 @@
+export declare class RemoveUnusedVarsCtx {
+    readonly params: symbol[];
+    readonly parent: RemoveUnusedVarsCtx | undefined;
+    readonly localVars: Record<symbol, number>;
+    constructor(params: symbol[], parent: RemoveUnusedVarsCtx | undefined);
+    static root(params?: symbol[]): RemoveUnusedVarsCtx;
+    newChild(params: symbol[]): RemoveUnusedVarsCtx;
+    private keys;
+    incrementVarUse(sym: symbol): void;
+    getUnusedVars(): symbol[];
+}

package/dist/IR/toUPLC/subRoutines/removeUnusuedVarsAndReturnRoot/RemoveUnusedVarsCtx.js

@@ -0,0 +1,46 @@
+export class RemoveUnusedVarsCtx {
+    params;
+    parent;
+    localVars;
+    // MUST BE A GETTER TO REFLECT CHANGES IN PARENT
+    // DO NOT MODIFY
+    // private get _parentDbn(): number {
+    //     return this.parent?.dbn ?? 0;
+    // }
+    // get dbn(): number {
+    //     return this._parentDbn + Object.getOwnPropertySymbols( this.localVars ).length;
+    // }
+    constructor(params, parent) {
+        this.params = params;
+        this.parent = parent;
+        params = params.slice();
+        this.localVars = {};
+        for (const p of params)
+            this.localVars[p] = 0;
+    }
+    static root(params = []) {
+        return new RemoveUnusedVarsCtx(params, undefined);
+    }
+    newChild(params) {
+        return new RemoveUnusedVarsCtx(params, this);
+    }
+    keys() {
+        return Object.getOwnPropertySymbols(this.localVars);
+    }
+    incrementVarUse(sym) {
+        if (typeof this.localVars[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.localVars[sym]++;
+    }
+    getUnusedVars() {
+        const keys = this.keys();
+        return keys.filter(k => this.localVars[k] === 0);
+    }
+}

package/dist/IR/toUPLC/subRoutines/removeUnusuedVarsAndReturnRoot/removeUnusuedVarsAndReturnRoot.d.ts

@@ -0,0 +1,2 @@
+import { IRTerm } from "../../../IRTerm.js";
+export declare function removeUnusedVarsAndReturnRoot(term: IRTerm): IRTerm;

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

@@ -0,0 +1,80 @@
+import { _ir_apps, IRFunc } from "../../../IRNodes/index.js";
+import { IRVar } from "../../../IRNodes/IRVar.js";
+import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
+import { getApplicationTerms } from "../../utils/getApplicationTerms.js";
+import { RemoveUnusedVarsCtx } from "./RemoveUnusedVarsCtx.js";
+export function removeUnusedVarsAndReturnRoot(term) {
+    // 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 _removeUnusedVars(term, RemoveUnusedVarsCtx.root());
+}
+function _removeUnusedVars(term, ctx) {
+    if (term instanceof IRVar) {
+        // increment used
+        ctx.incrementVarUse(term.name);
+        return term;
+    }
+    const applicationTerms = getApplicationTerms(term);
+    if (!applicationTerms) {
+        const childrens = term.children();
+        const nextCtx = term instanceof IRFunc
+            ? ctx.newChild(term.params)
+            : ctx;
+        for (const c of childrens) {
+            _removeUnusedVars(c, nextCtx);
+        }
+        return term;
+    }
+    const { func, args } = applicationTerms;
+    if (!(func instanceof IRFunc)) {
+        for (const child of term.children()) {
+            // same as parent ctx
+            _removeUnusedVars(child, ctx);
+        }
+        return term;
+    }
+    const funcCtx = ctx.newChild(func.params);
+    func.body = _removeUnusedVars(func.body, funcCtx);
+    const unusedVars = funcCtx.getUnusedVars();
+    // if all variables are used, keep as is
+    if (unusedVars.length <= 0) {
+        for (const funcArg of args) {
+            // arguments passed have the same context of the function called
+            _removeUnusedVars(funcArg, ctx);
+        }
+        return term;
+    }
+    const originalParams = func.params.slice();
+    const filteredArgs = [];
+    for (let i = 0; i < originalParams.length; i++) {
+        const p = originalParams[i];
+        if (!unusedVars.includes(p))
+            filteredArgs.push(args[i]);
+    }
+    // remove vars here
+    filterParamsInplace(func.params, unusedVars);
+    for (const funcArg of filteredArgs) {
+        // arguments passed have the same context of the function called
+        _removeUnusedVars(funcArg, ctx);
+    }
+    const someArgsWereUsed = filteredArgs.length > 0;
+    const newTerm = someArgsWereUsed
+        ? _ir_apps(func, ...filteredArgs)
+        : func.body; // all unused, remove function, just keep the body
+    const parent = term.parent;
+    if (parent)
+        _modifyChildFromTo(parent, term, newTerm);
+    return newTerm;
+}
+function filterParamsInplace(params, unusedVars) {
+    let writeIdx = 0;
+    for (let readIdx = 0; readIdx < params.length; readIdx++) {
+        const p = params[readIdx];
+        if (!unusedVars.includes(p)) {
+            params[writeIdx] = p;
+            writeIdx++;
+        }
+    }
+    params.length = writeIdx;
+}