arkanalyzer 1.0.32 → 1.0.33

package/lib/core/common/ArkValueTransformer.js

@@ -198,8 +198,7 @@ class ArkValueTransformer {
         let { value, valueOriginalPositions, stmts } = this.tsNodeToValueAndStmts(node);
         stmts.forEach(stmt => allStmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(value)) {
-            ({ value, valueOriginalPositions, stmts } =
-                this.arkIRTransformer.generateAssignStmtForValue(value, valueOriginalPositions));
+            ({ value, valueOriginalPositions, stmts } = this.arkIRTransformer.generateAssignStmtForValue(value, valueOriginalPositions));
             stmts.forEach(stmt => allStmts.push(stmt));
         }
         return { value, valueOriginalPositions, stmts: allStmts };
@@ -234,7 +233,11 @@ class ArkValueTransformer {
         assignStmt.setOperandOriginalPositions([...resultLocalPosition, ...whenFalsePositions]);
         stmts.push(assignStmt);
         stmts.push(new ArkIRTransformer_1.DummyStmt(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_END_STMT + currConditionalOperatorIndex));
-        return { value: resultLocal, valueOriginalPositions: resultLocalPosition, stmts: stmts };
+        return {
+            value: resultLocal,
+            valueOriginalPositions: resultLocalPosition,
+            stmts: stmts,
+        };
     }
     objectLiteralExpresionToValueAndStmts(objectLiteralExpression) {
         const declaringArkClass = this.declaringMethod.getDeclaringArkClass();
@@ -263,7 +266,11 @@ class ArkValueTransformer {
         const constructorInvokeStmt = new Stmt_1.ArkInvokeStmt(constructorInvokeExpr);
         constructorInvokeStmt.setOperandOriginalPositions(constructorInvokeExprPositions);
         stmts.push(constructorInvokeStmt);
-        return { value: newExprLocal, valueOriginalPositions: newExprLocalPositions, stmts: stmts };
+        return {
+            value: newExprLocal,
+            valueOriginalPositions: newExprLocalPositions,
+            stmts: stmts,
+        };
     }
     generateSystemComponentStmt(componentName, args, argPositionsAllFlat, componentExpression, currStmts) {
         const stmts = [...currStmts];
@@ -276,7 +283,11 @@ class ArkValueTransformer {
             }
         }
         stmts.push(this.generateComponentPopStmts(componentName, componentExpressionPosition));
-        return { value: componentValue, valueOriginalPositions: componentPositions, stmts: stmts };
+        return {
+            value: componentValue,
+            valueOriginalPositions: componentPositions,
+            stmts: stmts,
+        };
     }
     generateCustomViewStmt(componentName, args, argPositionsAllFlat, componentExpression, currStmts) {
         const stmts = [...currStmts];
@@ -301,21 +312,29 @@ class ArkValueTransformer {
             anonymous.pos = componentExpression.body.pos;
             // @ts-expect-error: add end info for the created ArrowFunction
             anonymous.end = componentExpression.body.end;
-            const { value: builderMethod, valueOriginalPositions: builderMethodPositions, } = this.callableNodeToValueAndStmts(anonymous);
+            const { value: builderMethod, valueOriginalPositions: builderMethodPositions } = this.callableNodeToValueAndStmts(anonymous);
             createViewArgs.push(builderMethod);
             createViewArgPositionsAll.push(builderMethodPositions);
         }
         const { value: componentValue, valueOriginalPositions: componentPositions, stmts: componentStmts, } = this.generateComponentCreationStmts(EtsConst_1.COMPONENT_CUSTOMVIEW, createViewArgs, componentExpressionPosition, createViewArgPositionsAll.flat());
         componentStmts.forEach(stmt => stmts.push(stmt));
         stmts.push(this.generateComponentPopStmts(EtsConst_1.COMPONENT_CUSTOMVIEW, componentExpressionPosition));
-        return { value: componentValue, valueOriginalPositions: componentPositions, stmts: stmts };
+        return {
+            value: componentValue,
+            valueOriginalPositions: componentPositions,
+            stmts: stmts,
+        };
     }
     generateComponentCreationStmts(componentName, createArgs, componentExpressionPosition, createArgsPositionsAllFlat) {
         const createMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(componentName, EtsConst_1.COMPONENT_CREATE_FUNCTION);
         const createInvokeExpr = new Expr_1.ArkStaticInvokeExpr(createMethodSignature, createArgs);
         const createInvokeExprPositions = [componentExpressionPosition, ...createArgsPositionsAllFlat];
         const { value: componentValue, valueOriginalPositions: componentPositions, stmts: componentStmts, } = this.arkIRTransformer.generateAssignStmtForValue(createInvokeExpr, createInvokeExprPositions);
-        return { value: componentValue, valueOriginalPositions: componentPositions, stmts: componentStmts };
+        return {
+            value: componentValue,
+            valueOriginalPositions: componentPositions,
+            stmts: componentStmts,
+        };
     }
     generateComponentPopStmts(componentName, componentExpressionPosition) {
         const popMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(componentName, EtsConst_1.COMPONENT_POP_FUNCTION);
@@ -368,8 +387,11 @@ class ArkValueTransformer {
             let placeholderPosition = [placeholderPositions[i]];
             let placeholderStmts = [];
             if (!(placeholderValue instanceof Local_1.Local)) {
-                ({ value: placeholderValue, valueOriginalPositions: placeholderPosition, stmts: placeholderStmts } =
-                    this.arkIRTransformer.generateAssignStmtForValue(placeholderValue, placeholderPosition));
+                ({
+                    value: placeholderValue,
+                    valueOriginalPositions: placeholderPosition,
+                    stmts: placeholderStmts,
+                } = this.arkIRTransformer.generateAssignStmtForValue(placeholderValue, placeholderPosition));
             }
             placeholderStmts.forEach(stmt => newStmts.push(stmt));
             const toStringExpr = new Expr_1.ArkInstanceInvokeExpr(placeholderValue, Builtin_1.Builtin.TO_STRING_METHOD_SIGNATURE, []);
@@ -379,7 +401,11 @@ class ArkValueTransformer {
             placeholderStringLocalPositions.push(placeholderStringPositions[0]);
             toStringStmts.forEach(stmt => newStmts.push(stmt));
         }
-        return { placeholderStringLocals, placeholderStringLocalPositions, newStmts };
+        return {
+            placeholderStringLocals,
+            placeholderStringLocalPositions,
+            newStmts,
+        };
     }
     combineTemplateParts(stringTextValues, stringTextPositions, placeholderStringLocals, placeholderStringLocalPositions, currStmts) {
         const templateParts = [];
@@ -402,17 +428,24 @@ class ArkValueTransformer {
         for (let i = 1; i < templateParts.length; i++) {
             const nextTemplatePartPosition = templatePartPositions[i];
             const normalBinopExpr = new Expr_1.ArkNormalBinopExpr(currTemplateResult, templateParts[i], Expr_1.NormalBinaryOperator.Addition);
-            const normalBinopExprPositions = [Position_1.FullPosition.merge(currTemplateResultPosition, nextTemplatePartPosition),
-                currTemplateResultPosition, nextTemplatePartPosition];
+            const normalBinopExprPositions = [
+                Position_1.FullPosition.merge(currTemplateResultPosition, nextTemplatePartPosition),
+                currTemplateResultPosition,
+                nextTemplatePartPosition,
+            ];
             const { value: combinationValue, valueOriginalPositions: combinationValuePositions, stmts: combinationStmts, } = this.arkIRTransformer.generateAssignStmtForValue(normalBinopExpr, normalBinopExprPositions);
             combinationStmts.forEach(stmt => finalStmts.push(stmt));
             currTemplateResult = combinationValue;
             currTemplateResultPosition = combinationValuePositions[0];
         }
-        return { value: currTemplateResult, valueOriginalPositions: [currTemplateResultPosition], stmts: finalStmts };
+        return {
+            value: currTemplateResult,
+            valueOriginalPositions: [currTemplateResultPosition],
+            stmts: finalStmts,
+        };
     }
     taggedTemplateExpressionToValueAndStmts(taggedTemplateExpression) {
-        const { stmts, stringTextValues, placeholderValues, stringTextPositions, placeholderPositions, } = this.collectTemplateValues(taggedTemplateExpression.template);
+        const { stmts, stringTextValues, placeholderValues, stringTextPositions, placeholderPositions } = this.collectTemplateValues(taggedTemplateExpression.template);
         const stringTextBaseType = Type_1.StringType.getInstance();
         const stringTextArrayLen = stringTextValues.length;
         const stringTextArrayLenValue = ValueUtil_1.ValueUtil.getOrCreateNumberConst(stringTextArrayLen);
@@ -424,7 +457,8 @@ class ArkValueTransformer {
         const placeholdersArrayLenPosition = Position_1.FullPosition.DEFAULT;
         const { value: placeholdersLocal, valueOriginalPositions: placeholdersLocalPositions, stmts: placeholdersStmts, } = this.generateArrayExprAndStmts(placeholderBaseType, placeholdersArrayLenValue, placeholdersArrayLenPosition, placeholdersArrayLen, placeholderValues, placeholderPositions, templateObjectStmts, Position_1.FullPosition.DEFAULT, true);
         const taggedFuncArgus = {
-            realGenericTypes: undefined, args: [templateObjectLocal, placeholdersLocal],
+            realGenericTypes: undefined,
+            args: [templateObjectLocal, placeholdersLocal],
             argPositions: [templateObjectLocalPositions[0], placeholdersLocalPositions[0]],
         };
         return this.generateInvokeValueAndStmts(taggedTemplateExpression.tag, taggedFuncArgus, placeholdersStmts, taggedTemplateExpression);
@@ -434,7 +468,8 @@ class ArkValueTransformer {
         if (ts.isNoSubstitutionTemplateLiteral(templateLiteral)) {
             const templateLiteralString = templateLiteral.getText(this.sourceFile);
             return {
-                stmts: [], stringTextValues: [ValueUtil_1.ValueUtil.createStringConst(templateLiteralString)],
+                stmts: [],
+                stringTextValues: [ValueUtil_1.ValueUtil.createStringConst(templateLiteralString)],
                 placeholderValues: [],
                 stringTextPositions: [Position_1.FullPosition.buildFromNode(templateLiteral, this.sourceFile)],
                 placeholderPositions: [],
@@ -446,11 +481,14 @@ class ArkValueTransformer {
         const stringTextPositions = [Position_1.FullPosition.buildFromNode(head, this.sourceFile)];
         const placeholderPositions = [];
         for (const templateSpan of templateLiteral.templateSpans) {
-            let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts, } = this.tsNodeToValueAndStmts(templateSpan.expression);
+            let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts } = this.tsNodeToValueAndStmts(templateSpan.expression);
             exprStmts.forEach(stmt => stmts.push(stmt));
             if (IRUtils_1.IRUtils.moreThanOneAddress(exprValue)) {
-                ({ value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts } =
-                    this.arkIRTransformer.generateAssignStmtForValue(exprValue, exprPositions));
+                ({
+                    value: exprValue,
+                    valueOriginalPositions: exprPositions,
+                    stmts: exprStmts,
+                } = this.arkIRTransformer.generateAssignStmtForValue(exprValue, exprPositions));
                 exprStmts.forEach(stmt => stmts.push(stmt));
             }
             placeholderValues.push(exprValue);
@@ -458,7 +496,13 @@ class ArkValueTransformer {
             stringTextPositions.push(Position_1.FullPosition.buildFromNode(templateSpan.literal, this.sourceFile));
             stringTextValues.push(ValueUtil_1.ValueUtil.createStringConst(templateSpan.literal.rawText || ''));
         }
-        return { stmts, stringTextValues, placeholderValues, stringTextPositions, placeholderPositions };
+        return {
+            stmts,
+            stringTextValues,
+            placeholderValues,
+            stringTextPositions,
+            placeholderPositions,
+        };
     }
     identifierToValueAndStmts(identifier, variableDefFlag = false) {
         let identifierValue;
@@ -474,20 +518,30 @@ class ArkValueTransformer {
                 identifierValue = this.getOrCreateLocal(identifier.text);
             }
         }
-        return { value: identifierValue, valueOriginalPositions: identifierPositions, stmts: [] };
+        return {
+            value: identifierValue,
+            valueOriginalPositions: identifierPositions,
+            stmts: [],
+        };
     }
     propertyAccessExpressionToValue(propertyAccessExpression) {
         const stmts = [];
-        let { value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts, } = this.tsNodeToValueAndStmts(propertyAccessExpression.expression);
+        let { value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } = this.tsNodeToValueAndStmts(propertyAccessExpression.expression);
         baseStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(baseValue)) {
-            ({ value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } =
-                this.arkIRTransformer.generateAssignStmtForValue(baseValue, basePositions));
+            ({
+                value: baseValue,
+                valueOriginalPositions: basePositions,
+                stmts: baseStmts,
+            } = this.arkIRTransformer.generateAssignStmtForValue(baseValue, basePositions));
             baseStmts.forEach(stmt => stmts.push(stmt));
         }
         if (!(baseValue instanceof Local_1.Local)) {
-            ({ value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } =
-                this.arkIRTransformer.generateAssignStmtForValue(baseValue, basePositions));
+            ({
+                value: baseValue,
+                valueOriginalPositions: basePositions,
+                stmts: baseStmts,
+            } = this.arkIRTransformer.generateAssignStmtForValue(baseValue, basePositions));
             baseStmts.forEach(stmt => stmts.push(stmt));
         }
         const fieldRefPositions = [Position_1.FullPosition.buildFromNode(propertyAccessExpression, this.sourceFile), ...basePositions];
@@ -496,7 +550,11 @@ class ArkValueTransformer {
             this.locals.delete(baseValue.getName());
             const fieldSignature = new ArkSignature_1.FieldSignature(propertyAccessExpression.name.getText(this.sourceFile), Builtin_1.Builtin.OBJECT_CLASS_SIGNATURE, Type_1.UnknownType.getInstance(), true);
             const fieldRef = new Ref_1.ArkStaticFieldRef(fieldSignature);
-            return { value: fieldRef, valueOriginalPositions: fieldRefPositions, stmts: stmts };
+            return {
+                value: fieldRef,
+                valueOriginalPositions: fieldRefPositions,
+                stmts: stmts,
+            };
         }
         let fieldSignature;
         if (baseValue instanceof Local_1.Local && baseValue.getType() instanceof Type_1.ClassType) {
@@ -506,22 +564,32 @@ class ArkValueTransformer {
             fieldSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildFieldSignatureFromFieldName(propertyAccessExpression.name.getText(this.sourceFile));
         }
         const fieldRef = new Ref_1.ArkInstanceFieldRef(baseValue, fieldSignature);
-        return { value: fieldRef, valueOriginalPositions: fieldRefPositions, stmts: stmts };
+        return {
+            value: fieldRef,
+            valueOriginalPositions: fieldRefPositions,
+            stmts: stmts,
+        };
     }
     elementAccessExpressionToValueAndStmts(elementAccessExpression) {
         const stmts = [];
         let { value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } = this.tsNodeToValueAndStmts(elementAccessExpression.expression);
         baseStmts.forEach(stmt => stmts.push(stmt));
         if (!(baseValue instanceof Local_1.Local)) {
-            ({ value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } =
-                this.arkIRTransformer.generateAssignStmtForValue(baseValue, basePositions));
+            ({
+                value: baseValue,
+                valueOriginalPositions: basePositions,
+                stmts: baseStmts,
+            } = this.arkIRTransformer.generateAssignStmtForValue(baseValue, basePositions));
             baseStmts.forEach(stmt => stmts.push(stmt));
         }
         let { value: argumentValue, valueOriginalPositions: arguPositions, stmts: argumentStmts, } = this.tsNodeToValueAndStmts(elementAccessExpression.argumentExpression);
         argumentStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(argumentValue)) {
-            ({ value: argumentValue, valueOriginalPositions: arguPositions, stmts: argumentStmts } =
-                this.arkIRTransformer.generateAssignStmtForValue(argumentValue, arguPositions));
+            ({
+                value: argumentValue,
+                valueOriginalPositions: arguPositions,
+                stmts: argumentStmts,
+            } = this.arkIRTransformer.generateAssignStmtForValue(argumentValue, arguPositions));
             argumentStmts.forEach(stmt => stmts.push(stmt));
         }
         let elementAccessExpr;
@@ -534,9 +602,12 @@ class ArkValueTransformer {
             elementAccessExpr = new Ref_1.ArkInstanceFieldRef(baseValue, fieldSignature);
         }
         // reserve positions for field name
-        const exprPositions = [Position_1.FullPosition.buildFromNode(elementAccessExpression, this.sourceFile), ...basePositions,
-            ...arguPositions];
-        return { value: elementAccessExpr, valueOriginalPositions: exprPositions, stmts: stmts };
+        const exprPositions = [Position_1.FullPosition.buildFromNode(elementAccessExpression, this.sourceFile), ...basePositions, ...arguPositions];
+        return {
+            value: elementAccessExpr,
+            valueOriginalPositions: exprPositions,
+            stmts: stmts,
+        };
     }
     callExpressionToValueAndStmts(callExpression) {
         const stmts = [];
@@ -545,7 +616,7 @@ class ArkValueTransformer {
     }
     generateInvokeValueAndStmts(functionNameNode, argus, currStmts, callExpression) {
         const stmts = [...currStmts];
-        let { value: callerValue, valueOriginalPositions: callerPositions, stmts: callerStmts, } = this.tsNodeToValueAndStmts(functionNameNode);
+        let { value: callerValue, valueOriginalPositions: callerPositions, stmts: callerStmts } = this.tsNodeToValueAndStmts(functionNameNode);
         callerStmts.forEach(stmt => stmts.push(stmt));
         let invokeValue;
         let invokeValuePositions = [Position_1.FullPosition.buildFromNode(callExpression, this.sourceFile)];
@@ -587,14 +658,21 @@ class ArkValueTransformer {
             }
         }
         else {
-            ({ value: callerValue, valueOriginalPositions: callerPositions, stmts: callerStmts } =
-                this.arkIRTransformer.generateAssignStmtForValue(callerValue, callerPositions));
+            ({
+                value: callerValue,
+                valueOriginalPositions: callerPositions,
+                stmts: callerStmts,
+            } = this.arkIRTransformer.generateAssignStmtForValue(callerValue, callerPositions));
             callerStmts.forEach(stmt => stmts.push(stmt));
             const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(callerValue.getName());
             invokeValue = new Expr_1.ArkStaticInvokeExpr(methodSignature, args, realGenericTypes);
         }
         invokeValuePositions.push(...argPositions);
-        return { value: invokeValue, valueOriginalPositions: invokeValuePositions, stmts: stmts };
+        return {
+            value: invokeValue,
+            valueOriginalPositions: invokeValuePositions,
+            stmts: stmts,
+        };
     }
     parseArgumentsOfCallExpression(currStmts, callExpression) {
         let realGenericTypes;
@@ -612,7 +690,11 @@ class ArkValueTransformer {
             }
         }
         const { args: args, argPositions: argPositions } = this.parseArguments(currStmts, callExpression.arguments, builderMethodIndexes);
-        return { realGenericTypes: realGenericTypes, args: args, argPositions: argPositions };
+        return {
+            realGenericTypes: realGenericTypes,
+            args: args,
+            argPositions: argPositions,
+        };
     }
     parseArguments(currStmts, argumentNodes, builderMethodIndexes) {
         const args = [];
@@ -625,13 +707,16 @@ class ArkValueTransformer {
                     this.builderMethodContextFlag = true;
                     this.arkIRTransformer.setBuilderMethodContextFlag(true);
                 }
-                let { value: argValue, valueOriginalPositions: argPositionsSingle, stmts: argStmts, } = this.tsNodeToValueAndStmts(argument);
+                let { value: argValue, valueOriginalPositions: argPositionsSingle, stmts: argStmts } = this.tsNodeToValueAndStmts(argument);
                 this.builderMethodContextFlag = prevBuilderMethodContextFlag;
                 this.arkIRTransformer.setBuilderMethodContextFlag(prevBuilderMethodContextFlag);
                 argStmts.forEach(s => currStmts.push(s));
                 if (IRUtils_1.IRUtils.moreThanOneAddress(argValue)) {
-                    ({ value: argValue, valueOriginalPositions: argPositionsSingle, stmts: argStmts } =
-                        this.arkIRTransformer.generateAssignStmtForValue(argValue, argPositionsSingle));
+                    ({
+                        value: argValue,
+                        valueOriginalPositions: argPositionsSingle,
+                        stmts: argStmts,
+                    } = this.arkIRTransformer.generateAssignStmtForValue(argValue, argPositionsSingle));
                     argStmts.forEach(s => currStmts.push(s));
                 }
                 args.push(argValue);
@@ -691,7 +776,11 @@ class ArkValueTransformer {
         const invokeStmt = new Stmt_1.ArkInvokeStmt(instanceInvokeExpr);
         invokeStmt.setOperandOriginalPositions(instanceInvokeExprPositions);
         stmts.push(invokeStmt);
-        return { value: newLocal, valueOriginalPositions: newLocalPositions, stmts: stmts };
+        return {
+            value: newLocal,
+            valueOriginalPositions: newLocalPositions,
+            stmts: stmts,
+        };
     }
     newArrayExpressionToValueAndStmts(newArrayExpression) {
         let baseType = Type_1.UnknownType.getInstance();
@@ -707,9 +796,7 @@ class ArkValueTransformer {
         let arrayLengthValue;
         let arrayLength = -1;
         let arrayLengthPosition = Position_1.FullPosition.DEFAULT;
-        if ((argumentsLength === 1) &&
-            ((argumentValues[0].getType() instanceof Type_1.NumberType) || argumentValues[0].getType() instanceof
-                Type_1.UnknownType)) {
+        if (argumentsLength === 1 && (argumentValues[0].getType() instanceof Type_1.NumberType || argumentValues[0].getType() instanceof Type_1.UnknownType)) {
             arrayLengthValue = argumentValues[0];
             arrayLengthPosition = argPositions[0];
         }
@@ -718,7 +805,7 @@ class ArkValueTransformer {
             arrayLength = argumentsLength;
         }
         if (baseType instanceof Type_1.UnknownType) {
-            if ((argumentsLength > 1) && !(argumentValues[0].getType() instanceof Type_1.UnknownType)) {
+            if (argumentsLength > 1 && !(argumentValues[0].getType() instanceof Type_1.UnknownType)) {
                 baseType = argumentValues[0].getType();
             }
             else {
@@ -735,11 +822,14 @@ class ArkValueTransformer {
         const elementPositions = [];
         const arrayLength = arrayLiteralExpression.elements.length;
         for (const element of arrayLiteralExpression.elements) {
-            let { value: elementValue, valueOriginalPositions: elementPosition, stmts: elementStmts, } = this.tsNodeToValueAndStmts(element);
+            let { value: elementValue, valueOriginalPositions: elementPosition, stmts: elementStmts } = this.tsNodeToValueAndStmts(element);
             elementStmts.forEach(stmt => stmts.push(stmt));
             if (IRUtils_1.IRUtils.moreThanOneAddress(elementValue)) {
-                ({ value: elementValue, valueOriginalPositions: elementPosition, stmts: elementStmts } =
-                    this.arkIRTransformer.generateAssignStmtForValue(elementValue, elementPosition));
+                ({
+                    value: elementValue,
+                    valueOriginalPositions: elementPosition,
+                    stmts: elementStmts,
+                } = this.arkIRTransformer.generateAssignStmtForValue(elementValue, elementPosition));
                 elementStmts.forEach(stmt => stmts.push(stmt));
             }
             elementValues.push(elementValue);
@@ -770,15 +860,22 @@ class ArkValueTransformer {
             assignStmt.setOperandOriginalPositions([...arrayRefPositions, initializerPositions[i]]);
             stmts.push(assignStmt);
         }
-        return { value: arrayLocal, valueOriginalPositions: arrayLocalPositions, stmts: stmts };
+        return {
+            value: arrayLocal,
+            valueOriginalPositions: arrayLocalPositions,
+            stmts: stmts,
+        };
     }
     prefixUnaryExpressionToValueAndStmts(prefixUnaryExpression) {
         const stmts = [];
-        let { value: operandValue, valueOriginalPositions: operandPositions, stmts: operandStmts, } = this.tsNodeToValueAndStmts(prefixUnaryExpression.operand);
+        let { value: operandValue, valueOriginalPositions: operandPositions, stmts: operandStmts } = this.tsNodeToValueAndStmts(prefixUnaryExpression.operand);
         operandStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(operandValue)) {
-            ({ value: operandValue, valueOriginalPositions: operandPositions, stmts: operandStmts } =
-                this.arkIRTransformer.generateAssignStmtForValue(operandValue, operandPositions));
+            ({
+                value: operandValue,
+                valueOriginalPositions: operandPositions,
+                stmts: operandStmts,
+            } = this.arkIRTransformer.generateAssignStmtForValue(operandValue, operandPositions));
             operandStmts.forEach(stmt => stmts.push(stmt));
         }
         const operatorToken = prefixUnaryExpression.operator;
@@ -790,10 +887,18 @@ class ArkValueTransformer {
             const assignStmt = new Stmt_1.ArkAssignStmt(operandValue, binopExpr);
             assignStmt.setOperandOriginalPositions([...operandPositions, ...exprPositions]);
             stmts.push(assignStmt);
-            return { value: operandValue, valueOriginalPositions: operandPositions, stmts: stmts };
+            return {
+                value: operandValue,
+                valueOriginalPositions: operandPositions,
+                stmts: stmts,
+            };
         }
         else if (operatorToken === ts.SyntaxKind.PlusToken) {
-            return { value: operandValue, valueOriginalPositions: operandPositions, stmts: stmts };
+            return {
+                value: operandValue,
+                valueOriginalPositions: operandPositions,
+                stmts: stmts,
+            };
         }
         else {
             let unopExpr;
@@ -806,16 +911,23 @@ class ArkValueTransformer {
                 unopExpr = ValueUtil_1.ValueUtil.getUndefinedConst();
                 exprPositions = [Position_1.FullPosition.DEFAULT];
             }
-            return { value: unopExpr, valueOriginalPositions: exprPositions, stmts: stmts };
+            return {
+                value: unopExpr,
+                valueOriginalPositions: exprPositions,
+                stmts: stmts,
+            };
         }
     }
     postfixUnaryExpressionToValueAndStmts(postfixUnaryExpression) {
         const stmts = [];
-        let { value: operandValue, valueOriginalPositions: operandPositions, stmts: exprStmts, } = this.tsNodeToValueAndStmts(postfixUnaryExpression.operand);
+        let { value: operandValue, valueOriginalPositions: operandPositions, stmts: exprStmts } = this.tsNodeToValueAndStmts(postfixUnaryExpression.operand);
         exprStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(operandValue)) {
-            ({ value: operandValue, valueOriginalPositions: operandPositions, stmts: exprStmts } =
-                this.arkIRTransformer.generateAssignStmtForValue(operandValue, operandPositions));
+            ({
+                value: operandValue,
+                valueOriginalPositions: operandPositions,
+                stmts: exprStmts,
+            } = this.arkIRTransformer.generateAssignStmtForValue(operandValue, operandPositions));
             exprStmts.forEach(stmt => stmts.push(stmt));
         }
         let value;
@@ -834,45 +946,66 @@ class ArkValueTransformer {
             value = ValueUtil_1.ValueUtil.getUndefinedConst();
             exprPositions = [Position_1.FullPosition.DEFAULT];
         }
-        return { value: value, valueOriginalPositions: exprPositions, stmts: stmts };
+        return {
+            value: value,
+            valueOriginalPositions: exprPositions,
+            stmts: stmts,
+        };
     }
     awaitExpressionToValueAndStmts(awaitExpression) {
         const stmts = [];
-        let { value: promiseValue, valueOriginalPositions: promisePositions, stmts: promiseStmts, } = this.tsNodeToValueAndStmts(awaitExpression.expression);
+        let { value: promiseValue, valueOriginalPositions: promisePositions, stmts: promiseStmts } = this.tsNodeToValueAndStmts(awaitExpression.expression);
         promiseStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(promiseValue)) {
-            ({ value: promiseValue, valueOriginalPositions: promisePositions, stmts: promiseStmts } =
-                this.arkIRTransformer.generateAssignStmtForValue(promiseValue, promisePositions));
+            ({
+                value: promiseValue,
+                valueOriginalPositions: promisePositions,
+                stmts: promiseStmts,
+            } = this.arkIRTransformer.generateAssignStmtForValue(promiseValue, promisePositions));
             promiseStmts.forEach(stmt => stmts.push(stmt));
         }
         const awaitExpr = new Expr_1.ArkAwaitExpr(promiseValue);
         const awaitExprPositions = [Position_1.FullPosition.buildFromNode(awaitExpression, this.sourceFile), ...promisePositions];
-        return { value: awaitExpr, valueOriginalPositions: awaitExprPositions, stmts: stmts };
+        return {
+            value: awaitExpr,
+            valueOriginalPositions: awaitExprPositions,
+            stmts: stmts,
+        };
     }
     yieldExpressionToValueAndStmts(yieldExpression) {
         let yieldValue = ValueUtil_1.ValueUtil.getUndefinedConst();
         let yieldPositions = [Position_1.FullPosition.DEFAULT];
         let stmts = [];
         if (yieldExpression.expression) {
-            ({ value: yieldValue, valueOriginalPositions: yieldPositions, stmts: stmts } =
-                this.tsNodeToValueAndStmts(yieldExpression.expression));
+            ({ value: yieldValue, valueOriginalPositions: yieldPositions, stmts: stmts } = this.tsNodeToValueAndStmts(yieldExpression.expression));
         }
         const yieldExpr = new Expr_1.ArkYieldExpr(yieldValue);
         const yieldExprPositions = [Position_1.FullPosition.buildFromNode(yieldExpression, this.sourceFile), ...yieldPositions];
-        return { value: yieldExpr, valueOriginalPositions: yieldExprPositions, stmts: stmts };
+        return {
+            value: yieldExpr,
+            valueOriginalPositions: yieldExprPositions,
+            stmts: stmts,
+        };
     }
     deleteExpressionToValueAndStmts(deleteExpression) {
         const { value: exprValue, valueOriginalPositions: exprPositions, stmts: stmts } = this.tsNodeToValueAndStmts(deleteExpression.expression);
         const deleteExpr = new Expr_1.ArkDeleteExpr(exprValue);
-        const deleteExprPositions = [Position_1.FullPosition.buildFromNode(deleteExpression, this.sourceFile),
-            ...exprPositions];
-        return { value: deleteExpr, valueOriginalPositions: deleteExprPositions, stmts: stmts };
+        const deleteExprPositions = [Position_1.FullPosition.buildFromNode(deleteExpression, this.sourceFile), ...exprPositions];
+        return {
+            value: deleteExpr,
+            valueOriginalPositions: deleteExprPositions,
+            stmts: stmts,
+        };
     }
     voidExpressionToValueAndStmts(voidExpression) {
         const { value: exprValue, valueOriginalPositions: exprPositions, stmts: stmts } = this.tsNodeToValueAndStmts(voidExpression.expression);
         const { stmts: exprStmts } = this.arkIRTransformer.generateAssignStmtForValue(exprValue, exprPositions);
         exprStmts.forEach(stmt => stmts.push(stmt));
-        return { value: ValueUtil_1.ValueUtil.getUndefinedConst(), valueOriginalPositions: [Position_1.FullPosition.DEFAULT], stmts: stmts };
+        return {
+            value: ValueUtil_1.ValueUtil.getUndefinedConst(),
+            valueOriginalPositions: [Position_1.FullPosition.DEFAULT],
+            stmts: stmts,
+        };
     }
     nonNullExpressionToValueAndStmts(nonNullExpression) {
         return this.tsNodeToValueAndStmts(nonNullExpression.expression);
@@ -881,29 +1014,44 @@ class ArkValueTransformer {
         return this.tsNodeToValueAndStmts(parenthesizedExpression.expression);
     }
     typeOfExpressionToValueAndStmts(typeOfExpression) {
-        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts, } = this.tsNodeToValueAndStmts(typeOfExpression.expression);
+        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts } = this.tsNodeToValueAndStmts(typeOfExpression.expression);
         const typeOfExpr = new Expr_1.ArkTypeOfExpr(exprValue);
         const typeOfExprPositions = [Position_1.FullPosition.buildFromNode(typeOfExpression, this.sourceFile), ...exprPositions];
-        return { value: typeOfExpr, valueOriginalPositions: typeOfExprPositions, stmts: exprStmts };
+        return {
+            value: typeOfExpr,
+            valueOriginalPositions: typeOfExprPositions,
+            stmts: exprStmts,
+        };
     }
     asExpressionToValueAndStmts(asExpression) {
         const stmts = [];
         let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts } = this.tsNodeToValueAndStmts(asExpression.expression);
         exprStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(exprValue)) {
-            ({ value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts } =
-                this.arkIRTransformer.generateAssignStmtForValue(exprValue, exprPositions));
+            ({
+                value: exprValue,
+                valueOriginalPositions: exprPositions,
+                stmts: exprStmts,
+            } = this.arkIRTransformer.generateAssignStmtForValue(exprValue, exprPositions));
             exprStmts.forEach(stmt => stmts.push(stmt));
         }
         const castExpr = new Expr_1.ArkCastExpr(exprValue, this.resolveTypeNode(asExpression.type));
         const castExprPositions = [Position_1.FullPosition.buildFromNode(asExpression, this.sourceFile), ...exprPositions];
-        return { value: castExpr, valueOriginalPositions: castExprPositions, stmts: stmts };
+        return {
+            value: castExpr,
+            valueOriginalPositions: castExprPositions,
+            stmts: stmts,
+        };
     }
     typeAssertionToValueAndStmts(typeAssertion) {
-        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts, } = this.tsNodeToValueAndStmts(typeAssertion.expression);
+        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts } = this.tsNodeToValueAndStmts(typeAssertion.expression);
         const castExpr = new Expr_1.ArkCastExpr(exprValue, this.resolveTypeNode(typeAssertion.type));
         const castExprPositions = [Position_1.FullPosition.buildFromNode(typeAssertion, this.sourceFile), ...exprPositions];
-        return { value: castExpr, valueOriginalPositions: castExprPositions, stmts: exprStmts };
+        return {
+            value: castExpr,
+            valueOriginalPositions: castExprPositions,
+            stmts: exprStmts,
+        };
     }
     variableDeclarationListToValueAndStmts(variableDeclarationList) {
         const stmts = [];
@@ -912,7 +1060,11 @@ class ArkValueTransformer {
             const { stmts: declaredStmts } = this.variableDeclarationToValueAndStmts(declaration, isConst);
             declaredStmts.forEach(s => stmts.push(s));
         }
-        return { value: ValueUtil_1.ValueUtil.getUndefinedConst(), valueOriginalPositions: [Position_1.FullPosition.DEFAULT], stmts: stmts };
+        return {
+            value: ValueUtil_1.ValueUtil.getUndefinedConst(),
+            valueOriginalPositions: [Position_1.FullPosition.DEFAULT],
+            stmts: stmts,
+        };
     }
     variableDeclarationToValueAndStmts(variableDeclaration, isConst, needRightOp = true) {
         const leftOpNode = variableDeclaration.name;
@@ -943,15 +1095,18 @@ class ArkValueTransformer {
                     leftValue.setConstFlag(isConst);
                     leftValue.setType(declarationType);
                 }
-                if (leftValue.getType() instanceof Type_1.UnknownType && !(rightValue.getType() instanceof Type_1.UnknownType) &&
+                if (leftValue.getType() instanceof Type_1.UnknownType &&
+                    !(rightValue.getType() instanceof Type_1.UnknownType) &&
                     !(rightValue.getType() instanceof Type_1.UndefinedType)) {
                     leftValue.setType(rightValue.getType());
                 }
             }
             const assignStmt = new Stmt_1.ArkAssignStmt(leftValue, rightValue);
             assignStmt.setOperandOriginalPositions([...leftPositions, ...rightPositions]);
-            if (ts.isArrayBindingPattern(leftOpNode) || ts.isArrayLiteralExpression(leftOpNode) ||
-                ts.isObjectBindingPattern(leftOpNode) || ts.isObjectLiteralExpression(leftOpNode)) {
+            if (ts.isArrayBindingPattern(leftOpNode) ||
+                ts.isArrayLiteralExpression(leftOpNode) ||
+                ts.isObjectBindingPattern(leftOpNode) ||
+                ts.isObjectLiteralExpression(leftOpNode)) {
                 rightStmts.forEach(stmt => stmts.push(stmt));
                 stmts.push(assignStmt);
                 leftStmts.forEach(stmt => stmts.push(stmt));
@@ -965,7 +1120,11 @@ class ArkValueTransformer {
         else {
             stmts = leftStmts;
         }
-        return { value: leftValue, valueOriginalPositions: leftPositions, stmts: stmts };
+        return {
+            value: leftValue,
+            valueOriginalPositions: leftPositions,
+            stmts: stmts,
+        };
     }
     assignmentRightOpToValueAndStmts(rightOpNode, leftValue) {
         let rightValue;
@@ -973,8 +1132,7 @@ class ArkValueTransformer {
         let tempRightStmts = [];
         const rightStmts = [];
         if (rightOpNode) {
-            ({ value: rightValue, valueOriginalPositions: rightPositions, stmts: tempRightStmts } =
-                this.tsNodeToValueAndStmts(rightOpNode));
+            ({ value: rightValue, valueOriginalPositions: rightPositions, stmts: tempRightStmts } = this.tsNodeToValueAndStmts(rightOpNode));
             tempRightStmts.forEach(stmt => rightStmts.push(stmt));
         }
         else {
@@ -982,11 +1140,18 @@ class ArkValueTransformer {
             rightPositions = [Position_1.FullPosition.DEFAULT];
         }
         if (IRUtils_1.IRUtils.moreThanOneAddress(leftValue) && IRUtils_1.IRUtils.moreThanOneAddress(rightValue)) {
-            ({ value: rightValue, valueOriginalPositions: rightPositions, stmts: tempRightStmts } =
-                this.arkIRTransformer.generateAssignStmtForValue(rightValue, rightPositions));
+            ({
+                value: rightValue,
+                valueOriginalPositions: rightPositions,
+                stmts: tempRightStmts,
+            } = this.arkIRTransformer.generateAssignStmtForValue(rightValue, rightPositions));
             tempRightStmts.forEach(stmt => rightStmts.push(stmt));
         }
-        return { value: rightValue, valueOriginalPositions: rightPositions, stmts: rightStmts };
+        return {
+            value: rightValue,
+            valueOriginalPositions: rightPositions,
+            stmts: rightStmts,
+        };
     }
     // In assignment patterns, the left operand will be an array literal expression
     arrayDestructuringToValueAndStmts(arrayDestructuring, isConst = false) {
@@ -1008,7 +1173,11 @@ class ArkValueTransformer {
             stmts.push(assignStmt);
             index++;
         }
-        return { value: arrayTempLocal, valueOriginalPositions: [leftOriginalPosition], stmts: stmts };
+        return {
+            value: arrayTempLocal,
+            valueOriginalPositions: [leftOriginalPosition],
+            stmts: stmts,
+        };
     }
     // In assignment patterns, the left operand will be an object literal expression
     objectDestructuringToValueAndStmts(objectDestructuring, isConst = false) {
@@ -1045,7 +1214,11 @@ class ArkValueTransformer {
             assignStmt.setOperandOriginalPositions([targetLocalPosition, ...fieldRefPositions]);
             stmts.push(assignStmt);
         }
-        return { value: objectTempLocal, valueOriginalPositions: [leftOriginalPosition], stmts: stmts };
+        return {
+            value: objectTempLocal,
+            valueOriginalPositions: [leftOriginalPosition],
+            stmts: stmts,
+        };
     }
     binaryExpressionToValueAndStmts(binaryExpression) {
         const operatorToken = binaryExpression.operatorToken;
@@ -1060,16 +1233,20 @@ class ArkValueTransformer {
         }
         const stmts = [];
         const binaryExpressionPosition = Position_1.FullPosition.buildFromNode(binaryExpression, this.sourceFile);
-        const { value: opValue1, valueOriginalPositions: opPositions1, stmts: opStmts1, } = this.tsNodeToSingleAddressValueAndStmts(binaryExpression.left);
+        const { value: opValue1, valueOriginalPositions: opPositions1, stmts: opStmts1 } = this.tsNodeToSingleAddressValueAndStmts(binaryExpression.left);
         opStmts1.forEach(stmt => stmts.push(stmt));
         if (operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword) {
             const instanceOfExpr = new Expr_1.ArkInstanceOfExpr(opValue1, new Type_1.UnclearReferenceType(binaryExpression.right.getText(this.sourceFile)));
             const instanceOfExprPositions = [binaryExpressionPosition, ...opPositions1];
             const { value: instanceofRes, valueOriginalPositions: instanceofPos, stmts: instanceofStmt, } = this.arkIRTransformer.generateAssignStmtForValue(instanceOfExpr, instanceOfExprPositions);
             instanceofStmt.forEach(stmt => stmts.push(stmt));
-            return { value: instanceofRes, valueOriginalPositions: instanceofPos, stmts: stmts };
+            return {
+                value: instanceofRes,
+                valueOriginalPositions: instanceofPos,
+                stmts: stmts,
+            };
         }
-        const { value: opValue2, valueOriginalPositions: opPositions2, stmts: opStmts2, } = this.tsNodeToSingleAddressValueAndStmts(binaryExpression.right);
+        const { value: opValue2, valueOriginalPositions: opPositions2, stmts: opStmts2 } = this.tsNodeToSingleAddressValueAndStmts(binaryExpression.right);
         opStmts2.forEach(stmt => stmts.push(stmt));
         let exprValue;
         let exprValuePositions = [binaryExpressionPosition];
@@ -1092,13 +1269,17 @@ class ArkValueTransformer {
                 exprValuePositions.push(binaryExpressionPosition);
             }
         }
-        return { value: exprValue, valueOriginalPositions: exprValuePositions, stmts: stmts };
+        return {
+            value: exprValue,
+            valueOriginalPositions: exprValuePositions,
+            stmts: stmts,
+        };
     }
     compoundAssignmentToValueAndStmts(binaryExpression) {
         const stmts = [];
-        let { value: leftValue, valueOriginalPositions: leftPositions, stmts: leftStmts, } = this.tsNodeToValueAndStmts(binaryExpression.left);
+        let { value: leftValue, valueOriginalPositions: leftPositions, stmts: leftStmts } = this.tsNodeToValueAndStmts(binaryExpression.left);
         leftStmts.forEach(stmt => stmts.push(stmt));
-        let { value: rightValue, valueOriginalPositions: rightPositions, stmts: rightStmts, } = this.tsNodeToValueAndStmts(binaryExpression.right);
+        let { value: rightValue, valueOriginalPositions: rightPositions, stmts: rightStmts } = this.tsNodeToValueAndStmts(binaryExpression.right);
         rightStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(leftValue) && IRUtils_1.IRUtils.moreThanOneAddress(rightValue)) {
             const { value: newRightValue, valueOriginalPositions: newRightPositions, stmts: rightStmts, } = this.arkIRTransformer.generateAssignStmtForValue(rightValue, rightPositions);
@@ -1122,7 +1303,11 @@ class ArkValueTransformer {
             leftOpValue = ValueUtil_1.ValueUtil.getUndefinedConst();
             leftOpPositions = [leftPositions[0]];
         }
-        return { value: leftOpValue, valueOriginalPositions: leftOpPositions, stmts: stmts };
+        return {
+            value: leftOpValue,
+            valueOriginalPositions: leftOpPositions,
+            stmts: stmts,
+        };
     }
     compoundAssignmentTokenToBinaryOperator(token) {
         switch (token) {
@@ -1157,16 +1342,15 @@ class ArkValueTransformer {
             case ts.SyntaxKind.BarBarEqualsToken:
                 return Expr_1.NormalBinaryOperator.LogicalOr;
             default:
-                ;
         }
         return null;
     }
     conditionToValueAndStmts(condition) {
         const stmts = [];
-        let { value: conditionValue, valueOriginalPositions: conditionPositions, stmts: conditionStmts, } = this.tsNodeToValueAndStmts(condition);
+        let { value: conditionValue, valueOriginalPositions: conditionPositions, stmts: conditionStmts } = this.tsNodeToValueAndStmts(condition);
         conditionStmts.forEach(stmt => stmts.push(stmt));
         let conditionExpr;
-        if ((conditionValue instanceof Expr_1.AbstractBinopExpr) && this.isRelationalOperator(conditionValue.getOperator())) {
+        if (conditionValue instanceof Expr_1.AbstractBinopExpr && this.isRelationalOperator(conditionValue.getOperator())) {
             const operator = conditionValue.getOperator();
             conditionExpr = new Expr_1.ArkConditionExpr(conditionValue.getOp1(), conditionValue.getOp2(), operator);
         }
@@ -1182,7 +1366,11 @@ class ArkValueTransformer {
             conditionExpr = new Expr_1.ArkConditionExpr(conditionValue, ValueUtil_1.ValueUtil.getOrCreateNumberConst(0), Expr_1.RelationalBinaryOperator.InEquality);
             conditionPositions = [conditionPositions[0], ...conditionPositions, Position_1.FullPosition.DEFAULT];
         }
-        return { value: conditionExpr, valueOriginalPositions: conditionPositions, stmts: stmts };
+        return {
+            value: conditionExpr,
+            valueOriginalPositions: conditionPositions,
+            stmts: stmts,
+        };
     }
     literalNodeToValueAndStmts(literalNode) {
         const syntaxKind = literalNode.kind;
@@ -1244,14 +1432,14 @@ class ArkValueTransformer {
         return tempLocal;
     }
     isRelationalOperator(operator) {
-        return operator === Expr_1.RelationalBinaryOperator.LessThan ||
+        return (operator === Expr_1.RelationalBinaryOperator.LessThan ||
             operator === Expr_1.RelationalBinaryOperator.LessThanOrEqual ||
             operator === Expr_1.RelationalBinaryOperator.GreaterThan ||
             operator === Expr_1.RelationalBinaryOperator.GreaterThanOrEqual ||
             operator === Expr_1.RelationalBinaryOperator.Equality ||
             operator === Expr_1.RelationalBinaryOperator.InEquality ||
             operator === Expr_1.RelationalBinaryOperator.StrictEquality ||
-            operator === Expr_1.RelationalBinaryOperator.StrictInequality;
+            operator === Expr_1.RelationalBinaryOperator.StrictInequality);
     }
     isLiteralNode(node) {
         if (ts.isStringLiteral(node) ||
@@ -1391,7 +1579,6 @@ class ArkValueTransformer {
             case ts.SyntaxKind.PrefixUnaryExpression:
                 return new Type_1.LiteralType(parseFloat(literal.getText(sourceFile)));
             default:
-                ;
         }
         return new Type_1.LiteralType(literal.getText(sourceFile));
     }
@@ -1415,8 +1602,7 @@ class ArkValueTransformer {
             }
             const unfoldTemplateTypeStrs = [];
             for (const unfoldTemplateType of unfoldTemplateTypes) {
-                unfoldTemplateTypeStrs.push(unfoldTemplateType instanceof Type_1.AliasType ? unfoldTemplateType.getOriginalType()
-                    .toString() : unfoldTemplateType.toString());
+                unfoldTemplateTypeStrs.push(unfoldTemplateType instanceof Type_1.AliasType ? unfoldTemplateType.getOriginalType().toString() : unfoldTemplateType.toString());
             }
             const templateSpanString = templateSpan.literal.rawText || '';
             for (const stringLiteral of stringLiterals) {