arkanalyzer 1.0.5

package/lib/core/model/builder/ArkMethodBuilder.js

@@ -0,0 +1,419 @@
+"use strict";
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addInitInConstructor = exports.buildInitMethod = exports.buildDefaultConstructor = exports.MethodParameter = exports.ArrayBindingPatternParameter = exports.ObjectBindingPatternParameter = exports.buildArkMethodFromArkClass = exports.buildDefaultArkMethodFromArkClass = void 0;
+const Type_1 = require("../../base/Type");
+const BodyBuilder_1 = require("../../common/BodyBuilder");
+const ViewTreeBuilder_1 = require("../../graph/builder/ViewTreeBuilder");
+const ArkClass_1 = require("../ArkClass");
+const ArkMethod_1 = require("../ArkMethod");
+const ohos_typescript_1 = __importDefault(require("ohos-typescript"));
+const builderUtils_1 = require("./builderUtils");
+const logger_1 = __importStar(require("../../../utils/logger"));
+const Ref_1 = require("../../base/Ref");
+const ArkBody_1 = require("../ArkBody");
+const Cfg_1 = require("../../graph/Cfg");
+const Expr_1 = require("../../base/Expr");
+const ArkSignature_1 = require("../ArkSignature");
+const Stmt_1 = require("../../base/Stmt");
+const BasicBlock_1 = require("../../graph/BasicBlock");
+const Local_1 = require("../../base/Local");
+const TSConst_1 = require("../../common/TSConst");
+const Const_1 = require("../../common/Const");
+const ArkSignatureBuilder_1 = require("./ArkSignatureBuilder");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ArkMethodBuilder');
+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.setSignature(methodSignature);
+    const defaultMethodNode = node ? node : sourceFile;
+    let bodyBuilder = new BodyBuilder_1.BodyBuilder(mtd.getSignature(), defaultMethodNode, mtd, sourceFile);
+    mtd.setBodyBuilder(bodyBuilder);
+}
+exports.buildDefaultArkMethodFromArkClass = buildDefaultArkMethodFromArkClass;
+function buildArkMethodFromArkClass(methodNode, declaringClass, mtd, sourceFile, declaringMethod) {
+    mtd.setDeclaringArkClass(declaringClass);
+    if (ohos_typescript_1.default.isFunctionDeclaration(methodNode)) {
+        mtd.setAsteriskToken(methodNode.asteriskToken != undefined);
+    }
+    mtd.setCode(methodNode.getText(sourceFile));
+    const { line, character } = ohos_typescript_1.default.getLineAndCharacterOfPosition(sourceFile, methodNode.getStart(sourceFile));
+    mtd.setLine(line + 1);
+    mtd.setColumn(character + 1);
+    (0, builderUtils_1.buildModifiers)(methodNode, sourceFile).forEach((value) => {
+        mtd.addModifier(value);
+    });
+    if (methodNode.typeParameters) {
+        mtd.setGenericTypes((0, builderUtils_1.buildTypeParameters)(methodNode.typeParameters, sourceFile, mtd));
+    }
+    // build MethodSignature
+    const methodName = buildMethodName(methodNode, declaringClass, sourceFile, declaringMethod);
+    const methodParameters = [];
+    (0, builderUtils_1.buildParameters)(methodNode.parameters, mtd, sourceFile).forEach((parameter) => {
+        methodParameters.push(parameter);
+    });
+    let returnType = Type_1.UnknownType.getInstance();
+    if (methodNode.type) {
+        returnType = (0, builderUtils_1.buildGenericType)((0, builderUtils_1.buildReturnType)(methodNode.type, sourceFile, mtd), mtd);
+    }
+    const methodSubSignature = new ArkSignature_1.MethodSubSignature(methodName, methodParameters, returnType, mtd.isStatic());
+    const methodSignature = new ArkSignature_1.MethodSignature(mtd.getDeclaringArkClass().getSignature(), methodSubSignature);
+    mtd.setSignature(methodSignature);
+    let bodyBuilder = new BodyBuilder_1.BodyBuilder(mtd.getSignature(), methodNode, mtd, sourceFile);
+    mtd.setBodyBuilder(bodyBuilder);
+    if (mtd.hasBuilderDecorator()) {
+        mtd.setViewTree((0, ViewTreeBuilder_1.buildViewTree)(mtd));
+    }
+    else if (declaringClass.hasComponentDecorator() &&
+        mtd.getSubSignature().toString() == 'build()' &&
+        !mtd.containsModifier('StaticKeyword')) {
+        declaringClass.setViewTree((0, ViewTreeBuilder_1.buildViewTree)(mtd));
+    }
+    declaringClass.addMethod(mtd);
+}
+exports.buildArkMethodFromArkClass = buildArkMethodFromArkClass;
+function buildMethodName(node, declaringClass, sourceFile, declaringMethod) {
+    let name = '';
+    if (ohos_typescript_1.default.isFunctionDeclaration(node) || ohos_typescript_1.default.isFunctionExpression(node)) {
+        if (node.name) {
+            name = node.name.text;
+        }
+        else {
+            name = buildAnonymousMethodName(node, declaringClass, declaringMethod);
+        }
+    }
+    else if (ohos_typescript_1.default.isFunctionTypeNode(node)) {
+        if (node.name) {
+            //TODO: check name type
+            name = node.name.getText(sourceFile);
+        }
+        else {
+            name = buildAnonymousMethodName(node, declaringClass, declaringMethod);
+        }
+    }
+    else if (ohos_typescript_1.default.isMethodDeclaration(node) || ohos_typescript_1.default.isMethodSignature(node)) {
+        if (ohos_typescript_1.default.isIdentifier(node.name)) {
+            name = node.name.text;
+        }
+        else if (ohos_typescript_1.default.isComputedPropertyName(node.name)) {
+            if (ohos_typescript_1.default.isIdentifier(node.name.expression)) {
+                name = node.name.expression.text;
+            }
+            else if (ohos_typescript_1.default.isPropertyAccessExpression(node.name.expression)) {
+                name = (0, builderUtils_1.handlePropertyAccessExpression)(node.name.expression);
+            }
+            else {
+                logger.warn('Other method ComputedPropertyName found!');
+            }
+        }
+        else {
+            logger.warn('Other method declaration type found!');
+        }
+    }
+    //TODO, hard code
+    else if (ohos_typescript_1.default.isConstructorDeclaration(node)) {
+        name = TSConst_1.CONSTRUCTOR_NAME;
+    }
+    else if (ohos_typescript_1.default.isConstructSignatureDeclaration(node)) {
+        name = 'construct-signature';
+    }
+    else if (ohos_typescript_1.default.isCallSignatureDeclaration(node)) {
+        name = Const_1.CALL_SIGNATURE_NAME;
+    }
+    else if (ohos_typescript_1.default.isGetAccessor(node) && ohos_typescript_1.default.isIdentifier(node.name)) {
+        name = 'Get-' + node.name.text;
+    }
+    else if (ohos_typescript_1.default.isSetAccessor(node) && ohos_typescript_1.default.isIdentifier(node.name)) {
+        name = 'Set-' + node.name.text;
+    }
+    else if (ohos_typescript_1.default.isArrowFunction(node)) {
+        name = buildAnonymousMethodName(node, declaringClass, declaringMethod);
+    }
+    return name;
+}
+function buildAnonymousMethodName(node, declaringClass, declaringMethod) {
+    let declaringMethodName = '';
+    if (declaringMethod) {
+        declaringMethodName = declaringMethod.getName() + '-';
+    }
+    const mtdName = 'AnonymousMethod-' + declaringMethodName + declaringClass.getAnonymousMethodNumber();
+    return mtdName;
+}
+class ObjectBindingPatternParameter {
+    constructor() {
+        this.propertyName = '';
+        this.name = '';
+        this.optional = false;
+    }
+    getName() {
+        return this.name;
+    }
+    setName(name) {
+        this.name = name;
+    }
+    getPropertyName() {
+        return this.propertyName;
+    }
+    setPropertyName(propertyName) {
+        this.propertyName = propertyName;
+    }
+    isOptional() {
+        return this.optional;
+    }
+    setOptional(optional) {
+        this.optional = optional;
+    }
+}
+exports.ObjectBindingPatternParameter = ObjectBindingPatternParameter;
+class ArrayBindingPatternParameter {
+    constructor() {
+        this.propertyName = '';
+        this.name = '';
+        this.optional = false;
+    }
+    getName() {
+        return this.name;
+    }
+    setName(name) {
+        this.name = name;
+    }
+    getPropertyName() {
+        return this.propertyName;
+    }
+    setPropertyName(propertyName) {
+        this.propertyName = propertyName;
+    }
+    isOptional() {
+        return this.optional;
+    }
+    setOptional(optional) {
+        this.optional = optional;
+    }
+}
+exports.ArrayBindingPatternParameter = ArrayBindingPatternParameter;
+class MethodParameter {
+    constructor() {
+        this.name = '';
+        this.optional = false;
+        this.dotDotDotToken = false;
+        this.objElements = [];
+        this.arrayElements = [];
+    }
+    getName() {
+        return this.name;
+    }
+    setName(name) {
+        this.name = name;
+    }
+    getType() {
+        return this.type;
+    }
+    setType(type) {
+        this.type = type;
+    }
+    isOptional() {
+        return this.optional;
+    }
+    setOptional(optional) {
+        this.optional = optional;
+    }
+    hasDotDotDotToken() {
+        return this.dotDotDotToken;
+    }
+    setDotDotDotToken(dotDotDotToken) {
+        this.dotDotDotToken = dotDotDotToken;
+    }
+    addObjElement(element) {
+        this.objElements.push(element);
+    }
+    getObjElements() {
+        return this.objElements;
+    }
+    setObjElements(objElements) {
+        this.objElements = objElements;
+    }
+    addArrayElement(element) {
+        this.arrayElements.push(element);
+    }
+    getArrayElements() {
+        return this.arrayElements;
+    }
+    setArrayElements(arrayElements) {
+        this.arrayElements = arrayElements;
+    }
+}
+exports.MethodParameter = MethodParameter;
+function needDefaultConstructorInClass(arkClass) {
+    const originClassType = arkClass.getCategory();
+    return arkClass.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME) == null &&
+        (originClassType == ArkClass_1.ClassCategory.CLASS || originClassType == ArkClass_1.ClassCategory.OBJECT) &&
+        arkClass.getName() != Const_1.DEFAULT_ARK_CLASS_NAME &&
+        !arkClass.getModifiers().has(TSConst_1.DECLARE_KEYWORD);
+}
+function buildDefaultConstructor(arkClass) {
+    if (!needDefaultConstructorInClass(arkClass)) {
+        return false;
+    }
+    let parentConstructor = null;
+    let superClass = arkClass.getSuperClass() || null;
+    while (superClass != null) {
+        parentConstructor = superClass.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME);
+        if (parentConstructor != null) {
+            break;
+        }
+        superClass = superClass.getSuperClass() || null;
+    }
+    const defaultConstructor = new ArkMethod_1.ArkMethod();
+    defaultConstructor.setDeclaringArkClass(arkClass);
+    defaultConstructor.setCode('');
+    defaultConstructor.setIsGeneratedFlag(true);
+    const thisLocal = new Local_1.Local(TSConst_1.THIS_NAME);
+    const locals = new Set([thisLocal]);
+    const basicBlock = new BasicBlock_1.BasicBlock();
+    let startingStmt = new Stmt_1.ArkAssignStmt(thisLocal, new Ref_1.ArkThisRef(new Type_1.ClassType(arkClass.getSignature())));
+    basicBlock.addStmt(startingStmt);
+    if (parentConstructor != null) {
+        const methodParameters = [];
+        parentConstructor.getParameters().forEach(parameter => {
+            methodParameters.push(parameter);
+        });
+        let returnType = parentConstructor.getReturnType();
+        const methodSubSignature = new ArkSignature_1.MethodSubSignature(TSConst_1.CONSTRUCTOR_NAME, methodParameters, returnType, defaultConstructor.isStatic());
+        const methodSignature = new ArkSignature_1.MethodSignature(defaultConstructor.getDeclaringArkClass().getSignature(), methodSubSignature);
+        defaultConstructor.setSignature(methodSignature);
+        const stmts = [];
+        let index = 0;
+        const parameterLocals = [];
+        for (const methodParameter of defaultConstructor.getParameters()) {
+            const parameterRef = new Ref_1.ArkParameterRef(index, methodParameter.getType());
+            const parameterLocal = new Local_1.Local(methodParameter.getName(), parameterRef.getType());
+            locals.add(parameterLocal);
+            parameterLocals.push(parameterLocal);
+            stmts.push(new Stmt_1.ArkAssignStmt(parameterLocal, parameterRef));
+            index++;
+        }
+        const superMethodSubSignature = new ArkSignature_1.MethodSubSignature(TSConst_1.SUPER_NAME, parentConstructor.getParameters(), defaultConstructor.getReturnType());
+        const superMethodSignature = new ArkSignature_1.MethodSignature(arkClass.getSignature(), superMethodSubSignature);
+        const superInvokeExpr = new Expr_1.ArkStaticInvokeExpr(superMethodSignature, parameterLocals);
+        const superInvokeStmt = new Stmt_1.ArkInvokeStmt(superInvokeExpr);
+        basicBlock.addStmt(superInvokeStmt);
+        const returnVoidStmt = new Stmt_1.ArkReturnVoidStmt();
+        basicBlock.addStmt(returnVoidStmt);
+    }
+    else {
+        const methodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(TSConst_1.CONSTRUCTOR_NAME);
+        const methodSignature = new ArkSignature_1.MethodSignature(defaultConstructor.getDeclaringArkClass().getSignature(), methodSubSignature);
+        defaultConstructor.setSignature(methodSignature);
+        if (arkClass.getSuperClass()) {
+            const superClass = arkClass.getSuperClass();
+            const superMethodSubSignature = new ArkSignature_1.MethodSubSignature(TSConst_1.SUPER_NAME, [], Type_1.UnknownType.getInstance());
+            const superMethodSignature = new ArkSignature_1.MethodSignature(superClass.getSignature(), superMethodSubSignature);
+            const superInvokeExpr = new Expr_1.ArkStaticInvokeExpr(superMethodSignature, []);
+            const superInvokeStmt = new Stmt_1.ArkInvokeStmt(superInvokeExpr);
+            basicBlock.addStmt(superInvokeStmt);
+            const returnVoidStmt = new Stmt_1.ArkReturnVoidStmt();
+            basicBlock.addStmt(returnVoidStmt);
+        }
+        else {
+            const returnVoidStmt = new Stmt_1.ArkReturnVoidStmt();
+            basicBlock.addStmt(returnVoidStmt);
+        }
+    }
+    const cfg = new Cfg_1.Cfg();
+    cfg.addBlock(basicBlock);
+    cfg.setStartingStmt(startingStmt);
+    cfg.setDeclaringMethod(defaultConstructor);
+    cfg.getStmts().forEach(s => s.setCfg(cfg));
+    const originalCfg = new Cfg_1.Cfg();
+    defaultConstructor.setBody(new ArkBody_1.ArkBody(locals, originalCfg, cfg, new Map(), new Map()));
+    arkClass.addMethod(defaultConstructor);
+    return true;
+}
+exports.buildDefaultConstructor = buildDefaultConstructor;
+function buildInitMethod(initMethod, stmtMap, 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.addStmt(assignStmt);
+    const locals = new Set();
+    for (const stmt of stmtMap.keys()) {
+        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();
+    cfg.setDeclaringMethod(initMethod);
+    initMethod.setBody(new ArkBody_1.ArkBody(locals, new Cfg_1.Cfg(), cfg, stmtMap, new Map()));
+}
+exports.buildInitMethod = buildInitMethod;
+function addInitInConstructor(arkClass) {
+    var _a, _b;
+    for (const method of arkClass.getMethods(true)) {
+        if (method.getName() == TSConst_1.CONSTRUCTOR_NAME) {
+            const thisLocal = (_a = method.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals().get(TSConst_1.THIS_NAME);
+            if (!thisLocal) {
+                continue;
+            }
+            const initInvokeStmt = new Stmt_1.ArkInvokeStmt(new Expr_1.ArkInstanceInvokeExpr(thisLocal, arkClass.getInstanceInitMethod().getSignature(), []));
+            const blocks = (_b = method.getCfg()) === null || _b === void 0 ? void 0 : _b.getBlocks();
+            if (!blocks) {
+                continue;
+            }
+            const firstBlockStmts = [...blocks][0].getStmts();
+            let index = 0;
+            if (firstBlockStmts[0].getDef() instanceof Local_1.Local && firstBlockStmts[0].getDef().getName() == TSConst_1.THIS_NAME) {
+                index = 1;
+            }
+            firstBlockStmts.splice(index, 0, initInvokeStmt);
+        }
+    }
+}
+exports.addInitInConstructor = addInitInConstructor;

package/lib/core/model/builder/ArkNamespaceBuilder.d.ts

@@ -0,0 +1,5 @@
+import { ArkFile } from '../ArkFile';
+import ts from 'ohos-typescript';
+import { ArkNamespace } from '../ArkNamespace';
+export declare function buildArkNamespace(node: ts.ModuleDeclaration, declaringInstance: ArkFile | ArkNamespace, ns: ArkNamespace, sourceFile: ts.SourceFile): void;
+//# sourceMappingURL=ArkNamespaceBuilder.d.ts.map

package/lib/core/model/builder/ArkNamespaceBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArkNamespaceBuilder.d.ts","sourceRoot":"","sources":["../../../../src/core/model/builder/ArkNamespaceBuilder.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,OAAO,EAAE,MAAM,iBAAiB,CAAC;AACjC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAU/C,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,EAAE,OAAO,GAAG,YAAY,EAAE,EAAE,EAAE,YAAY,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,QAuDnJ"}

package/lib/core/model/builder/ArkNamespaceBuilder.js

@@ -0,0 +1,171 @@
+"use strict";
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildArkNamespace = void 0;
+const Position_1 = require("../../base/Position");
+const ArkClassBuilder_1 = require("./ArkClassBuilder");
+const ArkFile_1 = require("../ArkFile");
+const ArkMethodBuilder_1 = require("./ArkMethodBuilder");
+const ohos_typescript_1 = __importDefault(require("ohos-typescript"));
+const ArkNamespace_1 = require("../ArkNamespace");
+const builderUtils_1 = require("./builderUtils");
+const logger_1 = __importStar(require("../../../utils/logger"));
+const ArkExportBuilder_1 = require("./ArkExportBuilder");
+const ArkClass_1 = require("../ArkClass");
+const ArkMethod_1 = require("../ArkMethod");
+const ArkSignature_1 = require("../ArkSignature");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ArkNamespaceBuilder');
+function buildArkNamespace(node, declaringInstance, ns, sourceFile) {
+    var _a;
+    // modifiers
+    if (node.modifiers) {
+        (0, builderUtils_1.buildModifiers)(node, sourceFile).forEach((modifier) => {
+            ns.addModifier(modifier);
+        });
+    }
+    if (declaringInstance instanceof ArkFile_1.ArkFile) {
+        ns.setDeclaringArkFile(declaringInstance);
+    }
+    else {
+        ns.setDeclaringArkNamespace(declaringInstance);
+        ns.setDeclaringArkFile(declaringInstance.getDeclaringArkFile());
+    }
+    ns.setDeclaringInstance(declaringInstance);
+    const namespaceName = node.name.text;
+    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.getText(sourceFile));
+    // set line and column
+    const { line, character } = ohos_typescript_1.default.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+    ns.setLine(line + 1);
+    ns.setColumn(character + 1);
+    genDefaultArkClass(ns, node, sourceFile);
+    // build ns member
+    if (node.body) {
+        if (ohos_typescript_1.default.isModuleBlock(node.body)) {
+            buildNamespaceMembers(node.body, ns, sourceFile);
+        }
+        // NamespaceDeclaration extends ModuleDeclaration
+        //TODO: Check
+        else if (ohos_typescript_1.default.isModuleDeclaration(node.body)) {
+            logger.warn("This ModuleBody is an NamespaceDeclaration.");
+            let childNs = new ArkNamespace_1.ArkNamespace();
+            buildArkNamespace(node.body, ns, childNs, sourceFile);
+        }
+        else if (ohos_typescript_1.default.isIdentifier(node.body)) {
+            logger.warn("ModuleBody is Identifier.");
+        }
+        else {
+            logger.warn("JSDocNamespaceDeclaration found.");
+        }
+    }
+    else {
+        logger.warn("JSDocNamespaceDeclaration found.");
+    }
+}
+exports.buildArkNamespace = buildArkNamespace;
+// TODO: check and update
+function buildNamespaceMembers(node, namespace, sourceFile) {
+    const statements = node.statements;
+    statements.forEach((child) => {
+        if (ohos_typescript_1.default.isModuleDeclaration(child)
+        //child.kind === ts.SyntaxKind.ModuleDeclaration
+        ) {
+            let childNs = new ArkNamespace_1.ArkNamespace();
+            childNs.setDeclaringArkNamespace(namespace);
+            childNs.setDeclaringArkFile(namespace.getDeclaringArkFile());
+            buildArkNamespace(child, namespace, childNs, sourceFile);
+            namespace.addNamespace(childNs);
+            if (childNs.isExported()) {
+                namespace.addExportInfo((0, ArkExportBuilder_1.buildExportInfo)(childNs, namespace.getDeclaringArkFile(), Position_1.LineColPosition.buildFromNode(child, sourceFile)));
+            }
+        }
+        else if (ohos_typescript_1.default.isClassDeclaration(child) ||
+            ohos_typescript_1.default.isInterfaceDeclaration(child) ||
+            ohos_typescript_1.default.isEnumDeclaration(child) ||
+            ohos_typescript_1.default.isStructDeclaration(child)) {
+            let cls = new ArkClass_1.ArkClass();
+            (0, ArkClassBuilder_1.buildNormalArkClassFromArkNamespace)(child, namespace, cls, sourceFile);
+            namespace.addArkClass(cls);
+            if (cls.isExported()) {
+                namespace.addExportInfo((0, ArkExportBuilder_1.buildExportInfo)(cls, namespace.getDeclaringArkFile(), Position_1.LineColPosition.buildFromNode(child, sourceFile)));
+            }
+        }
+        // TODO: Check
+        else if (ohos_typescript_1.default.isMethodDeclaration(child)) {
+            logger.warn("This is a MethodDeclaration in ArkNamespace.");
+            let mthd = new ArkMethod_1.ArkMethod();
+            (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(child, namespace.getDefaultClass(), mthd, sourceFile);
+            namespace.getDefaultClass().addMethod(mthd);
+            if (mthd.isExported()) {
+                namespace.addExportInfo((0, ArkExportBuilder_1.buildExportInfo)(mthd, namespace.getDeclaringArkFile(), Position_1.LineColPosition.buildFromNode(child, sourceFile)));
+            }
+        }
+        else if (ohos_typescript_1.default.isFunctionDeclaration(child)) {
+            let mthd = new ArkMethod_1.ArkMethod();
+            (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(child, namespace.getDefaultClass(), mthd, sourceFile);
+            namespace.getDefaultClass().addMethod(mthd);
+            if (mthd.isExported()) {
+                namespace.addExportInfo((0, ArkExportBuilder_1.buildExportInfo)(mthd, namespace.getDeclaringArkFile(), Position_1.LineColPosition.buildFromNode(child, sourceFile)));
+            }
+        }
+        else if (ohos_typescript_1.default.isExportDeclaration(child)) {
+            (0, ArkExportBuilder_1.buildExportDeclaration)(child, sourceFile, namespace.getDeclaringArkFile())
+                .forEach(item => namespace.addExportInfo(item));
+        }
+        else if (ohos_typescript_1.default.isExportAssignment(child)) {
+            (0, ArkExportBuilder_1.buildExportAssignment)(child, sourceFile, namespace.getDeclaringArkFile())
+                .forEach(item => namespace.addExportInfo(item));
+        }
+        else {
+            logger.info('Child joined default method of arkFile: ', ohos_typescript_1.default.SyntaxKind[child.kind]);
+            // join default method
+        }
+    });
+}
+function genDefaultArkClass(ns, node, sourceFile) {
+    let defaultClass = new ArkClass_1.ArkClass();
+    (0, ArkClassBuilder_1.buildDefaultArkClassFromArkNamespace)(ns, defaultClass, node, sourceFile);
+    ns.setDefaultClass(defaultClass);
+    ns.addArkClass(defaultClass);
+}

package/lib/core/model/builder/ArkSignatureBuilder.d.ts

@@ -0,0 +1,9 @@
+import { ClassSignature, FieldSignature, MethodSignature, MethodSubSignature } from '../ArkSignature';
+export declare class ArkSignatureBuilder {
+    static buildMethodSignatureFromClassNameAndMethodName(className: string, methodName: string, staticFlag?: boolean): MethodSignature;
+    static buildMethodSignatureFromMethodName(methodName: string, staticFlag?: boolean): MethodSignature;
+    static buildMethodSubSignatureFromMethodName(methodName: string, staticFlag?: boolean): MethodSubSignature;
+    static buildClassSignatureFromClassName(className: string): ClassSignature;
+    static buildFieldSignatureFromFieldName(fieldName: string, staticFlag?: boolean): FieldSignature;
+}
+//# sourceMappingURL=ArkSignatureBuilder.d.ts.map

package/lib/core/model/builder/ArkSignatureBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArkSignatureBuilder.d.ts","sourceRoot":"","sources":["../../../../src/core/model/builder/ArkSignatureBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,cAAc,EAAE,cAAc,EAAiB,eAAe,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAGrH,qBAAa,mBAAmB;WACd,8CAA8C,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EACrC,UAAU,GAAE,OAAe,GAAG,eAAe;WAM5F,kCAAkC,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,GAAE,OAAe,GAAG,eAAe;WAKpG,qCAAqC,CAAC,UAAU,EAAE,MAAM,EAClB,UAAU,GAAE,OAAe,GAAG,kBAAkB;WAItF,gCAAgC,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc;WAInE,gCAAgC,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,GAAE,OAAe,GAAG,cAAc;CAGjH"}

package/lib/core/model/builder/ArkSignatureBuilder.js

@@ -0,0 +1,40 @@
+"use strict";
+/*
+ * Copyright (c) 2024 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.ArkSignatureBuilder = void 0;
+const ArkSignature_1 = require("../ArkSignature");
+const Type_1 = require("../../base/Type");
+class ArkSignatureBuilder {
+    static buildMethodSignatureFromClassNameAndMethodName(className, methodName, staticFlag = false) {
+        const classSignature = this.buildClassSignatureFromClassName(className);
+        const methodSubSignature = this.buildMethodSubSignatureFromMethodName(methodName, staticFlag);
+        return new ArkSignature_1.MethodSignature(classSignature, methodSubSignature);
+    }
+    static buildMethodSignatureFromMethodName(methodName, staticFlag = false) {
+        const methodSubSignature = this.buildMethodSubSignatureFromMethodName(methodName, staticFlag);
+        return new ArkSignature_1.MethodSignature(ArkSignature_1.ClassSignature.DEFAULT, methodSubSignature);
+    }
+    static buildMethodSubSignatureFromMethodName(methodName, staticFlag = false) {
+        return new ArkSignature_1.MethodSubSignature(methodName, [], Type_1.UnknownType.getInstance(), staticFlag);
+    }
+    static buildClassSignatureFromClassName(className) {
+        return new ArkSignature_1.ClassSignature(className, ArkSignature_1.FileSignature.DEFAULT);
+    }
+    static buildFieldSignatureFromFieldName(fieldName, staticFlag = false) {
+        return new ArkSignature_1.FieldSignature(fieldName, ArkSignature_1.ClassSignature.DEFAULT, Type_1.UnknownType.getInstance(), staticFlag);
+    }
+}
+exports.ArkSignatureBuilder = ArkSignatureBuilder;

package/lib/core/model/builder/builderUtils.d.ts

@@ -0,0 +1,18 @@
+import ts, { HeritageClause, ParameterDeclaration, TypeNode, TypeParameterDeclaration } from 'ohos-typescript';
+import { GenericType, Type } from '../../base/Type';
+import { ArkField } from '../ArkField';
+import { ArkClass } from '../ArkClass';
+import { ArkMethod } from '../ArkMethod';
+import { Decorator } from '../../base/Decorator';
+import { MethodParameter } from './ArkMethodBuilder';
+export declare function handleQualifiedName(node: ts.QualifiedName): string;
+export declare function handlePropertyAccessExpression(node: ts.PropertyAccessExpression): string;
+export declare function buildModifiers(node: ts.Node, sourceFile: ts.SourceFile): Set<string | Decorator>;
+export declare function buildHeritageClauses(heritageClauses: ts.NodeArray<HeritageClause>): Map<string, string>;
+export declare function buildTypeParameters(typeParameters: ts.NodeArray<TypeParameterDeclaration>, sourceFile: ts.SourceFile, arkInstance: ArkMethod | ArkClass): GenericType[];
+export declare function buildParameters(params: ts.NodeArray<ParameterDeclaration>, arkInstance: ArkMethod | ArkField, sourceFile: ts.SourceFile): MethodParameter[];
+export declare function buildGenericType(type: Type, arkInstance: ArkMethod | ArkField): Type;
+export declare function buildReturnType(node: TypeNode, sourceFile: ts.SourceFile, method: ArkMethod): Type;
+export declare function tsNode2Type(typeNode: ts.TypeNode | ts.TypeParameterDeclaration, sourceFile: ts.SourceFile, arkInstance: ArkMethod | ArkClass | ArkField): Type;
+export declare function buildTypeFromPreStr(preStr: string): Type;
+//# sourceMappingURL=builderUtils.d.ts.map