arkanalyzer 1.0.5

package/lib/core/model/ArkSignature.d.ts

@@ -0,0 +1,98 @@
+import { ClassType, Type } from '../base/Type';
+import { MethodParameter } from './builder/ArkMethodBuilder';
+export type Signature = FileSignature | NamespaceSignature | ClassSignature | MethodSignature | FieldSignature | LocalSignature;
+export interface ArkSignature {
+    getSignature(): Signature;
+}
+/**
+ * @category core/model
+ */
+export declare class FileSignature {
+    private projectName;
+    private fileName;
+    static readonly DEFAULT: FileSignature;
+    constructor(projectName: string, fileName: string);
+    getProjectName(): string;
+    getFileName(): string;
+    toString(): string;
+}
+export declare class NamespaceSignature {
+    private namespaceName;
+    private declaringFileSignature;
+    private declaringNamespaceSignature;
+    static readonly DEFAULT: NamespaceSignature;
+    constructor(namespaceName: string, declaringFileSignature: FileSignature, declaringNamespaceSignature?: NamespaceSignature | null);
+    getNamespaceName(): string;
+    getDeclaringFileSignature(): FileSignature;
+    getDeclaringNamespaceSignature(): NamespaceSignature | null;
+    toString(): string;
+}
+export declare class ClassSignature {
+    private declaringFileSignature;
+    private declaringNamespaceSignature;
+    private className;
+    static readonly DEFAULT: ClassSignature;
+    constructor(className: string, declaringFileSignature: FileSignature, declaringNamespaceSignature?: NamespaceSignature | null);
+    getDeclaringFileSignature(): FileSignature;
+    getDeclaringNamespaceSignature(): NamespaceSignature | null;
+    getClassName(): string;
+    setClassName(className: string): void;
+    getType(): ClassType;
+    toString(): string;
+}
+export type BaseSignature = ClassSignature | NamespaceSignature;
+export declare class FieldSignature {
+    private declaringSignature;
+    private fieldName;
+    private type;
+    private staticFlag;
+    constructor(fieldName: string, declaringSignature: BaseSignature, type: Type, staticFlag?: boolean);
+    getDeclaringSignature(): BaseSignature;
+    getBaseName(): string;
+    getFieldName(): string;
+    getType(): Type;
+    isStatic(): boolean;
+    setType(type: Type): void;
+    setStaticFlag(flag: boolean): void;
+    toString(): string;
+}
+export declare class MethodSubSignature {
+    private methodName;
+    private parameters;
+    private returnType;
+    private staticFlag;
+    constructor(methodName: string, parameters: MethodParameter[], returnType: Type, staticFlag?: boolean);
+    getMethodName(): string;
+    getParameters(): MethodParameter[];
+    getParameterTypes(): Type[];
+    getReturnType(): Type;
+    isStatic(): boolean;
+    toString(): string;
+}
+/**
+ * @category core/model
+ */
+export declare class MethodSignature {
+    private declaringClassSignature;
+    private methodSubSignature;
+    constructor(declaringClassSignature: ClassSignature, methodSubSignature: MethodSubSignature);
+    getDeclaringClassSignature(): ClassSignature;
+    getMethodSubSignature(): MethodSubSignature;
+    getType(): Type;
+    toString(): string;
+}
+export declare class LocalSignature {
+    private name;
+    private declaringMethodSignature;
+    constructor(name: string, declaringMethodSignature: MethodSignature);
+    getName(): string;
+    getDeclaringMethodSubSignature(): MethodSignature;
+    toString(): string;
+}
+export declare function fieldSignatureCompare(leftSig: FieldSignature, rightSig: FieldSignature): boolean;
+export declare function methodSignatureCompare(leftSig: MethodSignature, rightSig: MethodSignature): boolean;
+export declare function methodSubSignatureCompare(leftSig: MethodSubSignature, rightSig: MethodSubSignature): boolean;
+export declare function classSignatureCompare(leftSig: ClassSignature, rightSig: ClassSignature): boolean;
+export declare function fileSignatureCompare(leftSig: FileSignature, rightSig: FileSignature): boolean;
+export declare function genSignature4ImportClause(arkFileName: string, importClauseName: string): string;
+//# sourceMappingURL=ArkSignature.d.ts.map

package/lib/core/model/ArkSignature.d.ts.map

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

package/lib/core/model/ArkSignature.js

@@ -0,0 +1,281 @@
+"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.genSignature4ImportClause = exports.fileSignatureCompare = exports.classSignatureCompare = exports.methodSubSignatureCompare = exports.methodSignatureCompare = exports.fieldSignatureCompare = exports.LocalSignature = exports.MethodSignature = exports.MethodSubSignature = exports.FieldSignature = exports.ClassSignature = exports.NamespaceSignature = exports.FileSignature = void 0;
+const pathTransfer_1 = require("../../utils/pathTransfer");
+const Type_1 = require("../base/Type");
+const Const_1 = require("../common/Const");
+/**
+ * @category core/model
+ */
+class FileSignature {
+    constructor(projectName, fileName) {
+        this.projectName = projectName;
+        this.fileName = fileName;
+    }
+    getProjectName() {
+        return this.projectName;
+    }
+    getFileName() {
+        return this.fileName;
+    }
+    toString() {
+        let tmpSig = (0, pathTransfer_1.transfer2UnixPath)(this.fileName);
+        tmpSig = '@' + this.projectName + '/' + tmpSig + ': ';
+        return tmpSig;
+    }
+}
+exports.FileSignature = FileSignature;
+FileSignature.DEFAULT = new FileSignature(Const_1.UNKNOWN_PROJECT_NAME, Const_1.UNKNOWN_FILE_NAME);
+class NamespaceSignature {
+    constructor(namespaceName, declaringFileSignature, declaringNamespaceSignature = null) {
+        this.namespaceName = namespaceName;
+        this.declaringFileSignature = declaringFileSignature;
+        this.declaringNamespaceSignature = declaringNamespaceSignature;
+    }
+    getNamespaceName() {
+        return this.namespaceName;
+    }
+    getDeclaringFileSignature() {
+        return this.declaringFileSignature;
+    }
+    getDeclaringNamespaceSignature() {
+        return this.declaringNamespaceSignature;
+    }
+    toString() {
+        if (this.declaringNamespaceSignature) {
+            return this.declaringNamespaceSignature.toString() + '.' + this.namespaceName;
+        }
+        else {
+            return this.declaringFileSignature.toString() + this.namespaceName;
+        }
+    }
+}
+exports.NamespaceSignature = NamespaceSignature;
+NamespaceSignature.DEFAULT = new NamespaceSignature(Const_1.UNKNOWN_NAMESPACE_NAME, FileSignature.DEFAULT, null);
+class ClassSignature {
+    constructor(className, declaringFileSignature, declaringNamespaceSignature = null) {
+        this.className = className;
+        this.declaringFileSignature = declaringFileSignature;
+        this.declaringNamespaceSignature = declaringNamespaceSignature;
+    }
+    getDeclaringFileSignature() {
+        return this.declaringFileSignature;
+    }
+    getDeclaringNamespaceSignature() {
+        return this.declaringNamespaceSignature;
+    }
+    getClassName() {
+        return this.className;
+    }
+    setClassName(className) {
+        this.className = className;
+    }
+    getType() {
+        return new Type_1.ClassType(this);
+    }
+    toString() {
+        if (this.declaringNamespaceSignature) {
+            return this.declaringNamespaceSignature.toString() + '.' + this.className;
+        }
+        else {
+            return this.declaringFileSignature.toString() + this.className;
+        }
+    }
+}
+exports.ClassSignature = ClassSignature;
+ClassSignature.DEFAULT = new ClassSignature(Const_1.UNKNOWN_CLASS_NAME, FileSignature.DEFAULT, null);
+class FieldSignature {
+    constructor(fieldName, declaringSignature, type, staticFlag = false) {
+        this.fieldName = fieldName;
+        this.declaringSignature = declaringSignature;
+        this.type = type;
+        this.staticFlag = staticFlag;
+    }
+    getDeclaringSignature() {
+        return this.declaringSignature;
+    }
+    getBaseName() {
+        return this.declaringSignature instanceof ClassSignature ? this.declaringSignature.getClassName()
+            : this.declaringSignature.getNamespaceName();
+    }
+    getFieldName() {
+        return this.fieldName;
+    }
+    getType() {
+        return this.type;
+    }
+    isStatic() {
+        return this.staticFlag;
+    }
+    // temp for being compatible with existing type inference
+    setType(type) {
+        this.type = type;
+    }
+    // temp for being compatible with existing type inference
+    setStaticFlag(flag) {
+        this.staticFlag = flag;
+    }
+    toString() {
+        let tmpSig = this.fieldName;
+        if (this.isStatic()) {
+            tmpSig = '[static]' + tmpSig;
+        }
+        return this.getDeclaringSignature().toString() + '.' + tmpSig;
+    }
+}
+exports.FieldSignature = FieldSignature;
+class MethodSubSignature {
+    constructor(methodName, parameters, returnType, staticFlag = false) {
+        this.methodName = methodName;
+        this.parameters = parameters;
+        this.returnType = returnType;
+        this.staticFlag = staticFlag;
+    }
+    getMethodName() {
+        return this.methodName;
+    }
+    getParameters() {
+        return this.parameters;
+    }
+    getParameterTypes() {
+        const parameterTypes = [];
+        this.parameters.forEach((parameter) => {
+            parameterTypes.push(parameter.getType());
+        });
+        return parameterTypes;
+    }
+    getReturnType() {
+        return this.returnType;
+    }
+    isStatic() {
+        return this.staticFlag;
+    }
+    // // temp for being compatible with existing type inference
+    // public setReturnType(returnType: Type): void {
+    //     this.returnType = returnType;
+    // }
+    //
+    // // temp for being compatible with existing type inference
+    // public setStaticFlag(flag: boolean): void {
+    //     this.staticFlag = flag;
+    // }
+    toString() {
+        let paraStr = "";
+        this.getParameterTypes().forEach((parameterType) => {
+            paraStr += parameterType.toString() + ", ";
+        });
+        paraStr = paraStr.replace(/, $/, '');
+        let tmpSig = `${this.getMethodName()}(${paraStr})`;
+        if (this.isStatic()) {
+            tmpSig = '[static]' + tmpSig;
+        }
+        return tmpSig;
+    }
+}
+exports.MethodSubSignature = MethodSubSignature;
+/**
+ * @category core/model
+ */
+class MethodSignature {
+    constructor(declaringClassSignature, methodSubSignature) {
+        this.declaringClassSignature = declaringClassSignature;
+        this.methodSubSignature = methodSubSignature;
+    }
+    getDeclaringClassSignature() {
+        return this.declaringClassSignature;
+    }
+    getMethodSubSignature() {
+        return this.methodSubSignature;
+    }
+    getType() {
+        return this.methodSubSignature.getReturnType();
+    }
+    toString() {
+        return this.declaringClassSignature.toString() + '.' + this.methodSubSignature.toString();
+    }
+}
+exports.MethodSignature = MethodSignature;
+class LocalSignature {
+    constructor(name, declaringMethodSignature) {
+        this.name = name;
+        this.declaringMethodSignature = declaringMethodSignature;
+    }
+    getName() {
+        return this.name;
+    }
+    getDeclaringMethodSubSignature() {
+        return this.declaringMethodSignature;
+    }
+    toString() {
+        return this.declaringMethodSignature.toString() + '#' + this.name;
+    }
+}
+exports.LocalSignature = LocalSignature;
+//TODO, reconstruct
+function fieldSignatureCompare(leftSig, rightSig) {
+    if (leftSig.getDeclaringSignature().toString() === rightSig.getDeclaringSignature().toString() &&
+        (leftSig.getFieldName() == rightSig.getFieldName())) {
+        return true;
+    }
+    return false;
+}
+exports.fieldSignatureCompare = fieldSignatureCompare;
+function methodSignatureCompare(leftSig, rightSig) {
+    if (classSignatureCompare(leftSig.getDeclaringClassSignature(), rightSig.getDeclaringClassSignature()) &&
+        methodSubSignatureCompare(leftSig.getMethodSubSignature(), rightSig.getMethodSubSignature())) {
+        return true;
+    }
+    return false;
+}
+exports.methodSignatureCompare = methodSignatureCompare;
+function methodSubSignatureCompare(leftSig, rightSig) {
+    if ((leftSig.getMethodName() == rightSig.getMethodName()) && arrayCompare(leftSig.getParameterTypes(), rightSig.getParameterTypes()) && leftSig.getReturnType() == rightSig.getReturnType()) {
+        return true;
+    }
+    return false;
+}
+exports.methodSubSignatureCompare = methodSubSignatureCompare;
+function classSignatureCompare(leftSig, rightSig) {
+    if ((fileSignatureCompare(leftSig.getDeclaringFileSignature(), rightSig.getDeclaringFileSignature())) &&
+        (leftSig.getClassName() == rightSig.getClassName())) {
+        return true;
+    }
+    return false;
+}
+exports.classSignatureCompare = classSignatureCompare;
+function fileSignatureCompare(leftSig, rightSig) {
+    if ((leftSig.getFileName() == rightSig.getFileName()) && (leftSig.getProjectName() == rightSig.getProjectName())) {
+        return true;
+    }
+    return false;
+}
+exports.fileSignatureCompare = fileSignatureCompare;
+function arrayCompare(leftArray, rightArray) {
+    if (leftArray.length != rightArray.length) {
+        return false;
+    }
+    for (let i = 0; i < leftArray.length; i++) {
+        if (leftArray[i] != rightArray[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+function genSignature4ImportClause(arkFileName, importClauseName) {
+    return `<${arkFileName}>.<${importClauseName}>`;
+}
+exports.genSignature4ImportClause = genSignature4ImportClause;

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

@@ -0,0 +1,13 @@
+import { ArkFile } from '../ArkFile';
+import { ArkMethod } from '../ArkMethod';
+import { ArkNamespace } from '../ArkNamespace';
+import ts from 'ohos-typescript';
+import { ArkClass } from '../ArkClass';
+export type ClassLikeNode = ts.ClassDeclaration | ts.InterfaceDeclaration | ts.EnumDeclaration | ts.ClassExpression | ts.TypeLiteralNode | ts.StructDeclaration | ts.ObjectLiteralExpression;
+export declare function buildDefaultArkClassFromArkFile(arkFile: ArkFile, defaultClass: ArkClass, astRoot: ts.SourceFile): void;
+export declare function buildDefaultArkClassFromArkNamespace(arkNamespace: ArkNamespace, defaultClass: ArkClass, nsNode: ts.ModuleDeclaration, sourceFile: ts.SourceFile): void;
+export declare function buildNormalArkClassFromArkMethod(clsNode: ts.TypeLiteralNode, cls: ArkClass, sourceFile: ts.SourceFile): void;
+export declare function buildNormalArkClassFromArkFile(clsNode: ClassLikeNode, arkFile: ArkFile, cls: ArkClass, sourceFile: ts.SourceFile, declaringMethod?: ArkMethod): void;
+export declare function buildNormalArkClassFromArkNamespace(clsNode: ClassLikeNode, arkNamespace: ArkNamespace, cls: ArkClass, sourceFile: ts.SourceFile, declaringMethod?: ArkMethod): void;
+export declare function buildNormalArkClass(clsNode: ClassLikeNode, cls: ArkClass, sourceFile: ts.SourceFile, declaringMethod?: ArkMethod): void;
+//# sourceMappingURL=ArkClassBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ArkClassBuilder.d.ts","sourceRoot":"","sources":["../../../../src/core/model/builder/ArkClassBuilder.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,EAAE,MAAM,iBAAiB,CAAC;AACjC,OAAO,EAAE,QAAQ,EAAiB,MAAM,aAAa,CAAC;AAqBtD,MAAM,MAAM,aAAa,GACrB,EAAE,CAAC,gBAAgB,GACnB,EAAE,CAAC,oBAAoB,GACvB,EAAE,CAAC,eAAe,GAClB,EAAE,CAAC,eAAe,GAClB,EAAE,CAAC,eAAe,GAClB,EAAE,CAAC,iBAAiB,GACpB,EAAE,CAAC,uBAAuB,CAAC;AAE/B,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,CAAC,UAAU,QAG/G;AAED,wBAAgB,oCAAoC,CAAC,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,QAAQ,EAClD,MAAM,EAAE,EAAE,CAAC,iBAAiB,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,QAI3G;AAED,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,EAAE,CAAC,eAAe,EAC3B,GAAG,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,QAOxF;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EACvD,UAAU,EAAE,EAAE,CAAC,UAAU,EAAE,eAAe,CAAC,EAAE,SAAS,QAYpG;AAED,wBAAgB,mCAAmC,CAAC,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,GAAG,EAAE,QAAQ,EACjE,UAAU,EAAE,EAAE,CAAC,UAAU,EAAE,eAAe,CAAC,EAAE,SAAS,QAazG;AAgBD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,EAAE,eAAe,CAAC,EAAE,SAAS,QAwBhI"}