arkanalyzer 1.0.86 → 1.0.88

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

@@ -0,0 +1,422 @@
+"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.isMethodImplementation = exports.addInitInConstructor = exports.buildInitMethod = exports.buildDefaultConstructor = exports.recursivelyCheckAndBuildSuperConstructor = exports.buildArkMethodFromArkClass = exports.handleFunctionTemplateDecl = exports.buildDefaultArkMethodFromArkClass = void 0;
+const Type_1 = require("../../../../core/base/Type");
+const BodyBuilder_1 = require("./BodyBuilder");
+const ArkMethod_1 = require("../../../../core/model/ArkMethod");
+const builderUtils_1 = require("./builderUtils");
+const Ref_1 = require("../../../../core/base/Ref");
+const ArkBody_1 = require("../../../../core/model/ArkBody");
+const Cfg_1 = require("../../../../core/graph/Cfg");
+const Expr_1 = require("../../../../core/base/Expr");
+const ArkSignature_1 = require("../../../../core/model/ArkSignature");
+const Stmt_1 = require("../../../../core/base/Stmt");
+const BasicBlock_1 = require("../../../../core/graph/BasicBlock");
+const Local_1 = require("../../../../core/base/Local");
+const Const_1 = require("../../../../core/common/Const");
+const IRUtils_1 = require("../../common/IRUtils");
+const ArkMethodBuilder_1 = require("../../../../core/model/builder/ArkMethodBuilder");
+const builderUtils_2 = require("../../../../core/model/builder/builderUtils");
+const TSConst_1 = require("../../../../core/common/TSConst");
+const ArkSignatureBuilder_1 = require("../../../../core/model/builder/ArkSignatureBuilder");
+const logger_1 = __importStar(require("../../../../utils/logger"));
+const ast_1 = require("../../ast");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ArkMethodBuilder');
+function getSpecificNodes(methodNode, targetNode) {
+    if (!methodNode || !methodNode.inner) {
+        return [];
+    }
+    // Handle Cpp lambda functions
+    if (methodNode.type && !((0, builderUtils_1.isCxxFunctionPointer)(methodNode.type.qualType)) &&
+        !['FunctionDecl', 'CXXMethodDecl', 'CXXConstructorDecl', 'CXXDestructorDecl', 'FriendDecl', 'LambdaExpr', 'FunctionTemplateDecl'].includes(methodNode.kind) &&
+        methodNode.inner) {
+        return getSpecificNodes(methodNode.inner[0], targetNode);
+    }
+    let result = [];
+    methodNode.inner.forEach((childNode) => {
+        if (childNode.kind.toString() === targetNode) {
+            result.push(childNode);
+        }
+    });
+    return result.length > 0 ? result : [];
+}
+function buildDefaultArkMethodFromArkClass(declaringClass, mtd, sourceFile, node) {
+    mtd.setDeclaringArkClass(declaringClass);
+    const methodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(Const_1.DEFAULT_ARK_METHOD_NAME, true);
+    const methodSignature = new ArkSignature_1.MethodSignature(mtd.getDeclaringArkClass().getSignature(), methodSubSignature);
+    mtd.setImplementationSignature(methodSignature);
+    mtd.setLineCol(0);
+    const defaultMethodNode = node ? node : sourceFile;
+    let bodyBuilder = new BodyBuilder_1.CxxBodyBuilder(mtd.getSignature(), defaultMethodNode, mtd, sourceFile);
+    mtd.setCxxBodyBuilder(bodyBuilder);
+}
+exports.buildDefaultArkMethodFromArkClass = buildDefaultArkMethodFromArkClass;
+function handleFunctionTemplateDecl(methodNode, mtd, sourceFile) {
+    if (methodNode.kind !== 'FunctionTemplateDecl' && methodNode.kind !== 'LambdaExpr') {
+        return;
+    }
+    mtd.isGenericsMethod();
+    let templateTypesArray = [];
+    let index = -1;
+    for (const innerNode of methodNode.inner) {
+        if (innerNode.kind !== 'TemplateTypeParmVarDecl' && innerNode.kind !== 'TemplateTypeParmDecl') {
+            continue;
+        }
+        let typename = innerNode.name;
+        // Template for handling parameter folding
+        if (innerNode.code.includes('...')) {
+            typename = typename + '...';
+        }
+        let defaultType;
+        if (innerNode.defaultArg) {
+            defaultType = (0, builderUtils_1.cxxNode2Type)(innerNode, undefined);
+        }
+        let templateType = new Type_1.GenericType(typename, defaultType);
+        templateType.setIndex(++index);
+        templateTypesArray.push(templateType);
+    }
+    mtd.setGenericTypes(templateTypesArray);
+}
+exports.handleFunctionTemplateDecl = handleFunctionTemplateDecl;
+function buildArkMethodFromArkClass(methodNode, declaringClass, mtd, sourceFile, declaringMethod) {
+    mtd.setDeclaringArkClass(declaringClass);
+    if (declaringMethod !== undefined) {
+        mtd.setOuterMethod(declaringMethod);
+    }
+    if (methodNode.kind === 'FunctionDecl' || methodNode.kind === 'FunctionTemplateDecl') {
+        mtd.setAsteriskToken(false);
+    }
+    handleFunctionTemplateDecl(methodNode, mtd, sourceFile);
+    // After processing the template parameters, proceed to the corresponding functions below
+    methodNode = methodNode.kind === 'FunctionTemplateDecl' ? methodNode.inner[methodNode.inner.length - 1] : methodNode;
+    mtd.setCode(methodNode.code);
+    mtd.addModifier((0, builderUtils_1.buildModifiers)(methodNode));
+    if (methodNode.kind === 'FriendDecl' && methodNode.inner.length > 0) {
+        methodNode = methodNode.inner[0];
+    }
+    const methodName = buildMethodName(methodNode, declaringClass, sourceFile, declaringMethod);
+    const methodParameters = [];
+    const parameters = getSpecificNodes(methodNode, 'ParmVarDecl');
+    (0, builderUtils_1.buildParameters)(parameters, mtd, sourceFile).forEach(parameter => {
+        (0, builderUtils_2.buildGenericType)(parameter.getType(), mtd);
+        methodParameters.push(parameter);
+    });
+    let returnType = Type_1.UnknownType.getInstance();
+    if (methodNode.type) {
+        returnType = (0, builderUtils_2.buildGenericType)((0, builderUtils_1.buildReturnType)(methodNode, sourceFile, mtd), mtd);
+    }
+    if (isRelatedToCXXInheritedCtorInitExpr(methodNode)) {
+        addParamsToCXXInheritedCtorInitExpr(methodNode, mtd, methodParameters);
+        returnType = Type_1.VoidType.getInstance();
+    }
+    reCheckModifiers(methodName, declaringClass, mtd, methodParameters);
+    const methodSubSignature = new ArkSignature_1.MethodSubSignature(methodName, methodParameters, returnType, mtd.isStatic());
+    const methodSignature = new ArkSignature_1.MethodSignature(mtd.getDeclaringArkClass().getSignature(), methodSubSignature);
+    const nodePos = (0, ast_1.getNodeStartLineAndCol)(methodNode);
+    if (isMethodImplementation(methodNode)) {
+        mtd.setImplementationSignature(methodSignature);
+        mtd.setLine(nodePos.line);
+        mtd.setColumn(nodePos.col);
+        let bodyBuilder = new BodyBuilder_1.CxxBodyBuilder(mtd.getSignature(), methodNode, mtd, sourceFile);
+        mtd.setCxxBodyBuilder(bodyBuilder);
+    }
+    else {
+        mtd.setDeclareSignatures(methodSignature);
+        mtd.setDeclareLinesAndCols([nodePos.line], [nodePos.col]);
+    }
+    checkAndUpdateCxxMethod(mtd, declaringClass);
+    declaringClass.addMethod(mtd);
+    IRUtils_1.IRUtils.setComments(mtd, methodNode, sourceFile, mtd.getDeclaringArkFile().getScene().getOptions());
+}
+exports.buildArkMethodFromArkClass = buildArkMethodFromArkClass;
+// When a function is implemented outside the class, it retrieves the modifier at the original definition
+function reCheckModifiers(methodName, cls, method, parameters) {
+    let methodsWithSameName = cls.getAllMethodsWithName(methodName);
+    if (methodsWithSameName.length === 0) {
+        return;
+    }
+    for (const preMtd of methodsWithSameName) {
+        let preParameters = preMtd.getSubSignature().getParameters();
+        if (compareParameters(preParameters, parameters)) {
+            method.addModifier(preMtd.getModifiers());
+        }
+    }
+}
+function compareParameters(preParameters, parameters) {
+    if (preParameters.length !== parameters.length) {
+        return false;
+    }
+    for (let i = 0; i < parameters.length; i++) {
+        if (parameters[i].getType().toString() !== preParameters[i].getType().toString()) {
+            return false;
+        }
+    }
+    return true;
+}
+function checkAndUpdateCxxMethod(method, cls) {
+    const methodName = method.getName();
+    const methodSignature = method.getSignature();
+    let methodsWithSameName = cls.getAllMethodsWithName(methodName);
+    if (methodsWithSameName.length === 0) {
+        return;
+    }
+    for (const preMtd of methodsWithSameName) {
+        if (preMtd.getSignature().isMatch(methodSignature)) {
+            (0, ArkMethodBuilder_1.updateMethodSignaturesAndLineCols)(method, preMtd);
+            break;
+        }
+    }
+}
+function isRelatedToCXXInheritedCtorInitExpr(node) {
+    if (!node) {
+        return false;
+    }
+    let innerNodes = node.inner;
+    while (innerNodes) {
+        if (innerNodes.length === 0) {
+            return false;
+        }
+        if (innerNodes[0].kind === 'CXXInheritedCtorInitExpr') {
+            return true;
+        }
+        innerNodes = innerNodes[0].inner;
+    }
+    return false;
+}
+function addParamsToCXXInheritedCtorInitExpr(mtdNode, mtd, methodParameters) {
+    var _a, _b, _c;
+    const cls = mtd.getDeclaringArkClass();
+    const superClassName = (_c = (_b = (_a = mtdNode.inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.baseInit) === null || _c === void 0 ? void 0 : _c.qualType;
+    if (!superClassName) {
+        return;
+    }
+    let superClass = cls.getHeritageClass(superClassName);
+    if (!superClass) {
+        cls.addHeritageClassName(superClassName);
+        superClass = cls.getDeclaringArkFile().getClassWithName(superClassName);
+        if (!superClass) {
+            return;
+        }
+    }
+    buildDefaultConstructor(superClass);
+    const superConstructor = superClass.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME);
+    if (!superConstructor) {
+        return;
+    }
+    superConstructor.getParameters().forEach(param => {
+        (0, builderUtils_2.buildGenericType)(param.getType(), mtd);
+        methodParameters.push(param);
+    });
+}
+function buildMethodName(node, declaringClass, sourceFile, declaringMethod) {
+    let name = '';
+    let declType = node.kind.toString();
+    switch (declType) {
+        case 'CXXMethodDecl':
+        case 'FunctionDecl':
+        case 'CXXDestructorDecl':
+        case 'FunctionTemplateDecl':
+            name = node.name.toString();
+            break;
+        case 'CXXConstructorDecl':
+            name = 'constructor';
+            break;
+        case 'LambdaExpr':
+            name = buildAnonymousMethodName(node, declaringClass);
+            break;
+        case 'VarDecl':
+        case 'ParmVarDecl':
+            if ((0, builderUtils_1.isCxxFunctionPointer)(node.type.qualType)) {
+                name = buildAnonymousMethodName(node, declaringClass);
+            }
+            break;
+        default:
+            break;
+    }
+    if (declaringMethod !== undefined && !declaringMethod.isDefaultArkMethod()) {
+        name = (0, ArkMethodBuilder_1.buildNestedMethodName)(name, declaringMethod.getName());
+    }
+    return name;
+}
+function buildAnonymousMethodName(node, declaringClass) {
+    return `${Const_1.ANONYMOUS_METHOD_PREFIX}${declaringClass.getAnonymousMethodNumber()}`;
+}
+function recursivelyCheckAndBuildSuperConstructor(arkClass) {
+    const superClasses = arkClass.getAllHeritageClasses();
+    if (!superClasses) {
+        return;
+    }
+    for (const superClass of superClasses) {
+        if (superClass.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME) === null) {
+            buildDefaultConstructor(superClass);
+        }
+        recursivelyCheckAndBuildSuperConstructor(superClass);
+    }
+}
+exports.recursivelyCheckAndBuildSuperConstructor = recursivelyCheckAndBuildSuperConstructor;
+function buildDefaultConstructor(arkClass) {
+    var _a;
+    if (!(0, ArkMethodBuilder_1.needDefaultConstructorInClass)(arkClass)) {
+        return false;
+    }
+    recursivelyCheckAndBuildSuperConstructor(arkClass);
+    const defaultConstructor = new ArkMethod_1.ArkMethod();
+    defaultConstructor.setDeclaringArkClass(arkClass);
+    defaultConstructor.setCode(arkClass.getName());
+    defaultConstructor.setIsGeneratedFlag(false);
+    const thisLocal = new Local_1.Local(TSConst_1.THIS_NAME, new Type_1.ClassType(arkClass.getSignature()));
+    const locals = new Set([thisLocal]);
+    const basicBlock = new BasicBlock_1.BasicBlock();
+    basicBlock.setId(0);
+    let parameters = [];
+    let parameterArgs = [];
+    const superConstructor = (_a = arkClass.getSuperClass()) === null || _a === void 0 ? void 0 : _a.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME);
+    if (superConstructor) {
+        parameters = superConstructor.getParameters();
+        for (let index = 0; index < parameters.length; index++) {
+            const parameterRef = new Ref_1.ArkParameterRef(index, parameters[index].getType());
+            const parameterLocal = new Local_1.Local(parameters[index].getName(), parameterRef.getType());
+            locals.add(parameterLocal);
+            parameterArgs.push(parameterLocal);
+            basicBlock.addStmt(new Stmt_1.ArkAssignStmt(parameterLocal, parameterRef));
+        }
+    }
+    basicBlock.addStmt(new Stmt_1.ArkAssignStmt(thisLocal, new Ref_1.ArkThisRef(new Type_1.ClassType(arkClass.getSignature()))));
+    if (superConstructor) {
+        const superMethodSubSignature = new ArkSignature_1.MethodSubSignature(TSConst_1.SUPER_NAME, parameters, superConstructor.getReturnType());
+        const superMethodSignature = new ArkSignature_1.MethodSignature(arkClass.getSignature(), superMethodSubSignature);
+        const superInvokeExpr = new Expr_1.ArkStaticInvokeExpr(superMethodSignature, parameterArgs);
+        basicBlock.addStmt(new Stmt_1.ArkInvokeStmt(superInvokeExpr));
+    }
+    const methodSubSignature = new ArkSignature_1.MethodSubSignature(TSConst_1.CONSTRUCTOR_NAME, parameters, thisLocal.getType(), defaultConstructor.isStatic());
+    defaultConstructor.setImplementationSignature(new ArkSignature_1.MethodSignature(arkClass.getSignature(), methodSubSignature));
+    basicBlock.addStmt(new Stmt_1.ArkReturnStmt(thisLocal));
+    const cfg = new Cfg_1.Cfg();
+    cfg.addBlock(basicBlock);
+    cfg.setStartingStmt(basicBlock.getHead());
+    cfg.setDeclaringMethod(defaultConstructor);
+    cfg.getStmts().forEach(s => s.setCfg(cfg));
+    defaultConstructor.setBody(new ArkBody_1.ArkBody(locals, cfg));
+    checkAndUpdateCxxMethod(defaultConstructor, arkClass);
+    arkClass.addMethod(defaultConstructor);
+    return true;
+}
+exports.buildDefaultConstructor = buildDefaultConstructor;
+function buildInitMethod(initMethod, fieldInitializerStmts, thisLocal) {
+    const classType = new Type_1.ClassType(initMethod.getDeclaringArkClass().getSignature());
+    const assignStmt = new Stmt_1.ArkAssignStmt(thisLocal, new Ref_1.ArkThisRef(classType));
+    const block = new BasicBlock_1.BasicBlock();
+    block.setId(0);
+    block.addStmt(assignStmt);
+    const locals = new Set([thisLocal]);
+    for (const stmt of fieldInitializerStmts) {
+        block.addStmt(stmt);
+        if (stmt.getDef() && stmt.getDef() instanceof Local_1.Local) {
+            locals.add(stmt.getDef());
+        }
+    }
+    block.addStmt(new Stmt_1.ArkReturnVoidStmt());
+    const cfg = new Cfg_1.Cfg();
+    cfg.addBlock(block);
+    for (const stmt of block.getStmts()) {
+        stmt.setCfg(cfg);
+    }
+    cfg.setStartingStmt(assignStmt);
+    cfg.buildDefUseStmt(locals);
+    cfg.setDeclaringMethod(initMethod);
+    initMethod.setBody(new ArkBody_1.ArkBody(locals, cfg));
+}
+exports.buildInitMethod = buildInitMethod;
+function addInitInConstructor(constructor) {
+    var _a, _b;
+    const thisLocal = (_a = constructor.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals().get(TSConst_1.THIS_NAME);
+    if (!thisLocal) {
+        return;
+    }
+    const cfg = constructor.getCfg();
+    if (cfg === undefined) {
+        return;
+    }
+    const blocks = (_b = constructor.getCfg()) === null || _b === void 0 ? void 0 : _b.getBlocks();
+    if (!blocks) {
+        return;
+    }
+    const firstBlockStmts = [...blocks][0].getStmts();
+    let index = 0;
+    for (let i = 0; i < firstBlockStmts.length; i++) {
+        const stmt = firstBlockStmts[i];
+        if ((stmt.getDef() instanceof Local_1.Local && stmt.getDef().getName() === TSConst_1.THIS_NAME) ||
+            (stmt instanceof Stmt_1.ArkInvokeStmt && stmt.getInvokeExpr().getMethodSignature().getMethodSubSignature().getMethodName() === TSConst_1.CONSTRUCTOR_NAME)) {
+            index = i + 1;
+        }
+    }
+    let initInvokeStmt;
+    try {
+        initInvokeStmt = new Stmt_1.ArkInvokeStmt(new Expr_1.ArkInstanceInvokeExpr(thisLocal, constructor.getDeclaringArkClass().getInstanceInitMethod().getSignature(), []));
+    }
+    catch (e) {
+        logger.warn('addInitInConstructor: failed to build initInvokeStmt due to exception: ', e);
+        return;
+    }
+    if (initInvokeStmt) {
+        initInvokeStmt.setCfg(cfg);
+        firstBlockStmts.splice(index, 0, initInvokeStmt);
+    }
+}
+exports.addInitInConstructor = addInitInConstructor;
+function isMethodImplementation(node) {
+    var _a;
+    switch (node.kind) {
+        case 'LambdaExpr':
+            return (node.inner && node.inner.length > 0);
+        case 'CXXMethodDecl':
+        case 'CXXConstructorDecl':
+        case 'CXXDestructorDecl':
+        case 'FunctionDecl':
+        case 'FunctionTemplateDecl':
+        case 'FriendDecl':
+            // CXXConstructorDecl-CXXCtorInitializer: using Base::Base
+            // ==> The constructor of the subclass has the same implementation as that of the parent class.
+            return !!((_a = node.inner) === null || _a === void 0 ? void 0 : _a.find((inn) => (inn.kind === 'CompoundStmt' || inn.kind === 'CXXCtorInitializer')));
+        default:
+            return false;
+    }
+}
+exports.isMethodImplementation = isMethodImplementation;

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

@@ -0,0 +1,8 @@
+import { ArkFile } from '../../../../core/model/ArkFile';
+import { ArkNamespace } from '../../../../core/model/ArkNamespace';
+import { ArkClass } from '../../../../core/model/ArkClass';
+import { CxxAstNode } from '../../ast';
+export declare function buildDefaultArkClassFromArkNamespace(arkNamespace: ArkNamespace, defaultClass: ArkClass, nsNode: CxxAstNode, sourceFile: CxxAstNode): void;
+export declare function genDefaultArkClass(ns: ArkNamespace, node: CxxAstNode, sourceFile: CxxAstNode): void;
+export declare function buildArkNamespace(node: CxxAstNode, declaringInstance: ArkFile | ArkNamespace, ns: ArkNamespace, sourceFile: CxxAstNode): void;
+//# sourceMappingURL=ArkNamespaceBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ArkNamespaceBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/model/builder/ArkNamespaceBuilder.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAGnE,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAG3D,OAAO,EAAE,UAAU,EAA0B,MAAM,WAAW,CAAC;AAuB/D,wBAAgB,oCAAoC,CAChD,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,QAAQ,EACtB,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,UAAU,GACvB,IAAI,CAIN;AAGD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI,CAMnG;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,EAAE,iBAAiB,EAAE,OAAO,GAAG,YAAY,EAAE,EAAE,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI,CAsC7I"}

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

@@ -0,0 +1,194 @@
+"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.buildArkNamespace = exports.genDefaultArkClass = exports.buildDefaultArkClassFromArkNamespace = void 0;
+const ArkClassBuilder_1 = require("./ArkClassBuilder");
+const ArkFile_1 = require("../../../../core/model/ArkFile");
+const ArkMethodBuilder_1 = require("./ArkMethodBuilder");
+const ArkNamespace_1 = require("../../../../core/model/ArkNamespace");
+const builderUtils_1 = require("./builderUtils");
+const logger_1 = __importStar(require("../../../../utils/logger"));
+const ArkClass_1 = require("../../../../core/model/ArkClass");
+const ArkMethod_1 = require("../../../../core/model/ArkMethod");
+const ArkSignature_1 = require("../../../../core/model/ArkSignature");
+const ast_1 = require("../../ast");
+const Const_1 = require("../../../../core/common/Const");
+const ArkMethodBuilder_2 = require("./ArkMethodBuilder");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ArkNamespaceBuilder');
+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_2.buildDefaultArkMethodFromArkClass)(cls, defaultMethod, sourceFile, node);
+    cls.setDefaultArkMethod(defaultMethod);
+}
+function buildDefaultArkClassFromArkNamespace(arkNamespace, defaultClass, nsNode, sourceFile) {
+    defaultClass.setDeclaringArkNamespace(arkNamespace);
+    defaultClass.setDeclaringArkFile(arkNamespace.getDeclaringArkFile());
+    buildDefaultArkClass(defaultClass, sourceFile, nsNode);
+}
+exports.buildDefaultArkClassFromArkNamespace = buildDefaultArkClassFromArkNamespace;
+function genDefaultArkClass(ns, node, sourceFile) {
+    let defaultClass = new ArkClass_1.ArkClass();
+    buildDefaultArkClassFromArkNamespace(ns, defaultClass, node, sourceFile);
+    ns.setDefaultClass(defaultClass);
+    ns.addArkClass(defaultClass);
+}
+exports.genDefaultArkClass = genDefaultArkClass;
+function buildArkNamespace(node, declaringInstance, ns, sourceFile) {
+    var _a;
+    // modifiers
+    if (node.modifiers) {
+        ns.setModifiers((0, builderUtils_1.buildModifiers)(node));
+        ns.setDecorators((0, builderUtils_1.buildDecorators)(node, sourceFile));
+    }
+    if (declaringInstance instanceof ArkFile_1.ArkFile) {
+        ns.setDeclaringArkFile(declaringInstance);
+    }
+    else {
+        ns.setDeclaringArkNamespace(declaringInstance);
+        ns.setDeclaringArkFile(declaringInstance.getDeclaringArkFile());
+    }
+    ns.setDeclaringInstance(declaringInstance);
+    const namespaceName = genNamespaceName(node.name ? node.name : '', declaringInstance);
+    const namespaceSignature = new ArkSignature_1.NamespaceSignature(namespaceName, ns.getDeclaringArkFile().getFileSignature(), ((_a = ns.getDeclaringArkNamespace()) === null || _a === void 0 ? void 0 : _a.getSignature()) || null);
+    ns.setSignature(namespaceSignature);
+    // TODO: whether needed?
+    ns.setCode(node.code);
+    // set line and column
+    const nodePos = (0, ast_1.getNodeStartLineAndCol)(node);
+    ns.setLine(nodePos.line);
+    ns.setColumn(nodePos.col);
+    genDefaultArkClass(ns, node, sourceFile);
+    // build ns member
+    if (node.inner) {
+        buildNamespaceMembers(node, ns, sourceFile);
+    }
+    else {
+        logger.warn('JSDocNamespaceDeclaration found.');
+    }
+}
+exports.buildArkNamespace = buildArkNamespace;
+function genNamespaceName(name, declaringInstance) {
+    if (!name) {
+        const num = declaringInstance.getAnonymousNamespaceNumber();
+        name = Const_1.ANONYMOUS_NAMESPACE_PREFIX + num;
+    }
+    return name;
+}
+function processUsingDeclInNamespace(usingDeclNode, namespace) {
+    // CXXTodo: using NS::Member,  scenario 'NS is from other file' is not handled.
+    const curArkFile = namespace.getDeclaringArkFile();
+    let curNS;
+    if (usingDeclNode.name.includes('::')) {
+        const namespaceName = usingDeclNode.name.substring(0, usingDeclNode.name.indexOf('::'));
+        const memberName = usingDeclNode.name.substring(usingDeclNode.name.indexOf('::') + 2);
+        curNS = curArkFile.getNamespaceWithName(namespaceName);
+        let usingFunc = curNS === null || curNS === void 0 ? void 0 : curNS.getDefaultClass().getMethodWithName(memberName);
+        if (usingFunc) {
+            namespace.getDefaultClass().addMethod(usingFunc);
+            return;
+        }
+    }
+}
+// TODO: check and update
+function buildNamespaceMembers(node, namespace, sourceFile) {
+    const statements = node.inner;
+    statements.forEach((child) => {
+        switch (child.kind) {
+            case 'NamespaceDecl': {
+                let childNs = new ArkNamespace_1.ArkNamespace();
+                childNs.setDeclaringArkNamespace(namespace);
+                childNs.setDeclaringArkFile(namespace.getDeclaringArkFile());
+                buildArkNamespace(child, namespace, childNs, sourceFile);
+                namespace.addNamespace(childNs);
+                return;
+            }
+            case 'CXXRecordDecl':
+            case 'ClassTemplateDecl': {
+                let cls = new ArkClass_1.ArkClass();
+                (0, ArkClassBuilder_1.buildNormalArkClassFromArkNamespace)(child, namespace, cls, sourceFile);
+                return;
+            }
+            case 'CXXConstructorDecl':
+            case 'CXXDestructorDecl':
+            case 'CXXMethodDecl': {
+                buildArkMethodForClassMethodInNamespace(child, namespace, sourceFile);
+                return;
+            }
+            case 'FunctionTemplateDecl':
+            case 'FunctionDecl':
+            case 'FriendDecl': {
+                let mthd = new ArkMethod_1.ArkMethod();
+                (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(child, namespace.getDefaultClass(), mthd, sourceFile);
+                return;
+            }
+            case 'UsingDecl':
+                // CXXTodo: using NS::Member,  scenario 'NS is from other file' is not handled.
+                processUsingDeclInNamespace(child, namespace);
+                return;
+            default:
+                logger.trace('Child joined default method of arkFile: ', child.kind);
+            // join default method
+        }
+    });
+}
+function buildArkMethodForClassMethodInNamespace(methodNode, namespace, sourceFile) {
+    var _a;
+    let className = methodNode.mangledName;
+    if (!className) {
+        logger.trace('Declaration class not found', methodNode);
+        return;
+    }
+    let arkClass = namespace.getClassWithName(className);
+    if (!arkClass) {
+        arkClass = new ArkClass_1.ArkClass();
+        arkClass.setDeclaringArkNamespace(namespace);
+        arkClass.setDeclaringArkFile(namespace.getDeclaringArkFile());
+        const classSignature = new ArkSignature_1.ClassSignature(className, arkClass.getDeclaringArkFile().getFileSignature(), ((_a = arkClass.getDeclaringArkNamespace()) === null || _a === void 0 ? void 0 : _a.getSignature()) || null);
+        arkClass.setSignature(classSignature);
+        namespace.addArkClass(arkClass, className);
+    }
+    let mtd = new ArkMethod_1.ArkMethod();
+    (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(methodNode, arkClass, mtd, sourceFile);
+}