arkanalyzer 1.0.85 → 1.0.87

package/lib/frontend/cppFrontend/model/builder/BodyBuilder.d.ts

@@ -0,0 +1,59 @@
+import { ArkBody } from '../../../../core/model/ArkBody';
+import { ArkMethod } from '../../../../core/model/ArkMethod';
+import { MethodSignature } from '../../../../core/model/ArkSignature';
+import { CfgBuilder } from '../../graph/builder/CfgBuilder';
+import { GlobalRef } from '../../../../core/base/Ref';
+import { CxxAstNode } from '../../ast/ArkCxxAstNode';
+export declare class CxxBodyBuilder {
+    private cfgBuilder;
+    private globals?;
+    constructor(methodSignature: MethodSignature, sourceAstNode: CxxAstNode, declaringMethod: ArkMethod, sourceFile: CxxAstNode);
+    build(): ArkBody | null;
+    getCfgBuilder(): CfgBuilder;
+    getGlobals(): Map<string, GlobalRef> | undefined;
+    setGlobals(globals: Map<string, GlobalRef>): void;
+    /**
+     * Find out all locals in the parent method which are used by the nested method, these locals are the closures of the rnested method.
+     * nestedMethod is current nested method.
+     * baseLocals are all locals defined in the outer function.
+     * baseClosures are all closures of the outer function.
+     *
+     * When processing the CxxAstNode 'lambdaExpr', the closures of the nested function may be initially constructed.
+     * Here, the true closures of the nested function are filtered out based on the locals and closures of the outer function.
+     */
+    private findClosuresUsedInNested;
+    /**
+     * 1. Find out all locals in the parent method which are used by the childrenChain, these locals are the closures of the root node of the childrenChain.
+     * 2. Create a lexical env local in the parent method, and pass it to root node of the childrenChain through the method signature.
+     * 3. Update the root node of the childrenChain to add parameterRef assign stmt and closureRef assign stmt.
+     * 4. Recursively do this for all nested method level by level.
+     */
+    private buildLexicalEnv;
+    /**
+     * Find out and tag all closures from globals, and remove closures from both globals and locals.
+     * Precondition: body build has been done. All locals, globals and closures are both set as Local in body,
+     * while potential globals and closures are also recorded in bodybuilder.
+     * Constraint: only the outermost function can call this method to recursively handle closures of itself as well as all nested methods.
+     */
+    handleGlobalAndClosure(): void;
+    private freeBodyBuilder;
+    private updateLocalTypesWithTypeAlias;
+    private inferUnclearReferenceTypeWithTypeAlias;
+    private generateNestedMethodChains;
+    private getNestedChildrenChains;
+    private moveCurrentMethodLocalToGlobal;
+    private reorganizeGlobalAndLocal;
+    private inferTypesDefineInOuter;
+    private updateNestedMethodUsedInOuter;
+    private updateNestedMethodWithClosures;
+    private updateOuterMethodWithClosures;
+    private getOriginalNestedMethodName;
+    private updateGlobalInfoWithClosures;
+    private updateLocalInfoWithClosures;
+    private updateAbstractInvokeExprWithClosures;
+    private createNewSignatureWithClosures;
+    private updateSignatureAndArgsInArkInvokeExpr;
+    private addClosureParamsAssignStmts;
+    private buildExplicitClosureCaptureTypeMap;
+}
+//# sourceMappingURL=BodyBuilder.d.ts.map

package/lib/frontend/cppFrontend/model/builder/BodyBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BodyBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/model/builder/BodyBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAC7D,OAAO,EAAkB,eAAe,EAA8C,MAAM,qCAAqC,CAAC;AAClI,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAI5D,OAAO,EAAsC,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAI1F,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAYrD,qBAAa,cAAc;IACvB,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,OAAO,CAAC,CAAyB;gBAE7B,eAAe,EAAE,eAAe,EAAE,aAAa,EAAE,UAAU,EAAE,eAAe,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU;IAIpH,KAAK,IAAI,OAAO,GAAG,IAAI;IAcvB,aAAa,IAAI,UAAU;IAI3B,UAAU,IAAI,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,SAAS;IAIhD,UAAU,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAI;IAIxD;;;;;;;;OAQG;IACH,OAAO,CAAC,wBAAwB;IAiChC;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IA2BvB;;;;;OAKG;IACI,sBAAsB,IAAI,IAAI;IAwDrC,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,6BAA6B;IASrC,OAAO,CAAC,sCAAsC;IA4B9C,OAAO,CAAC,0BAA0B;IAiBlC,OAAO,CAAC,uBAAuB;IAgB/B,OAAO,CAAC,8BAA8B;IAmBtC,OAAO,CAAC,wBAAwB;IAuBhC,OAAO,CAAC,uBAAuB;IAe/B,OAAO,CAAC,6BAA6B;IAyCrC,OAAO,CAAC,8BAA8B;IAkBtC,OAAO,CAAC,6BAA6B;IA2BrC,OAAO,CAAC,2BAA2B;IAUnC,OAAO,CAAC,4BAA4B;IAqBpC,OAAO,CAAC,2BAA2B;IAyBnC,OAAO,CAAC,oCAAoC;IA+B5C,OAAO,CAAC,8BAA8B;IAWtC,OAAO,CAAC,qCAAqC;IA8B7C,OAAO,CAAC,2BAA2B;IAuDnC,OAAO,CAAC,kCAAkC;CAkB7C"}

package/lib/frontend/cppFrontend/model/builder/BodyBuilder.js

@@ -0,0 +1,605 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CxxBodyBuilder = void 0;
+const ArkBody_1 = require("../../../../core/model/ArkBody");
+const ArkSignature_1 = require("../../../../core/model/ArkSignature");
+const CfgBuilder_1 = require("../../graph/builder/CfgBuilder");
+const Local_1 = require("../../../../core/base/Local");
+const ArkMethodBuilder_1 = require("../../../../core/model/builder/ArkMethodBuilder");
+const Const_1 = require("../../../../core/common/Const");
+const Ref_1 = require("../../../../core/base/Ref");
+const Stmt_1 = require("../../../../core/base/Stmt");
+const Type_1 = require("../../../../core/base/Type");
+const Expr_1 = require("../../../../core/base/Expr");
+const IRUtils_1 = require("../../common/IRUtils");
+const Ref_2 = require("../../base/Ref");
+const logger_1 = __importStar(require("../../../../utils/logger"));
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'BodyBuilder');
+class CxxBodyBuilder {
+    constructor(methodSignature, sourceAstNode, declaringMethod, sourceFile) {
+        this.cfgBuilder = new CfgBuilder_1.CfgBuilder(sourceAstNode, methodSignature.getMethodSubSignature().getMethodName(), declaringMethod, sourceFile);
+    }
+    build() {
+        this.cfgBuilder.buildCfgBuilder();
+        if (!this.cfgBuilder.isBodyEmpty()) {
+            const { cfg, locals, globals, aliasTypeMap, traps } = this.cfgBuilder.buildCfg();
+            if (globals !== null) {
+                this.setGlobals(globals);
+            }
+            cfg.buildDefUseStmt(locals);
+            return new ArkBody_1.ArkBody(locals, cfg, aliasTypeMap, traps.length ? traps : undefined);
+        }
+        return null;
+    }
+    getCfgBuilder() {
+        return this.cfgBuilder;
+    }
+    getGlobals() {
+        return this.globals;
+    }
+    setGlobals(globals) {
+        this.globals = globals;
+    }
+    /**
+     * Find out all locals in the parent method which are used by the nested method, these locals are the closures of the rnested method.
+     * nestedMethod is current nested method.
+     * baseLocals are all locals defined in the outer function.
+     * baseClosures are all closures of the outer function.
+     *
+     * When processing the CxxAstNode 'lambdaExpr', the closures of the nested function may be initially constructed.
+     * Here, the true closures of the nested function are filtered out based on the locals and closures of the outer function.
+     */
+    findClosuresUsedInNested(childrenChain, baseLocals, allNestedLocals) {
+        var _a, _b;
+        let closuresRes = [];
+        const nestedMethod = childrenChain.parent;
+        let nestedGlobals = (_a = nestedMethod.getCxxBodyBuilder()) === null || _a === void 0 ? void 0 : _a.getGlobals();
+        if (nestedGlobals !== undefined) {
+            for (let global of nestedGlobals.values()) {
+                const nestedLocal = allNestedLocals.get(global.getName());
+                const closure = baseLocals.get(global.getName());
+                if (nestedLocal === undefined && closure !== undefined) {
+                    closuresRes.push(closure);
+                }
+            }
+        }
+        const children = childrenChain.children;
+        if (children === null) {
+            return closuresRes;
+        }
+        for (let chain of children) {
+            const nestedLocals = (_b = nestedMethod.getBody()) === null || _b === void 0 ? void 0 : _b.getLocals();
+            if (nestedLocals !== undefined) {
+                nestedLocals.forEach((value, key) => {
+                    allNestedLocals.set(key, value);
+                });
+            }
+            const closures = this.findClosuresUsedInNested(chain, baseLocals, allNestedLocals);
+            if (closures) {
+                closuresRes.push(...closures);
+            }
+        }
+        return closuresRes;
+    }
+    /**
+     * 1. Find out all locals in the parent method which are used by the childrenChain, these locals are the closures of the root node of the childrenChain.
+     * 2. Create a lexical env local in the parent method, and pass it to root node of the childrenChain through the method signature.
+     * 3. Update the root node of the childrenChain to add parameterRef assign stmt and closureRef assign stmt.
+     * 4. Recursively do this for all nested method level by level.
+     */
+    buildLexicalEnv(childrenChain, baseLocals, index, baseClosures) {
+        var _a;
+        let usedClosures = this.findClosuresUsedInNested(childrenChain, baseLocals, new Map());
+        const nestedMethod = childrenChain.parent;
+        const nestedSignature = nestedMethod.getImplementationSignature();
+        if (nestedSignature !== null && usedClosures !== null && usedClosures.length > 0) {
+            let lexicalEnv = new Type_1.LexicalEnvType(nestedSignature, usedClosures);
+            const closuresLocal = new Local_1.Local(`${Const_1.LEXICAL_ENV_NAME_PREFIX}${index++}`, lexicalEnv);
+            baseLocals.set(closuresLocal.getName(), closuresLocal);
+            this.updateNestedMethodWithClosures(nestedMethod, closuresLocal);
+        }
+        else if (usedClosures === null || usedClosures.length === 0) {
+            this.moveCurrentMethodLocalToGlobal(nestedMethod);
+        }
+        const nextNestedChains = childrenChain.children;
+        if (nextNestedChains === null) {
+            return index;
+        }
+        for (let nextChain of nextNestedChains) {
+            const newBaseLocals = (_a = nestedMethod.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals();
+            if (newBaseLocals === undefined) {
+                return index;
+            }
+            index = this.buildLexicalEnv(nextChain, newBaseLocals, index, usedClosures);
+        }
+        return index;
+    }
+    /**
+     * Find out and tag all closures from globals, and remove closures from both globals and locals.
+     * Precondition: body build has been done. All locals, globals and closures are both set as Local in body,
+     * while potential globals and closures are also recorded in bodybuilder.
+     * Constraint: only the outermost function can call this method to recursively handle closures of itself as well as all nested methods.
+     */
+    handleGlobalAndClosure() {
+        var _a, _b, _c;
+        /**
+         * Step1: Handle the outermost function, take it as Level 0.
+         * There must be no closures in Level 0. So only need to remove the locals which with the same name as the ones in globals.
+         */
+        let outerMethod = this.getCfgBuilder().getDeclaringMethod();
+        let outerGlobals = (_a = outerMethod.getCxxBodyBuilder()) === null || _a === void 0 ? void 0 : _a.getGlobals();
+        outerMethod.freeCxxBodyBuilder();
+        let outerLocals = (_b = outerMethod.getBody()) === null || _b === void 0 ? void 0 : _b.getLocals();
+        if (outerGlobals !== undefined && outerLocals !== undefined) {
+            outerGlobals.forEach((value, key) => {
+                const local = outerLocals.get(key);
+                if (local !== undefined) {
+                    value.addUsedStmts(local.getUsedStmts());
+                    outerLocals.delete(key);
+                }
+            });
+            if (outerGlobals.size > 0) {
+                (_c = outerMethod.getBody()) === null || _c === void 0 ? void 0 : _c.setUsedGlobals(outerGlobals);
+            }
+        }
+        let nestedMethodChains = this.generateNestedMethodChains(outerMethod).children;
+        if (nestedMethodChains === null || outerLocals === undefined) {
+            return;
+        }
+        let closuresIndex = 0;
+        for (let nestedChain of nestedMethodChains) {
+            /**
+             * Step2: Handle each nested function in Level 1 one by one.
+             * Find out all closures from Level 0 used by these Level 1 functions as well as all their children nested functions.
+             * This will be done level by level recursively.
+             */
+            closuresIndex = this.buildLexicalEnv(nestedChain, outerLocals, closuresIndex, null);
+            /**
+             * Step3: Delete old globals which are recognized as closures, then the rest globals are the true globals.
+             * The redundancy locals should be deleted but the used stmts of them should be restored to globals.
+             * This will be done level by level recursively.
+             */
+            this.reorganizeGlobalAndLocal(nestedChain);
+            /**
+             * Step4: Infer UnclearReferenceType to check whether it is the type alias define in its parent function..
+             */
+            this.inferTypesDefineInOuter(outerMethod, nestedChain);
+            /**
+             * Step5: For each nested function, find out whether it is called by its parent function and update the related locals, globals and stmts.
+             */
+            this.updateNestedMethodUsedInOuter(nestedChain);
+            this.freeBodyBuilder(nestedChain);
+        }
+    }
+    freeBodyBuilder(nestedChain) {
+        nestedChain.parent.freeCxxBodyBuilder();
+        const childrenChains = nestedChain.children;
+        if (childrenChains === null) {
+            return;
+        }
+        for (const chain of childrenChains) {
+            this.freeBodyBuilder(chain);
+        }
+    }
+    updateLocalTypesWithTypeAlias(locals, typeAliases) {
+        for (let local of locals.values()) {
+            const newType = this.inferUnclearReferenceTypeWithTypeAlias(local.getType(), typeAliases);
+            if (newType !== null) {
+                local.setType(newType);
+            }
+        }
+    }
+    inferUnclearReferenceTypeWithTypeAlias(localType, typeAliases) {
+        if (localType instanceof Type_1.ArrayType && localType.getBaseType() instanceof Type_1.UnclearReferenceType) {
+            const typeAlias = typeAliases.get(localType.getBaseType().getName());
+            if (typeAlias !== undefined) {
+                localType.setBaseType(typeAlias[0]);
+                return localType;
+            }
+            return null;
+        }
+        if (localType instanceof Type_1.UnionType) {
+            const optionTypes = localType.getTypes();
+            for (let i = 0; i < optionTypes.length; i++) {
+                const newType = this.inferUnclearReferenceTypeWithTypeAlias(optionTypes[i], typeAliases);
+                if (newType !== null) {
+                    optionTypes[i] = newType;
+                }
+            }
+            return localType;
+        }
+        if (localType instanceof Type_1.UnclearReferenceType) {
+            const typeAlias = typeAliases.get(localType.getName());
+            if (typeAlias !== undefined) {
+                return typeAlias[0];
+            }
+        }
+        return null;
+    }
+    generateNestedMethodChains(outerMethod) {
+        let candidateMethods = [];
+        outerMethod
+            .getDeclaringArkClass()
+            .getMethods()
+            .forEach(method => {
+            if (method.getName().startsWith(Const_1.NAME_PREFIX) && method.getName().endsWith(`${Const_1.NAME_DELIMITER}${outerMethod.getName()}`)) {
+                candidateMethods.push(method);
+            }
+        });
+        const childrenChains = this.getNestedChildrenChains(outerMethod, candidateMethods);
+        if (childrenChains.length > 0) {
+            return { parent: outerMethod, children: childrenChains };
+        }
+        return { parent: outerMethod, children: null };
+    }
+    getNestedChildrenChains(parentMethod, candidateMethods) {
+        var _a;
+        let nestedMethodChain = [];
+        for (let method of candidateMethods) {
+            const outerMethodSignature = (_a = method.getOuterMethod()) === null || _a === void 0 ? void 0 : _a.getSignature();
+            if (outerMethodSignature !== undefined && (0, ArkSignature_1.methodSignatureCompare)(parentMethod.getSignature(), outerMethodSignature)) {
+                const childrenChains = this.getNestedChildrenChains(method, candidateMethods);
+                if (childrenChains.length > 0) {
+                    nestedMethodChain.push({ parent: method, children: childrenChains });
+                }
+                else {
+                    nestedMethodChain.push({ parent: method, children: null });
+                }
+            }
+        }
+        return nestedMethodChain;
+    }
+    moveCurrentMethodLocalToGlobal(method) {
+        var _a, _b, _c;
+        const globals = (_a = method.getCxxBodyBuilder()) === null || _a === void 0 ? void 0 : _a.getGlobals();
+        const locals = (_b = method.getBody()) === null || _b === void 0 ? void 0 : _b.getLocals();
+        if (locals === undefined || globals === undefined) {
+            return;
+        }
+        globals.forEach((value, key) => {
+            const local = locals.get(key);
+            if (local !== undefined) {
+                value.addUsedStmts(local.getUsedStmts());
+                locals.delete(key);
+            }
+        });
+        if (globals.size > 0) {
+            (_c = method.getBody()) === null || _c === void 0 ? void 0 : _c.setUsedGlobals(globals);
+        }
+    }
+    reorganizeGlobalAndLocal(nestedChain) {
+        var _a;
+        const nestedMethod = nestedChain.parent;
+        const params = nestedMethod.getSubSignature().getParameters();
+        const globals = (_a = nestedMethod.getCxxBodyBuilder()) === null || _a === void 0 ? void 0 : _a.getGlobals();
+        if (params.length > 0 && params[0].getType() instanceof Type_1.LexicalEnvType && globals !== undefined) {
+            const closures = params[0].getType().getClosures();
+            for (let closure of closures) {
+                globals.delete(closure.getName());
+            }
+        }
+        this.moveCurrentMethodLocalToGlobal(nestedMethod);
+        const childrenChains = nestedChain.children;
+        if (childrenChains === null) {
+            return;
+        }
+        for (const chain of childrenChains) {
+            this.reorganizeGlobalAndLocal(chain);
+        }
+    }
+    // Type derivation of variables of UnclearReferenceType type in nested functions. Whether the type is a type alias defined in the outer function
+    inferTypesDefineInOuter(outerMethod, childrenChain) {
+        var _a, _b;
+        const typeAliases = (_a = outerMethod.getBody()) === null || _a === void 0 ? void 0 : _a.getAliasTypeMap();
+        const nestedLocals = (_b = childrenChain.parent.getBody()) === null || _b === void 0 ? void 0 : _b.getLocals();
+        if (typeAliases !== undefined && nestedLocals !== undefined) {
+            this.updateLocalTypesWithTypeAlias(nestedLocals, typeAliases);
+        }
+        const childrenChains = childrenChain.children;
+        if (childrenChains === null) {
+            return;
+        }
+        for (const chain of childrenChains) {
+            this.inferTypesDefineInOuter(childrenChain.parent, chain);
+        }
+    }
+    updateNestedMethodUsedInOuter(nestedChain) {
+        var _a, _b, _c, _d;
+        const nestedMethod = nestedChain.parent;
+        const outerMethod = nestedMethod.getOuterMethod();
+        if (outerMethod === undefined) {
+            return;
+        }
+        const outerLocals = (_a = outerMethod.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals();
+        if (outerLocals !== undefined) {
+            for (let local of outerLocals.values()) {
+                if (local.getType() instanceof Type_1.LexicalEnvType &&
+                    (0, ArkSignature_1.methodSignatureCompare)(local.getType().getNestedMethod(), nestedMethod.getSignature())) {
+                    this.updateOuterMethodWithClosures(outerMethod, nestedMethod, local);
+                    break;
+                }
+            }
+        }
+        const nestedMethodName = nestedMethod.getName();
+        const originalMethodName = (_b = this.getOriginalNestedMethodName(nestedMethodName)) !== null && _b !== void 0 ? _b : '';
+        const outerGlobals = (_c = outerMethod.getBody()) === null || _c === void 0 ? void 0 : _c.getUsedGlobals();
+        const callGlobal = (_d = outerGlobals === null || outerGlobals === void 0 ? void 0 : outerGlobals.get(nestedMethodName)) !== null && _d !== void 0 ? _d : outerGlobals === null || outerGlobals === void 0 ? void 0 : outerGlobals.get(originalMethodName);
+        if (callGlobal !== undefined && callGlobal instanceof Ref_1.GlobalRef && callGlobal.getRef() === null) {
+            const fieldSignature = new ArkSignature_1.FieldSignature(nestedMethodName, nestedMethod.getDeclaringArkClass().getSignature(), new Type_1.FunctionType(nestedMethod.getSignature()));
+            callGlobal.setRef(new Ref_1.ArkStaticFieldRef(fieldSignature));
+        }
+        const childrenChains = nestedChain.children;
+        if (childrenChains === null) {
+            return;
+        }
+        for (const chain of childrenChains) {
+            this.updateNestedMethodUsedInOuter(chain);
+        }
+    }
+    updateNestedMethodWithClosures(nestedMethod, closuresLocal) {
+        if (!(closuresLocal.getType() instanceof Type_1.LexicalEnvType)) {
+            return;
+        }
+        const declareSignatures = nestedMethod.getDeclareSignatures();
+        declareSignatures === null || declareSignatures === void 0 ? void 0 : declareSignatures.forEach((signature, index) => {
+            nestedMethod.setDeclareSignatureWithIndex(this.createNewSignatureWithClosures(closuresLocal, signature), index);
+        });
+        const implementSignature = nestedMethod.getImplementationSignature();
+        if (implementSignature !== null) {
+            nestedMethod.setImplementationSignature(this.createNewSignatureWithClosures(closuresLocal, implementSignature));
+        }
+        this.addClosureParamsAssignStmts(closuresLocal, nestedMethod);
+    }
+    updateOuterMethodWithClosures(outerMethod, nestedMethod, closuresLocal) {
+        var _a, _b, _c, _d, _e, _f;
+        const nestedMethodName = nestedMethod.getName();
+        const nestedMethodLocal = (_a = outerMethod.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals().get(nestedMethodName);
+        if (nestedMethodLocal !== undefined) {
+            this.updateLocalInfoWithClosures(nestedMethodLocal, outerMethod, nestedMethod, closuresLocal);
+        }
+        else {
+            const nestedMethodGlobal = (_c = (_b = outerMethod.getBody()) === null || _b === void 0 ? void 0 : _b.getUsedGlobals()) === null || _c === void 0 ? void 0 : _c.get(nestedMethodName);
+            if (nestedMethodGlobal !== undefined && nestedMethodGlobal instanceof Ref_1.GlobalRef) {
+                this.updateGlobalInfoWithClosures(nestedMethodGlobal, outerMethod, nestedMethod, closuresLocal);
+            }
+        }
+        const originalMethodName = this.getOriginalNestedMethodName(nestedMethodName);
+        if (originalMethodName === null) {
+            return;
+        }
+        const originalMethodLocal = (_d = outerMethod.getBody()) === null || _d === void 0 ? void 0 : _d.getLocals().get(originalMethodName);
+        if (originalMethodLocal !== undefined) {
+            this.updateLocalInfoWithClosures(originalMethodLocal, outerMethod, nestedMethod, closuresLocal);
+        }
+        else {
+            const originalMethodGlobal = (_f = (_e = outerMethod.getBody()) === null || _e === void 0 ? void 0 : _e.getUsedGlobals()) === null || _f === void 0 ? void 0 : _f.get(originalMethodName);
+            if (originalMethodGlobal !== undefined && originalMethodGlobal instanceof Ref_1.GlobalRef) {
+                this.updateGlobalInfoWithClosures(originalMethodGlobal, outerMethod, nestedMethod, closuresLocal);
+            }
+        }
+    }
+    getOriginalNestedMethodName(nestedMethodName) {
+        if (nestedMethodName.startsWith(Const_1.NAME_PREFIX) && nestedMethodName.includes(Const_1.NAME_DELIMITER)) {
+            const nameComponents = nestedMethodName.slice(1).split(Const_1.NAME_DELIMITER);
+            if (nameComponents.length > 1) {
+                return nameComponents[0];
+            }
+        }
+        return null;
+    }
+    updateGlobalInfoWithClosures(globalRef, outerMethod, nestedMethod, closuresLocal) {
+        if (globalRef.getRef() !== null) {
+            return;
+        }
+        const methodSignature = nestedMethod.getImplementationSignature();
+        if (methodSignature === null) {
+            return;
+        }
+        const lexicalEnv = closuresLocal.getType();
+        if (!(lexicalEnv instanceof Type_1.LexicalEnvType)) {
+            return;
+        }
+        const fieldSignature = new ArkSignature_1.FieldSignature(methodSignature.getMethodSubSignature().getMethodName(), methodSignature.getDeclaringClassSignature(), new Type_1.ClosureType(lexicalEnv, methodSignature));
+        globalRef.setRef(new Ref_1.ArkStaticFieldRef(fieldSignature));
+        this.updateAbstractInvokeExprWithClosures(globalRef, outerMethod.getSignature(), nestedMethod.getSignature(), closuresLocal);
+    }
+    updateLocalInfoWithClosures(local, outerMethod, nestedMethod, closuresLocal) {
+        const localType = local.getType();
+        if (!(localType instanceof Type_1.FunctionType)) {
+            return;
+        }
+        const lexicalEnv = closuresLocal.getType();
+        if (!(lexicalEnv instanceof Type_1.LexicalEnvType)) {
+            return;
+        }
+        // Update the local type to CloseType and methodSignature to inner nested function
+        const nestedMethodSignature = nestedMethod.getImplementationSignature();
+        if (nestedMethodSignature !== null) {
+            local.setType(new Type_1.ClosureType(lexicalEnv, nestedMethodSignature, localType.getRealGenericTypes()));
+        }
+        else {
+            local.setType(new Type_1.ClosureType(lexicalEnv, localType.getMethodSignature(), localType.getRealGenericTypes()));
+        }
+        this.updateAbstractInvokeExprWithClosures(local, outerMethod.getSignature(), nestedMethod.getSignature(), closuresLocal);
+    }
+    // Update the function signature and actual parameter args in AbstractInvokeExpr where the inner function is called in all stmt,
+    // and add the closure parameter.
+    // Update the function signature and actual parameter args in usedStmt of all function pointers defined in stmt, and add closure parameters
+    updateAbstractInvokeExprWithClosures(value, outerMethodSignature, nestedMethodSignature, closuresLocal) {
+        for (const usedStmt of value.getUsedStmts()) {
+            if (usedStmt instanceof Stmt_1.ArkInvokeStmt) {
+                this.updateSignatureAndArgsInArkInvokeExpr(usedStmt, nestedMethodSignature, closuresLocal);
+            }
+            else if (usedStmt instanceof Stmt_1.ArkAssignStmt) {
+                const rightOp = usedStmt.getRightOp();
+                if (rightOp instanceof Expr_1.AbstractInvokeExpr) {
+                    this.updateSignatureAndArgsInArkInvokeExpr(usedStmt, nestedMethodSignature, closuresLocal);
+                }
+                const leftOp = usedStmt.getLeftOp();
+                if (leftOp instanceof Local_1.Local) {
+                    leftOp.setType(rightOp.getType());
+                }
+            }
+            else if (usedStmt instanceof Stmt_1.ArkReturnStmt) {
+                outerMethodSignature.getMethodSubSignature().setReturnType(value.getType());
+            }
+            const defValue = usedStmt.getDef();
+            if (defValue === null) {
+                continue;
+            }
+            if ((defValue instanceof Local_1.Local || defValue instanceof Ref_1.GlobalRef) && defValue.getType() instanceof Type_1.FunctionType) {
+                this.updateAbstractInvokeExprWithClosures(defValue, outerMethodSignature, nestedMethodSignature, closuresLocal);
+            }
+        }
+    }
+    createNewSignatureWithClosures(closuresLocal, oldSignature) {
+        let oldSubSignature = oldSignature.getMethodSubSignature();
+        const params = oldSubSignature.getParameters();
+        const closuresParam = new ArkMethodBuilder_1.MethodParameter();
+        closuresParam.setName(closuresLocal.getName());
+        closuresParam.setType(closuresLocal.getType());
+        params.unshift(closuresParam);
+        let newSubSignature = new ArkSignature_1.MethodSubSignature(oldSubSignature.getMethodName(), params, oldSubSignature.getReturnType(), oldSubSignature.isStatic());
+        return new ArkSignature_1.MethodSignature(oldSignature.getDeclaringClassSignature(), newSubSignature);
+    }
+    updateSignatureAndArgsInArkInvokeExpr(stmt, methodSignature, closuresLocal) {
+        let expr;
+        if (stmt instanceof Stmt_1.ArkInvokeStmt) {
+            expr = stmt.getInvokeExpr();
+        }
+        else {
+            const rightOp = stmt.getRightOp();
+            if (!(rightOp instanceof Expr_1.AbstractInvokeExpr)) {
+                return;
+            }
+            expr = rightOp;
+        }
+        const exprMethodName = expr.getMethodSignature().getMethodSubSignature().getMethodName();
+        const nestedMethodName = methodSignature.getMethodSubSignature().getMethodName();
+        if (exprMethodName === nestedMethodName) {
+            expr.setMethodSignature(this.createNewSignatureWithClosures(closuresLocal, methodSignature));
+            expr.getArgs().unshift(closuresLocal);
+            closuresLocal.addUsedStmt(stmt);
+            return;
+        }
+        const originalMethodName = this.getOriginalNestedMethodName(nestedMethodName);
+        if (originalMethodName !== null) {
+            if (exprMethodName === originalMethodName || expr instanceof Expr_1.ArkPtrInvokeExpr) {
+                expr.setMethodSignature(methodSignature);
+                expr.getArgs().unshift(closuresLocal);
+                closuresLocal.addUsedStmt(stmt);
+            }
+        }
+    }
+    addClosureParamsAssignStmts(closuresParam, method) {
+        var _a, _b;
+        const lexicalEnv = closuresParam.getType();
+        if (!(lexicalEnv instanceof Type_1.LexicalEnvType)) {
+            return;
+        }
+        const closures = lexicalEnv.getClosures();
+        if (closures.length === 0) {
+            return;
+        }
+        const oldParamRefs = method.getParameterRefs();
+        let body = method.getBody();
+        if (body === undefined) {
+            return;
+        }
+        let stmts = body.getCfg().getStartingBlock().getStmts();
+        let index = 0;
+        const parameterRef = new Ref_1.ArkParameterRef(index, lexicalEnv);
+        const closuresLocal = new Local_1.Local(closuresParam.getName(), lexicalEnv);
+        body.addLocal(closuresLocal.getName(), closuresLocal);
+        let assignStmt = new Stmt_1.ArkAssignStmt(closuresLocal, parameterRef);
+        assignStmt.setCfg(body.getCfg());
+        body.getCfg().insertBefore(assignStmt, stmts[index]);
+        closuresLocal.setDeclaringStmt(assignStmt);
+        oldParamRefs === null || oldParamRefs === void 0 ? void 0 : oldParamRefs.forEach(paramRef => {
+            index++;
+            paramRef.setIndex(index);
+        });
+        const lambdaExprNode = (_a = method.getCxxBodyBuilder()) === null || _a === void 0 ? void 0 : _a.getCfgBuilder().astRoot;
+        const lambdaCaptureList = lambdaExprNode ? IRUtils_1.IRUtils.getLambdaCapture(lambdaExprNode.code) : '';
+        const defaultCaptureType = IRUtils_1.IRUtils.analyzeLambdaDefaultCapture(lambdaCaptureList);
+        const explicitVars = lambdaExprNode ? IRUtils_1.IRUtils.getLambdaExplicitCaptureVars(lambdaExprNode) : [];
+        const explicitCaptureTypeMap = this.buildExplicitClosureCaptureTypeMap(explicitVars);
+        for (let closure of closures) {
+            let local = body.getLocals().get(closure.getName());
+            if (local === undefined) {
+                local = new Local_1.Local(closure.getName(), closure.getType());
+                body.addLocal(local.getName(), local);
+            }
+            else {
+                local.setType(closure.getType());
+            }
+            index++;
+            const captureType = (_b = explicitCaptureTypeMap.get(closure.getName())) !== null && _b !== void 0 ? _b : (defaultCaptureType === Ref_2.CxxClosureCaptureType.BY_REF ? Ref_2.CxxClosureCaptureType.BY_REF : Ref_2.CxxClosureCaptureType.BY_VALUE);
+            const closureFieldRef = new Ref_2.CxxClosureFieldRef(closuresLocal, closure.getName(), closure.getType(), captureType);
+            let assignStmt = new Stmt_1.ArkAssignStmt(local, closureFieldRef);
+            assignStmt.setCfg(body.getCfg());
+            body.getCfg().insertBefore(assignStmt, stmts[index]);
+            local.setDeclaringStmt(assignStmt);
+            closuresLocal.addUsedStmt(assignStmt);
+        }
+    }
+    buildExplicitClosureCaptureTypeMap(explicitVars) {
+        var _a, _b, _c, _d, _e, _f;
+        const closureCaptureTypeMap = new Map();
+        let varName = '';
+        for (const explicitVar of explicitVars) {
+            if (explicitVar.kind === 'DeclRefExpr') {
+                // Reference capture
+                varName = (_b = (_a = explicitVar.referencedDecl) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : explicitVar.code;
+                closureCaptureTypeMap.set(varName, Ref_2.CxxClosureCaptureType.BY_REF);
+            }
+            else if (explicitVar.kind === 'ImplicitCastExpr' && ((_d = (_c = explicitVar.inner) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.kind) === 'DeclRefExpr') {
+                // Value capture
+                varName = (_f = (_e = explicitVar.inner[0].referencedDecl) === null || _e === void 0 ? void 0 : _e.name) !== null && _f !== void 0 ? _f : explicitVar.inner[0].code;
+                closureCaptureTypeMap.set(varName, Ref_2.CxxClosureCaptureType.BY_VALUE);
+            }
+            else {
+                logger.warn(`Unprocessed capture Node: ${explicitVar.kind}`);
+            }
+        }
+        return closureCaptureTypeMap;
+    }
+}
+exports.CxxBodyBuilder = CxxBodyBuilder;