arkanalyzer 1.0.86 → 1.0.88

package/lib/frontend/cppFrontend/ast/astJsonNapi/napiRunner.js

@@ -0,0 +1,183 @@
+"use strict";
+/*
+ * Copyright (c) 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.
+ */
+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.runAstJsonArgv = void 0;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const logger_1 = __importStar(require("../../../../utils/logger"));
+const astUtils_1 = require("../astUtils");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'astJsonDumper');
+let selectedRunArgv = null;
+function startNewAstJsonWorker(addonAbsolutePath, onExit) {
+    var _a, _b;
+    const workerPath = path.join(__dirname, 'napiWorker.cjs');
+    const proc = (0, node_child_process_1.fork)(workerPath, [addonAbsolutePath], {
+        serialization: 'advanced',
+        stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+    });
+    (_a = proc.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (chunk) => {
+        const text = chunk.toString();
+        if (text.trim().length > 0) {
+            logger.info(`[Debug] astJsonDumper worker stdout:\n${text}`);
+        }
+    });
+    (_b = proc.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (chunk) => {
+        const text = chunk.toString();
+        if (text.trim().length > 0) {
+            logger.error(`[Debug] astJsonDumper worker stderr:\n${text}`);
+        }
+    });
+    proc.on('exit', (code, signal) => {
+        onExit(proc, code, signal);
+    });
+    return proc;
+}
+function awaitWorkerArgvReply(proc, workerStillCurrent, disposeOnSendFail, context, argv) {
+    const state = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 2));
+    try {
+        proc.send({
+            type: 'run',
+            argv,
+            cwd: context.cwd,
+            envPath: context.env.PATH,
+            state: state.buffer,
+        });
+    }
+    catch (error) {
+        logger.error('[Debug] Failed to send astJsonDumper request to worker:', error);
+        disposeOnSendFail(proc);
+        return -1;
+    }
+    while (Atomics.load(state, 0) === 0) {
+        Atomics.wait(state, 0, 0, 1000);
+        if (!workerStillCurrent() || proc.exitCode !== null || proc.killed) {
+            logger.error('[Debug] astJsonDumper worker exited before replying.');
+            return -1;
+        }
+    }
+    return Atomics.load(state, 1);
+}
+function createPersistentWorkerRunner(addonAbsolutePath) {
+    let worker = null;
+    const disposeWorker = (proc) => {
+        if (worker === proc) {
+            worker = null;
+        }
+        if (proc.exitCode === null && !proc.killed) {
+            proc.kill();
+        }
+    };
+    const ensureWorker = () => {
+        if (worker && worker.exitCode === null && !worker.killed) {
+            return worker;
+        }
+        const proc = startNewAstJsonWorker(addonAbsolutePath, (exitedProc, code, signal) => {
+            if (worker === exitedProc) {
+                worker = null;
+            }
+            logger.warn(`[Debug] astJsonDumper worker exited (code=${code}, signal=${signal}).`);
+        });
+        worker = proc;
+        return proc;
+    };
+    return (context, ...argv) => {
+        const proc = ensureWorker();
+        return awaitWorkerArgvReply(proc, () => worker === proc, disposeWorker, context, argv);
+    };
+}
+function logSpawnSyncFailure(result) {
+    if (result.stdout) {
+        logger.error(`[Debug] child stdout:\n${result.stdout}`);
+    }
+    if (result.stderr) {
+        logger.error(`[Debug] child stderr:\n${result.stderr}`);
+    }
+    logger.error(`[Debug] astJsonDumper child exited with code ${result.status}`);
+    return -1;
+}
+function runArgvInSubprocess(context, ...argv) {
+    const addonPath = (0, astUtils_1.getAstJsonDumperNodePath)();
+    const childScript = 'const addon = require(process.argv[1]); ' +
+        'const rc = addon.runArgv(process.argv.slice(2)); ' +
+        "process.exitCode = typeof rc === 'number' ? rc : 1;";
+    const quoted = ['-e', childScript, addonPath, ...argv]
+        .map((arg) => (arg.includes(' ') ? `"${arg}"` : arg))
+        .join(' ');
+    logger.info('================================================================');
+    logger.info(`[Debug] CWD: ${context.cwd}`);
+    logger.info(`[Debug] astJsonDumper.node: ${addonPath}`);
+    logger.info(`[Debug] CMD: "${process.execPath}" ${quoted}`);
+    logger.info('================================================================');
+    if (!fs.existsSync(addonPath)) {
+        logger.error(`[Debug] Missing addon: ${addonPath}`);
+        return -1;
+    }
+    const result = (0, node_child_process_1.spawnSync)(process.execPath, ['-e', childScript, addonPath, ...argv], {
+        stdio: ['inherit', 'pipe', 'pipe'],
+        encoding: 'utf-8',
+        env: context.env,
+        cwd: context.cwd,
+    });
+    if (result.status !== 0) {
+        return logSpawnSyncFailure(result);
+    }
+    return 0;
+}
+function shouldIsolateRuns() {
+    if (process.env.ARKANALYZER_AST_JSON_SUBPROCESS === '1') {
+        return true;
+    }
+    if (process.env.ARKANALYZER_AST_JSON_SUBPROCESS === '0') {
+        return false;
+    }
+    return process.env.VITEST === 'true';
+}
+function getRunArgv() {
+    if (!selectedRunArgv) {
+        selectedRunArgv = shouldIsolateRuns()
+            ? runArgvInSubprocess
+            : createPersistentWorkerRunner((0, astUtils_1.getAstJsonDumperNodePath)());
+    }
+    return selectedRunArgv;
+}
+function runAstJsonArgv(argv, context) {
+    return getRunArgv()(context, ...argv);
+}
+exports.runAstJsonArgv = runAstJsonArgv;

package/lib/frontend/cppFrontend/ast/astParser.d.ts

@@ -0,0 +1,25 @@
+import { CxxAstNode, CxxAstNodeLite } from './ArkCxxAstNode';
+export type GetParentFn = {
+    (isNeedInner: true): CxxAstNode;
+    (isNeedInner?: false): CxxAstNodeLite;
+};
+export declare class AstParser {
+    private static currentAccess;
+    private static deleteFileSync;
+    static parse(sourceFile: string, ccJsonPath: string | null, includeDirs: string[] | null, llvmPath: string, cppAstPath: string): CxxAstNode;
+    private static resolveProjectRoot;
+    private static getWorkingDir;
+    private static processAstFile;
+    private static createEmptyNode;
+    private static updateInner;
+    private static filter;
+    private static filterChildren;
+    private static makeGetParent;
+    private static fullInfo;
+    private static processAccess;
+    private static getCodeForExtractModifiers;
+    private static stripFucntionParams;
+    private static getAstOutputPath;
+    private static ensureOutputDir;
+}
+//# sourceMappingURL=astParser.d.ts.map

package/lib/frontend/cppFrontend/ast/astParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astParser.d.ts","sourceRoot":"","sources":["../../../../src/frontend/cppFrontend/ast/astParser.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAW,UAAU,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAMtE,MAAM,MAAM,WAAW,GAAG;IACtB,CAAC,WAAW,EAAE,IAAI,GAAG,UAAU,CAAC;IAChC,CAAC,WAAW,CAAC,EAAE,KAAK,GAAG,cAAc,CAAC;CACzC,CAAC;AAEF,qBAAa,SAAS;IAClB,OAAO,CAAC,MAAM,CAAC,aAAa,CAAc;IAE1C,OAAO,CAAC,MAAM,CAAC,cAAc;WAQf,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,UAAU;IA4BlJ,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAoBjC,OAAO,CAAC,MAAM,CAAC,aAAa;IAa5B,OAAO,CAAC,MAAM,CAAC,cAAc;IAqB7B,OAAO,CAAC,MAAM,CAAC,eAAe;IAI9B,OAAO,CAAC,MAAM,CAAC,WAAW;IAY1B,OAAO,CAAC,MAAM,CAAC,MAAM;IAYrB,OAAO,CAAC,MAAM,CAAC,cAAc;IAO7B,OAAO,CAAC,MAAM,CAAC,aAAa;IAa5B,OAAO,CAAC,MAAM,CAAC,QAAQ;IA8BvB,OAAO,CAAC,MAAM,CAAC,aAAa;IAgB5B,OAAO,CAAC,MAAM,CAAC,0BAA0B;IAUzC,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAyBlC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAQ/B,OAAO,CAAC,MAAM,CAAC,eAAe;CAKjC"}

package/lib/frontend/cppFrontend/ast/astParser.js

@@ -0,0 +1,280 @@
+"use strict";
+/*
+ * Copyright (c) 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.
+ */
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstParser = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = __importStar(require("../../../utils/logger"));
+const ArkCxxAstNode_1 = require("./ArkCxxAstNode");
+const napiApi_1 = require("./astJsonNapi/napiApi");
+const astUtils_1 = require("./astUtils");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'astParser');
+class AstParser {
+    static deleteFileSync(filePath) {
+        try {
+            fs.unlinkSync(filePath);
+        }
+        catch (_a) {
+            logger.warn('delete file failed:', filePath);
+        }
+    }
+    static parse(sourceFile, ccJsonPath, includeDirs, llvmPath, cppAstPath) {
+        logger.info(`[Debug] Parsing File: ${sourceFile}`);
+        if (!fs.existsSync(sourceFile)) {
+            logger.warn('parse file is not exists');
+            return this.createEmptyNode();
+        }
+        const rawAstPath = this.getAstOutputPath(sourceFile, cppAstPath);
+        const astPath = path.resolve(rawAstPath);
+        this.ensureOutputDir(path.dirname(astPath));
+        const workingDir = this.getWorkingDir(ccJsonPath);
+        const finalIncludeDirs = includeDirs ? [...includeDirs] : [];
+        const projectRoot = this.resolveProjectRoot(sourceFile);
+        if (projectRoot && !finalIncludeDirs.includes(projectRoot)) {
+            finalIncludeDirs.push(projectRoot);
+        }
+        const status = (0, napiApi_1.dumpAstJson)({
+            sourceFile,
+            outputFile: astPath,
+            ccJsonPath: ccJsonPath !== null && ccJsonPath !== void 0 ? ccJsonPath : undefined,
+            includeDirs: finalIncludeDirs,
+        }, workingDir, llvmPath);
+        return this.processAstFile(astPath, sourceFile, status);
+    }
+    static resolveProjectRoot(sourceFile) {
+        try {
+            let currentDir = path.dirname(sourceFile);
+            for (let i = 0; i < 10; i++) {
+                if (path.dirname(currentDir) === currentDir) {
+                    break;
+                }
+                if (path.basename(currentDir) === 'cpp' && path.basename(path.dirname(currentDir)) === 'main') {
+                    const absRoot = path.resolve(currentDir);
+                    logger.info(`[Debug] Found Source Root: ${absRoot}`);
+                    return absRoot;
+                }
+                currentDir = path.dirname(currentDir);
+            }
+        }
+        catch (e) {
+            logger.error('[Debug] Error finding source root:', e);
+        }
+        return null;
+    }
+    static getWorkingDir(ccJsonPath) {
+        let workingDir = process.cwd();
+        if (ccJsonPath && fs.existsSync(ccJsonPath)) {
+            const stats = fs.statSync(ccJsonPath);
+            if (stats.isFile()) {
+                workingDir = path.dirname(ccJsonPath);
+            }
+            else {
+                workingDir = ccJsonPath;
+            }
+        }
+        return workingDir;
+    }
+    static processAstFile(astPath, sourceFile, status) {
+        try {
+            if (!fs.existsSync(astPath)) {
+                logger.error(`[Debug] AST file missing at: ${astPath}`);
+                return this.createEmptyNode();
+            }
+            const content = fs.readFileSync(astPath, 'utf-8');
+            if (!content || content.trim() === '') {
+                return this.createEmptyNode();
+            }
+            let tu = JSON.parse(content);
+            tu = this.filter(sourceFile, tu);
+            return tu;
+        }
+        catch (e) {
+            logger.error('Failed to parse AST json:', e);
+            return this.createEmptyNode();
+        }
+        finally {
+            this.deleteFileSync(astPath);
+        }
+    }
+    static createEmptyNode() {
+        return { kind: '', name: '', code: '', type: { qualType: '' }, inner: [] };
+    }
+    static updateInner(sourceFile, entry, newInner) {
+        if (entry.isImplicit) {
+            return;
+        }
+        const loc = entry.loc;
+        if (!loc) {
+            logger.warn('Node skipped due to missing "locFile", kind of node: ', entry.kind);
+            return;
+        }
+        newInner.push(entry);
+    }
+    static filter(sourceFile, translationUnit) {
+        const newInner = [];
+        for (const entry of translationUnit.inner) {
+            this.updateInner(sourceFile, entry, newInner);
+        }
+        translationUnit.inner = newInner;
+        translationUnit.fileName = sourceFile;
+        translationUnit.projectName = path.dirname(sourceFile);
+        this.fullInfo(translationUnit);
+        return translationUnit;
+    }
+    static filterChildren(cursor) {
+        if (!cursor.inner) {
+            return [];
+        }
+        return cursor.inner.filter((item) => !item.isImplicit);
+    }
+    static makeGetParent(cursor) {
+        function getParent(isNeedInner) {
+            if (isNeedInner) {
+                return Object.assign({}, cursor);
+            }
+            const { inner } = cursor, rest = __rest(cursor, ["inner"]);
+            return rest;
+        }
+        return getParent;
+    }
+    static fullInfo(cursor) {
+        if (!cursor.inner) {
+            cursor.inner = [];
+        }
+        cursor.inner = this.filterChildren(cursor);
+        if (cursor.name === undefined) {
+            cursor.name = '';
+        }
+        if (cursor.kind === 'LambdaExpr') {
+            this.processAccess(cursor);
+        }
+        if (cursor.kind === ArkCxxAstNode_1.astKind.CXXRecordDecl && cursor.tagUsed === 'class') {
+            this.currentAccess = 'private';
+        }
+        else if (cursor.kind === ArkCxxAstNode_1.astKind.CXXRecordDecl && cursor.tagUsed === 'struct') {
+            this.currentAccess = 'public';
+        }
+        else {
+            this.currentAccess = '';
+        }
+        for (const currentCursor of cursor.inner) {
+            Object.assign(currentCursor, { getParent: this.makeGetParent(cursor) });
+            if (cursor.kind === ArkCxxAstNode_1.astKind.CXXRecordDecl || cursor.kind === ArkCxxAstNode_1.astKind.CXXMethodDecl || cursor.kind === ArkCxxAstNode_1.astKind.FunctionDecl) {
+                this.processAccess(currentCursor);
+            }
+            this.fullInfo(currentCursor);
+        }
+    }
+    static processAccess(cursor) {
+        var _a, _b;
+        cursor.modifiers = [];
+        if (cursor.kind === 'AccessSpecDecl') {
+            this.currentAccess = (_b = (_a = cursor.access) !== null && _a !== void 0 ? _a : (0, astUtils_1.extractAllCppModifiers)(cursor.code)[0]) !== null && _b !== void 0 ? _b : '';
+        }
+        else {
+            const extractedCode = this.getCodeForExtractModifiers(cursor);
+            const codeModifier = (0, astUtils_1.extractAllCppModifiers)(extractedCode);
+            if (this.currentAccess !== '') {
+                cursor.modifiers.push(this.currentAccess);
+            }
+            if (codeModifier !== null) {
+                cursor.modifiers.push(...codeModifier);
+            }
+        }
+    }
+    static getCodeForExtractModifiers(cursor) {
+        const extractedCode = cursor.code;
+        if (!['CXXConstructorDecl', 'CXXDestructorDecl', 'CXXMethodDecl', 'FriendDecl', 'FunctionDecl', 'FunctionTemplateDecl'].includes(cursor.kind)) {
+            return extractedCode;
+        }
+        const bodyNode = cursor.inner.filter((inner) => inner.kind === 'CompoundStmt');
+        const bodyCode = bodyNode.length === 0 ? '' : bodyNode[0].code;
+        return this.stripFucntionParams(extractedCode.replace(bodyCode, ''));
+    }
+    static stripFucntionParams(code) {
+        let depth = 0;
+        let start = -1;
+        let end = -1;
+        for (let i = 0; i < code.length; i++) {
+            const ch = code[i];
+            if (ch === '(') {
+                if (depth === 0) {
+                    start = i;
+                }
+                depth++;
+            }
+            else if (ch === ')') {
+                depth--;
+                if (depth === 0) {
+                    end = i;
+                    break;
+                }
+            }
+        }
+        if (start === -1 || end === -1) {
+            return code;
+        }
+        return code.slice(0, start).trimEnd() + ' ' + code.slice(end + 1).trimStart();
+    }
+    static getAstOutputPath(sourceFile, cppAstPath) {
+        const fileName = `${path.parse(path.basename(sourceFile)).name}_AST.json`;
+        if (cppAstPath !== '') {
+            return path.join(cppAstPath, fileName);
+        }
+        return path.join(astUtils_1.ClangPath.protectRoot, 'src', 'frontend', 'cppFrontend', 'ast', 'out', fileName);
+    }
+    static ensureOutputDir(dir) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+}
+exports.AstParser = AstParser;
+AstParser.currentAccess = '';

package/lib/frontend/cppFrontend/ast/astUtils.d.ts

@@ -0,0 +1,18 @@
+export declare function findProjectRoot(startDir?: string): string;
+/**
+ * Resolved path to the astJsonDumper N-API addon ({@code astJsonDumper.node} under dumper/ or lib/ast/).
+ */
+export declare function getAstJsonDumperNodePath(): string;
+/** True when {@link getAstJsonDumperNodePath} exists on disk. */
+export declare function isAstJsonDumperAvailable(): boolean;
+/** Project-root anchor for C++ AST output paths (legacy name: historically held Clang binary paths). */
+export declare class ClangPath {
+    static protectRoot: string;
+}
+export declare function extractAllCppModifiers(code: string): string[];
+/**
+ * Find the absolute path of compile_commands.json starting from a file path.
+ * Strict logic: only traverses upward (ancestors) to find a ".cxx" directory.
+ */
+export declare function findCompileCommands(filePath: string): string;
+//# sourceMappingURL=astUtils.d.ts.map

package/lib/frontend/cppFrontend/ast/astUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astUtils.d.ts","sourceRoot":"","sources":["../../../../src/frontend/cppFrontend/ast/astUtils.ts"],"names":[],"mappings":"AAqBA,wBAAgB,eAAe,CAAC,QAAQ,GAAE,MAAkB,GAAG,MAAM,CAYpE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAOjD;AAED,iEAAiE;AACjE,wBAAgB,wBAAwB,IAAI,OAAO,CAElD;AAED,wGAAwG;AACxG,qBAAa,SAAS;IAClB,OAAc,WAAW,SAA8B;CAC1D;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAqB7D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CA4B5D"}

package/lib/frontend/cppFrontend/ast/astUtils.js

@@ -0,0 +1,158 @@
+"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.findCompileCommands = exports.extractAllCppModifiers = exports.ClangPath = exports.isAstJsonDumperAvailable = exports.getAstJsonDumperNodePath = exports.findProjectRoot = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Module level cache: Sub project root directory (including .cxx directory) -> compile_commands.json absolute path
+const ccJsonCache = new Map();
+function findProjectRoot(startDir = __dirname) {
+    let dir = path.resolve(startDir);
+    while (true) {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            return dir;
+        }
+        const parentDir = path.dirname(dir);
+        if (parentDir === dir) {
+            return dir;
+        }
+        dir = parentDir;
+    }
+}
+exports.findProjectRoot = findProjectRoot;
+/**
+ * Resolved path to the astJsonDumper N-API addon ({@code astJsonDumper.node} under dumper/ or lib/ast/).
+ */
+function getAstJsonDumperNodePath() {
+    const projectRoot = findProjectRoot(__dirname);
+    let nodeAddonPath = path.join(projectRoot, 'src', 'frontend', 'cppFrontend', 'ast', 'dumper', 'astJsonDumper.node');
+    if (!fs.existsSync(nodeAddonPath)) {
+        nodeAddonPath = path.join(projectRoot, 'lib', 'ast', 'astJsonDumper.node');
+    }
+    return nodeAddonPath;
+}
+exports.getAstJsonDumperNodePath = getAstJsonDumperNodePath;
+/** True when {@link getAstJsonDumperNodePath} exists on disk. */
+function isAstJsonDumperAvailable() {
+    return fs.existsSync(getAstJsonDumperNodePath());
+}
+exports.isAstJsonDumperAvailable = isAstJsonDumperAvailable;
+/** Project-root anchor for C++ AST output paths (legacy name: historically held Clang binary paths). */
+class ClangPath {
+}
+exports.ClangPath = ClangPath;
+ClangPath.protectRoot = findProjectRoot(__dirname);
+function extractAllCppModifiers(code) {
+    if (!code) {
+        return [];
+    }
+    const cppModifiers = [
+        'static',
+        'public',
+        'private',
+        'protected',
+        'const',
+        'virtual',
+        'inline',
+        'mutable',
+        'explicit',
+        'friend',
+        'constexpr',
+        'volatile'
+    ];
+    const pattern = new RegExp(`\\b(${cppModifiers.join('|')})\\b`, 'g');
+    const matches = code.match(pattern);
+    return matches ? matches : [];
+}
+exports.extractAllCppModifiers = extractAllCppModifiers;
+/**
+ * Find the absolute path of compile_commands.json starting from a file path.
+ * Strict logic: only traverses upward (ancestors) to find a ".cxx" directory.
+ */
+function findCompileCommands(filePath) {
+    for (const [projectRoot, jsonPath] of ccJsonCache) {
+        if (filePath === projectRoot || filePath.startsWith(projectRoot + path.sep)) {
+            return jsonPath;
+        }
+    }
+    let currentDir = path.dirname(filePath);
+    while (true) {
+        const cxxDir = path.join(currentDir, '.cxx');
+        if (fs.existsSync(cxxDir) && fs.statSync(cxxDir).isDirectory()) {
+            const result = searchCompileCommandsInDir(cxxDir);
+            if (result) {
+                ccJsonCache.set(currentDir, result);
+                return result;
+            }
+            return '';
+        }
+        const parent = path.dirname(currentDir);
+        if (parent === currentDir) {
+            break;
+        }
+        currentDir = parent;
+    }
+    return '';
+}
+exports.findCompileCommands = findCompileCommands;
+/**
+ * Recursively search for compile_commands.json inside .cxx directory.
+ */
+function searchCompileCommandsInDir(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch (_a) {
+        return '';
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isFile() && entry.name === 'compile_commands.json') {
+            return dir;
+        }
+        if (entry.isDirectory()) {
+            const result = searchCompileCommandsInDir(fullPath);
+            if (result) {
+                return result;
+            }
+        }
+    }
+    return '';
+}