arkanalyzer 1.0.87 → 1.0.88

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

@@ -36,422 +36,110 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.findCompileCommands = exports.AstUtils = void 0;
-const child_process_1 = require("child_process");
+exports.findCompileCommands = exports.extractAllCppModifiers = exports.ClangPath = exports.isAstJsonDumperAvailable = exports.getAstJsonDumperNodePath = exports.findProjectRoot = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const logger_1 = __importStar(require("../../../utils/logger"));
-const const_1 = require("./const");
-const ArkCxxAstNode_1 = require("./ArkCxxAstNode");
-const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'astUtils');
-// Module level cache: Sub project root directory (including. cxx directory) ->compile_commands.json absolute path
+// Module level cache: Sub project root directory (including .cxx directory) -> compile_commands.json absolute path
 const ccJsonCache = new Map();
-class AstUtils {
-    static deleteFileSync(filePath) {
-        try {
-            fs.unlinkSync(filePath);
-        }
-        catch (_a) {
-            logger.warn('delete file failed:', filePath);
-        }
-    }
-    static parse(sourceFile, ccJsonPath, includeDirs, llvmPath, cppAstPath) {
-        var _a;
-        logger.info(`[Debug] Parsing File: ${sourceFile}`);
-        if (!fs.existsSync(sourceFile)) {
-            logger.warn('parse file is not exists');
-            return this.createEmptyNode();
-        }
-        const clangPath = this.getPlatformClang().toString();
-        logger.info(`[Debug] Clang Path: ${clangPath}`);
-        // 1. Prepare the path and directory
-        const rawAstPath = this.getAstOutputPath(sourceFile, cppAstPath);
-        const astPath = path.resolve(rawAstPath);
-        this.ensureOutputDir(path.dirname(astPath));
-        const workingDir = this.getWorkingDir(ccJsonPath);
-        // 2. Prepare the Include path (automatically inject source code root directory)
-        const finalIncludeDirs = includeDirs ? [...includeDirs] : [];
-        const projectRoot = this.resolveProjectRoot(sourceFile);
-        if (projectRoot && !finalIncludeDirs.includes(projectRoot)) {
-            finalIncludeDirs.push(projectRoot);
-        }
-        // 3. Build parameters and environment
-        let parseArguments = [sourceFile, '-o', astPath];
-        parseArguments = [...parseArguments, ...constructParseArguments(sourceFile, ccJsonPath, finalIncludeDirs)];
-        const sep = path.delimiter;
-        const existingPath = (_a = process.env.PATH) !== null && _a !== void 0 ? _a : '';
-        const shouldAppend = llvmPath && !existingPath.split(sep).includes(llvmPath);
-        const envVars = shouldAppend ? Object.assign(Object.assign({}, process.env), { PATH: existingPath + sep + llvmPath }) : undefined;
-        // 4. Execute Clang
-        const status = this.runClang(clangPath, parseArguments, envVars, workingDir);
-        // 5. Processing result
-        return this.processAstFile(astPath, sourceFile, status);
-    }
-    /**
-     * Auxiliary method: Try to find and return the root directory of src/main/cpp
-     */
-    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;
-    }
-    /**
-     * Auxiliary method: Determine Work Catalog (CWD)
-     */
-    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;
-    }
-    /**
-     * Auxiliary method: Execute Clang process and print debugging logs
-     */
-    static runClang(clangPath, args, env, cwd) {
-        var _a;
-        const fullCmd = `"${clangPath}" ${args.map(a => a.includes(' ') ? `"${a}"` : a).join(' ')}`;
-        logger.info('================================================================');
-        logger.info(`[Debug] CWD: ${cwd}`);
-        logger.info(`[Debug] CMD: ${fullCmd}`);
-        logger.info('================================================================');
-        const result = (0, child_process_1.spawnSync)(clangPath, args, {
-            stdio: ['inherit', 'pipe'],
-            encoding: 'utf-8',
-            env: env,
-            cwd: cwd
-        });
-        if (result.status !== 0) {
-            logger.error(`[Debug] Clang exited with code ${result.status}`);
-            logger.error(`[Debug] Stderr: ${result.stderr}`);
-            return (_a = result.status) !== null && _a !== void 0 ? _a : -1;
-        }
-        else {
-            logger.info('[Debug] Clang finished successfully.');
-            return 0;
-        }
-    }
-    /**
-     * Auxiliary method: Read and parse the generated AST JSON file
-     */
-    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 {
-            // [Debug] If you need to debug file generation, you can comment out the following line
-            this.deleteFileSync(astPath);
-        }
-    }
-    static createEmptyNode() {
-        return { kind: '', name: '', code: '', type: { qualType: '' }, inner: [] };
-    }
-    static updateInner(sourceFile, entry, newInner) {
-        // isImplicit=true indicates that the node must exist under the rules of the C/C++ language but is not explicitly
-        // written in the source code, so it needs to be filtered out.
-        if (entry.isImplicit) {
-            return;
-        }
-        let 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) {
-        let 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) {
-        let filteredChildren = [];
-        if (!cursor.inner) {
-            return filteredChildren;
-        }
-        filteredChildren = cursor.inner.filter((item) => !item.isImplicit);
-        return filteredChildren;
-    }
-    // Factory: generates a getParent implementation with overload signatures for a given cursor
-    static makeGetParent(cursor) {
-        function getParent(isNeedInner) {
-            if (isNeedInner) {
-                // Return the "full parent node": shallow copy, keeping the inner property
-                // Note: This will also copy getParent itself (usually not an issue)
-                return Object.assign({}, cursor);
-            }
-            // Return the "lightweight snapshot": shallow copy without inner, keeping other fields
-            const { inner } = cursor, rest = __rest(cursor, ["inner"]);
-            return rest; // Inferred as CxxAstNodeLite
-        }
-        return getParent;
-    }
-    static fullInfo(cursor) {
-        if (!cursor.inner) {
-            cursor.inner = [];
-        }
-        cursor.inner = this.filterChildren(cursor);
-        if (cursor.name === undefined) {
-            cursor.name = '';
-        }
-        // handle modifiers of lambda function
-        if (cursor.kind === 'LambdaExpr') {
-            this.processAccess(cursor);
-        }
-        // The default access property of class is 'private',The default access property of struct is 'public'
-        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) {
-            // Overloaded implementation without any usage of 'any' or type assertions
-            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 extractAllCppModifiers(code) {
-        if (!code) {
-            return [];
-        }
-        const cppModifiers = [
-            'static',
-            'public',
-            'private',
-            'protected',
-            'const',
-            'virtual',
-            'inline',
-            'mutable',
-            'explicit',
-            'friend',
-            'constexpr',
-            'volatile'
-        ];
-        // Construct the regular expression; \b ensures whole-word matching
-        const pattern = new RegExp(`\\b(${cppModifiers.join('|')})\\b`, 'g');
-        const matches = code.match(pattern);
-        return matches ? matches : [];
-    }
-    // Members in the syntax tree do not have control attributes, please process them here
-    static processAccess(cursor) {
-        var _a, _b;
-        cursor.modifiers = [];
-        // C++access control is a partition declaration that updates current information when encountering an access control symbol
-        if (cursor.kind === 'AccessSpecDecl') {
-            this.currentAccess = (_b = (_a = cursor.access) !== null && _a !== void 0 ? _a : this.extractAllCppModifiers(cursor.code)[0]) !== null && _b !== void 0 ? _b : '';
-        }
-        else {
-            const extractedCode = this.getCodeForExtractModifiers(cursor);
-            let codeModifier = this.extractAllCppModifiers(extractedCode);
-            if (this.currentAccess !== '') {
-                cursor.modifiers.push(this.currentAccess);
-            }
-            if (codeModifier !== null) {
-                cursor.modifiers.push(...codeModifier);
-            }
-        }
-    }
-    static getCodeForExtractModifiers(cursor) {
-        let extractedCode = cursor.code;
-        if (!['CXXConstructorDecl', 'CXXDestructorDecl', 'CXXMethodDecl', 'FriendDecl', 'FunctionDecl', 'FunctionTemplateDecl'].includes(cursor.kind)) {
-            return extractedCode;
-        }
-        const bodyNode = cursor.inner.filter(inn => inn.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(const_1.ClangPath.protectRoot, 'src', 'frontend', 'cppFrontend', 'ast', 'out', fileName);
-    }
-    static ensureOutputDir(dir) {
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
+function findProjectRoot(startDir = __dirname) {
+    let dir = path.resolve(startDir);
+    while (true) {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            return dir;
         }
-    }
-    static getPlatformClang() {
-        let platform = os.platform();
-        switch (platform) {
-            case 'win32':
-                return const_1.ClangPath.WindowsPath;
-            case 'linux':
-            case 'darwin':
-                return const_1.ClangPath.LinuxPath;
-            default:
-                return const_1.ClangPath.Unknown;
+        const parentDir = path.dirname(dir);
+        if (parentDir === dir) {
+            return dir;
         }
+        dir = parentDir;
     }
 }
-exports.AstUtils = AstUtils;
-AstUtils.currentAccess = '';
-function constructParseArguments(srcFilePath, ccJsonPath, includeDirs) {
-    const args = [];
-    if (ccJsonPath) {
-        args.push('-p', ccJsonPath);
-    }
-    if (includeDirs && includeDirs.length > 0) {
-        includeDirs.forEach(dir => {
-            args.push('--extra-arg-before=-I' + `${dir}`);
-        });
+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 args;
+    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.
- * Does NOT search sibling/uncle directories.
- * Caches the result based on the project root (the directory containing .cxx).
- * CxxTodo :Further confirmation can be made on whether there is a summary of the entire project's ccjson,
- * which only needs to be provided once in the scene build,(the directory containing ./.idea/.deveco/cxx/.cache)
- * * @param filePath Absolute path of the input file
- * @returns Absolute path of compile_commands.json if found, otherwise empty string
+ * Strict logic: only traverses upward (ancestors) to find a ".cxx" directory.
  */
 function findCompileCommands(filePath) {
-    // 1. [Cache hit check]
-    // Traverse the cache and check if the current file is located in a known sub project directory
-    // Logic: If the filePath starts with projectRoot, it means it belongs to this sub project
     for (const [projectRoot, jsonPath] of ccJsonCache) {
-        // Add path.sep to ensure directory level matching (prevent/app matching/apple)
         if (filePath === projectRoot || filePath.startsWith(projectRoot + path.sep)) {
             return jsonPath;
         }
     }
     let currentDir = path.dirname(filePath);
-    // 2. [Upstream search logic]
     while (true) {
-        // Core logic: Only check the. cxx directory under the current directory
-        // Will not check other sibling directories under the current directory, achieving the requirement of 'not querying uncle directories'
         const cxxDir = path.join(currentDir, '.cxx');
         if (fs.existsSync(cxxDir) && fs.statSync(cxxDir).isDirectory()) {
-            // Found. cxx, indicating that the current dir is the root directory of a sub project
-            // Recursive search for JSON files within. cxx (this is necessary as JSON is often hidden deep within. cxx)
             const result = searchCompileCommandsInDir(cxxDir);
             if (result) {
-                // [Establish cache]
-                // Key: CurrentDir (the root directory of the sub project, which is the parent directory of. cxx)
-                // Value: result (full path of json file)
                 ccJsonCache.set(currentDir, result);
                 return result;
             }
-            else {
-                // If there is a. cxx directory but json cannot be found, it usually means that it has not been compiled or the build structure is abnormal.
-                // At this point, the upward search should be stopped to prevent incorrect matching to higher-level parent projects (if nested),
-                // Alternatively, according to your needs, you can choose to continue searching upwards.
-                // The default strategy here is to identify. cxx as the project boundary.
-                return '';
-            }
+            return '';
         }
         const parent = path.dirname(currentDir);
         if (parent === currentDir) {
-            break; // Arriving at the system root directory, stop
+            break;
         }
-        currentDir = parent; // Continue moving up one layer
+        currentDir = parent;
     }
     return '';
 }
 exports.findCompileCommands = findCompileCommands;
 /**
- * Recursively search for compile_commands.json inside a directory
- * This is only used INSIDE the .cxx directory.
- * @param dir Directory path to start searching
- * @returns Absolute path of compile_commands.json if found, otherwise empty string
+ * Recursively search for compile_commands.json inside .cxx directory.
  */
 function searchCompileCommandsInDir(dir) {
     let entries;
     try {
         entries = fs.readdirSync(dir, { withFileTypes: true });
     }
-    catch (e) {
+    catch (_a) {
         return '';
     }
     for (const entry of entries) {
@@ -459,7 +147,7 @@ function searchCompileCommandsInDir(dir) {
         if (entry.isFile() && entry.name === 'compile_commands.json') {
             return dir;
         }
-        else if (entry.isDirectory()) {
+        if (entry.isDirectory()) {
             const result = searchCompileCommandsInDir(fullPath);
             if (result) {
                 return result;

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

@@ -14,17 +14,4 @@ export declare function getCxxHeaderFileExtensionSet(): ReadonlySet<string>;
 export declare function getCxxImplementationFileExtensions(): readonly string[];
 /** Returns a read-only set for fast C/C++ implementation-file checks. */
 export declare function getCxxImplementationFileExtensionSet(): ReadonlySet<string>;
-export declare function findProjectRoot(startDIr?: string): string;
-/**
- * Resolved path to the astJsonDumper executable for the current OS (Windows: .exe under dumper/ or lib/ast/).
- */
-export declare function getAstJsonDumperPath(): string;
-/** True when the astJsonDumper binary exists at {@link getAstJsonDumperPath}. */
-export declare function isAstJsonDumperAvailable(): boolean;
-export declare class ClangPath {
-    static WindowsPath: string;
-    static LinuxPath: string;
-    static Unknown: string;
-    static protectRoot: string;
-}
 //# sourceMappingURL=const.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../../../src/frontend/cppFrontend/ast/const.ts"],"names":[],"mappings":"AAgCA;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,SAAS,MAAM,EAAE,CAE9D;AAED,6EAA6E;AAC7E,wBAAgB,4BAA4B,IAAI,WAAW,CAAC,MAAM,CAAC,CAElE;AAED,sEAAsE;AACtE,wBAAgB,4BAA4B,IAAI,WAAW,CAAC,MAAM,CAAC,CAElE;AAED;;;GAGG;AACH,wBAAgB,kCAAkC,IAAI,SAAS,MAAM,EAAE,CAEtE;AAED,yEAAyE;AACzE,wBAAgB,oCAAoC,IAAI,WAAW,CAAC,MAAM,CAAC,CAE1E;AAED,wBAAgB,eAAe,CAAC,QAAQ,GAAE,MAAkB,GAAG,MAAM,CAYpE;AAuBD;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C;AAED,iFAAiF;AACjF,wBAAgB,wBAAwB,IAAI,OAAO,CAElD;AAED,qBAAa,SAAS;IAClB,MAAM,CAAC,WAAW,SAAmB;IACrC,MAAM,CAAC,SAAS,SAAwB;IACxC,MAAM,CAAC,OAAO,SAAM;IACpB,MAAM,CAAC,WAAW,SAAe;CACpC"}
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../../../src/frontend/cppFrontend/ast/const.ts"],"names":[],"mappings":"AA4BA;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,SAAS,MAAM,EAAE,CAE9D;AAED,6EAA6E;AAC7E,wBAAgB,4BAA4B,IAAI,WAAW,CAAC,MAAM,CAAC,CAElE;AAED,sEAAsE;AACtE,wBAAgB,4BAA4B,IAAI,WAAW,CAAC,MAAM,CAAC,CAElE;AAED;;;GAGG;AACH,wBAAgB,kCAAkC,IAAI,SAAS,MAAM,EAAE,CAEtE;AAED,yEAAyE;AACzE,wBAAgB,oCAAoC,IAAI,WAAW,CAAC,MAAM,CAAC,CAE1E"}

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

@@ -13,34 +13,8 @@
  * 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.ClangPath = exports.isAstJsonDumperAvailable = exports.getAstJsonDumperPath = exports.findProjectRoot = exports.getCxxImplementationFileExtensionSet = exports.getCxxImplementationFileExtensions = exports.getCxxHeaderFileExtensionSet = exports.getCxxSourceFileExtensionSet = exports.getCxxSourceFileExtensions = void 0;
-const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
+exports.getCxxImplementationFileExtensionSet = exports.getCxxImplementationFileExtensions = exports.getCxxHeaderFileExtensionSet = exports.getCxxSourceFileExtensionSet = exports.getCxxSourceFileExtensions = void 0;
 /** C/C++ implementation file extensions (translation units). */
 const CXX_IMPLEMENTATION_EXTENSIONS = ['.c', '.cc', '.cpp', '.cxx'];
 /** C/C++ header extensions. */
@@ -82,53 +56,3 @@ function getCxxImplementationFileExtensionSet() {
     return CXX_IMPLEMENTATION_EXTENSION_SET;
 }
 exports.getCxxImplementationFileExtensionSet = getCxxImplementationFileExtensionSet;
-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;
-const projectRoot = findProjectRoot(__dirname);
-function getPrintAstExePath() {
-    let printAstExePath = path.join(projectRoot, 'src', 'frontend', 'cppFrontend', 'ast', 'dumper', 'astJsonDumper.exe');
-    if (!fs.existsSync(printAstExePath)) {
-        printAstExePath = path.join(projectRoot, 'lib', 'ast', 'astJsonDumper.exe');
-    }
-    return printAstExePath;
-}
-function getPrintAstExePathLinux() {
-    let printAstExePath = path.join(projectRoot, 'src', 'frontend', 'cppFrontend', 'ast', 'dumper', 'astJsonDumper');
-    if (!fs.existsSync(printAstExePath)) {
-        printAstExePath = path.join(projectRoot, 'lib', 'ast', 'astJsonDumper');
-    }
-    return printAstExePath;
-}
-const printAstExePath = getPrintAstExePath();
-const printAstExePathLinux = getPrintAstExePathLinux();
-/**
- * Resolved path to the astJsonDumper executable for the current OS (Windows: .exe under dumper/ or lib/ast/).
- */
-function getAstJsonDumperPath() {
-    return os.platform() === 'win32' ? getPrintAstExePath() : getPrintAstExePathLinux();
-}
-exports.getAstJsonDumperPath = getAstJsonDumperPath;
-/** True when the astJsonDumper binary exists at {@link getAstJsonDumperPath}. */
-function isAstJsonDumperAvailable() {
-    return fs.existsSync(getAstJsonDumperPath());
-}
-exports.isAstJsonDumperAvailable = isAstJsonDumperAvailable;
-class ClangPath {
-}
-exports.ClangPath = ClangPath;
-ClangPath.WindowsPath = printAstExePath;
-ClangPath.LinuxPath = printAstExePathLinux;
-ClangPath.Unknown = '';
-ClangPath.protectRoot = projectRoot;

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

@@ -0,0 +1,5 @@
+export { getCxxImplementationFileExtensionSet, getCxxImplementationFileExtensions, getCxxHeaderFileExtensionSet, getCxxSourceFileExtensionSet, getCxxSourceFileExtensions, } from './const';
+export { astKind, CxxAstNode, CxxIncludeInfo, CxxTranslationUnit, defaultArg, getNodeStartLineAndCol, } from './ArkCxxAstNode';
+export { findCompileCommands, isAstJsonDumperAvailable } from './astUtils';
+export { AstParser } from './astParser';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/frontend/cppFrontend/ast/index.ts"],"names":[],"mappings":"AAeA,OAAO,EACH,oCAAoC,EACpC,kCAAkC,EAClC,4BAA4B,EAC5B,4BAA4B,EAC5B,0BAA0B,GAC7B,MAAM,SAAS,CAAC;AAEjB,OAAO,EACH,OAAO,EACP,UAAU,EACV,cAAc,EACd,kBAAkB,EAClB,UAAU,EACV,sBAAsB,GACzB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE3E,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}

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

@@ -0,0 +1,31 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstParser = exports.isAstJsonDumperAvailable = exports.findCompileCommands = exports.getNodeStartLineAndCol = exports.astKind = exports.getCxxSourceFileExtensions = exports.getCxxSourceFileExtensionSet = exports.getCxxHeaderFileExtensionSet = exports.getCxxImplementationFileExtensions = exports.getCxxImplementationFileExtensionSet = void 0;
+var const_1 = require("./const");
+Object.defineProperty(exports, "getCxxImplementationFileExtensionSet", { enumerable: true, get: function () { return const_1.getCxxImplementationFileExtensionSet; } });
+Object.defineProperty(exports, "getCxxImplementationFileExtensions", { enumerable: true, get: function () { return const_1.getCxxImplementationFileExtensions; } });
+Object.defineProperty(exports, "getCxxHeaderFileExtensionSet", { enumerable: true, get: function () { return const_1.getCxxHeaderFileExtensionSet; } });
+Object.defineProperty(exports, "getCxxSourceFileExtensionSet", { enumerable: true, get: function () { return const_1.getCxxSourceFileExtensionSet; } });
+Object.defineProperty(exports, "getCxxSourceFileExtensions", { enumerable: true, get: function () { return const_1.getCxxSourceFileExtensions; } });
+var ArkCxxAstNode_1 = require("./ArkCxxAstNode");
+Object.defineProperty(exports, "astKind", { enumerable: true, get: function () { return ArkCxxAstNode_1.astKind; } });
+Object.defineProperty(exports, "getNodeStartLineAndCol", { enumerable: true, get: function () { return ArkCxxAstNode_1.getNodeStartLineAndCol; } });
+var astUtils_1 = require("./astUtils");
+Object.defineProperty(exports, "findCompileCommands", { enumerable: true, get: function () { return astUtils_1.findCompileCommands; } });
+Object.defineProperty(exports, "isAstJsonDumperAvailable", { enumerable: true, get: function () { return astUtils_1.isAstJsonDumperAvailable; } });
+var astParser_1 = require("./astParser");
+Object.defineProperty(exports, "AstParser", { enumerable: true, get: function () { return astParser_1.AstParser; } });

package/lib/frontend/cppFrontend/common/ArkIRTransformer.d.ts

@@ -7,7 +7,7 @@ import { AliasType } from '../../../core/base/Type';
 import { ArkMethod } from '../../../core/model/ArkMethod';
 import { FullPosition } from '../../../core/base/Position';
 import { ArkIRTransformer } from '../../../core/common/ArkIRTransformer';
-import { CxxAstNode, CxxTranslationUnit } from '../ast/ArkCxxAstNode';
+import { CxxAstNode, CxxTranslationUnit } from '../ast';
 export type ValueAndStmts = {
     value: Value;
     valueOriginalPositions: FullPosition[];