arkanalyzer 1.0.5

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

@@ -0,0 +1,422 @@
+"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.buildNormalArkClass = exports.buildNormalArkClassFromArkNamespace = exports.buildNormalArkClassFromArkFile = exports.buildNormalArkClassFromArkMethod = exports.buildDefaultArkClassFromArkNamespace = exports.buildDefaultArkClassFromArkFile = void 0;
+const ArkMethod_1 = require("../ArkMethod");
+const logger_1 = __importStar(require("../../../utils/logger"));
+const ohos_typescript_1 = __importDefault(require("ohos-typescript"));
+const ArkClass_1 = require("../ArkClass");
+const ArkMethodBuilder_1 = require("./ArkMethodBuilder");
+const builderUtils_1 = require("./builderUtils");
+const ArkFieldBuilder_1 = require("./ArkFieldBuilder");
+const ArkIRTransformer_1 = require("../../common/ArkIRTransformer");
+const Stmt_1 = require("../../base/Stmt");
+const Ref_1 = require("../../base/Ref");
+const Const_1 = require("../../common/Const");
+const IRUtils_1 = require("../../common/IRUtils");
+const ArkSignature_1 = require("../ArkSignature");
+const ArkSignatureBuilder_1 = require("./ArkSignatureBuilder");
+const Position_1 = require("../../base/Position");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ArkClassBuilder');
+function buildDefaultArkClassFromArkFile(arkFile, defaultClass, astRoot) {
+    defaultClass.setDeclaringArkFile(arkFile);
+    buildDefaultArkClass(defaultClass, astRoot);
+}
+exports.buildDefaultArkClassFromArkFile = buildDefaultArkClassFromArkFile;
+function buildDefaultArkClassFromArkNamespace(arkNamespace, defaultClass, nsNode, sourceFile) {
+    defaultClass.setDeclaringArkNamespace(arkNamespace);
+    defaultClass.setDeclaringArkFile(arkNamespace.getDeclaringArkFile());
+    buildDefaultArkClass(defaultClass, sourceFile, nsNode);
+}
+exports.buildDefaultArkClassFromArkNamespace = buildDefaultArkClassFromArkNamespace;
+function buildNormalArkClassFromArkMethod(clsNode, cls, sourceFile) {
+    const namespace = cls.getDeclaringArkNamespace();
+    if (namespace) {
+        buildNormalArkClassFromArkNamespace(clsNode, namespace, cls, sourceFile);
+    }
+    else {
+        buildNormalArkClassFromArkFile(clsNode, cls.getDeclaringArkFile(), cls, sourceFile);
+    }
+}
+exports.buildNormalArkClassFromArkMethod = buildNormalArkClassFromArkMethod;
+function buildNormalArkClassFromArkFile(clsNode, arkFile, cls, sourceFile, declaringMethod) {
+    cls.setDeclaringArkFile(arkFile);
+    cls.setCode(clsNode.getText(sourceFile));
+    const { line, character } = ohos_typescript_1.default.getLineAndCharacterOfPosition(sourceFile, clsNode.getStart(sourceFile));
+    cls.setLine(line + 1);
+    cls.setColumn(character + 1);
+    buildNormalArkClass(clsNode, cls, sourceFile, declaringMethod);
+    arkFile.addArkClass(cls);
+}
+exports.buildNormalArkClassFromArkFile = buildNormalArkClassFromArkFile;
+function buildNormalArkClassFromArkNamespace(clsNode, arkNamespace, cls, sourceFile, declaringMethod) {
+    cls.setDeclaringArkNamespace(arkNamespace);
+    cls.setDeclaringArkFile(arkNamespace.getDeclaringArkFile());
+    cls.setCode(clsNode.getText(sourceFile));
+    const { line, character } = ohos_typescript_1.default.getLineAndCharacterOfPosition(sourceFile, clsNode.getStart(sourceFile));
+    cls.setLine(line + 1);
+    cls.setColumn(character + 1);
+    buildNormalArkClass(clsNode, cls, sourceFile, declaringMethod);
+    arkNamespace.addArkClass(cls);
+}
+exports.buildNormalArkClassFromArkNamespace = buildNormalArkClassFromArkNamespace;
+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);
+}
+function buildNormalArkClass(clsNode, cls, sourceFile, declaringMethod) {
+    switch (clsNode.kind) {
+        case ohos_typescript_1.default.SyntaxKind.StructDeclaration:
+            buildStruct2ArkClass(clsNode, cls, sourceFile, declaringMethod);
+            break;
+        case ohos_typescript_1.default.SyntaxKind.ClassDeclaration:
+            buildClass2ArkClass(clsNode, cls, sourceFile, declaringMethod);
+            break;
+        case ohos_typescript_1.default.SyntaxKind.ClassExpression:
+            buildClass2ArkClass(clsNode, cls, sourceFile, declaringMethod);
+            break;
+        case ohos_typescript_1.default.SyntaxKind.InterfaceDeclaration:
+            buildInterface2ArkClass(clsNode, cls, sourceFile, declaringMethod);
+            break;
+        case ohos_typescript_1.default.SyntaxKind.EnumDeclaration:
+            buildEnum2ArkClass(clsNode, cls, sourceFile, declaringMethod);
+            break;
+        case ohos_typescript_1.default.SyntaxKind.TypeLiteral:
+            buildTypeLiteralNode2ArkClass(clsNode, cls, sourceFile, declaringMethod);
+            break;
+        case ohos_typescript_1.default.SyntaxKind.ObjectLiteralExpression:
+            buildObjectLiteralExpression2ArkClass(clsNode, cls, sourceFile, declaringMethod);
+            break;
+    }
+}
+exports.buildNormalArkClass = buildNormalArkClass;
+function init4InstanceInitMethod(cls) {
+    const instanceInit = new ArkMethod_1.ArkMethod();
+    instanceInit.setDeclaringArkClass(cls);
+    instanceInit.setIsGeneratedFlag(true);
+    const methodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(Const_1.INSTANCE_INIT_METHOD_NAME);
+    const methodSignature = new ArkSignature_1.MethodSignature(instanceInit.getDeclaringArkClass().getSignature(), methodSubSignature);
+    instanceInit.setSignature(methodSignature);
+    cls.addMethod(instanceInit);
+    cls.setInstanceInitMethod(instanceInit);
+}
+function init4StaticInitMethod(cls) {
+    const staticInit = new ArkMethod_1.ArkMethod();
+    staticInit.setDeclaringArkClass(cls);
+    staticInit.setIsGeneratedFlag(true);
+    const methodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(Const_1.STATIC_INIT_METHOD_NAME);
+    const methodSignature = new ArkSignature_1.MethodSignature(staticInit.getDeclaringArkClass().getSignature(), methodSubSignature);
+    staticInit.setSignature(methodSignature);
+    cls.addMethod(staticInit);
+    cls.setStaticInitMethod(staticInit);
+}
+function buildStruct2ArkClass(clsNode, cls, sourceFile, declaringMethod) {
+    var _a;
+    let className = '';
+    if (clsNode.name) {
+        className = clsNode.name.text;
+    }
+    else {
+        className = genAnonymousClassName(clsNode, cls, declaringMethod);
+    }
+    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.typeParameters) {
+        (0, builderUtils_1.buildTypeParameters)(clsNode.typeParameters, sourceFile, cls).forEach((typeParameter) => {
+            cls.addGenericType(typeParameter);
+        });
+    }
+    if (clsNode.heritageClauses) {
+        for (let [key, value] of (0, builderUtils_1.buildHeritageClauses)(clsNode.heritageClauses)) {
+            if (value == 'ExtendsKeyword') {
+                cls.setSuperClassName(key);
+            }
+            else {
+                cls.addImplementedInterfaceName(key);
+            }
+        }
+    }
+    (0, builderUtils_1.buildModifiers)(clsNode, sourceFile).forEach((modifier) => {
+        cls.addModifier(modifier);
+    });
+    cls.setCategory(ArkClass_1.ClassCategory.STRUCT);
+    init4InstanceInitMethod(cls);
+    init4StaticInitMethod(cls);
+    buildArkClassMembers(clsNode, cls, sourceFile);
+}
+function buildClass2ArkClass(clsNode, cls, sourceFile, declaringMethod) {
+    var _a;
+    let className = '';
+    if (clsNode.name) {
+        className = clsNode.name.text;
+    }
+    else {
+        className = genAnonymousClassName(clsNode, cls, declaringMethod);
+    }
+    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.typeParameters) {
+        (0, builderUtils_1.buildTypeParameters)(clsNode.typeParameters, sourceFile, cls).forEach((typeParameter) => {
+            cls.addGenericType(typeParameter);
+        });
+    }
+    if (clsNode.heritageClauses) {
+        for (let [key, value] of (0, builderUtils_1.buildHeritageClauses)(clsNode.heritageClauses)) {
+            if (value == 'ExtendsKeyword') {
+                cls.setSuperClassName(key);
+            }
+            else {
+                cls.addImplementedInterfaceName(key);
+            }
+        }
+    }
+    (0, builderUtils_1.buildModifiers)(clsNode, sourceFile).forEach((modifier) => {
+        cls.addModifier(modifier);
+    });
+    cls.setCategory(ArkClass_1.ClassCategory.CLASS);
+    init4InstanceInitMethod(cls);
+    init4StaticInitMethod(cls);
+    buildArkClassMembers(clsNode, cls, sourceFile);
+}
+function buildInterface2ArkClass(clsNode, cls, sourceFile, declaringMethod) {
+    var _a;
+    let className = '';
+    if (clsNode.name) {
+        className = clsNode.name.text;
+    }
+    else {
+        className = genAnonymousClassName(clsNode, cls, declaringMethod);
+    }
+    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.typeParameters) {
+        (0, builderUtils_1.buildTypeParameters)(clsNode.typeParameters, sourceFile, cls).forEach((typeParameter) => {
+            cls.addGenericType(typeParameter);
+        });
+    }
+    if (clsNode.heritageClauses) {
+        for (let [key, value] of (0, builderUtils_1.buildHeritageClauses)(clsNode.heritageClauses)) {
+            if (value == 'ExtendsKeyword') {
+                cls.setSuperClassName(key);
+            }
+            else {
+                cls.addImplementedInterfaceName(key);
+            }
+        }
+    }
+    (0, builderUtils_1.buildModifiers)(clsNode, sourceFile).forEach((modifier) => {
+        cls.addModifier(modifier);
+    });
+    cls.setCategory(ArkClass_1.ClassCategory.INTERFACE);
+    buildArkClassMembers(clsNode, cls, sourceFile);
+}
+function buildEnum2ArkClass(clsNode, cls, sourceFile, declaringMethod) {
+    var _a;
+    let className = '';
+    if (clsNode.name) {
+        className = clsNode.name.text;
+    }
+    else {
+        className = genAnonymousClassName(clsNode, cls, declaringMethod);
+    }
+    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);
+    (0, builderUtils_1.buildModifiers)(clsNode, sourceFile).forEach((modifier) => {
+        cls.addModifier(modifier);
+    });
+    cls.setCategory(ArkClass_1.ClassCategory.ENUM);
+    init4StaticInitMethod(cls);
+    buildArkClassMembers(clsNode, cls, sourceFile);
+}
+function buildTypeLiteralNode2ArkClass(clsNode, cls, sourceFile, declaringMethod) {
+    var _a;
+    const className = genAnonymousClassName(clsNode, cls, declaringMethod);
+    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.TYPE_LITERAL);
+    if (ohos_typescript_1.default.isTypeAliasDeclaration(clsNode.parent) && clsNode.parent.typeParameters) {
+        (0, builderUtils_1.buildTypeParameters)(clsNode.parent.typeParameters, sourceFile, cls).forEach((typeParameter) => {
+            cls.addGenericType(typeParameter);
+        });
+    }
+    buildArkClassMembers(clsNode, cls, sourceFile);
+}
+function buildObjectLiteralExpression2ArkClass(clsNode, cls, sourceFile, declaringMethod) {
+    var _a;
+    const className = genAnonymousClassName(clsNode, cls, declaringMethod);
+    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.OBJECT);
+    let arkMethods = [];
+    init4InstanceInitMethod(cls);
+    const instanceInitStmtMap = new Map();
+    const instanceIRTransformer = new ArkIRTransformer_1.ArkIRTransformer(sourceFile, cls.getInstanceInitMethod());
+    clsNode.properties.forEach((property) => {
+        if (ohos_typescript_1.default.isPropertyAssignment(property) || ohos_typescript_1.default.isShorthandPropertyAssignment(property) || ohos_typescript_1.default.isSpreadAssignment(property)) {
+            const arkField = (0, ArkFieldBuilder_1.buildProperty2ArkField)(property, sourceFile, cls);
+            if (ohos_typescript_1.default.isPropertyAssignment(property)) {
+                getInitStmts(instanceIRTransformer, arkField, instanceInitStmtMap, property.initializer);
+            }
+        }
+        else {
+            let arkMethod = new ArkMethod_1.ArkMethod();
+            arkMethod.setDeclaringArkClass(cls);
+            (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(property, cls, arkMethod, sourceFile);
+        }
+    });
+    (0, ArkMethodBuilder_1.buildInitMethod)(cls.getInstanceInitMethod(), instanceInitStmtMap, instanceIRTransformer.getThisLocal());
+    arkMethods.forEach((mtd) => {
+        cls.addMethod(mtd);
+    });
+}
+function genAnonymousClassName(clsNode, cls, declaringMethod) {
+    const declaringArkNamespace = cls.getDeclaringArkNamespace();
+    const declaringArkFile = cls.getDeclaringArkFile();
+    let anonymousClassName = '';
+    let declaringMethodName = '';
+    if (declaringMethod) {
+        declaringMethodName = declaringMethod.getDeclaringArkClass().getName() + Const_1.ANONYMOUS_CLASS_DELIMITER + declaringMethod.getName() + Const_1.ANONYMOUS_CLASS_DELIMITER;
+    }
+    if (declaringArkNamespace) {
+        anonymousClassName = Const_1.ANONYMOUS_CLASS_PREFIX + Const_1.ANONYMOUS_CLASS_DELIMITER + declaringMethodName + declaringArkNamespace.getAnonymousClassNumber();
+    }
+    else {
+        anonymousClassName = Const_1.ANONYMOUS_CLASS_PREFIX + Const_1.ANONYMOUS_CLASS_DELIMITER + declaringMethodName + declaringArkFile.getAnonymousClassNumber();
+    }
+    return anonymousClassName;
+}
+function buildArkClassMembers(clsNode, cls, sourceFile) {
+    if (ohos_typescript_1.default.isObjectLiteralExpression(clsNode)) {
+        return;
+    }
+    let instanceIRTransformer;
+    let staticIRTransformer;
+    if (ohos_typescript_1.default.isClassDeclaration(clsNode) || ohos_typescript_1.default.isClassExpression(clsNode) || ohos_typescript_1.default.isStructDeclaration(clsNode)) {
+        instanceIRTransformer = new ArkIRTransformer_1.ArkIRTransformer(sourceFile, cls.getInstanceInitMethod());
+        staticIRTransformer = new ArkIRTransformer_1.ArkIRTransformer(sourceFile, cls.getStaticInitMethod());
+    }
+    if (ohos_typescript_1.default.isEnumDeclaration(clsNode)) {
+        staticIRTransformer = new ArkIRTransformer_1.ArkIRTransformer(sourceFile, cls.getStaticInitMethod());
+    }
+    const instanceInitStmtMap = new Map();
+    const staticInitStmtMap = new Map();
+    // 先构建所有method，再构建field
+    clsNode.members.forEach((member) => {
+        if (ohos_typescript_1.default.isMethodDeclaration(member) ||
+            ohos_typescript_1.default.isConstructorDeclaration(member) ||
+            ohos_typescript_1.default.isMethodSignature(member) ||
+            ohos_typescript_1.default.isConstructSignatureDeclaration(member) ||
+            ohos_typescript_1.default.isAccessor(member) ||
+            ohos_typescript_1.default.isCallSignatureDeclaration(member)) {
+            let mthd = new ArkMethod_1.ArkMethod();
+            (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(member, cls, mthd, sourceFile);
+            cls.addMethod(mthd);
+            if (ohos_typescript_1.default.isGetAccessor(member)) {
+                (0, ArkFieldBuilder_1.buildGetAccessor2ArkField)(member, mthd, sourceFile);
+            }
+        }
+    });
+    clsNode.members.forEach((member) => {
+        if (ohos_typescript_1.default.isPropertyDeclaration(member) || ohos_typescript_1.default.isPropertySignature(member)) {
+            const arkField = (0, ArkFieldBuilder_1.buildProperty2ArkField)(member, sourceFile, cls);
+            if (ohos_typescript_1.default.isClassDeclaration(clsNode) || ohos_typescript_1.default.isClassExpression(clsNode) || ohos_typescript_1.default.isStructDeclaration(clsNode)) {
+                if (arkField.isStatic()) {
+                    getInitStmts(staticIRTransformer, arkField, staticInitStmtMap, member.initializer);
+                }
+                else {
+                    if (!instanceIRTransformer)
+                        console.log(clsNode.getText(sourceFile));
+                    getInitStmts(instanceIRTransformer, arkField, instanceInitStmtMap, member.initializer);
+                }
+            }
+        }
+        else if (ohos_typescript_1.default.isEnumMember(member)) {
+            const arkField = (0, ArkFieldBuilder_1.buildProperty2ArkField)(member, sourceFile, cls);
+            getInitStmts(staticIRTransformer, arkField, staticInitStmtMap, member.initializer);
+        }
+        else if (ohos_typescript_1.default.isIndexSignatureDeclaration(member)) {
+            (0, ArkFieldBuilder_1.buildIndexSignature2ArkField)(member, sourceFile, cls);
+        }
+        else if (ohos_typescript_1.default.isSemicolonClassElement(member)) {
+            logger.debug('Skip these members.');
+        }
+        else {
+            logger.warn('Please contact developers to support new member type!');
+        }
+    });
+    if (ohos_typescript_1.default.isClassDeclaration(clsNode) || ohos_typescript_1.default.isClassExpression(clsNode) || ohos_typescript_1.default.isStructDeclaration(clsNode)) {
+        (0, ArkMethodBuilder_1.buildInitMethod)(cls.getInstanceInitMethod(), instanceInitStmtMap, instanceIRTransformer.getThisLocal());
+        (0, ArkMethodBuilder_1.buildInitMethod)(cls.getStaticInitMethod(), staticInitStmtMap, staticIRTransformer.getThisLocal());
+    }
+    if (ohos_typescript_1.default.isEnumDeclaration(clsNode)) {
+        (0, ArkMethodBuilder_1.buildInitMethod)(cls.getStaticInitMethod(), staticInitStmtMap, staticIRTransformer.getThisLocal());
+    }
+}
+function getInitStmts(transformer, field, initStmtMap, initNode) {
+    if (initNode) {
+        const stmts = [];
+        let { value: initValue, valueOriginalPositions: initPositions, stmts: initStmts, } = transformer.tsNodeToValueAndStmts(initNode);
+        stmts.push(...initStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(initValue)) {
+            ({ value: initValue, valueOriginalPositions: initPositions, stmts: initStmts } =
+                transformer.generateAssignStmtForValue(initValue, initPositions));
+            stmts.push(...initStmts);
+        }
+        const fieldRef = new Ref_1.ArkInstanceFieldRef(transformer.getThisLocal(), field.getSignature());
+        const fieldRefPositons = [Position_1.FullPosition.DEFAULT, Position_1.FullPosition.DEFAULT];
+        const assignStmt = new Stmt_1.ArkAssignStmt(fieldRef, initValue);
+        assignStmt.setOperandOriginalPositions([...fieldRefPositons, ...initPositions]);
+        stmts.push(assignStmt);
+        for (const stmt of stmts) {
+            const originStmt = new Stmt_1.OriginalStmt(field.getCode(), field.getOriginPosition());
+            initStmtMap.set(stmt, originStmt);
+        }
+        field.setInitializer(stmts);
+    }
+}

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

@@ -0,0 +1,25 @@
+import ts from 'ohos-typescript';
+import { LineColPosition } from '../../base/Position';
+import { ArkExport, ExportInfo, FromInfo } from '../ArkExport';
+import { ArkFile } from '../ArkFile';
+export { buildExportInfo, buildExportAssignment, buildExportDeclaration };
+declare function buildExportInfo(arkInstance: ArkExport, arkFile: ArkFile, line: LineColPosition): ExportInfo;
+export declare function buildDefaultExportInfo(im: FromInfo, file: ArkFile, arkExport?: ArkExport): ExportInfo;
+declare function buildExportDeclaration(node: ts.ExportDeclaration, sourceFile: ts.SourceFile, arkFile: ArkFile): ExportInfo[];
+declare function buildExportAssignment(node: ts.ExportAssignment, sourceFile: ts.SourceFile, arkFile: ArkFile): ExportInfo[];
+/**
+ * export const c = '', b = 1;
+ * @param node
+ * @param sourceFile
+ * @param arkFile
+ */
+export declare function buildExportVariableStatement(node: ts.VariableStatement, sourceFile: ts.SourceFile, arkFile: ArkFile): ExportInfo[];
+/**
+ * export type MyType = string;
+ * @param node
+ * @param sourceFile
+ * @param arkFile
+ */
+export declare function buildExportTypeAliasDeclaration(node: ts.TypeAliasDeclaration, sourceFile: ts.SourceFile, arkFile: ArkFile): ExportInfo[];
+export declare function isExported(modifierArray: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
+//# sourceMappingURL=ArkExportBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ArkExportBuilder.d.ts","sourceRoot":"","sources":["../../../../src/core/model/builder/ArkExportBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,MAAM,iBAAiB,CAAC;AACjC,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAc,QAAQ,EAAE,MAAM,cAAc,CAAC;AAG3E,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAGrC,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,CAAC;AAE1E,iBAAS,eAAe,CAAC,WAAW,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,eAAe,GAAG,UAAU,CASpG;AAGD,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,SAAS,cAOxF;AAED,iBAAS,sBAAsB,CAAC,IAAI,EAAE,EAAE,CAAC,iBAAiB,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,UAAU,EAAE,CA0CrH;AAED,iBAAS,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,gBAAgB,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,UAAU,EAAE,CA0CnH;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,EAAE,CAAC,iBAAiB,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,UAAU,EAAE,CAiBlI;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,EAAE,CAAC,oBAAoB,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,UAAU,EAAE,CAexI;AAED,wBAAgB,UAAU,CAAC,aAAa,EAAE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,SAAS,GAAG,OAAO,CAU5F"}

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

@@ -0,0 +1,207 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExported = exports.buildExportTypeAliasDeclaration = exports.buildExportVariableStatement = exports.buildDefaultExportInfo = exports.buildExportDeclaration = exports.buildExportAssignment = exports.buildExportInfo = void 0;
+const ohos_typescript_1 = __importDefault(require("ohos-typescript"));
+const Position_1 = require("../../base/Position");
+const ArkExport_1 = require("../ArkExport");
+const builderUtils_1 = require("./builderUtils");
+const TSConst_1 = require("../../common/TSConst");
+function buildExportInfo(arkInstance, arkFile, line) {
+    return new ArkExport_1.ExportInfo.Builder()
+        .exportClauseName(arkInstance.getName())
+        .exportClauseType(arkInstance.getExportType())
+        .modifiers(arkInstance.getModifiers())
+        .arkExport(arkInstance)
+        .originTsPosition(line)
+        .declaringArkFile(arkFile)
+        .build();
+}
+exports.buildExportInfo = buildExportInfo;
+function buildDefaultExportInfo(im, file, arkExport) {
+    var _a;
+    return new ArkExport_1.ExportInfo.Builder()
+        .exportClauseType((_a = arkExport === null || arkExport === void 0 ? void 0 : arkExport.getExportType()) !== null && _a !== void 0 ? _a : ArkExport_1.ExportType.CLASS)
+        .exportClauseName(im.getOriginName())
+        .declaringArkFile(file)
+        .arkExport(arkExport !== null && arkExport !== void 0 ? arkExport : file.getDefaultClass())
+        .build();
+}
+exports.buildDefaultExportInfo = buildDefaultExportInfo;
+function buildExportDeclaration(node, sourceFile, arkFile) {
+    const originTsPosition = Position_1.LineColPosition.buildFromNode(node, sourceFile);
+    const tsSourceCode = node.getText(sourceFile);
+    const modifiers = node.modifiers ? (0, builderUtils_1.buildModifiers)(node, sourceFile) : new Set();
+    let exportFrom = '';
+    if (node.moduleSpecifier && ohos_typescript_1.default.isStringLiteral(node.moduleSpecifier)) {
+        exportFrom = node.moduleSpecifier.text;
+    }
+    let exportInfos = [];
+    // just like: export {xxx as x} from './yy'
+    if (node.exportClause && ohos_typescript_1.default.isNamedExports(node.exportClause) && node.exportClause.elements) {
+        node.exportClause.elements.forEach((element) => {
+            let builder = new ArkExport_1.ExportInfo.Builder()
+                .exportClauseType(ArkExport_1.ExportType.UNKNOWN)
+                .exportClauseName(element.name.text)
+                .tsSourceCode(tsSourceCode)
+                .exportFrom(exportFrom)
+                .originTsPosition(originTsPosition)
+                .declaringArkFile(arkFile)
+                .modifiers(modifiers);
+            if (element.propertyName && ohos_typescript_1.default.isIdentifier(element.propertyName)) {
+                builder.nameBeforeAs(element.propertyName.text);
+            }
+            exportInfos.push(builder.build());
+        });
+        return exportInfos;
+    }
+    let builder1 = new ArkExport_1.ExportInfo.Builder()
+        .exportClauseType(ArkExport_1.ExportType.UNKNOWN)
+        .nameBeforeAs(TSConst_1.ALL)
+        .modifiers(modifiers)
+        .tsSourceCode(tsSourceCode)
+        .exportFrom(exportFrom)
+        .declaringArkFile(arkFile)
+        .originTsPosition(originTsPosition);
+    if (node.exportClause && ohos_typescript_1.default.isNamespaceExport(node.exportClause) && ohos_typescript_1.default.isIdentifier(node.exportClause.name)) { // just like: export * as xx from './yy'
+        exportInfos.push(builder1.exportClauseName(node.exportClause.name.text).build());
+    }
+    else if (!node.exportClause && node.moduleSpecifier) { // just like: export * from './yy'
+        exportInfos.push(builder1.exportClauseName(TSConst_1.ALL).build());
+    }
+    return exportInfos;
+}
+exports.buildExportDeclaration = buildExportDeclaration;
+function buildExportAssignment(node, sourceFile, arkFile) {
+    let exportInfos = [];
+    if (!node.expression) {
+        return exportInfos;
+    }
+    const originTsPosition = Position_1.LineColPosition.buildFromNode(node, sourceFile);
+    const tsSourceCode = node.getText(sourceFile);
+    const modifiers = (0, builderUtils_1.buildModifiers)(node, sourceFile);
+    if (isKeyword(node.getChildren(sourceFile), ohos_typescript_1.default.SyntaxKind.DefaultKeyword)) {
+        modifiers.add(ohos_typescript_1.default.SyntaxKind[ohos_typescript_1.default.SyntaxKind.DefaultKeyword]);
+    }
+    if (ohos_typescript_1.default.isObjectLiteralExpression(node.expression) && node.expression.properties) { // just like: export default {a,b,c}
+        node.expression.properties.forEach((property) => {
+            if (property.name && ohos_typescript_1.default.isIdentifier(property.name)) {
+                const exportInfo = new ArkExport_1.ExportInfo.Builder()
+                    .exportClauseName(property.name.text)
+                    .exportClauseType(ArkExport_1.ExportType.UNKNOWN)
+                    .nameBeforeAs(property.name.text)
+                    .modifiers(modifiers)
+                    .tsSourceCode(tsSourceCode)
+                    .originTsPosition(originTsPosition)
+                    .declaringArkFile(arkFile)
+                    .build();
+                exportInfos.push(exportInfo);
+            }
+        });
+    }
+    else {
+        const exportInfo = new ArkExport_1.ExportInfo.Builder()
+            .exportClauseType(ArkExport_1.ExportType.UNKNOWN)
+            .modifiers(modifiers)
+            .tsSourceCode(tsSourceCode)
+            .originTsPosition(originTsPosition)
+            .declaringArkFile(arkFile)
+            .exportClauseName(TSConst_1.DEFAULT);
+        if (ohos_typescript_1.default.isIdentifier(node.expression)) { // just like: export default xx
+            exportInfo.nameBeforeAs(node.expression.text);
+        }
+        else if (ohos_typescript_1.default.isAsExpression(node.expression)) { // just like: export default xx as YY
+            exportInfo.nameBeforeAs(node.expression.expression.getText(sourceFile));
+        }
+        exportInfos.push(exportInfo.build());
+    }
+    return exportInfos;
+}
+exports.buildExportAssignment = buildExportAssignment;
+/**
+ * export const c = '', b = 1;
+ * @param node
+ * @param sourceFile
+ * @param arkFile
+ */
+function buildExportVariableStatement(node, sourceFile, arkFile) {
+    let exportInfos = [];
+    const originTsPosition = Position_1.LineColPosition.buildFromNode(node, sourceFile);
+    const modifiers = node.modifiers ? (0, builderUtils_1.buildModifiers)(node, sourceFile) : new Set();
+    const tsSourceCode = node.getText(sourceFile);
+    node.declarationList.declarations.forEach(dec => {
+        const exportInfo = new ArkExport_1.ExportInfo.Builder()
+            .exportClauseName(dec.name.getText(sourceFile))
+            .exportClauseType(ArkExport_1.ExportType.LOCAL)
+            .modifiers(modifiers)
+            .tsSourceCode(tsSourceCode)
+            .originTsPosition(originTsPosition)
+            .declaringArkFile(arkFile)
+            .build();
+        exportInfos.push(exportInfo);
+    });
+    return exportInfos;
+}
+exports.buildExportVariableStatement = buildExportVariableStatement;
+/**
+ * export type MyType = string;
+ * @param node
+ * @param sourceFile
+ * @param arkFile
+ */
+function buildExportTypeAliasDeclaration(node, sourceFile, arkFile) {
+    let exportInfos = [];
+    const originTsPosition = Position_1.LineColPosition.buildFromNode(node, sourceFile);
+    const modifiers = node.modifiers ? (0, builderUtils_1.buildModifiers)(node, sourceFile) : new Set();
+    const tsSourceCode = node.getText(sourceFile);
+    const exportInfo = new ArkExport_1.ExportInfo.Builder()
+        .exportClauseName(node.name.text)
+        .exportClauseType(ArkExport_1.ExportType.TYPE)
+        .tsSourceCode(tsSourceCode)
+        .modifiers(modifiers)
+        .originTsPosition(originTsPosition)
+        .declaringArkFile(arkFile)
+        .build();
+    exportInfos.push(exportInfo);
+    return exportInfos;
+}
+exports.buildExportTypeAliasDeclaration = buildExportTypeAliasDeclaration;
+function isExported(modifierArray) {
+    if (!modifierArray) {
+        return false;
+    }
+    for (let child of modifierArray) {
+        if (child.kind === ohos_typescript_1.default.SyntaxKind.ExportKeyword) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isExported = isExported;
+function isKeyword(modifierArray, keyword) {
+    if (!modifierArray) {
+        return false;
+    }
+    for (let child of modifierArray) {
+        if (child.kind === keyword) {
+            return true;
+        }
+    }
+    return false;
+}

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

@@ -0,0 +1,9 @@
+import ts from 'ohos-typescript';
+import { ArkField } from '../ArkField';
+import { ArkClass } from '../ArkClass';
+import { ArkMethod } from '../ArkMethod';
+export type PropertyLike = ts.PropertyDeclaration | ts.PropertyAssignment;
+export declare function buildProperty2ArkField(member: ts.PropertyDeclaration | ts.PropertyAssignment | ts.ShorthandPropertyAssignment | ts.SpreadAssignment | ts.PropertySignature | ts.EnumMember, sourceFile: ts.SourceFile, cls: ArkClass): ArkField;
+export declare function buildIndexSignature2ArkField(member: ts.IndexSignatureDeclaration, sourceFile: ts.SourceFile, cls: ArkClass): void;
+export declare function buildGetAccessor2ArkField(member: ts.GetAccessorDeclaration, mthd: ArkMethod, sourceFile: ts.SourceFile): void;
+//# sourceMappingURL=ArkFieldBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ArkFieldBuilder.d.ts","sourceRoot":"","sources":["../../../../src/core/model/builder/ArkFieldBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,MAAM,iBAAiB,CAAC;AACjC,OAAO,EAAE,QAAQ,EAAiB,MAAM,aAAa,CAAC;AAEtD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAQzC,MAAM,MAAM,YAAY,GAAG,EAAE,CAAC,mBAAmB,GAAG,EAAE,CAAC,kBAAkB,CAAC;AAE1E,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,EAAE,CAAC,mBAAmB,GAAG,EAAE,CAAC,kBAAkB,GAAG,EAAE,CAAC,2BAA2B,GACxH,EAAE,CAAC,gBAAgB,GAAG,EAAE,CAAC,iBAAiB,GAAG,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,EAAE,GAAG,EAAE,QAAQ,GAAG,QAAQ,CAwDpH;AAED,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,EAAE,CAAC,yBAAyB,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,EAAE,GAAG,EAAE,QAAQ,QAoB1H;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,EAAE,CAAC,sBAAsB,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,QAiCtH"}