arkanalyzer 1.0.86 → 1.0.88

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

@@ -0,0 +1,413 @@
+"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.buildDefaultArkClassFromArkFile = exports.buildNormalArkClass = exports.buildNormalArkClassFromArkNamespace = exports.buildNormalArkClassFromArkFile = exports.buildNormalArkClassFromArkMethod = void 0;
+const ArkMethod_1 = require("../../../../core/model/ArkMethod");
+const logger_1 = __importStar(require("../../../../utils/logger"));
+const ArkClass_1 = require("../../../../core/model/ArkClass");
+const ArkMethodBuilder_1 = require("./ArkMethodBuilder");
+const builderUtils_1 = require("./builderUtils");
+const ArkFieldBuilder_1 = require("./ArkFieldBuilder");
+const Stmt_1 = require("../../../../core/base/Stmt");
+const Const_1 = require("../../../../core/common/Const");
+const IRUtils_1 = require("../../common/IRUtils");
+const ArkSignature_1 = require("../../../../core/model/ArkSignature");
+const ArkClassBuilder_1 = require("../../../../core/model/builder/ArkClassBuilder");
+const ArkIRTransformer_1 = require("../../common/ArkIRTransformer");
+const ast_1 = require("../../ast");
+const ArkField_1 = require("../../../../core/model/ArkField");
+const Constant_1 = require("../../../../core/base/Constant");
+const ValueUtil_1 = require("../../../../core/common/ValueUtil");
+const Expr_1 = require("../../../../core/base/Expr");
+const Local_1 = require("../../../../core/base/Local");
+const Position_1 = require("../../../../core/base/Position");
+const ArkMetadata_1 = require("../../../../core/model/ArkMetadata");
+const Ref_1 = require("../../../../core/base/Ref");
+const Type_1 = require("../../../../core/base/Type");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ArkClassBuilder');
+function buildNormalArkClassFromArkMethod(clsNode, cls, sourceFile, declaring) {
+    const namespace = cls.getDeclaringArkNamespace();
+    if (namespace) {
+        buildNormalArkClassFromArkNamespace(clsNode, namespace, cls, sourceFile, declaring);
+    }
+    else {
+        buildNormalArkClassFromArkFile(clsNode, cls.getDeclaringArkFile(), cls, sourceFile, declaring);
+    }
+}
+exports.buildNormalArkClassFromArkMethod = buildNormalArkClassFromArkMethod;
+function buildNormalArkClassFromArkFile(clsNode, arkFile, cls, sourceFile, declaring) {
+    cls.setDeclaringArkFile(arkFile);
+    cls.setCode(clsNode.code);
+    const nodePos = (0, ast_1.getNodeStartLineAndCol)(clsNode);
+    cls.setLine(nodePos.line);
+    cls.setColumn(nodePos.col);
+    buildNormalArkClass(clsNode, cls, sourceFile, declaring);
+    arkFile.addArkClass(cls);
+}
+exports.buildNormalArkClassFromArkFile = buildNormalArkClassFromArkFile;
+function buildNormalArkClassFromArkNamespace(clsNode, arkNamespace, cls, sourceFile, declaring) {
+    cls.setDeclaringArkNamespace(arkNamespace);
+    cls.setDeclaringArkFile(arkNamespace.getDeclaringArkFile());
+    cls.setCode(clsNode.code);
+    const nodePos = (0, ast_1.getNodeStartLineAndCol)(clsNode);
+    cls.setLine(nodePos.line);
+    cls.setColumn(nodePos.col);
+    buildNormalArkClass(clsNode, cls, sourceFile, declaring);
+    arkNamespace.addArkClass(cls);
+}
+exports.buildNormalArkClassFromArkNamespace = buildNormalArkClassFromArkNamespace;
+function buildNormalArkClass(clsNode, cls, sourceFile, declaring) {
+    if (clsNode.kind === 'CXXRecordDecl' || clsNode.kind === 'RecordDecl') {
+        switch (clsNode.tagUsed) {
+            case 'struct':
+                buildStruct2ArkClass(clsNode, cls, sourceFile, declaring);
+                break;
+            case 'class':
+                buildClass2ArkClass(clsNode, cls, sourceFile, declaring);
+                break;
+            case 'enum':
+                buildEnum2ArkClass(clsNode, cls, sourceFile, declaring);
+                break;
+            case 'union':
+                buildUnion2ArkClass(clsNode, cls, sourceFile, declaring);
+                break;
+            default:
+        }
+    }
+    if (clsNode.kind === 'ClassTemplateDecl') {
+        buildTemplateClass(clsNode, cls, sourceFile); // The kind attribute of template classes will not be automatically classified as 'class' in tagUsed
+    }
+    else if (clsNode.kind === 'EnumDecl') {
+        buildEnum2ArkClass(clsNode, cls, sourceFile, declaring);
+    }
+    IRUtils_1.IRUtils.setComments(cls, clsNode, sourceFile, cls.getDeclaringArkFile().getScene().getOptions());
+}
+exports.buildNormalArkClass = buildNormalArkClass;
+function buildUnion2ArkClass(clsNode, cls, sourceFile, declaring) {
+    var _a;
+    const className = genClassName(clsNode.name ? clsNode.name : '', cls, declaring);
+    const classSignature = new ArkSignature_1.ClassSignature(className, cls.getDeclaringArkFile().getFileSignature(), ((_a = cls.getDeclaringArkNamespace()) === null || _a === void 0 ? void 0 : _a.getSignature()) || null);
+    cls.setSignature(classSignature);
+    cls.setCategory(ArkClass_1.ClassCategory.UNION);
+    (0, ArkClassBuilder_1.init4InstanceInitMethod)(cls);
+    (0, ArkClassBuilder_1.init4StaticInitMethod)(cls);
+    buildArkClassMembers(clsNode, cls, sourceFile);
+}
+function buildStruct2ArkClass(clsNode, cls, sourceFile, declaring) {
+    var _a;
+    const className = genClassName(clsNode.name ? clsNode.name : '', cls, declaring);
+    const classSignature = new ArkSignature_1.ClassSignature(className, cls.getDeclaringArkFile().getFileSignature(), ((_a = cls.getDeclaringArkNamespace()) === null || _a === void 0 ? void 0 : _a.getSignature()) || null);
+    cls.setSignature(classSignature);
+    if (clsNode.inner) {
+        processCXXHeritage(clsNode, cls);
+    }
+    cls.setModifiers((0, builderUtils_1.buildModifiers)(clsNode));
+    cls.setDecorators((0, builderUtils_1.buildDecorators)(clsNode, sourceFile));
+    cls.setCategory(ArkClass_1.ClassCategory.STRUCT);
+    (0, ArkClassBuilder_1.init4InstanceInitMethod)(cls);
+    (0, ArkClassBuilder_1.init4StaticInitMethod)(cls);
+    buildArkClassMembers(clsNode, cls, sourceFile);
+}
+function buildClass2ArkClass(clsNode, cls, sourceFile, declaring) {
+    var _a;
+    const className = genClassName(clsNode.name ? clsNode.name : '', cls, declaring);
+    const classSignature = new ArkSignature_1.ClassSignature(className, cls.getDeclaringArkFile().getFileSignature(), ((_a = cls.getDeclaringArkNamespace()) === null || _a === void 0 ? void 0 : _a.getSignature()) || null);
+    cls.setSignature(classSignature);
+    if (clsNode.inner) {
+        processCXXHeritage(clsNode, cls);
+    }
+    if (clsNode.kind === 'ClassTemplateDecl') {
+        (0, builderUtils_1.buildTypeParameters)(clsNode, sourceFile, cls).forEach(typeParameter => {
+            cls.addGenericType(typeParameter);
+        });
+    }
+    cls.setCategory(clsNode.tagUsed === 'struct' ? ArkClass_1.ClassCategory.STRUCT : ArkClass_1.ClassCategory.CLASS);
+    (0, ArkClassBuilder_1.init4InstanceInitMethod)(cls);
+    (0, ArkClassBuilder_1.init4StaticInitMethod)(cls);
+    buildArkClassMembers(clsNode, cls, sourceFile);
+    cls.setModifiers((0, builderUtils_1.buildModifiersForCxxClass)(cls));
+}
+function buildTemplateClass(clsNode, cls, sourceFile, declaring) {
+    var _a;
+    const className = genClassName(clsNode.name ? clsNode.name : '', cls, declaring);
+    const classSignature = new ArkSignature_1.ClassSignature(className, cls.getDeclaringArkFile().getFileSignature(), ((_a = cls.getDeclaringArkNamespace()) === null || _a === void 0 ? void 0 : _a.getSignature()) || null);
+    cls.setSignature(classSignature);
+    if (clsNode.inner) {
+        processCXXHeritage(clsNode, cls);
+    }
+    (0, builderUtils_1.buildTypeParameters)(clsNode, sourceFile, cls).forEach(typeParameter => {
+        cls.addGenericType(typeParameter);
+    });
+    let classBody = clsNode.inner[clsNode.inner.length - 1];
+    cls.setCategory(clsNode.tagUsed === 'struct' ? ArkClass_1.ClassCategory.STRUCT : ArkClass_1.ClassCategory.CLASS);
+    (0, ArkClassBuilder_1.init4InstanceInitMethod)(cls);
+    (0, ArkClassBuilder_1.init4StaticInitMethod)(cls);
+    buildArkClassMembers(classBody, cls, sourceFile);
+    cls.setModifiers((0, builderUtils_1.buildModifiersForCxxClass)(cls));
+}
+function genClassName(declaringName, cls, declaring) {
+    if (!declaringName) {
+        const declaringArkNamespace = cls.getDeclaringArkNamespace();
+        const num = declaringArkNamespace ? declaringArkNamespace.getAnonymousClassNumber() : cls.getDeclaringArkFile().getAnonymousClassNumber();
+        declaringName = Const_1.ANONYMOUS_CLASS_PREFIX + num;
+    }
+    let suffix = '';
+    if (declaring instanceof ArkClass_1.ArkClass) {
+        suffix = Const_1.ANONYMOUS_CLASS_DELIMITER + declaring.getName();
+    }
+    else {
+        suffix = declaring ? Const_1.ANONYMOUS_CLASS_DELIMITER + declaring.getDeclaringArkClass().getName() + '.' + declaring.getName() : '';
+    }
+    return declaringName + suffix;
+}
+function processCXXHeritage(clsNode, cls) {
+    var _a, _b;
+    if (clsNode.bases) {
+        for (let i = 0; i < clsNode.bases.length; i++) {
+            let classInfo = {
+                baseClass: undefined,
+                isVirtual: (_a = clsNode.bases[i].isVirtual) !== null && _a !== void 0 ? _a : false,
+                access: (_b = clsNode.bases[i].access) !== null && _b !== void 0 ? _b : 'private',
+            };
+            cls.addHeritageClassNameWithInfo(clsNode.bases[i].type.qualType, classInfo);
+        }
+    }
+}
+function buildEnum2ArkClass(clsNode, cls, sourceFile, declaring) {
+    var _a;
+    const className = genClassName(clsNode.name ? clsNode.name : '', cls, declaring);
+    const classSignature = new ArkSignature_1.ClassSignature(className, cls.getDeclaringArkFile().getFileSignature(), ((_a = cls.getDeclaringArkNamespace()) === null || _a === void 0 ? void 0 : _a.getSignature()) || null);
+    cls.setSignature(classSignature);
+    cls.setCategory(ArkClass_1.ClassCategory.ENUM);
+    (0, ArkClassBuilder_1.init4StaticInitMethod)(cls);
+    buildArkClassMembers(clsNode, cls, sourceFile);
+}
+function buildInitMethodsForClassTag(tagStr, cls, sourceFile, instanceInitStmts, staticInitStmts) {
+    if (tagStr === 'class') {
+        const tu = sourceFile;
+        const instanceIRTransformer = new ArkIRTransformer_1.ArkCxxIRTransformer(tu, cls.getInstanceInitMethod());
+        const staticIRTransformer = new ArkIRTransformer_1.ArkCxxIRTransformer(tu, cls.getStaticInitMethod());
+        (0, ArkMethodBuilder_1.buildInitMethod)(cls.getInstanceInitMethod(), instanceInitStmts, instanceIRTransformer.getThisLocal());
+        (0, ArkMethodBuilder_1.buildInitMethod)(cls.getStaticInitMethod(), staticInitStmts, staticIRTransformer.getThisLocal());
+    }
+    else if (tagStr === 'enum') {
+        const tu = sourceFile;
+        const staticIRTransformer = new ArkIRTransformer_1.ArkCxxIRTransformer(tu, cls.getStaticInitMethod());
+        (0, ArkMethodBuilder_1.buildInitMethod)(cls.getStaticInitMethod(), staticInitStmts, staticIRTransformer.getThisLocal());
+    }
+}
+function buildArkClassMembers(clsNode, cls, sourceFile) {
+    var _a;
+    buildMethodsForClass(clsNode, cls, sourceFile);
+    let staticIRTransformer;
+    const tagStr = ((_a = clsNode.tagUsed) !== null && _a !== void 0 ? _a : '');
+    const staticInitStmts = [];
+    const instanceInitStmts = [];
+    const enumFieldInfo = { lastFieldName: '', curValue: 0, isCurValueValid: true };
+    for (let i = 0; i < clsNode.inner.length; i++) {
+        let member = clsNode.inner[i];
+        switch (member.kind) {
+            case 'FieldDecl':
+            case 'VarDecl': {
+                const arkField = (0, ArkFieldBuilder_1.buildProperty2ArkField)(member, sourceFile, cls);
+                // If the parameter inner is not empty, it means it contains initialization information
+                if (member.inner.length > 0 && member.hasInClassInitializer) {
+                    staticIRTransformer = new ArkIRTransformer_1.ArkCxxIRTransformer(sourceFile, cls.getStaticInitMethod());
+                    getInitStmts(staticIRTransformer, arkField, member.inner[member.inner.length - 1]);
+                }
+                arkField.getInitializer().forEach(stmt => instanceInitStmts.push(stmt));
+                break;
+            }
+            case 'EnumConstantDecl': {
+                const arkField = (0, ArkFieldBuilder_1.buildProperty2ArkField)(member, sourceFile, cls);
+                staticIRTransformer = new ArkIRTransformer_1.ArkCxxIRTransformer(sourceFile, cls.getStaticInitMethod());
+                getInitStmts(staticIRTransformer, arkField, member.inner[0], enumFieldInfo);
+                arkField.getInitializer().forEach(stmt => staticInitStmts.push(stmt));
+                break;
+            }
+            case 'CXXMethodDecl':
+            case 'CXXConstructorDecl':
+            case 'CXXAccessSpecifier':
+            case 'CXXDestructorDecl':
+                // ignore
+                break;
+            case 'EnumDecl':
+            case 'CXXRecordDecl': {
+                processClassDeclInClass(member, cls, sourceFile);
+                break;
+            }
+            case 'UsingDecl':
+                processUsingDeclInClass(member, cls);
+                break;
+            case 'TypeAliasDecl':
+                processTypeAliasDeclInClass(member, cls, sourceFile, instanceInitStmts);
+                break;
+            default:
+                logger.warn('Please contact developers to support new member type: ', member.kind);
+                break;
+        }
+    }
+    buildInitMethodsForClassTag(tagStr, cls, sourceFile, instanceInitStmts, staticInitStmts);
+}
+function processClassDeclInClass(classDeclNode, cls, sourceFile) {
+    const newCls = new ArkClass_1.ArkClass();
+    const namespace = cls.getDeclaringArkNamespace();
+    if (namespace) {
+        buildNormalArkClassFromArkNamespace(classDeclNode, namespace, newCls, sourceFile, cls);
+    }
+    else {
+        buildNormalArkClassFromArkFile(classDeclNode, cls.getDeclaringArkFile(), newCls, sourceFile, cls);
+    }
+}
+function processUsingDeclInClass(usingDecl, cls) {
+    var _a;
+    if (usingDecl.inner.length !== 2) {
+        return;
+    }
+    const curFile = cls.getDeclaringArkFile();
+    const usingClass = curFile.getClassWithName(usingDecl.inner[0].name.replace(/struct |class /g, ''));
+    if (!usingClass) {
+        return;
+    }
+    const usingMemberName = usingDecl.inner[1].name;
+    const member = (_a = usingClass.getMethodWithName(usingMemberName)) !== null && _a !== void 0 ? _a : usingClass.getStaticFieldWithName(usingMemberName);
+    // CXXTodo: classSignature belongs to the base class and needs special handling during the inferType process.
+    if (member instanceof ArkMethod_1.ArkMethod) {
+        cls.addMethod(member);
+    }
+    if (member instanceof ArkField_1.ArkField) {
+        cls.addField(member);
+    }
+}
+function processTypeAliasDeclInClass(typeAliasDecl, cls, sourceFile, instanceInitStmts) {
+    const arkField = (0, ArkFieldBuilder_1.buildProperty2ArkField)(typeAliasDecl, sourceFile, cls);
+    //  it's a  type alias declaration
+    const staticIRTransformer = new ArkIRTransformer_1.ArkCxxIRTransformer(sourceFile, cls.getStaticInitMethod());
+    const stmts = staticIRTransformer.cxxNodeToStmts(typeAliasDecl);
+    if (stmts.length === 0) {
+        return;
+    }
+    stmts.forEach(stmt => instanceInitStmts.push(stmt));
+    arkField.getInitializer().push(...stmts);
+    if (stmts[0] instanceof Stmt_1.ArkAliasTypeDefineStmt) {
+        arkField.getSignature().setType(stmts[0].getAliasType());
+    }
+}
+function buildMethodsForClass(clsNode, cls, sourceFile) {
+    clsNode.inner.forEach((member) => {
+        if (member.kind.toString() === 'CXXMethodDecl' ||
+            member.kind.toString() === 'CXXConstructorDecl' ||
+            member.kind.toString() === 'CXXDestructorDecl' ||
+            member.kind.toString() === 'FriendDecl') {
+            let method = new ArkMethod_1.ArkMethod();
+            (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(member, cls, method, sourceFile);
+        }
+    });
+}
+function buildDefaultArkClassFromArkFile(arkFile, defaultClass, astRoot) {
+    defaultClass.setDeclaringArkFile(arkFile);
+    defaultClass.setCategory(ArkClass_1.ClassCategory.CLASS);
+    buildDefaultArkClass(defaultClass, astRoot);
+}
+exports.buildDefaultArkClassFromArkFile = buildDefaultArkClassFromArkFile;
+function buildDefaultArkClass(cls, sourceFile, node) {
+    var _a;
+    const defaultArkClassSignature = new ArkSignature_1.ClassSignature(Const_1.DEFAULT_ARK_CLASS_NAME, cls.getDeclaringArkFile().getFileSignature(), ((_a = cls.getDeclaringArkNamespace()) === null || _a === void 0 ? void 0 : _a.getSignature()) || null);
+    cls.setSignature(defaultArkClassSignature);
+    genDefaultArkMethod(cls, sourceFile, node);
+}
+function genDefaultArkMethod(cls, sourceFile, node) {
+    let defaultMethod = new ArkMethod_1.ArkMethod();
+    (0, ArkMethodBuilder_1.buildDefaultArkMethodFromArkClass)(cls, defaultMethod, sourceFile, node);
+    cls.setDefaultArkMethod(defaultMethod);
+}
+// Get initialization statement when member variables contain default values
+function getInitStmts(transformer, field, initNode, enumFieldInfo) {
+    let initValue;
+    let initPositions;
+    const stmts = [];
+    if (!transformer) {
+        return;
+    }
+    if (initNode) {
+        let initStmts = [];
+        ({ value: initValue, valueOriginalPositions: initPositions, stmts: initStmts } = transformer.cxxNodeToValueAndStmts(initNode));
+        initStmts.forEach(stmt => stmts.push(stmt));
+        if (enumFieldInfo !== undefined) {
+            if (initValue instanceof Constant_1.NumberConstant) {
+                enumFieldInfo.curValue = parseFloat(initValue.getValue()) + 1;
+                enumFieldInfo.isCurValueValid = true;
+            }
+            else {
+                enumFieldInfo.lastFieldName = field.getName();
+                enumFieldInfo.isCurValueValid = false;
+            }
+        }
+    }
+    else if (enumFieldInfo !== undefined) {
+        if (enumFieldInfo.isCurValueValid) {
+            initValue = ValueUtil_1.ValueUtil.getOrCreateNumberConst(enumFieldInfo.curValue);
+            enumFieldInfo.curValue += 1;
+        }
+        else {
+            initValue = new Expr_1.ArkNormalBinopExpr(new Local_1.Local(enumFieldInfo.lastFieldName), ValueUtil_1.ValueUtil.getOrCreateNumberConst(1), Expr_1.NormalBinaryOperator.Addition);
+            enumFieldInfo.lastFieldName = field.getName();
+        }
+        initPositions = [Position_1.FullPosition.DEFAULT];
+        field.setMetadata(ArkMetadata_1.ArkMetadataKind.ENUM_INIT_TYPE_USER, new ArkMetadata_1.EnumInitTypeUserMetadata(false));
+    }
+    else {
+        return;
+    }
+    const fieldRef = new Ref_1.ArkInstanceFieldRef(transformer.getThisLocal(), field.getSignature());
+    const fieldRefPositions = [Position_1.FullPosition.DEFAULT, Position_1.FullPosition.DEFAULT];
+    const assignStmt = new Stmt_1.ArkAssignStmt(fieldRef, initValue);
+    assignStmt.setOperandOriginalPositions([...fieldRefPositions, ...initPositions]);
+    stmts.push(assignStmt);
+    const fieldSourceCode = field.getCode();
+    const fieldOriginPosition = field.getOriginPosition();
+    for (const stmt of stmts) {
+        stmt.setOriginPositionInfo(fieldOriginPosition);
+        stmt.setOriginalText(fieldSourceCode);
+    }
+    field.setInitializer(stmts);
+    if (field.getType() instanceof Type_1.UnknownType) {
+        field.getSignature().setType(initValue.getType());
+    }
+}

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

@@ -0,0 +1,5 @@
+import { ArkField } from '../../../../core/model/ArkField';
+import { ArkClass } from '../../../../core/model/ArkClass';
+import { CxxAstNode } from '../../ast';
+export declare function buildProperty2ArkField(member: CxxAstNode, sourceFile: CxxAstNode, cls: ArkClass): ArkField;
+//# sourceMappingURL=ArkFieldBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ArkFieldBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/model/builder/ArkFieldBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,QAAQ,EAAiB,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAQ3D,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,EAAE,QAAQ,GAAG,QAAQ,CAuB1G"}

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

@@ -0,0 +1,61 @@
+"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.buildProperty2ArkField = void 0;
+const ArkField_1 = require("../../../../core/model/ArkField");
+const builderUtils_1 = require("./builderUtils");
+const ArkSignature_1 = require("../../../../core/model/ArkSignature");
+const Type_1 = require("../../../../core/base/Type");
+const Position_1 = require("../../../../core/base/Position");
+const ArkBaseModel_1 = require("../../../../core/model/ArkBaseModel");
+const IRUtils_1 = require("../../common/IRUtils");
+const builderUtils_2 = require("../../../../core/model/builder/builderUtils");
+function buildProperty2ArkField(member, sourceFile, cls) {
+    let field = new ArkField_1.ArkField();
+    field.setCategory(mapSyntaxKindToFieldOriginType(member.kind));
+    field.setCode(member.code);
+    field.setDeclaringArkClass(cls);
+    field.setOriginPosition(Position_1.LineColPosition.cxxBuildFromNode(member));
+    let fieldName = member.name;
+    field.addModifier((0, builderUtils_1.buildModifiers)(member));
+    let fieldType = Type_1.UnknownType.getInstance();
+    if ((member.kind === 'FieldDecl' || member.kind === 'VarDecl') && member.type) {
+        fieldType = (0, builderUtils_2.buildGenericType)((0, builderUtils_1.cxxNode2Type)(member, cls, sourceFile), field);
+    }
+    if (member.kind === 'EnumConstantDecl') {
+        field.addModifier(ArkBaseModel_1.ModifierType.STATIC);
+        fieldType = new Type_1.ClassType(cls.getSignature());
+    }
+    field.setSignature(new ArkSignature_1.FieldSignature(fieldName, cls.getSignature(), fieldType, field.isStatic()));
+    IRUtils_1.IRUtils.setComments(field, member, sourceFile, cls.getDeclaringArkFile().getScene().getOptions());
+    cls.addField(field);
+    return field;
+}
+exports.buildProperty2ArkField = buildProperty2ArkField;
+function mapSyntaxKindToFieldOriginType(syntaxKind) {
+    let fieldOriginType = null;
+    switch (syntaxKind) {
+        case 'FieldDecl':
+        case 'TypeAliasDecl':
+            fieldOriginType = ArkField_1.FieldCategory.PROPERTY_DECLARATION;
+            break;
+        case 'EnumConstantDecl':
+            fieldOriginType = ArkField_1.FieldCategory.ENUM_MEMBER;
+            break;
+        default:
+    }
+    return fieldOriginType;
+}

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

@@ -0,0 +1,17 @@
+import { ArkFile } from '../../../../core/model/ArkFile';
+import { ArkClass } from '../../../../core/model/ArkClass';
+import { CxxAstNode } from '../../ast';
+export declare const classMap: Map<string, ArkClass>;
+/**
+ * Entry of building ArkFile instance
+ *
+ * @param absoluteFilePath
+ * @param projectDir
+ * @param arkFile
+ * @param projectName
+ * @param includeDirs
+ * @returns
+ */
+export declare function buildArkFileFromFile(absoluteFilePath: string, projectDir: string, arkFile: ArkFile, projectName: string, includeDirs?: string[]): void;
+export declare function buildArkClassFromCxxClass(classNode: CxxAstNode, arkFile: ArkFile, astRoot: CxxAstNode): void;
+//# sourceMappingURL=ArkFileBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ArkFileBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/model/builder/ArkFileBuilder.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAMzD,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAS3D,OAAO,EAAsB,UAAU,EAAkB,MAAM,WAAW,CAAC;AAa3E,eAAO,MAAM,QAAQ,EAAG,GAAG,CAAC,MAAM,EAAE,QAAQ,CAA+B,CAAC;AAgD5E;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,gBAAgB,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAE,MAAM,EAAO,GAAG,IAAI,CAa1J;AAED,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CAU5G"}