arkanalyzer 1.0.85 → 1.0.87

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

@@ -0,0 +1,285 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildArkClassFromCxxClass = exports.buildArkFileFromFile = exports.classMap = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ArkNamespace_1 = require("../../../../core/model/ArkNamespace");
+const ArkClassBuilder_1 = require("./ArkClassBuilder");
+const ArkMethodBuilder_1 = require("./ArkMethodBuilder");
+const ArkExportBuilder_1 = require("../../../../core/model/builder/ArkExportBuilder");
+const ArkNamespaceBuilder_1 = require("./ArkNamespaceBuilder");
+const ArkClass_1 = require("../../../../core/model/ArkClass");
+const ArkClassBuilder_2 = require("./ArkClassBuilder");
+const ArkMethod_1 = require("../../../../core/model/ArkMethod");
+const astUtils_1 = require("../../ast/astUtils");
+const ArkSignature_1 = require("../../../../core/model/ArkSignature");
+const Position_1 = require("../../../../core/base/Position");
+const ArkImportBuilder_1 = require("./ArkImportBuilder");
+const ModelUtils_1 = require("../../common/ModelUtils");
+const logger_1 = __importStar(require("../../../../utils/logger"));
+const ArkClassBuilder_3 = require("../../../../core/model/builder/ArkClassBuilder");
+const ArkCxxAstNode_1 = require("../../ast/ArkCxxAstNode");
+const ArkFieldBuilder_1 = require("./ArkFieldBuilder");
+const Const_1 = require("../../../../core/common/Const");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ArkFileBuilder');
+exports.classMap = new Map();
+function extractOhosSdkPath(mapData) {
+    for (const [key, value] of mapData.entries()) {
+        if (key !== 'ohosSdk') {
+            continue;
+        }
+        const sdkPath = Object.prototype.hasOwnProperty.call(value, 'path') ? value.path : '';
+        if (typeof sdkPath === 'string' && sdkPath) {
+            return sdkPath;
+        }
+    }
+    return '';
+}
+function findLLVMPath(inputPath) {
+    if (!inputPath || !inputPath.trim() || !path_1.default.isAbsolute(inputPath)) {
+        return '';
+    }
+    const normalized = path_1.default.normalize(inputPath);
+    const parts = normalized.split(path_1.default.sep);
+    const devEcoIndex = parts.findIndex(p => p.trim() === 'DevEco Studio');
+    if (devEcoIndex === -1) {
+        return '';
+    }
+    const basePath = path_1.default.join(...parts.slice(0, devEcoIndex + 1));
+    // Prioritize finding LLVM path in environment variables
+    const envPathList = (process.env.PATH || '').split(';');
+    const llvmEnvPath = envPathList.find(p => p.includes('clang+llvm-19.1.7-x86_64-pc-windows-msvc') && fs_1.default.existsSync(p)) || '';
+    const llvmBinCandidates = [
+        llvmEnvPath,
+        path_1.default.join(basePath, 'sdk', 'default', 'openharmony', 'native', 'clang+llvm-19.1.7-x86_64-pc-windows-msvc', 'bin'),
+        path_1.default.join(basePath, 'sdk', 'default', 'openharmony', 'native', 'llvm', 'bin'),
+    ];
+    for (const candidate of llvmBinCandidates) {
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return '';
+}
+/**
+ * Entry of building ArkFile instance
+ *
+ * @param absoluteFilePath
+ * @param projectDir
+ * @param arkFile
+ * @param projectName
+ * @param includeDirs
+ * @returns
+ */
+function buildArkFileFromFile(absoluteFilePath, projectDir, arkFile, projectName, includeDirs = []) {
+    let scene = arkFile.getScene();
+    arkFile.setFilePath(absoluteFilePath);
+    arkFile.setProjectDir(projectDir);
+    const fileSignature = new ArkSignature_1.FileSignature(projectName, path_1.default.relative(projectDir, absoluteFilePath));
+    arkFile.setFileSignature(fileSignature);
+    arkFile.setCode(fs_1.default.readFileSync(arkFile.getFilePath(), 'utf8'));
+    let sdkPath = extractOhosSdkPath(arkFile.getScene().getProjectSdkMap());
+    let llvmPath = findLLVMPath(sdkPath);
+    const jsonObject = astUtils_1.AstUtils.parse(absoluteFilePath, scene.getCcjsonPath(), includeDirs, llvmPath, scene.getCppAstPath());
+    genDefaultArkClass(arkFile, jsonObject);
+    buildArkFile(arkFile, jsonObject);
+}
+exports.buildArkFileFromFile = buildArkFileFromFile;
+function buildArkClassFromCxxClass(classNode, arkFile, astRoot) {
+    let cls = new ArkClass_1.ArkClass();
+    if (classNode.kind === 'ClassTemplateDecl') {
+        classNode.tagUsed = classNode.tagUsed ? classNode.tagUsed : 'class';
+    }
+    (0, ArkClassBuilder_1.buildNormalArkClassFromArkFile)(classNode, arkFile, cls, astRoot);
+    addExportInfoOnCondition(classNode, cls, arkFile);
+    if (classNode.id) {
+        exports.classMap.set(classNode.id, cls);
+    }
+}
+exports.buildArkClassFromCxxClass = buildArkClassFromCxxClass;
+/**
+ * Building import info from inclusion directive (just like: #include '../xxx.h')
+ *
+ * @param includeInfo Info of inclusion
+ * @param includeNode Ast node of inclusion
+ * @param astRoot Ast node of translate unit file
+ * @param arkFile ArkFile of translate unit file
+ * @returns
+ */
+function buildImportInfoFromInclude(includeInfo, includeNode, astRoot, arkFile) {
+    let importInfo = (0, ArkImportBuilder_1.buildGenericImportInfo)(includeInfo, includeNode, astRoot, arkFile);
+    if (!importInfo) {
+        return;
+    }
+    importInfo.setDeclaringArkFile(arkFile);
+    if ((0, ModelUtils_1.shouldAddCxxHeaderImport)(importInfo)) {
+        arkFile.addImportInfo(importInfo);
+    }
+}
+/**
+ * Building import info from using namespace declaration (just like: using namespace xxx)
+ *
+ * @param usingNode Ast node of using declaration
+ * @param astRoot Ast node of translate unit file
+ * @param arkFile ArkFile of translate unit file
+ * @returns
+ */
+function buildImportInfoFromUsing(usingNode, astRoot, arkFile) {
+    let importInfo = (0, ArkImportBuilder_1.buildUsingNamespaceImportInfo)(usingNode, astRoot, arkFile);
+    if (!importInfo) {
+        return;
+    }
+    importInfo.setDeclaringArkFile(arkFile);
+    if ((0, ModelUtils_1.shouldAddCxxHeaderImport)(importInfo)) {
+        arkFile.addImportInfo(importInfo);
+    }
+}
+function addExportInfoOnCondition(currNode, arkInstance, arkFile) {
+    var _a, _b;
+    if ((_b = (_a = currNode.loc) === null || _a === void 0 ? void 0 : _a.file) === null || _b === void 0 ? void 0 : _b.endsWith('.h')) {
+        arkFile.addExportInfo((0, ArkExportBuilder_1.buildExportInfo)(arkInstance, arkFile, Position_1.LineColPosition.cxxBuildFromNode(currNode)));
+    }
+}
+function buildArkMethodFromCxxMethod(mtdNode, arkFile, astRoot, arkClass) {
+    let mtd = new ArkMethod_1.ArkMethod();
+    (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(mtdNode, arkClass !== null && arkClass !== void 0 ? arkClass : arkFile.getDefaultClass(), mtd, astRoot);
+    addExportInfoOnCondition(mtdNode, mtd, arkFile);
+}
+/**
+ * Building ArkFile instance
+ *
+ * @param arkFile
+ * @param astRoot
+ * @returns
+ */
+function buildArkFile(arkFile, astRoot) {
+    var _a, _b;
+    // handle header units
+    (_a = astRoot.headerUnits) === null || _a === void 0 ? void 0 : _a.forEach((child) => {
+        var _a;
+        if (!child.includes) {
+            return;
+        }
+        for (const includeInfo of child.includes) {
+            if (includeInfo.kind !== 'InclusionDirective') {
+                logger.trace('Unprocess kind of header unit: ', (_a = includeInfo.kind) !== null && _a !== void 0 ? _a : includeInfo.code);
+                continue;
+            }
+            buildImportInfoFromInclude(includeInfo, child, astRoot, arkFile);
+        }
+    });
+    // handle non-header unit
+    const statements = (_b = astRoot.inner) !== null && _b !== void 0 ? _b : [];
+    statements.forEach((child) => {
+        var _a;
+        let childKind = child.kind;
+        switch (childKind) {
+            // 'RecordDecl' ---C Language (struct/class/union)
+            // 'CXXRecordDecl' ---C++ Language (struct/class/union)
+            case ArkCxxAstNode_1.astKind.RecordDecl:
+            case ArkCxxAstNode_1.astKind.CXXRecordDecl:
+            case ArkCxxAstNode_1.astKind.ClassTemplateDecl:
+                buildArkClassFromCxxClass(child, arkFile, astRoot);
+                break;
+            case ArkCxxAstNode_1.astKind.FunctionDecl:
+            case ArkCxxAstNode_1.astKind.FriendDecl:
+            case ArkCxxAstNode_1.astKind.FunctionTemplateDecl:
+                buildArkMethodFromCxxMethod(child, arkFile, astRoot);
+                break;
+            case ArkCxxAstNode_1.astKind.NamespaceDecl:
+                let ns = new ArkNamespace_1.ArkNamespace();
+                ns.setDeclaringArkFile(arkFile);
+                (0, ArkNamespaceBuilder_1.buildArkNamespace)(child, arkFile, ns, astRoot);
+                arkFile.addNamespace(ns);
+                addExportInfoOnCondition(child, ns, arkFile);
+                break;
+            case ArkCxxAstNode_1.astKind.CXXMethodDecl:
+            case ArkCxxAstNode_1.astKind.CXXConstructorDecl:
+            case ArkCxxAstNode_1.astKind.CXXDestructorDecl:
+                // Member function, construction and destructor need to establish the function class first
+                const arkClass = getDeclaringArkClassOfMethod(child, arkFile);
+                buildArkMethodFromCxxMethod(child, arkFile, astRoot, arkClass);
+                break;
+            case ArkCxxAstNode_1.astKind.EnumDecl:
+                child = Object.assign(Object.assign({}, child), { tagUsed: 'enum' });
+                buildArkClassFromCxxClass(child, arkFile, astRoot);
+                break;
+            case ArkCxxAstNode_1.astKind.UsingDirectiveDecl:
+                buildImportInfoFromUsing(child, astRoot, arkFile);
+                break;
+            case ArkCxxAstNode_1.astKind.VarDecl:
+                // handle global variable
+                child.mangledName = Const_1.DEFAULT_ARK_CLASS_NAME;
+                const arkDefaultClass = getDeclaringArkClassOfMethod(child, arkFile);
+                (0, ArkFieldBuilder_1.buildProperty2ArkField)(child, astRoot, arkDefaultClass);
+                break;
+            case ArkCxxAstNode_1.astKind.LinkageSpecDecl:
+                buildArkFile(arkFile, child);
+            default:
+                logger.trace('Child joined default method of arkFile: ', (_a = child.kind) !== null && _a !== void 0 ? _a : child.code);
+                break;
+        }
+    });
+}
+// Get ArkClass of 'CXXMethodDecl'/'CXXConstructorDecl'/'CXXDestructorDecl'
+function getDeclaringArkClassOfMethod(mtd, arkFile) {
+    var _a;
+    const className = (_a = mtd.mangledName) !== null && _a !== void 0 ? _a : '';
+    let arkClass = arkFile.getClasses().find(arkClass => arkClass.getName() === className);
+    if (!arkClass) {
+        arkClass = new ArkClass_1.ArkClass();
+        const classSignature = new ArkSignature_1.ClassSignature(className, arkFile.getFileSignature());
+        arkClass.setSignature(classSignature);
+        arkClass.setDeclaringArkFile(arkFile);
+        arkFile.addArkClass(arkClass);
+        (0, ArkClassBuilder_3.init4InstanceInitMethod)(arkClass);
+        (0, ArkClassBuilder_3.init4StaticInitMethod)(arkClass);
+    }
+    return arkClass;
+}
+function genDefaultArkClass(arkFile, astRoot) {
+    let defaultClass = new ArkClass_1.ArkClass();
+    (0, ArkClassBuilder_2.buildDefaultArkClassFromArkFile)(arkFile, defaultClass, astRoot);
+    arkFile.setDefaultClass(defaultClass);
+    arkFile.addArkClass(defaultClass);
+}

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

@@ -0,0 +1,6 @@
+import { ImportInfo } from '../../../../core/model/ArkImport';
+import { ArkFile } from '../../../../core/model/ArkFile';
+import { CxxAstNode, CxxIncludeInfo } from '../../ast/ArkCxxAstNode';
+export declare function buildGenericImportInfo(includeInfo: CxxIncludeInfo, includeNode: CxxAstNode, sourceFile: CxxAstNode, arkFile: ArkFile): ImportInfo;
+export declare function buildUsingNamespaceImportInfo(node: CxxAstNode, sourceFile: CxxAstNode, arkFile: ArkFile): ImportInfo | null;
+//# sourceMappingURL=ArkImportBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ArkImportBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/model/builder/ArkImportBuilder.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAE9D,OAAO,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAEzD,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAGrE,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,cAAc,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,UAAU,CAWjJ;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI,CAmB3H"}

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

@@ -0,0 +1,57 @@
+"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.buildUsingNamespaceImportInfo = exports.buildGenericImportInfo = void 0;
+const Position_1 = require("../../../../core/base/Position");
+const ArkImport_1 = require("../../../../core/model/ArkImport");
+const IRUtils_1 = require("../../common/IRUtils");
+const path_1 = require("path");
+const ArkExportBuilder_1 = require("../../../../core/model/builder/ArkExportBuilder");
+function buildGenericImportInfo(includeInfo, includeNode, sourceFile, arkFile) {
+    var _a, _b;
+    const originTsPosition = Position_1.LineColPosition.cxxBuildFromNode(includeNode);
+    const tsSourceCode = includeInfo.code;
+    const importFrom = (0, path_1.normalize)((_b = (_a = includeInfo.fileName) !== null && _a !== void 0 ? _a : includeInfo.includeName) !== null && _b !== void 0 ? _b : '');
+    let importClauseName = `#include "${includeInfo.includeName}"`;
+    let importType = '';
+    let importInfo = new ArkImport_1.ImportInfo();
+    importInfo.build(importClauseName, importType, importFrom, originTsPosition, 0);
+    importInfo.setTsSourceCode(tsSourceCode);
+    IRUtils_1.IRUtils.setComments(importInfo, includeNode, sourceFile, arkFile.getScene().getOptions());
+    return importInfo;
+}
+exports.buildGenericImportInfo = buildGenericImportInfo;
+function buildUsingNamespaceImportInfo(node, sourceFile, arkFile) {
+    const originTsPosition = Position_1.LineColPosition.cxxBuildFromNode(node);
+    if (!node.nominatedNamespace) {
+        return null;
+    }
+    const importClauseName = node.nominatedNamespace.name;
+    const sourceCode = `using namespace ${importClauseName}`;
+    const importFrom = '';
+    let importType = 'NamespaceImport';
+    let importInfo = new ArkImport_1.ImportInfo();
+    importInfo.build(importClauseName, importType, importFrom, originTsPosition, 0);
+    importInfo.setTsSourceCode(sourceCode);
+    IRUtils_1.IRUtils.setComments(importInfo, node, sourceFile, arkFile.getScene().getOptions());
+    // scenario in cpp file: namespace xxx { Func() {} }; using namespace xxx;
+    const namespaceInCpp = arkFile.getNamespaceWithName(importClauseName);
+    if (namespaceInCpp) {
+        importInfo.setExportInfo((0, ArkExportBuilder_1.buildExportInfo)(namespaceInCpp, arkFile, new Position_1.LineColPosition(namespaceInCpp.getLine(), namespaceInCpp.getColumn())));
+    }
+    return importInfo;
+}
+exports.buildUsingNamespaceImportInfo = buildUsingNamespaceImportInfo;

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

@@ -0,0 +1,14 @@
+import { ArkClass } from '../../../../core/model/ArkClass';
+import { ArkMethod } from '../../../../core/model/ArkMethod';
+import { Stmt } from '../../../../core/base/Stmt';
+import { Local } from '../../../../core/base/Local';
+import { CxxAstNode } from '../../ast/ArkCxxAstNode';
+export declare function buildDefaultArkMethodFromArkClass(declaringClass: ArkClass, mtd: ArkMethod, sourceFile: CxxAstNode, node?: CxxAstNode): void;
+export declare function handleFunctionTemplateDecl(methodNode: CxxAstNode, mtd: ArkMethod, sourceFile: CxxAstNode): void;
+export declare function buildArkMethodFromArkClass(methodNode: CxxAstNode, declaringClass: ArkClass, mtd: ArkMethod, sourceFile: CxxAstNode, declaringMethod?: ArkMethod): void;
+export declare function recursivelyCheckAndBuildSuperConstructor(arkClass: ArkClass): void;
+export declare function buildDefaultConstructor(arkClass: ArkClass): boolean;
+export declare function buildInitMethod(initMethod: ArkMethod, fieldInitializerStmts: Stmt[], thisLocal: Local): void;
+export declare function addInitInConstructor(constructor: ArkMethod): void;
+export declare function isMethodImplementation(node: CxxAstNode): boolean;
+//# sourceMappingURL=ArkMethodBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ArkMethodBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/model/builder/ArkMethodBuilder.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAa7D,OAAO,EAAkE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAElH,OAAO,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAcpD,OAAO,EAAE,UAAU,EAA0B,MAAM,yBAAyB,CAAC;AA0B7E,wBAAgB,iCAAiC,CAAC,cAAc,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,CAY3I;AAED,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI,CA0B/G;AAED,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,EAChE,UAAU,EAAE,UAAU,EAAE,eAAe,CAAC,EAAE,SAAS,GAAG,IAAI,CAiDpG;AAyHD,wBAAgB,wCAAwC,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAWjF;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAuDnE;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,SAAS,EAAE,qBAAqB,EAAE,IAAI,EAAE,EAAE,SAAS,EAAE,KAAK,GAAG,IAAI,CAuB5G;AAED,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,SAAS,GAAG,IAAI,CAmCjE;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAkBhE"}