arkanalyzer 1.0.85 → 1.0.87

package/lib/frontend/cppFrontend/graph/builder/TrapBuilder.js

@@ -0,0 +1,302 @@
+"use strict";
+/*
+ * Copyright (c) 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.CxxTrapBuilder = void 0;
+const Trap_1 = require("../../base/Trap");
+const logger_1 = __importStar(require("../../../../utils/logger"));
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'TrapBuilder');
+/**
+ * Builder for traps from try...catch
+ */
+class CxxTrapBuilder {
+    constructor(blockBuildersBeforeTry, blockBuilderToCfgBlock, basicBlockSet) {
+        this.blockBuildersBeforeTry = blockBuildersBeforeTry;
+        this.processedBlockBuildersBeforeTry = new Set();
+        this.basicBlockSet = basicBlockSet;
+        this.blockBuilderToCfgBlock = blockBuilderToCfgBlock;
+    }
+    buildTraps() {
+        const traps = [];
+        const blockBuildersBeforeTry = Array.from(this.blockBuildersBeforeTry);
+        for (const blockBuilderBeforeTry of blockBuildersBeforeTry) {
+            traps.push(...this.buildTrapGroup(blockBuilderBeforeTry).traps);
+        }
+        return traps;
+    }
+    buildTrapGroup(blockBuilderBeforeTry) {
+        if (this.shouldSkipProcessing(blockBuilderBeforeTry)) {
+            return { traps: [], headBlockBuilder: null };
+        }
+        const tryStmtBuilder = this.getTryStatementBuilder(blockBuilderBeforeTry);
+        if (!tryStmtBuilder) {
+            return { traps: [], headBlockBuilder: null };
+        }
+        const finallyBlockBuilder = this.getFinallyBlock(tryStmtBuilder);
+        if (!finallyBlockBuilder) {
+            return { traps: [], headBlockBuilder: null };
+        }
+        const headBlockBuilderWithinTry = this.prepareHeadBlock(blockBuilderBeforeTry);
+        const traps = [];
+        const tryResult = this.processTryBlock(headBlockBuilderWithinTry, finallyBlockBuilder);
+        traps.push(...tryResult.traps);
+        const updatedHeadBlock = tryResult.newStartBlockBuilder;
+        const catchResult = this.processCatchBlock(tryStmtBuilder);
+        traps.push(...catchResult.traps);
+        const blockBuilderAfterFinally = this.getAfterFinallyBlock(tryStmtBuilder);
+        if (!blockBuilderAfterFinally) {
+            return { traps: [], headBlockBuilder: null };
+        }
+        const singleTraps = this.buildSingleTraps(tryResult.bfsBlocks, tryResult.tailBlocks, catchResult.bfsBlocks, // It is a two-dimensional array here now.
+        catchResult.tailBlocks, // It is a two-dimensional array here now.
+        finallyBlockBuilder);
+        traps.push(...singleTraps);
+        return { traps, headBlockBuilder: updatedHeadBlock };
+    }
+    shouldSkipProcessing(blockBuilderBeforeTry) {
+        if (this.processedBlockBuildersBeforeTry.has(blockBuilderBeforeTry)) {
+            return true;
+        }
+        this.processedBlockBuildersBeforeTry.add(blockBuilderBeforeTry);
+        if (blockBuilderBeforeTry.nexts.length === 0) {
+            logger.error(`can't find try block.`);
+            return true;
+        }
+        return false;
+    }
+    getTryStatementBuilder(blockBuilderBeforeTry) {
+        const stmtsCnt = blockBuilderBeforeTry.stmts.length;
+        return blockBuilderBeforeTry.stmts[stmtsCnt - 1];
+    }
+    getFinallyBlock(tryStmtBuilder) {
+        var _a;
+        const finallyBlockBuilder = (_a = tryStmtBuilder.finallyStatement) === null || _a === void 0 ? void 0 : _a.block;
+        if (!finallyBlockBuilder) {
+            logger.error(`can't find finally block or dummy finally block.`);
+            return null;
+        }
+        return finallyBlockBuilder;
+    }
+    prepareHeadBlock(blockBuilderBeforeTry) {
+        const headBlockBuilderWithinTry = blockBuilderBeforeTry.nexts[0];
+        this.removeEmptyBlockBeforeTry(blockBuilderBeforeTry);
+        return headBlockBuilderWithinTry;
+    }
+    processTryBlock(headBlockBuilderWithinTry, finallyBlockBuilder) {
+        const result = this.buildTrapsRecursively(headBlockBuilderWithinTry, finallyBlockBuilder);
+        const { bfsBlocks, tailBlocks } = this.getAllBlocksBFS(result.newStartBlockBuilder, finallyBlockBuilder);
+        return {
+            traps: result.traps,
+            newStartBlockBuilder: result.newStartBlockBuilder,
+            bfsBlocks,
+            tailBlocks
+        };
+    }
+    processCatchBlock(tryStmtBuilder) {
+        const allCatchBfsBlocks = [];
+        const allCatchTailBlocks = [];
+        const allTraps = [];
+        // 处理每个 catch 块
+        for (const catchStatement of tryStmtBuilder.catchStatement) {
+            const catchBlockBuilder = catchStatement === null || catchStatement === void 0 ? void 0 : catchStatement.block;
+            if (catchBlockBuilder) {
+                const result = this.buildTrapsRecursively(catchBlockBuilder);
+                const { bfsBlocks, tailBlocks } = this.getAllBlocksBFS(result.newStartBlockBuilder);
+                allCatchBfsBlocks.push(bfsBlocks);
+                allCatchTailBlocks.push(tailBlocks);
+                allTraps.push(...result.traps);
+            }
+        }
+        return {
+            traps: allTraps,
+            bfsBlocks: allCatchBfsBlocks,
+            tailBlocks: allCatchTailBlocks
+        };
+    }
+    getAfterFinallyBlock(tryStmtBuilder) {
+        var _a;
+        const blockBuilderAfterFinally = (_a = tryStmtBuilder.afterFinal) === null || _a === void 0 ? void 0 : _a.block;
+        if (!blockBuilderAfterFinally) {
+            logger.error(`can't find block after try...catch.`);
+            return null;
+        }
+        return blockBuilderAfterFinally;
+    }
+    buildSingleTraps(tryBfsBlocks, tryTailBlocks, catchBfsBlocks, catchTailBlocks, finallyBlockBuilder) {
+        return this.buildTrapsIfNoFinally(tryBfsBlocks, tryTailBlocks, catchBfsBlocks, catchTailBlocks, finallyBlockBuilder);
+    }
+    buildTrapsRecursively(startBlockBuilder, endBlockBuilder) {
+        const queue = [];
+        const visitedBlockBuilders = new Set();
+        queue.push(startBlockBuilder);
+        while (queue.length !== 0) {
+            const currBlockBuilder = queue.splice(0, 1)[0];
+            if (visitedBlockBuilders.has(currBlockBuilder)) {
+                continue;
+            }
+            visitedBlockBuilders.add(currBlockBuilder);
+            const childList = currBlockBuilder.nexts;
+            for (const child of childList) {
+                if (child !== endBlockBuilder) {
+                    queue.push(child);
+                }
+            }
+        }
+        const allTraps = [];
+        for (const blockBuilder of visitedBlockBuilders) {
+            if (this.blockBuildersBeforeTry.has(blockBuilder)) {
+                const { traps, headBlockBuilder } = this.buildTrapGroup(blockBuilder);
+                allTraps.push(...traps);
+                if (blockBuilder === startBlockBuilder && this.shouldRemoveEmptyBlockBeforeTry(blockBuilder)) {
+                    startBlockBuilder = headBlockBuilder;
+                }
+            }
+        }
+        return { traps: allTraps, newStartBlockBuilder: startBlockBuilder };
+    }
+    removeEmptyBlockBeforeTry(blockBuilderBeforeTry) {
+        if (!this.shouldRemoveEmptyBlockBeforeTry(blockBuilderBeforeTry)) {
+            return;
+        }
+        const headBlockBuilderWithinTry = blockBuilderBeforeTry.nexts[0];
+        const headBlockWithinTry = this.blockBuilderToCfgBlock.get(headBlockBuilderWithinTry);
+        headBlockWithinTry.getPredecessors().splice(0, 1);
+        const prevsOfBlockBuilderBeforeTry = blockBuilderBeforeTry.lasts;
+        for (const prevBlockBuilder of prevsOfBlockBuilderBeforeTry) {
+            const prevBlock = this.blockBuilderToCfgBlock.get(prevBlockBuilder);
+            for (let j = 0; j < prevBlockBuilder.nexts.length; j++) {
+                if (prevBlockBuilder.nexts[j] === blockBuilderBeforeTry) {
+                    prevBlockBuilder.nexts[j] = headBlockBuilderWithinTry;
+                    prevBlock.setSuccessorBlock(j, headBlockWithinTry);
+                    break;
+                }
+            }
+            headBlockWithinTry.addPredecessorBlock(prevBlock);
+        }
+        headBlockBuilderWithinTry.lasts.splice(0, 1, ...prevsOfBlockBuilderBeforeTry);
+        this.basicBlockSet.delete(this.blockBuilderToCfgBlock.get(blockBuilderBeforeTry));
+        this.blockBuilderToCfgBlock.delete(blockBuilderBeforeTry);
+    }
+    shouldRemoveEmptyBlockBeforeTry(blockBuilderBeforeTry) {
+        const stmtsCnt = blockBuilderBeforeTry.stmts.length;
+        // This BlockBuilder contains only one redundant TryStatementBuilder, so the BlockBuilder can be deleted.
+        return stmtsCnt === 1;
+    }
+    buildTrapsIfNoFinally(tryBfsBlocks, tryTailBlocks, catchBfsBlocks, // Two-dimensional array, each subarray represents a catch block group
+    catchTailBlocks, finallyBlockBuilder) {
+        if (catchBfsBlocks.length === 0) {
+            logger.error(`catch block expected.`);
+            return [];
+        }
+        const blockBuilderAfterFinally = finallyBlockBuilder.nexts[0];
+        let blockAfterFinally = this.blockBuilderToCfgBlock.get(blockBuilderAfterFinally);
+        if (!this.blockBuilderToCfgBlock.has(finallyBlockBuilder)) {
+            logger.error(`can't find basicBlock corresponding to the blockBuilder.`);
+            return [];
+        }
+        const finallyBlock = this.blockBuilderToCfgBlock.get(finallyBlockBuilder);
+        let dummyFinallyIdxInPredecessors = -1;
+        for (let i = 0; i < blockAfterFinally.getPredecessors().length; i++) {
+            if (blockAfterFinally.getPredecessors()[i] === finallyBlock) {
+                dummyFinallyIdxInPredecessors = i;
+                break;
+            }
+        }
+        if (dummyFinallyIdxInPredecessors === -1) {
+            logger.error(`Dummy finally block isn't a predecessor of block after finally block.`);
+            return [];
+        }
+        blockAfterFinally.getPredecessors().splice(dummyFinallyIdxInPredecessors, 1);
+        for (const tryTailBlock of tryTailBlocks) {
+            const finallyIndex = tryTailBlock.getSuccessors().findIndex(succ => succ === finallyBlock);
+            tryTailBlock.setSuccessorBlock(finallyIndex, blockAfterFinally);
+            blockAfterFinally.addPredecessorBlock(tryTailBlock);
+        }
+        this.basicBlockSet.delete(finallyBlock);
+        // 连接所有catch块组到finally后的块
+        for (let i = 0; i < catchBfsBlocks.length; i++) {
+            const catchBfsBlockGroup = catchBfsBlocks[i];
+            const catchTailBlockGroup = catchTailBlocks[i];
+            for (const catchTailBlock of catchTailBlockGroup) {
+                catchTailBlock.addSuccessorBlock(blockAfterFinally);
+                blockAfterFinally.addPredecessorBlock(catchTailBlock);
+            }
+            // 建立try到每个catch块组的异常连接
+            for (const tryTailBlock of tryTailBlocks) {
+                tryTailBlock.addExceptionalSuccessorBlock(catchBfsBlockGroup[0]);
+                catchBfsBlockGroup[0].addExceptionalPredecessorBlock(tryTailBlock);
+            }
+        }
+        // 创建一个Trap，包含一个try块和多个catch块组
+        return [new Trap_1.CxxTrap(tryBfsBlocks, catchBfsBlocks)];
+    }
+    getAllBlocksBFS(startBlockBuilder, endBlockBuilder) {
+        const bfsBlocks = [];
+        const tailBlocks = [];
+        const startBlock = this.blockBuilderToCfgBlock.get(startBlockBuilder);
+        const endBlock = endBlockBuilder ? this.blockBuilderToCfgBlock.get(endBlockBuilder) : undefined;
+        const queue = [];
+        const visitedBlocks = new Set();
+        queue.push(startBlock);
+        while (queue.length !== 0) {
+            const currBlock = queue.splice(0, 1)[0];
+            if (visitedBlocks.has(currBlock)) {
+                continue;
+            }
+            visitedBlocks.add(currBlock);
+            bfsBlocks.push(currBlock);
+            const successors = currBlock.getSuccessors();
+            if (successors.length !== 0) {
+                for (const successor of successors) {
+                    if (successor === endBlock) {
+                        tailBlocks.push(currBlock);
+                    }
+                    else {
+                        // A tail block's successor may be within the traversal range
+                        queue.push(successor);
+                    }
+                }
+            }
+            else {
+                tailBlocks.push(currBlock);
+            }
+        }
+        return { bfsBlocks, tailBlocks };
+    }
+}
+exports.CxxTrapBuilder = CxxTrapBuilder;

package/lib/frontend/cppFrontend/inference/CxxInference.d.ts

@@ -0,0 +1,10 @@
+import { InferenceBuilder } from '../../../core/inference/InferenceBuilder';
+import { ClassInference, FileInference, ImportInfoInference, MethodInference, StmtInference } from '../../../core/inference/ModelInference';
+export declare class CxxInferenceBuilder extends InferenceBuilder {
+    buildFileInference(): FileInference;
+    buildImportInfoInference(): ImportInfoInference;
+    buildClassInference(): ClassInference;
+    buildMethodInference(): MethodInference;
+    buildStmtInference(): StmtInference;
+}
+//# sourceMappingURL=CxxInference.d.ts.map

package/lib/frontend/cppFrontend/inference/CxxInference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CxxInference.d.ts","sourceRoot":"","sources":["../../../../src/frontend/cppFrontend/inference/CxxInference.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAC5E,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,mBAAmB,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAW5I,qBAAa,mBAAoB,SAAQ,gBAAgB;IAE9C,kBAAkB,IAAI,aAAa;IAInC,wBAAwB,IAAI,mBAAmB;IAI/C,mBAAmB,IAAI,cAAc;IAIrC,oBAAoB,IAAI,eAAe;IAIvC,kBAAkB,IAAI,aAAa;CAK7C"}

package/lib/frontend/cppFrontend/inference/CxxInference.js

@@ -0,0 +1,41 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CxxInferenceBuilder = void 0;
+const InferenceBuilder_1 = require("../../../core/inference/InferenceBuilder");
+const ValueInference_1 = require("../../../core/inference/ValueInference");
+const CxxValueInference_1 = require("./CxxValueInference");
+const CxxModelInference_1 = require("./CxxModelInference");
+class CxxInferenceBuilder extends InferenceBuilder_1.InferenceBuilder {
+    buildFileInference() {
+        return new CxxModelInference_1.CxxFileInference(this.buildImportInfoInference(), this.buildClassInference());
+    }
+    buildImportInfoInference() {
+        return new CxxModelInference_1.CxxImportInference();
+    }
+    buildClassInference() {
+        return new CxxModelInference_1.CxxClassInference(this.buildMethodInference());
+    }
+    buildMethodInference() {
+        return new CxxModelInference_1.CxxMethodInference(this.buildStmtInference());
+    }
+    buildStmtInference() {
+        const valueInferences = this.getValueInferences(ValueInference_1.InferLanguage.COMMON);
+        (0, CxxValueInference_1.getCxxValueInferences)().forEach(e => valueInferences.push(e));
+        return new CxxModelInference_1.CxxStmtInference(valueInferences);
+    }
+}
+exports.CxxInferenceBuilder = CxxInferenceBuilder;

package/lib/frontend/cppFrontend/inference/CxxModelInference.d.ts

@@ -0,0 +1,28 @@
+import { ClassInference, FileInference, ImportInfoInference, MethodInference, StmtInference } from '../../../core/inference/ModelInference';
+import { ArkFile } from '../../../core/model/ArkFile';
+import { ImportInfo } from '../../../core/model/ArkImport';
+import { ArkClass } from '../../../core/model/ArkClass';
+import { ArkMethod } from '../../../core/model/ArkMethod';
+import { ExportInfo } from '../../../core/model/ArkExport';
+import { ValueInference } from '../../../core/inference/ValueInference';
+import { Value } from '../../../core/base/Value';
+import { Stmt } from '../../../core/base/Stmt';
+export declare class CxxFileInference extends FileInference {
+    private preprocessedProjectName;
+    preInfer(file: ArkFile): void;
+}
+export declare class CxxImportInference extends ImportInfoInference {
+    preInfer(fromInfo: ImportInfo): void;
+    infer(fromInfo: ImportInfo): ExportInfo | null;
+}
+export declare class CxxClassInference extends ClassInference {
+    preInfer(arkClass: ArkClass): void;
+}
+export declare class CxxMethodInference extends MethodInference {
+    preInfer(arkMethod: ArkMethod): void;
+}
+export declare class CxxStmtInference extends StmtInference {
+    constructor(valueInferences: ValueInference<Value>[]);
+    typeSpread(stmt: Stmt, method: ArkMethod): Set<Stmt>;
+}
+//# sourceMappingURL=CxxModelInference.d.ts.map

package/lib/frontend/cppFrontend/inference/CxxModelInference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CxxModelInference.d.ts","sourceRoot":"","sources":["../../../../src/frontend/cppFrontend/inference/CxxModelInference.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,mBAAmB,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAC5I,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAEtD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAExD,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAE1D,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AACxE,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACjD,OAAO,EAA0B,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAEvE,qBAAa,gBAAiB,SAAQ,aAAa;IAC/C,OAAO,CAAC,uBAAuB,CAAc;IAEtC,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;CASvC;AAED,qBAAa,kBAAmB,SAAQ,mBAAmB;IAChD,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,IAAI;IAIpC,KAAK,CAAC,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,IAAI;CAGxD;AAED,qBAAa,iBAAkB,SAAQ,cAAc;IAC1C,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;CAY5C;AAED,qBAAa,kBAAmB,SAAQ,eAAe;IAC5C,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;CAiB9C;AAED,qBAAa,gBAAiB,SAAQ,aAAa;gBACnC,eAAe,EAAE,cAAc,CAAC,KAAK,CAAC,EAAE;IAI7C,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,GAAG,GAAG,CAAC,IAAI,CAAC;CAS9D"}

package/lib/frontend/cppFrontend/inference/CxxModelInference.js

@@ -0,0 +1,98 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CxxStmtInference = exports.CxxMethodInference = exports.CxxClassInference = exports.CxxImportInference = exports.CxxFileInference = void 0;
+const ModelInference_1 = require("../../../core/inference/ModelInference");
+const IRInference_1 = require("../common/IRInference");
+const ModelUtils_1 = require("../common/ModelUtils");
+const TypeInference_1 = require("../common/TypeInference");
+const Stmt_1 = require("../../../core/base/Stmt");
+class CxxFileInference extends ModelInference_1.FileInference {
+    constructor() {
+        super(...arguments);
+        this.preprocessedProjectName = '';
+    }
+    preInfer(file) {
+        const scene = file.getScene();
+        if (this.preprocessedProjectName !== scene.getProjectName()) {
+            IRInference_1.IRInference.mapCxxDeclAndImpl(scene);
+            this.preprocessedProjectName = scene.getProjectName();
+        }
+        file.getImportInfos().filter(i => i.getExportInfo() === undefined)
+            .forEach(info => this.importInfoInference.doInfer(info));
+    }
+}
+exports.CxxFileInference = CxxFileInference;
+class CxxImportInference extends ModelInference_1.ImportInfoInference {
+    preInfer(fromInfo) {
+        this.fromFile = (0, ModelUtils_1.getArkFile)(fromInfo) || null;
+    }
+    infer(fromInfo) {
+        return (0, ModelUtils_1.findExportInfo)(fromInfo, this.fromFile);
+    }
+}
+exports.CxxImportInference = CxxImportInference;
+class CxxClassInference extends ModelInference_1.ClassInference {
+    preInfer(arkClass) {
+        super.preInfer(arkClass);
+        TypeInference_1.TypeInference.inferGenericType(arkClass.getGenericsTypes(), arkClass);
+        arkClass.getFields()
+            .filter(p => TypeInference_1.TypeInference.isUnclearType(p.getType()))
+            .forEach(f => {
+            const newType = TypeInference_1.TypeInference.inferUnclearedType(f.getType(), arkClass);
+            if (newType) {
+                f.getSignature().setType(newType);
+            }
+        });
+    }
+}
+exports.CxxClassInference = CxxClassInference;
+class CxxMethodInference extends ModelInference_1.MethodInference {
+    preInfer(arkMethod) {
+        var _a;
+        TypeInference_1.TypeInference.inferGenericType(arkMethod.getGenericTypes(), arkMethod.getDeclaringArkClass());
+        const signatures = [];
+        (_a = arkMethod.getDeclareSignatures()) === null || _a === void 0 ? void 0 : _a.forEach(m => signatures.push(m));
+        const impl = arkMethod.getImplementationSignature();
+        if (impl) {
+            signatures.push(impl);
+        }
+        signatures.forEach(s => {
+            s.getMethodSubSignature()
+                .getParameters()
+                .forEach(p => {
+                TypeInference_1.TypeInference.inferParameterType(p, arkMethod);
+            });
+            TypeInference_1.TypeInference.inferSignatureReturnType(s, arkMethod);
+        });
+    }
+}
+exports.CxxMethodInference = CxxMethodInference;
+class CxxStmtInference extends ModelInference_1.StmtInference {
+    constructor(valueInferences) {
+        super(valueInferences);
+    }
+    typeSpread(stmt, method) {
+        if (stmt instanceof Stmt_1.ArkAliasTypeDefineStmt && TypeInference_1.TypeInference.isUnclearType(stmt.getAliasType().getOriginalType())) {
+            const originalType = stmt.getAliasTypeExpr().getOriginalType();
+            if (originalType) {
+                stmt.getAliasType().setOriginalType(originalType);
+            }
+        }
+        return super.typeSpread(stmt, method);
+    }
+}
+exports.CxxStmtInference = CxxStmtInference;

package/lib/frontend/cppFrontend/inference/CxxValueInference.d.ts

@@ -0,0 +1,20 @@
+import { ArkNewExpr, ArkInstanceInvokeExpr } from '../../../core/base/Expr';
+import { ArkInstanceFieldRef } from '../../../core/base/Ref';
+import { Stmt } from '../../../core/base/Stmt';
+import { Value } from '../../../core/base/Value';
+import { ValueInference, FieldRefInference, InstanceInvokeExprInference } from '../../../core/inference/ValueInference';
+export declare class CxxFieldRefInference extends FieldRefInference {
+    getValueName(): string;
+    infer(value: ArkInstanceFieldRef, stmt: Stmt): Value | undefined;
+}
+export declare class CxxInstanceInvokeExprInference extends InstanceInvokeExprInference {
+    preInfer(value: ArkInstanceInvokeExpr, stmt?: Stmt): boolean;
+    infer(value: ArkInstanceInvokeExpr, stmt: Stmt): Value | undefined;
+}
+export declare class CxxArkNewExprInference extends ValueInference<ArkNewExpr> {
+    getValueName(): string;
+    preInfer(value: ArkNewExpr): boolean;
+    infer(value: ArkNewExpr, stmt: Stmt): Value | undefined;
+}
+export declare function getCxxValueInferences(): ValueInference<Value>[];
+//# sourceMappingURL=CxxValueInference.d.ts.map

package/lib/frontend/cppFrontend/inference/CxxValueInference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CxxValueInference.d.ts","sourceRoot":"","sources":["../../../../src/frontend/cppFrontend/inference/CxxValueInference.ts"],"names":[],"mappings":"AAeA,OAAO,EAAuB,UAAU,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACjG,OAAO,EAAE,mBAAmB,EAAqB,MAAM,wBAAwB,CAAC;AAChF,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAE/C,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,2BAA2B,EAAE,MAAM,wCAAwC,CAAC;AAWxH,qBAAa,oBAAqB,SAAQ,iBAAiB;IAChD,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,KAAK,EAAE,mBAAmB,EAAE,IAAI,EAAE,IAAI,GAAG,KAAK,GAAG,SAAS;CAY1E;AAED,qBAAa,8BAA+B,SAAQ,2BAA2B;IACpE,QAAQ,CAAC,KAAK,EAAE,qBAAqB,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,OAAO;IAO5D,KAAK,CAAC,KAAK,EAAE,qBAAqB,EAAE,IAAI,EAAE,IAAI,GAAG,KAAK,GAAG,SAAS;CAwB5E;AAED,qBAAa,sBAAuB,SAAQ,cAAc,CAAC,UAAU,CAAC;IAC3D,YAAY,IAAI,MAAM;IAItB,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAIpC,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,GAAG,KAAK,GAAG,SAAS;CA4BjE;AAED,wBAAgB,qBAAqB,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE,CAM/D"}

package/lib/frontend/cppFrontend/inference/CxxValueInference.js

@@ -0,0 +1,128 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2026 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCxxValueInferences = exports.CxxArkNewExprInference = exports.CxxInstanceInvokeExprInference = exports.CxxFieldRefInference = void 0;
+const Expr_1 = require("../../../core/base/Expr");
+const Ref_1 = require("../../../core/base/Ref");
+const Type_1 = require("../../../core/base/Type");
+const ValueInference_1 = require("../../../core/inference/ValueInference");
+const ArkMethod_1 = require("../../../core/model/ArkMethod");
+const IRInference_1 = require("../../../core/common/IRInference");
+const ModelUtils_1 = require("../../../core/common/ModelUtils");
+const TypeInference_1 = require("../../../core/common/TypeInference");
+const Local_1 = require("../../../core/base/Local");
+const TypeInference_2 = require("../common/TypeInference");
+const IRInference_2 = require("../common/IRInference");
+const ModelUtils_2 = require("../common/ModelUtils");
+const Type_2 = require("../base/Type");
+class CxxFieldRefInference extends ValueInference_1.FieldRefInference {
+    getValueName() {
+        return 'ArkCxxInstanceFieldRef';
+    }
+    infer(value, stmt) {
+        const baseType = TypeInference_2.TypeInference.replaceAliasType(value.getBase().getType());
+        const arkMethod = stmt.getCfg().getDeclaringMethod();
+        const newFieldSignature = IRInference_2.IRInference.generateNewFieldSignature(value, arkMethod.getDeclaringArkClass(), baseType);
+        if (newFieldSignature) {
+            value.setFieldSignature(newFieldSignature);
+            if (newFieldSignature.isStatic()) {
+                return new Ref_1.ArkStaticFieldRef(newFieldSignature);
+            }
+        }
+        return undefined;
+    }
+}
+exports.CxxFieldRefInference = CxxFieldRefInference;
+class CxxInstanceInvokeExprInference extends ValueInference_1.InstanceInvokeExprInference {
+    preInfer(value, stmt) {
+        const needBySignature = value.getArgs().length !== value.getMethodSignature().getParamLength() ||
+            value.getMethodSignature().getMethodSubSignature().getParameterTypes().some(t => TypeInference_1.TypeInference.isUnclearType(t));
+        return needBySignature || super.preInfer(value, stmt);
+    }
+    infer(value, stmt) {
+        var _a;
+        const arkMethod = stmt.getCfg().getDeclaringMethod();
+        let baseType = value.getBase().getType();
+        if (baseType instanceof Type_2.PointerType || baseType instanceof Type_2.ReferenceType) {
+            baseType = baseType.getBaseType();
+        }
+        const methodName = this.getMethodName(value, arkMethod);
+        const result = (_a = ValueInference_1.InstanceInvokeExprInference.inferInvokeExpr(baseType, value, arkMethod)) !== null && _a !== void 0 ? _a : TypeInference_2.TypeInference.inferMethodFromImportNamespace(baseType, value, arkMethod, methodName);
+        if (!result && baseType instanceof Type_1.AnnotationNamespaceType) {
+            const namespace = arkMethod.getDeclaringArkFile().getScene().getNamespace(baseType.getNamespaceSignature());
+            if (namespace) {
+                const foundMethod = ModelUtils_2.CxxModelUtils.findPropertyInNamespace(methodName, namespace);
+                if (foundMethod instanceof ArkMethod_1.ArkMethod) {
+                    const signature = foundMethod.matchMethodSignature(value.getArgs());
+                    TypeInference_2.TypeInference.inferSignatureReturnType(signature, foundMethod);
+                    value.setMethodSignature(signature);
+                    return new Expr_1.ArkStaticInvokeExpr(signature, value.getArgs(), value.getRealGenericTypes());
+                }
+            }
+        }
+        return !result || result === value ? undefined : result;
+    }
+}
+exports.CxxInstanceInvokeExprInference = CxxInstanceInvokeExprInference;
+class CxxArkNewExprInference extends ValueInference_1.ValueInference {
+    getValueName() {
+        return 'ArkNewExpr';
+    }
+    preInfer(value) {
+        return IRInference_1.IRInference.needInfer(value.getClassType().getClassSignature().getDeclaringFileSignature());
+    }
+    infer(value, stmt) {
+        var _a;
+        const className = value.getClassType().getClassSignature().getClassName();
+        const arkMethod = stmt.getCfg().getDeclaringMethod();
+        let type = (_a = ModelUtils_1.ModelUtils.findDeclaredLocal(new Local_1.Local(className), arkMethod, 1)) === null || _a === void 0 ? void 0 : _a.getType();
+        if (TypeInference_1.TypeInference.isUnclearType(type)) {
+            type = TypeInference_2.TypeInference.inferUnclearRefName(className, arkMethod.getDeclaringArkClass());
+        }
+        if (type instanceof Type_1.AliasType) {
+            const originType = TypeInference_1.TypeInference.replaceAliasType(type);
+            if (originType instanceof Type_1.FunctionType) {
+                type = originType.getMethodSignature().getMethodSubSignature().getReturnType();
+            }
+            else if (originType instanceof Type_2.PointerType) {
+                const baseType = originType.getBaseType();
+                if (baseType instanceof Type_1.FunctionType) {
+                    type = baseType.getMethodSignature().getMethodSubSignature().getReturnType();
+                }
+                else {
+                    type = originType;
+                }
+            }
+            else {
+                type = originType;
+            }
+        }
+        if (type && type instanceof Type_1.ClassType) {
+            value.getClassType().setClassSignature(type.getClassSignature());
+            TypeInference_1.TypeInference.inferRealGenericTypes(value.getClassType().getRealGenericTypes(), arkMethod.getDeclaringArkClass());
+        }
+        return undefined;
+    }
+}
+exports.CxxArkNewExprInference = CxxArkNewExprInference;
+function getCxxValueInferences() {
+    return [
+        new CxxFieldRefInference(),
+        new CxxInstanceInvokeExprInference(),
+        new CxxArkNewExprInference(),
+    ];
+}
+exports.getCxxValueInferences = getCxxValueInferences;

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

@@ -0,0 +1,11 @@
+import { ArkFile } from '../../../../core/model/ArkFile';
+import { ArkMethod } from '../../../../core/model/ArkMethod';
+import { ArkNamespace } from '../../../../core/model/ArkNamespace';
+import { ArkClass } from '../../../../core/model/ArkClass';
+import { CxxAstNode } from '../../ast/ArkCxxAstNode';
+export declare function buildNormalArkClassFromArkMethod(clsNode: CxxAstNode, cls: ArkClass, sourceFile: CxxAstNode, declaring?: ArkMethod | ArkClass): void;
+export declare function buildNormalArkClassFromArkFile(clsNode: CxxAstNode, arkFile: ArkFile, cls: ArkClass, sourceFile: CxxAstNode, declaring?: ArkMethod | ArkClass): void;
+export declare function buildNormalArkClassFromArkNamespace(clsNode: CxxAstNode, arkNamespace: ArkNamespace, cls: ArkClass, sourceFile: CxxAstNode, declaring?: ArkMethod | ArkClass): void;
+export declare function buildNormalArkClass(clsNode: CxxAstNode, cls: ArkClass, sourceFile: CxxAstNode, declaring?: ArkMethod | ArkClass): void;
+export declare function buildDefaultArkClassFromArkFile(arkFile: ArkFile, defaultClass: ArkClass, astRoot: CxxAstNode): void;
+//# sourceMappingURL=ArkClassBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ArkClassBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/model/builder/ArkClassBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAEnE,OAAO,EAAE,QAAQ,EAAwC,MAAM,iCAAiC,CAAC;AAUjG,OAAO,EAAE,UAAU,EAA8C,MAAM,yBAAyB,CAAC;AAcjG,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,QAAQ,GAAG,IAAI,CAOnJ;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EACpD,UAAU,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,QAAQ,GAAG,IAAI,CAQ7G;AAED,wBAAgB,mCAAmC,CAC/C,OAAO,EAAE,UAAU,EACnB,YAAY,EAAE,YAAY,EAC1B,GAAG,EAAE,QAAQ,EACb,UAAU,EAAE,UAAU,EACtB,SAAS,CAAC,EAAE,SAAS,GAAG,QAAQ,GACjC,IAAI,CASN;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,QAAQ,GAAG,IAAI,CAwBtI;AA+PD,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CAInH"}