arkanalyzer 1.0.86 → 1.0.87

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

@@ -0,0 +1,46 @@
+import { GenericType, Type } from '../../../../core/base/Type';
+import { ArkField } from '../../../../core/model/ArkField';
+import { ArkClass } from '../../../../core/model/ArkClass';
+import { ArkMethod } from '../../../../core/model/ArkMethod';
+import { MethodParameter } from '../../../../core/model/builder/ArkMethodBuilder';
+import { CxxAstNode, CxxTranslationUnit, defaultArg } from '../../ast/ArkCxxAstNode';
+import { Decorator } from '../../../../core/base/Decorator';
+export declare function buildModifiers(node: CxxAstNode): number;
+export declare function buildDecorators(node: CxxAstNode, sourceFile: CxxAstNode): Set<Decorator>;
+export declare function buildModifiersForCxxClass(cls: ArkClass): number;
+export declare function buildTypeParameters(clsNode: CxxAstNode, sourceFile: CxxAstNode, arkInstance: ArkMethod | ArkClass): GenericType[];
+export declare function buildParameters(params: CxxAstNode[], arkInstance: ArkMethod | ArkField, sourceFile: CxxAstNode): MethodParameter[];
+export declare function buildReturnType(mtdNode: CxxAstNode, sourceFile: CxxAstNode, method: ArkMethod): Type;
+export declare function isCxxFunctionPointer(type: string): boolean;
+export declare function buildFuncPtrType(funcPtrNode: CxxAstNode, arkMtd: ArkMethod, sourceFile: CxxAstNode | CxxTranslationUnit): Type;
+/**
+ *Convert C++AST node to Type
+ *@ param nodeQualType - type information of C++AST node or string type
+ *@ param arkInstance - Ark instance (method, class or field) that may contain generic information
+ *@ param sourceFile - optional source file node
+ *@ returns Type after conversion
+ */
+export declare function cxxNode2Type(nodeQualType: CxxAstNode, arkInstance: ArkMethod | ArkClass | ArkField | undefined, sourceFile?: CxxAstNode, currNode?: CxxAstNode, defaultArg?: defaultArg): Type;
+/**
+ *The corresponding Type object is constructed according to the pre type string and the optional Ark instance.
+ *
+ *The main processing flow of this function includes:
+ *1 Remove modifiers (such as const, static, mutable);
+ *2 Judge whether it is a function pointer, and handle pointers and references;
+ *3 Type inference to generate basic types;
+ *4 Wrap the final Type object according to the pointer level and the number of references.
+ *
+ *@ param preStr The original pre type string, such as "const int *" or "std:: vector<int>&"
+ *@ param arkInstance The optional ArkMethod, ArkClass or ArkField instances are used to assist type construction
+ *@ returns Type object constructed
+ */
+export declare function buildTypeFromPreStr(preStr: string, node: CxxAstNode, arkInstance: ArkMethod | ArkClass | ArkField | undefined): Type;
+export declare function buildArrayType(qualType: string, node: CxxAstNode, arkInstance: ArkMethod | ArkClass | ArkField | undefined): Type;
+export declare function buildPointerType(preStr: string, pointerLevel: number, node: CxxAstNode, arkInstance: ArkMethod | ArkClass | ArkField | undefined): Type;
+export declare function buildReferenceType(preStr: string, referenceCount: number, node: CxxAstNode, arkInstance: ArkMethod | ArkClass | ArkField | undefined): Type;
+export declare function isCXXSTLContainer(qualType: string): boolean;
+export declare function isFuncInClassOrNamespace(callNode: CxxAstNode): boolean;
+export declare function isCxxBasicString(qualType: string): boolean;
+export declare function buildTypeFromDerivedType(preStr: string, node: CxxAstNode, arkInstance: ArkMethod | ArkClass | ArkField | undefined): Type;
+export declare function convertDataType(typeName: string): string;
+//# sourceMappingURL=builderUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"builderUtils.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/model/builder/builderUtils.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,499 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertDataType = exports.buildTypeFromDerivedType = exports.isCxxBasicString = exports.isFuncInClassOrNamespace = exports.isCXXSTLContainer = exports.buildReferenceType = exports.buildPointerType = exports.buildArrayType = exports.buildTypeFromPreStr = exports.cxxNode2Type = exports.buildFuncPtrType = exports.isCxxFunctionPointer = exports.buildReturnType = exports.buildParameters = exports.buildTypeParameters = exports.buildModifiersForCxxClass = exports.buildDecorators = exports.buildModifiers = void 0;
+const Type_1 = require("../../../../core/base/Type");
+const Type_2 = require("../../base/Type");
+const TypeInference_1 = require("../../common/TypeInference");
+const ArkClass_1 = require("../../../../core/model/ArkClass");
+const ArkMethod_1 = require("../../../../core/model/ArkMethod");
+const ArkMethodBuilder_1 = require("../../../../core/model/builder/ArkMethodBuilder");
+const ArkBaseModel_1 = require("../../../../core/model/ArkBaseModel");
+const builderUtils_1 = require("../../../../core/model/builder/builderUtils");
+const ArkCxxAstNode_1 = require("../../ast/ArkCxxAstNode");
+const ArkMethodBuilder_2 = require("./ArkMethodBuilder");
+const Builtin_1 = require("../../common/Builtin");
+const ModelUtils_1 = require("../../common/ModelUtils");
+const logger_1 = __importStar(require("../../../../utils/logger"));
+const FUNC_PTR_REGEX = /\(\s*\*\s*(?:\[\s*[^]]*\s*\])?\s*\)\s*\(\s*[^)]*\s*\)/;
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ArkValueTransformer');
+function extractCommonModifiers(node) {
+    var _a;
+    let modifiers = 0;
+    if (!node.modifiers) {
+        return modifiers;
+    }
+    for (let i = 0; i < node.modifiers.length; i++) {
+        if (Object.prototype.hasOwnProperty.call(node, 'modifiers')) {
+            modifiers |= (0, ArkBaseModel_1.modifierKind2CxxEnum)(node.modifiers[i]);
+        }
+    }
+    if (Object.prototype.hasOwnProperty.call(node, 'storageClass')) {
+        modifiers |= (0, ArkBaseModel_1.modifierKind2CxxEnum)((_a = node.storageClass) !== null && _a !== void 0 ? _a : '');
+    }
+    return modifiers;
+}
+function hasOverrideAttr(inner) {
+    if (!inner) {
+        return false;
+    }
+    return inner.some(child => child.kind === 'attribute(override)');
+}
+function getMtdModifier(node, modifiers) {
+    if (node.code.startsWith('virtual ')) {
+        modifiers |= (0, ArkBaseModel_1.modifierKind2CxxEnum)('virtual');
+        // Definition of pure virtual function: virtual func()=0/virtual func()=0
+        if (node.code.endsWith('= 0') || node.code.endsWith('=0')) {
+            modifiers |= (0, ArkBaseModel_1.modifierKind2CxxEnum)('pure virtual');
+        }
+    }
+    if (hasOverrideAttr(node.inner)) {
+        modifiers |= (0, ArkBaseModel_1.modifierKind2CxxEnum)('override');
+    }
+    return modifiers;
+}
+function buildModifiers(node) {
+    let modifiers = extractCommonModifiers(node);
+    if (node.kind === 'CXXMethodDecl') {
+        modifiers = getMtdModifier(node, modifiers);
+    }
+    if (node.kind === 'FriendDecl') {
+        modifiers |= (0, ArkBaseModel_1.modifierKind2CxxEnum)('friend');
+    }
+    return modifiers;
+}
+exports.buildModifiers = buildModifiers;
+function buildDecorators(node, sourceFile) {
+    let decorators = new Set();
+    return decorators;
+}
+exports.buildDecorators = buildDecorators;
+function buildModifiersForCxxClass(cls) {
+    const mtds = cls.getMethods();
+    for (const mtd of mtds) {
+        // If a class contains a pure virtual member function, then the class is an abstract class.
+        if (mtd.isPureVirtual()) {
+            return (0, ArkBaseModel_1.modifierKind2CxxEnum)('abstract');
+        }
+    }
+    return 0;
+}
+exports.buildModifiersForCxxClass = buildModifiersForCxxClass;
+function buildTypeParameters(clsNode, sourceFile, arkInstance) {
+    const genericTypes = [];
+    let index = -1;
+    for (const innerNode of clsNode.inner) {
+        if (innerNode.kind === ArkCxxAstNode_1.astKind.TemplateTypeParmDecl) {
+            let defaultType;
+            if (innerNode.inner && innerNode.inner.length > 0) {
+                innerNode.default = innerNode.inner[0].type.qualType;
+            }
+            if (innerNode.defaultArg) {
+                defaultType = cxxNode2Type(innerNode, arkInstance);
+            }
+            let templateType = new Type_1.GenericType(innerNode.name, defaultType);
+            templateType.setIndex(++index);
+            genericTypes.push(templateType);
+        }
+        else if (innerNode.kind === ArkCxxAstNode_1.astKind.NonTypeTemplateParmDecl) {
+            let templateType;
+            if (innerNode.type.qualType === 'auto') {
+                templateType = new Type_2.CxxNonType(innerNode.name, Type_2.AutoType.getInstance());
+            }
+            else {
+                const nonType = cxxNode2Type(innerNode, arkInstance, sourceFile);
+                templateType = new Type_2.CxxNonType(innerNode.name, nonType);
+            }
+            templateType.setIndex(++index);
+            genericTypes.push(templateType);
+        }
+    }
+    return genericTypes;
+}
+exports.buildTypeParameters = buildTypeParameters;
+function buildParameters(params, arkInstance, sourceFile) {
+    let parameters = [];
+    if (!params || params.length === 0) {
+        return [];
+    }
+    params.forEach((parameter) => {
+        let methodParameter = new ArkMethodBuilder_1.MethodParameter();
+        // name
+        if (parameter.name) {
+            methodParameter.setName(parameter.name.toString());
+        }
+        else {
+            methodParameter.setName('');
+        }
+        // Is it optional,If there are default parameters, they should be set as optional parameters
+        if (parameter.inner.length > 0 && parameter.inner[parameter.inner.length - 1].kind !== 'TypeRef') {
+            methodParameter.setOptional(true);
+        }
+        // type
+        if (parameter.type) {
+            methodParameter.setType((0, builderUtils_1.buildGenericType)(cxxNode2Type(parameter, arkInstance, sourceFile, parameter), arkInstance));
+        }
+        else {
+            methodParameter.setType(Type_1.UnknownType.getInstance());
+        }
+        parameters.push(methodParameter);
+    });
+    return parameters;
+}
+exports.buildParameters = buildParameters;
+function buildReturnType(mtdNode, sourceFile, method) {
+    let nodeType = mtdNode.type;
+    if (nodeType) {
+        if (nodeType === null || nodeType === void 0 ? void 0 : nodeType.qualType) {
+            const qualType = nodeType.qualType;
+            if (qualType.includes('noexcept') && !qualType.includes('noexcept(false)')) {
+                method.addModifier((0, ArkBaseModel_1.modifierKind2CxxEnum)('noexcept'));
+            }
+        }
+        let isLambdaFunc = nodeType.qualType.startsWith('(lambda at');
+        if (!isLambdaFunc) {
+            // Retrieve the function return value portion from the function signature
+            mtdNode.type.qualType = nodeType.qualType.split('(')[0].trim();
+        }
+        else {
+            // Lambda function without return value
+            return Type_1.UnknownType.getInstance();
+        }
+        return cxxNode2Type(mtdNode, method, sourceFile);
+    }
+    else {
+        return Type_1.UnknownType.getInstance();
+    }
+}
+exports.buildReturnType = buildReturnType;
+function isCxxFunctionPointer(type) {
+    return FUNC_PTR_REGEX.test(type);
+}
+exports.isCxxFunctionPointer = isCxxFunctionPointer;
+function buildFuncPtrType(funcPtrNode, arkMtd, sourceFile) {
+    const anonymousMethod = new ArkMethod_1.ArkMethod();
+    const declaringClass = arkMtd.getDeclaringArkClass();
+    (0, ArkMethodBuilder_2.buildArkMethodFromArkClass)(funcPtrNode, declaringClass, anonymousMethod, sourceFile);
+    const funcType = new Type_1.FunctionType(anonymousMethod.getSignature());
+    return new Type_2.PointerType(funcType, 1);
+}
+exports.buildFuncPtrType = buildFuncPtrType;
+/**
+ *Convert C++AST node to Type
+ *@ param nodeQualType - type information of C++AST node or string type
+ *@ param arkInstance - Ark instance (method, class or field) that may contain generic information
+ *@ param sourceFile - optional source file node
+ *@ returns Type after conversion
+ */
+function cxxNode2Type(nodeQualType, arkInstance, sourceFile, currNode, defaultArg) {
+    if (defaultArg) {
+        return buildTypeFromPreStr(defaultArg.type.qualType, nodeQualType, arkInstance);
+    }
+    // Handle function pointer type
+    if (currNode && arkInstance instanceof ArkMethod_1.ArkMethod && isCxxFunctionPointer(currNode.type.qualType)) {
+        return buildFuncPtrType(currNode, arkInstance, sourceFile);
+    }
+    // Default processing
+    let typeString = getTrueTypeString(nodeQualType);
+    if (typeString === '') {
+        return Type_1.UnknownType.getInstance();
+    }
+    if (nodeQualType.kind === 'InitListExpr' && typeString === 'void') {
+        let multipleTypePara = [];
+        nodeQualType.inner.forEach((item) => {
+            multipleTypePara.push(cxxNode2Type(item, arkInstance, sourceFile));
+        });
+        return new Type_1.UnionType(multipleTypePara);
+    }
+    return buildTypeFromPreStr(typeString, nodeQualType, arkInstance);
+}
+exports.cxxNode2Type = cxxNode2Type;
+function getTrueTypeString(nodeQualType) {
+    var _a, _b, _c;
+    if (nodeQualType.kind === 'CXXTypeidExpr' && nodeQualType.typeArg) {
+        return (_a = nodeQualType.typeArg.desugaredQualType) !== null && _a !== void 0 ? _a : nodeQualType.typeArg.qualType;
+    }
+    else if (['TemplateTypeParmDecl', 'TemplateTypeParmVarDecl'].includes(nodeQualType.kind) && nodeQualType.defaultArg) {
+        return (_b = nodeQualType.defaultArg.type.desugaredQualType) !== null && _b !== void 0 ? _b : nodeQualType.defaultArg.type.qualType;
+    }
+    else if (nodeQualType.type) {
+        return (_c = nodeQualType.type.desugaredQualType) !== null && _c !== void 0 ? _c : nodeQualType.type.qualType;
+    }
+    return '';
+}
+/**
+ *The corresponding Type object is constructed according to the pre type string and the optional Ark instance.
+ *
+ *The main processing flow of this function includes:
+ *1 Remove modifiers (such as const, static, mutable);
+ *2 Judge whether it is a function pointer, and handle pointers and references;
+ *3 Type inference to generate basic types;
+ *4 Wrap the final Type object according to the pointer level and the number of references.
+ *
+ *@ param preStr The original pre type string, such as "const int *" or "std:: vector<int>&"
+ *@ param arkInstance The optional ArkMethod, ArkClass or ArkField instances are used to assist type construction
+ *@ returns Type object constructed
+ */
+function buildTypeFromPreStr(preStr, node, arkInstance) {
+    var _a, _b;
+    // 1. Remove modifiers such as const/static/mutable
+    preStr = preStr.replace(/\b(const|static|mutable)\s*\b/g, '');
+    // 2. One traversal simultaneously counts the number of references and pointers, and constructs a base string without references
+    let referenceCount = 0;
+    let pointerLevel = 0;
+    let baseStr = '';
+    for (let i = 0; i < preStr.length; i++) {
+        const char = preStr[i];
+        if (char === '&') {
+            referenceCount++;
+        }
+        else if (char === '*') {
+            pointerLevel++;
+            baseStr += char; // Keep * characters
+        }
+        else {
+            baseStr += char; // Keep other characters
+        }
+    }
+    baseStr = baseStr.trim(); // Remove the leading and trailing spaces
+    // 3. Handling reference types
+    if (referenceCount > 0) {
+        return buildReferenceType(baseStr, referenceCount, node, arkInstance);
+    }
+    // 4. Array judgment
+    if (baseStr.includes('[') && baseStr.includes(']')) {
+        return buildArrayType(baseStr, node, arkInstance);
+    }
+    // 5. Handling pointer types
+    if (pointerLevel > 0) {
+        baseStr = baseStr.replace(/\*/g, '').trim();
+        return buildPointerType(baseStr, pointerLevel, node, arkInstance);
+    }
+    // 6. template
+    let templateTypes;
+    if (arkInstance instanceof ArkMethod_1.ArkMethod) {
+        templateTypes = (_a = arkInstance.getGenericTypes()) !== null && _a !== void 0 ? _a : (_b = arkInstance.getDeclaringArkClass()) === null || _b === void 0 ? void 0 : _b.getGenericsTypes();
+    }
+    else if (arkInstance instanceof ArkClass_1.ArkClass) {
+        templateTypes = arkInstance.getGenericsTypes();
+    }
+    if (templateTypes) {
+        for (const t of templateTypes) {
+            if (preStr === t.getName()) {
+                return t;
+            }
+        }
+    }
+    // 7. Base type
+    const baseTypeStr = convertDataType(baseStr);
+    if (baseTypeStr !== 'unsupported') {
+        return TypeInference_1.TypeInference.buildTypeFromStr(baseTypeStr, baseStr);
+    }
+    // 8.STL Type and custom type
+    return buildTypeFromDerivedType(baseStr, node, arkInstance);
+}
+exports.buildTypeFromPreStr = buildTypeFromPreStr;
+function buildArrayType(qualType, node, arkInstance) {
+    var _a, _b, _c;
+    const count = (_b = (_a = qualType.match(/\[/g)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+    let baseType = buildTypeFromPreStr(qualType.slice(0, qualType.indexOf('[')) +
+        qualType.slice(qualType.lastIndexOf(']') + 1), node, arkInstance);
+    let dimensionSizes = [];
+    const dimensionMatches = qualType.match(/\[(\d*)\]/g);
+    if (dimensionMatches) {
+        dimensionSizes = dimensionMatches.map(dim => {
+            var _a;
+            const numStr = (_a = dim.match(/\d+/)) === null || _a === void 0 ? void 0 : _a[0];
+            return numStr ? parseInt(numStr, 10) : 0;
+        });
+    }
+    else {
+        // If dimensions cannot be extracted from the string, try getting them from node-INNER
+        try {
+            for (let i = 0; i < count; i++) {
+                dimensionSizes.push((_c = Number(node.inner[i].value)) !== null && _c !== void 0 ? _c : 0);
+            }
+        }
+        catch (e) {
+            // When a node is of reference type, the processing strategy is to parse the type as much as possible,
+            // so it is not directly parsed according to Unclear Reference.
+            // At this time, the type field cannot obtain array length information.
+            logger.warn(node + 'this node case is unexpect');
+            return TypeInference_1.TypeInference.buildTypeFromStr(qualType);
+        }
+    }
+    if (baseType instanceof Type_1.UnclearReferenceType) {
+        return new Type_2.CxxArrayType(new Type_1.UnclearReferenceType(qualType.slice(0, qualType.indexOf('['))), count);
+    }
+    return new Type_2.CxxArrayType(baseType, count, dimensionSizes);
+}
+exports.buildArrayType = buildArrayType;
+function buildPointerType(preStr, pointerLevel, node, arkInstance) {
+    let baseType = buildTypeFromPreStr(preStr, node, arkInstance);
+    const pointerType = new Type_2.PointerType(baseType, pointerLevel);
+    let oriStr = node.type.qualType;
+    const starIndex = oriStr.indexOf('*');
+    if (starIndex === -1) {
+        return pointerType;
+    }
+    // Analyze the const keywords to the left and right of the asterisk
+    const leftPart = oriStr.substring(0, starIndex);
+    const rightPart = oriStr.substring(starIndex + 1);
+    pointerType.setIsPointerToVolatileType(/\bvolatile\b/.test(leftPart));
+    pointerType.setIsVolatilePointer(/\bvolatile\b/.test(rightPart));
+    pointerType.setIsPointerToConst(/\bconst\b/.test(leftPart));
+    pointerType.setIsConstPointer(/\bconst\b/.test(rightPart));
+    return pointerType;
+}
+exports.buildPointerType = buildPointerType;
+function buildReferenceType(preStr, referenceCount, node, arkInstance) {
+    let referCategory = referenceCount % 2 === 1 ? Type_2.ReferCategory.LVALUE_REF : Type_2.ReferCategory.RVALUE_REF;
+    // cxxTodo: this need to confirm;
+    preStr = preStr.replace(/(\(\))+$/g, '');
+    let baseType = buildTypeFromPreStr(preStr, node, arkInstance);
+    if (baseType instanceof Type_1.GenericType && referenceCount % 2 === 0) {
+        referCategory = Type_2.ReferCategory.UNIVERSAL_REF;
+    }
+    return new Type_2.ReferenceType(baseType, referCategory);
+}
+exports.buildReferenceType = buildReferenceType;
+function isCXXSTLContainer(qualType) {
+    let STLContainerPtn = /(set|map|vector|queue|deque|stack|list|pair)<[^>]*>/g;
+    return STLContainerPtn.test(qualType);
+}
+exports.isCXXSTLContainer = isCXXSTLContainer;
+function isFuncInClassOrNamespace(callNode) {
+    return callNode.kind === 'DeclRefExpr' && callNode.inner.length === 0 &&
+        callNode.code.includes('::') && !callNode.code.startsWith(Builtin_1.BuiltinCxx.CXXSTDREF);
+}
+exports.isFuncInClassOrNamespace = isFuncInClassOrNamespace;
+function isCxxBasicString(qualType) {
+    const preType = qualType.replace(/\b(const|static|mutable)\s*\b/g, '');
+    return convertDataType(preType) === 'string';
+}
+exports.isCxxBasicString = isCxxBasicString;
+function buildTypeFromDerivedType(preStr, node, arkInstance) {
+    var _a, _b, _c, _d, _e, _f;
+    const outerPartMatch = preStr.match(/^([^<]+)/);
+    const outerPart = outerPartMatch ? outerPartMatch[1] : null;
+    let typeStr;
+    let firstSpaceIndex;
+    if (outerPart === null) {
+        firstSpaceIndex = preStr.indexOf(' ');
+        typeStr = firstSpaceIndex === -1 ? preStr : preStr.substring(firstSpaceIndex + 1);
+    }
+    else {
+        firstSpaceIndex = outerPart.indexOf(' ');
+        typeStr = firstSpaceIndex === -1 ? outerPart : outerPart.substring(firstSpaceIndex + 1);
+    }
+    const innerPartMatch = preStr.match(/<([^>]+)>/);
+    const innerPart = innerPartMatch ? innerPartMatch[1] : null;
+    let innerType = innerPart === null ? [] : [buildTypeFromPreStr(innerPart, node, arkInstance)];
+    if (arkInstance instanceof ArkMethod_1.ArkMethod) {
+        // Obtain the use of alias types
+        let aliasType = (_a = arkInstance.getBody()) === null || _a === void 0 ? void 0 : _a.getAliasTypeByName(typeStr);
+        if (aliasType) {
+            return aliasType;
+        }
+    }
+    let arkClass = null;
+    if (arkInstance instanceof ArkMethod_1.ArkMethod || arkInstance instanceof ArkClass_1.ArkClass) {
+        const file = (_b = arkInstance.getDeclaringArkFile) === null || _b === void 0 ? void 0 : _b.call(arkInstance);
+        arkClass = (_d = (_c = file === null || file === void 0 ? void 0 : file.getClassWithName) === null || _c === void 0 ? void 0 : _c.call(file, typeStr)) !== null && _d !== void 0 ? _d : ModelUtils_1.CxxModelUtils.getClassFromAnonymousNamespaceByName(typeStr, file);
+        // Obtain the use of alias types
+        let aliasType = (_f = (_e = file === null || file === void 0 ? void 0 : file.getDefaultClass().getDefaultArkMethod()) === null || _e === void 0 ? void 0 : _e.getBody()) === null || _f === void 0 ? void 0 : _f.getAliasTypeByName(typeStr);
+        if (aliasType) {
+            return aliasType;
+        }
+    }
+    if (arkClass) {
+        return new Type_1.ClassType(arkClass.getSignature(), innerType);
+    }
+    return TypeInference_1.TypeInference.buildTypeFromStr(preStr);
+}
+exports.buildTypeFromDerivedType = buildTypeFromDerivedType;
+const typeMap = {
+    bool: 'boolean',
+    // String
+    string: 'string',
+    'std::string': 'string',
+    char: 'string',
+    'signed char': 'string',
+    'unsigned char': 'string',
+    'unsignedchar': 'string',
+    wchar_t: 'string',
+    char16_t: 'string',
+    char32_t: 'string',
+    'std::basic_string<char>': 'string',
+    'basic_string<char>': 'string',
+    // Number
+    short: 'number',
+    'unsigned short': 'number',
+    'unsigned int': 'number',
+    int: 'number',
+    long: 'number',
+    'unsigned long': 'number',
+    'long long': 'number',
+    'unsigned long long': 'number',
+    float: 'number',
+    double: 'number',
+    'long double': 'number',
+    uint8_t: 'number',
+    uint16_t: 'number',
+    uint32_t: 'number',
+    uint64_t: 'number',
+    int8_t: 'number',
+    int16_t: 'number',
+    int32_t: 'number',
+    int64_t: 'number',
+    size_t: 'number',
+    intptr_t: 'number',
+    uintptr_t: 'number',
+    // void
+    void: 'void',
+    'std::type_info': 'type_info',
+    'type_info': 'type_info',
+    auto: 'auto',
+};
+function convertDataType(typeName) {
+    var _a;
+    const formattedTypeName = typeName.replace(Builtin_1.BuiltinCxx.CXXSTDREF, '');
+    return (_a = typeMap[formattedTypeName]) !== null && _a !== void 0 ? _a : 'unsupported';
+}
+exports.convertDataType = convertDataType;

package/lib/frontend/cppFrontend/utils/cmakeUtils.d.ts

@@ -0,0 +1,44 @@
+export declare class CmakeUtils {
+    /**
+     * Scan the CMakeLists.txt files in the directory and obtain all dependent header file directories.
+     * @param dir - the target project directory.
+     * @returns - include directories set by CMakeLists.txt
+     */
+    static scanCMakeIncludeDirsOnly(dir: string): string[];
+    /**
+     * Get the variable and definition in the set statements, e.g. set(VAR value)
+     * @param line - The line content in CMakeLists.
+     * @returns - an array containing variable names and set values, or null
+     */
+    private static extractSetVar;
+    /**
+     * Recursively parse variables in current CMakeLists.
+     * @param val - the definition of variables. e.g. set(VAR value)
+     * @param varTable - variable definition record
+     * @param depth - current recursive depth
+     * @returns - include directory set by Set statement.
+     */
+    private static resolveCMakeVar;
+    /**
+     * Determine whether the current line is the start of include_directories or target_include_directories,
+     * If so, enter the collection state and handle scenarios where a single line is immediately closed.
+     * @param line - The line content in CMakeLists.
+     * @param results - Include directories.
+     * @returns new collecting state, funcType, buffer(supporting multi-line parameters).
+     */
+    private static tryStartCollectingIncludeDirs;
+    /**
+     * Extract all include directories from CMakeLists.
+     * @param lines - All lines in CMakeLists.
+     * @returns - include Directories.
+     */
+    private static extractAllIncludeDirs;
+    /**
+     * Parse parameters in line buffer.
+     * @param buffer - line buffer.
+     * @param isTarget - is it a target variable name
+     * @returns - parameters.
+     */
+    private static parseCMakeArgs;
+}
+//# sourceMappingURL=cmakeUtils.d.ts.map

package/lib/frontend/cppFrontend/utils/cmakeUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cmakeUtils.d.ts","sourceRoot":"","sources":["../../../../src/frontend/cppFrontend/utils/cmakeUtils.ts"],"names":[],"mappings":"AAkBA,qBAAa,UAAU;IAEnB;;;;OAIG;WACW,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAyD7D;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;IAS5B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAa9B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,6BAA6B;IAmC5C;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IA2BpC;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;CAwDhC"}