arkanalyzer 1.0.5

package/lib/save/source/SourceTransformer.d.ts

@@ -0,0 +1,37 @@
+import { Constant } from '../../core/base/Constant';
+import { ArkInstanceInvokeExpr, ArkStaticInvokeExpr } from '../../core/base/Expr';
+import { Local } from '../../core/base/Local';
+import { ArkClass } from '../../core/model/ArkClass';
+import { ArkMethod } from '../../core/model/ArkMethod';
+import { ClassSignature, MethodSignature } from '../../core/model/ArkSignature';
+import { ArkCodeBuffer } from '../ArkStream';
+import { ClassType, Type } from '../../core/base/Type';
+import { Value } from '../../core/base/Value';
+import { AbstractRef } from '../../core/base/Ref';
+import { ArkFile } from '../../core/model/ArkFile';
+import { ArkNamespace } from '../../core/model/ArkNamespace';
+export interface TransformerContext {
+    getArkFile(): ArkFile;
+    getDeclaringArkNamespace(): ArkNamespace | undefined;
+    getMethod(signature: MethodSignature): ArkMethod | null;
+    getClass(signature: ClassSignature): ArkClass | null;
+    getPrinter(): ArkCodeBuffer;
+    transTemp2Code(temp: Local): string;
+    isInBuilderMethod(): boolean;
+}
+export declare class SourceTransformer {
+    protected context: TransformerContext;
+    constructor(context: TransformerContext);
+    private anonymousMethodToString;
+    private anonymousClassToString;
+    instanceInvokeExprToString(invokeExpr: ArkInstanceInvokeExpr): string;
+    staticInvokeExprToString(invokeExpr: ArkStaticInvokeExpr): string;
+    typeArrayToString(types: Type[], split?: string): string;
+    static constToString(value: Constant): string;
+    private exprToString;
+    refToString(value: AbstractRef): string;
+    valueToString(value: Value, operator?: string): string;
+    literalObjectToString(type: ClassType): string;
+    typeToString(type: Type): string;
+}
+//# sourceMappingURL=SourceTransformer.d.ts.map

package/lib/save/source/SourceTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SourceTransformer.d.ts","sourceRoot":"","sources":["../../../src/save/source/SourceTransformer.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAMH,qBAAqB,EAKrB,mBAAmB,EAKtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAiB,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAI7C,OAAO,EAEH,SAAS,EAMT,IAAI,EAKP,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAmE,MAAM,qBAAqB,CAAC;AACnH,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AASnD,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAI7D,MAAM,WAAW,kBAAkB;IAC/B,UAAU,IAAI,OAAO,CAAC;IACtB,wBAAwB,IAAI,YAAY,GAAG,SAAS,CAAC;IAErD,SAAS,CAAC,SAAS,EAAE,eAAe,GAAG,SAAS,GAAG,IAAI,CAAC;IAExD,QAAQ,CAAC,SAAS,EAAE,cAAc,GAAG,QAAQ,GAAG,IAAI,CAAC;IAErD,UAAU,IAAI,aAAa,CAAC;IAE5B,cAAc,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;IAEpC,iBAAiB,IAAI,OAAO,CAAC;CAChC;AAED,qBAAa,iBAAiB;IAC1B,SAAS,CAAC,OAAO,EAAE,kBAAkB,CAAC;gBAE1B,OAAO,EAAE,kBAAkB;IAIvC,OAAO,CAAC,uBAAuB;IAM/B,OAAO,CAAC,sBAAsB;IAKvB,0BAA0B,CAAC,UAAU,EAAE,qBAAqB,GAAG,MAAM;IAiBrE,wBAAwB,CAAC,UAAU,EAAE,mBAAmB,GAAG,MAAM;IAwDjE,iBAAiB,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,KAAK,GAAE,MAAa,GAAG,MAAM;WASvD,aAAa,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;IAQpD,OAAO,CAAC,YAAY;IA2Db,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM;IA8BvC,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM;IAiDtD,qBAAqB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM;IAW9C,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;CAmF1C"}

package/lib/save/source/SourceTransformer.js

@@ -0,0 +1,338 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceTransformer = void 0;
+const Constant_1 = require("../../core/base/Constant");
+const Expr_1 = require("../../core/base/Expr");
+const Local_1 = require("../../core/base/Local");
+const ArkClass_1 = require("../../core/model/ArkClass");
+const logger_1 = __importStar(require("../../utils/logger"));
+const SourceUtils_1 = require("./SourceUtils");
+const SourceMethod_1 = require("./SourceMethod");
+const Type_1 = require("../../core/base/Type");
+const SourceClass_1 = require("./SourceClass");
+const Ref_1 = require("../../core/base/Ref");
+const EtsConst_1 = require("../../core/common/EtsConst");
+const Const_1 = require("../../core/common/Const");
+const Stmt_1 = require("../../core/base/Stmt");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'SourceTransformer');
+class SourceTransformer {
+    constructor(context) {
+        this.context = context;
+    }
+    anonymousMethodToString(method, indent) {
+        let mtdPrinter = new SourceMethod_1.SourceMethod(method, indent);
+        mtdPrinter.setInBuilder(this.context.isInBuilderMethod());
+        return mtdPrinter.dump().trimStart();
+    }
+    anonymousClassToString(cls, indent) {
+        let clsPrinter = new SourceClass_1.SourceClass(cls, indent);
+        return clsPrinter.dump().trimStart();
+    }
+    instanceInvokeExprToString(invokeExpr) {
+        let methodName = invokeExpr.getMethodSignature().getMethodSubSignature().getMethodName();
+        if (methodName == Const_1.INSTANCE_INIT_METHOD_NAME) {
+            return '';
+        }
+        let args = [];
+        invokeExpr.getArgs().forEach((v) => {
+            args.push(this.valueToString(v));
+        });
+        if (SourceUtils_1.SourceUtils.isComponentAttributeInvoke(invokeExpr) && this.context.isInBuilderMethod()) {
+            return `.${methodName}(${args.join(', ')})`;
+        }
+        return `${this.valueToString(invokeExpr.getBase())}.${methodName}(${args.join(', ')})`;
+    }
+    staticInvokeExprToString(invokeExpr) {
+        let methodSignature = invokeExpr.getMethodSignature();
+        let method = this.context.getMethod(methodSignature);
+        if (method && SourceUtils_1.SourceUtils.isAnonymousMethod(method.getName())) {
+            return this.anonymousMethodToString(method, this.context.getPrinter().getIndent());
+        }
+        let classSignature = methodSignature.getDeclaringClassSignature();
+        let className = SourceUtils_1.SourceUtils.getStaticInvokeClassFullName(classSignature, this.context.getDeclaringArkNamespace());
+        let methodName = methodSignature.getMethodSubSignature().getMethodName();
+        let args = [];
+        invokeExpr.getArgs().forEach((v) => {
+            args.push(this.valueToString(v));
+        });
+        if (this.context.isInBuilderMethod()) {
+            if (className == EtsConst_1.COMPONENT_CUSTOMVIEW) {
+                if (methodName == EtsConst_1.COMPONENT_CREATE_FUNCTION) {
+                    // Anonymous @Builder method
+                    if (args.length > 1) {
+                        args[1] = args[1].substring('() => '.length);
+                    }
+                    return `${args.join(' ')}`;
+                }
+                if (methodName == EtsConst_1.COMPONENT_POP_FUNCTION) {
+                    return '';
+                }
+            }
+            if (SourceUtils_1.SourceUtils.isComponentCreate(invokeExpr)) {
+                if (className == EtsConst_1.COMPONENT_IF) {
+                    return `if (${args.join(', ')})`;
+                }
+                return `${className}(${args.join(', ')})`;
+            }
+            if (SourceUtils_1.SourceUtils.isComponentIfBranchInvoke(invokeExpr)) {
+                let arg0 = invokeExpr.getArg(0);
+                if (arg0.getValue() == '0') {
+                    return ``;
+                }
+                else {
+                    return '} else {';
+                }
+            }
+            if (SourceUtils_1.SourceUtils.isComponentPop(invokeExpr)) {
+                return '}';
+            }
+        }
+        if (className && className.length > 0) {
+            return `${className}.${methodName}(${args.join(', ')})`;
+        }
+        return `${methodName}(${args.join(', ')})`;
+    }
+    typeArrayToString(types, split = ', ') {
+        let typesStr = [];
+        types.forEach((t) => {
+            typesStr.push(this.typeToString(t));
+        });
+        return typesStr.join(split);
+    }
+    static constToString(value) {
+        if (value.getType() == 'string') {
+            return `'${SourceUtils_1.SourceUtils.escape(value.getValue())}'`;
+        }
+        else {
+            return value.getValue();
+        }
+    }
+    exprToString(expr) {
+        if (expr instanceof Expr_1.ArkInstanceInvokeExpr) {
+            return `${this.instanceInvokeExprToString(expr)}`;
+        }
+        if (expr instanceof Expr_1.ArkStaticInvokeExpr) {
+            return `${this.staticInvokeExprToString(expr)}`;
+        }
+        if (expr instanceof Expr_1.ArkNewArrayExpr) {
+            return `new Array<${this.typeToString(expr.getBaseType())}>(${expr.getSize()})`;
+        }
+        if (expr instanceof Expr_1.ArkNewExpr) {
+            return `new ${this.typeToString(expr.getType())}()`;
+        }
+        if (expr instanceof Expr_1.ArkDeleteExpr) {
+            return `delete ${this.valueToString(expr.getField())}`;
+        }
+        if (expr instanceof Expr_1.AbstractBinopExpr) {
+            let op1 = expr.getOp1();
+            let op2 = expr.getOp2();
+            let operator = expr.getOperator();
+            return `${this.valueToString(op1, operator)} ${operator} ${this.valueToString(op2, operator)}`;
+        }
+        if (expr instanceof Expr_1.ArkTypeOfExpr) {
+            return `typeof(${this.valueToString(expr.getOp())})`;
+        }
+        if (expr instanceof Expr_1.ArkInstanceOfExpr) {
+            return `${this.valueToString(expr.getOp())} instanceof ${this.typeToString(expr.getType())}`;
+        }
+        if (expr instanceof Expr_1.ArkCastExpr) {
+            let baseOp = expr.getOp();
+            return `${this.valueToString(baseOp)} as ${this.typeToString(expr.getType())}`;
+        }
+        if (expr instanceof Expr_1.ArkUnopExpr) {
+            return `${expr.getOperator()}${this.valueToString(expr.getOp())}`;
+        }
+        if (expr instanceof Expr_1.ArkAwaitExpr) {
+            return `await ${this.valueToString(expr.getPromise())}`;
+        }
+        if (expr instanceof Expr_1.ArkYieldExpr) {
+            return `yield ${this.valueToString(expr.getYieldValue())}`;
+        }
+        logger.info(`exprToString ${expr.constructor} not support.`);
+        // ArkPhiExpr
+        return `${expr}`;
+    }
+    refToString(value) {
+        if (value instanceof Ref_1.ArkInstanceFieldRef) {
+            return `${this.valueToString(value.getBase())}.${value.getFieldName()}`;
+        }
+        if (value instanceof Ref_1.ArkStaticFieldRef) {
+            return `${value.getFieldSignature().getBaseName()}.${value.getFieldName()}`;
+        }
+        if (value instanceof Ref_1.ArkArrayRef) {
+            let index = value.getIndex();
+            if (index instanceof Constant_1.Constant &&
+                index.getType() instanceof Type_1.StringType &&
+                SourceUtils_1.SourceUtils.isTemp(index.getValue())) {
+                return `${this.valueToString(value.getBase())}[${this.valueToString(new Local_1.Local(index.getValue()))}]`;
+            }
+            return `${this.valueToString(value.getBase())}[${this.valueToString(value.getIndex())}]`;
+        }
+        if (value instanceof Ref_1.ArkThisRef) {
+            return 'this';
+        }
+        // ArkCaughtExceptionRef
+        logger.info(`refToString ${value.constructor} not support.`);
+        return `${value}`;
+    }
+    valueToString(value, operator) {
+        if (value instanceof Expr_1.AbstractExpr) {
+            return this.exprToString(value);
+        }
+        if (value instanceof Ref_1.AbstractRef) {
+            return this.refToString(value);
+        }
+        if (value instanceof Constant_1.Constant) {
+            return SourceTransformer.constToString(value);
+        }
+        if (value instanceof Local_1.Local) {
+            if (SourceUtils_1.SourceUtils.isAnonymousMethod(value.getName())) {
+                let methodSignature = value.getType().getMethodSignature();
+                let anonymousMethod = this.context.getMethod(methodSignature);
+                if (anonymousMethod) {
+                    return this.anonymousMethodToString(anonymousMethod, this.context.getPrinter().getIndent());
+                }
+            }
+            if (SourceUtils_1.SourceUtils.isAnonymousClass(value.getName())) {
+                let clsSignature = value.getType().getClassSignature();
+                let cls = this.context.getClass(clsSignature);
+                if (cls) {
+                    return this.anonymousClassToString(cls, this.context.getPrinter().getIndent());
+                }
+            }
+            if (operator == Expr_1.NormalBinaryOperator.Division ||
+                operator == Expr_1.NormalBinaryOperator.Multiplication ||
+                operator == Expr_1.NormalBinaryOperator.Remainder) {
+                if (SourceUtils_1.SourceUtils.isTemp(value.getName())) {
+                    let stmt = value.getDeclaringStmt();
+                    if (stmt instanceof Stmt_1.ArkAssignStmt && stmt.getRightOp() instanceof Expr_1.ArkNormalBinopExpr) {
+                        return `(${this.context.transTemp2Code(value)})`;
+                    }
+                }
+            }
+            return this.context.transTemp2Code(value);
+        }
+        logger.info(`valueToString ${value.constructor} not support.`);
+        return `${value}`;
+    }
+    literalObjectToString(type) {
+        let name = type.getClassSignature().getClassName();
+        if (SourceUtils_1.SourceUtils.isAnonymousClass(name)) {
+            let cls = this.context.getClass(type.getClassSignature());
+            if (cls) {
+                return this.anonymousClassToString(cls, this.context.getPrinter().getIndent());
+            }
+        }
+        return name;
+    }
+    typeToString(type) {
+        if (type instanceof Type_1.LiteralType) {
+            let literalName = type.getLiteralName();
+            if (typeof literalName === 'string' && literalName.endsWith('Keyword')) {
+                return literalName.substring(0, literalName.length - 'Keyword'.length).toLowerCase();
+            }
+            return `${literalName}`;
+        }
+        if (type instanceof Type_1.PrimitiveType) {
+            return type.getName();
+        }
+        if (type instanceof Type_1.UnionType) {
+            let typesStr = [];
+            for (const member of type.getTypes()) {
+                typesStr.push(this.typeToString(member));
+            }
+            return typesStr.join(' | ');
+        }
+        if (type instanceof Type_1.UnknownType) {
+            return 'any';
+        }
+        if (type instanceof Type_1.VoidType) {
+            return 'void';
+        }
+        if (type instanceof Type_1.ClassType) {
+            let name = type.getClassSignature().getClassName();
+            if (SourceUtils_1.SourceUtils.isDefaultClass(name)) {
+                return 'any';
+            }
+            if (SourceUtils_1.SourceUtils.isAnonymousClass(name)) {
+                let cls = this.context.getClass(type.getClassSignature());
+                if (cls && cls.getCategory() == ArkClass_1.ClassCategory.TYPE_LITERAL) {
+                    return this.anonymousClassToString(cls, this.context.getPrinter().getIndent());
+                }
+                return 'Object';
+            }
+            return name;
+        }
+        if (type instanceof Type_1.ArrayType) {
+            const dimensions = [];
+            for (let i = 0; i < type.getDimension(); i++) {
+                dimensions.push('[]');
+            }
+            let baseType = type.getBaseType();
+            if (baseType instanceof Type_1.UnionType) {
+                return `(${this.typeToString(baseType)})${dimensions.join('')}`;
+            }
+            return `${this.typeToString(baseType)}${dimensions.join('')}`;
+        }
+        if (type instanceof Type_1.FunctionType) {
+            let methodSignature = type.getMethodSignature();
+            let method = this.context.getMethod(methodSignature);
+            if (method && SourceUtils_1.SourceUtils.isAnonymousMethod(method.getName())) {
+                return new SourceMethod_1.SourceMethod(method).toArrowFunctionTypeString();
+            }
+        }
+        if (type instanceof Type_1.UnclearReferenceType) {
+            let genericTypes = type.getGenericTypes();
+            if (genericTypes.length > 0) {
+                return `${type.getName()}<${genericTypes.join(', ')}>`;
+            }
+            return type.getName();
+        }
+        if (type instanceof Type_1.GenericType) {
+            return type.getName();
+        }
+        if (!type) {
+            return 'any';
+        }
+        logger.info(`valueToString ${type.constructor} not support.`);
+        return type.toString();
+    }
+}
+exports.SourceTransformer = SourceTransformer;

package/lib/save/source/SourceUtils.d.ts

@@ -0,0 +1,25 @@
+import { ArkInstanceInvokeExpr, ArkStaticInvokeExpr, NormalBinaryOperator } from '../../core/base/Expr';
+import { Stmt } from '../../core/base/Stmt';
+import { ArkClass } from '../../core/model/ArkClass';
+import { ClassSignature } from '../../core/model/ArkSignature';
+import { ArkNamespace } from '../../core/model/ArkNamespace';
+export declare const CLASS_CATEGORY_COMPONENT = 100;
+export declare class SourceUtils {
+    static classOriginTypeToString: Map<number, string>;
+    static isAnonymousClass(name: string): boolean;
+    static isDefaultClass(name: string): boolean;
+    static isAnonymousMethod(name: string): boolean;
+    static isConstructorMethod(name: string): boolean;
+    static isDeIncrementStmt(stmt: Stmt | null, op: NormalBinaryOperator): boolean;
+    static isTemp(name: string): boolean;
+    static getOriginType(cls: ArkClass): number;
+    static isComponentPop(invokeExpr: ArkStaticInvokeExpr): boolean;
+    static isComponentCreate(invokeExpr: ArkStaticInvokeExpr): boolean;
+    static isComponentAttributeInvoke(invokeExpr: ArkInstanceInvokeExpr, visitor?: Set<ArkInstanceInvokeExpr>): boolean;
+    static isComponentIfBranchInvoke(invokeExpr: ArkStaticInvokeExpr): boolean;
+    static isComponentIfElseInvoke(invokeExpr: ArkStaticInvokeExpr): boolean;
+    static getStaticInvokeClassFullName(classSignature: ClassSignature, namespace: ArkNamespace | undefined): string;
+    static isIdentifierText(text: string): boolean;
+    static escape(text: string): string;
+}
+//# sourceMappingURL=SourceUtils.d.ts.map

package/lib/save/source/SourceUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SourceUtils.d.ts","sourceRoot":"","sources":["../../../src/save/source/SourceUtils.ts"],"names":[],"mappings":"AAgBA,OAAO,EACH,qBAAqB,EAErB,mBAAmB,EACnB,oBAAoB,EACvB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAiB,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAS3D,OAAO,EAAE,QAAQ,EAAiB,MAAM,2BAA2B,CAAC;AAGpE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAK7D,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAE5C,qBAAa,WAAW;IACpB,OAAc,uBAAuB,sBAQlC;WAEW,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAIvC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAIrC,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAIxC,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAI1C,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,EAAE,EAAE,oBAAoB,GAAG,OAAO;WAqBvE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAI7B,aAAa,CAAC,GAAG,EAAE,QAAQ,GAAG,MAAM;WAOpC,cAAc,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO;WAcxD,iBAAiB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO;WAc3D,0BAA0B,CACpC,UAAU,EAAE,qBAAqB,EACjC,OAAO,GAAE,GAAG,CAAC,qBAAqB,CAAa,GAChD,OAAO;WA2BI,yBAAyB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO;WAUnE,uBAAuB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO;WAajE,4BAA4B,CACtC,cAAc,EAAE,cAAc,EAC9B,SAAS,EAAE,YAAY,GAAG,SAAS,GACpC,MAAM;WAeK,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAevC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAY7C"}

package/lib/save/source/SourceUtils.js

@@ -0,0 +1,201 @@
+"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.SourceUtils = exports.CLASS_CATEGORY_COMPONENT = void 0;
+const Constant_1 = require("../../core/base/Constant");
+const Expr_1 = require("../../core/base/Expr");
+const Local_1 = require("../../core/base/Local");
+const Stmt_1 = require("../../core/base/Stmt");
+const EtsConst_1 = require("../../core/common/EtsConst");
+const ArkClass_1 = require("../../core/model/ArkClass");
+const logger_1 = __importStar(require("../../utils/logger"));
+const Const_1 = require("../../core/common/Const");
+const ohos_typescript_1 = __importDefault(require("ohos-typescript"));
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'SourceUtils');
+exports.CLASS_CATEGORY_COMPONENT = 100;
+class SourceUtils {
+    static isAnonymousClass(name) {
+        return name.startsWith(Const_1.ANONYMOUS_CLASS_PREFIX);
+    }
+    static isDefaultClass(name) {
+        return name == Const_1.DEFAULT_ARK_CLASS_NAME;
+    }
+    static isAnonymousMethod(name) {
+        return name.startsWith('AnonymousMethod-');
+    }
+    static isConstructorMethod(name) {
+        return name == 'constructor';
+    }
+    static isDeIncrementStmt(stmt, op) {
+        if (!(stmt instanceof Stmt_1.ArkAssignStmt)) {
+            return false;
+        }
+        let leftOp = stmt.getLeftOp();
+        let rightOp = stmt.getRightOp();
+        if (!(leftOp instanceof Local_1.Local) || !(rightOp instanceof Expr_1.ArkNormalBinopExpr)) {
+            return false;
+        }
+        let op1 = rightOp.getOp1();
+        let op2 = rightOp.getOp2();
+        let operator = rightOp.getOperator();
+        if (!(op1 instanceof Local_1.Local) || !(op2 instanceof Constant_1.Constant)) {
+            return false;
+        }
+        return leftOp.getName() == op1.getName() && operator == op && op2.getValue() == '1';
+    }
+    static isTemp(name) {
+        return name.startsWith('$temp');
+    }
+    static getOriginType(cls) {
+        if (cls.hasComponentDecorator()) {
+            return exports.CLASS_CATEGORY_COMPONENT;
+        }
+        return cls.getCategory();
+    }
+    static isComponentPop(invokeExpr) {
+        let className = invokeExpr.getMethodSignature().getDeclaringClassSignature().getClassName();
+        let methodName = invokeExpr.getMethodSignature().getMethodSubSignature().getMethodName();
+        if (methodName == EtsConst_1.COMPONENT_POP_FUNCTION &&
+            ((0, EtsConst_1.isEtsSystemComponent)(className) || EtsConst_1.SPECIAL_CONTAINER_COMPONENT.has(className))) {
+            return true;
+        }
+        return false;
+    }
+    static isComponentCreate(invokeExpr) {
+        let className = invokeExpr.getMethodSignature().getDeclaringClassSignature().getClassName();
+        let methodName = invokeExpr.getMethodSignature().getMethodSubSignature().getMethodName();
+        if (methodName == EtsConst_1.COMPONENT_CREATE_FUNCTION &&
+            ((0, EtsConst_1.isEtsSystemComponent)(className) || EtsConst_1.SPECIAL_CONTAINER_COMPONENT.has(className))) {
+            return true;
+        }
+        return false;
+    }
+    static isComponentAttributeInvoke(invokeExpr, visitor = new Set()) {
+        if (visitor.has(invokeExpr)) {
+            return false;
+        }
+        visitor.add(invokeExpr);
+        let base = invokeExpr.getBase();
+        if (!(base instanceof Local_1.Local)) {
+            logger.error(`SourceUtils->isComponentAttributeInvoke illegal invoke expr ${invokeExpr}`);
+            return false;
+        }
+        let stmt = base.getDeclaringStmt();
+        if (!stmt || !(stmt instanceof Stmt_1.ArkAssignStmt)) {
+            return false;
+        }
+        let rightOp = stmt.getRightOp();
+        if (rightOp instanceof Expr_1.ArkInstanceInvokeExpr) {
+            return SourceUtils.isComponentAttributeInvoke(rightOp, visitor);
+        }
+        if (rightOp instanceof Expr_1.ArkStaticInvokeExpr) {
+            return SourceUtils.isComponentCreate(rightOp);
+        }
+        return false;
+    }
+    static isComponentIfBranchInvoke(invokeExpr) {
+        let className = invokeExpr.getMethodSignature().getDeclaringClassSignature().getClassName();
+        let methodName = invokeExpr.getMethodSignature().getMethodSubSignature().getMethodName();
+        if (className == EtsConst_1.COMPONENT_IF && methodName == EtsConst_1.COMPONENT_BRANCH_FUNCTION) {
+            return true;
+        }
+        return false;
+    }
+    static isComponentIfElseInvoke(invokeExpr) {
+        let className = invokeExpr.getMethodSignature().getDeclaringClassSignature().getClassName();
+        let methodName = invokeExpr.getMethodSignature().getMethodSubSignature().getMethodName();
+        if (className == EtsConst_1.COMPONENT_IF && methodName == EtsConst_1.COMPONENT_BRANCH_FUNCTION) {
+            let arg0 = invokeExpr.getArg(0);
+            if (arg0.getValue() == '1') {
+                return true;
+            }
+        }
+        return false;
+    }
+    static getStaticInvokeClassFullName(classSignature, namespace) {
+        var _a;
+        let namespaceName = (_a = classSignature.getDeclaringNamespaceSignature()) === null || _a === void 0 ? void 0 : _a.getNamespaceName();
+        let className = classSignature.getClassName();
+        let code = [];
+        if (namespaceName && namespaceName.length > 0 && namespaceName != (namespace === null || namespace === void 0 ? void 0 : namespace.getName())) {
+            code.push(namespaceName);
+        }
+        if (className && className.length > 0 && !SourceUtils.isDefaultClass(className)) {
+            code.push(className);
+        }
+        return code.join('.');
+    }
+    static isIdentifierText(text) {
+        let ch = text.charCodeAt(0);
+        if (!ohos_typescript_1.default.isIdentifierStart(ch, ohos_typescript_1.default.ScriptTarget.Latest)) {
+            return false;
+        }
+        for (let i = 1; i < text.length; i++) {
+            if (!ohos_typescript_1.default.isIdentifierPart(text.charCodeAt(i), ohos_typescript_1.default.ScriptTarget.Latest)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static escape(text) {
+        return text
+            .replace(/\\/g, '\\\\')
+            .replace(/\f/g, `\\f`)
+            .replace(/\n/g, `\\n`)
+            .replace(/\r/g, '\\r')
+            .replace(/\t/g, '\\t')
+            .replace(/\v/g, '\\v')
+            .replace(/\?/g, '\\?')
+            .replace(/\'/g, "\\'")
+            .replace(/\"/g, '\\"');
+    }
+}
+exports.SourceUtils = SourceUtils;
+SourceUtils.classOriginTypeToString = new Map([
+    [ArkClass_1.ClassCategory.CLASS, 'class'],
+    [ArkClass_1.ClassCategory.STRUCT, 'struct'],
+    [ArkClass_1.ClassCategory.INTERFACE, 'interface'],
+    [ArkClass_1.ClassCategory.ENUM, 'enum'],
+    [ArkClass_1.ClassCategory.TYPE_LITERAL, 'typeliteral'],
+    [ArkClass_1.ClassCategory.OBJECT, 'object'],
+    [exports.CLASS_CATEGORY_COMPONENT, 'component'],
+]);

package/lib/transformer/FunctionTransformer.d.ts

@@ -0,0 +1,3 @@
+declare class FunctionTransformer extends Transformer {
+}
+//# sourceMappingURL=FunctionTransformer.d.ts.map

package/lib/transformer/FunctionTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionTransformer.d.ts","sourceRoot":"","sources":["../../src/transformer/FunctionTransformer.ts"],"names":[],"mappings":"AAgBA,cAAM,mBAAoB,SAAQ,WAAW;CAE5C"}

package/lib/transformer/FunctionTransformer.js

@@ -0,0 +1,17 @@
+"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.
+ */
+class FunctionTransformer extends Transformer {
+}

package/lib/transformer/SceneTransformer.d.ts

@@ -0,0 +1,3 @@
+declare class SceneTransformer extends Transformer {
+}
+//# sourceMappingURL=SceneTransformer.d.ts.map

package/lib/transformer/SceneTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneTransformer.d.ts","sourceRoot":"","sources":["../../src/transformer/SceneTransformer.ts"],"names":[],"mappings":"AAgBA,cAAM,gBAAiB,SAAQ,WAAW;CAEzC"}

package/lib/transformer/SceneTransformer.js

@@ -0,0 +1,17 @@
+"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.
+ */
+class SceneTransformer extends Transformer {
+}