arkanalyzer 1.0.11 → 1.0.13

package/lib/core/common/ArkValueTransformer.js

@@ -125,6 +125,9 @@ class ArkValueTransformer {
         else if (ts.isTemplateExpression(node)) {
             return this.templateExpressionToValueAndStmts(node);
         }
+        else if (ts.isTaggedTemplateExpression(node)) {
+            return this.taggedTemplateExpressionToValueAndStmts(node);
+        }
         else if (ts.isAwaitExpression(node)) {
             return this.awaitExpressionToValueAndStmts(node);
         }
@@ -191,11 +194,11 @@ class ArkValueTransformer {
     tsNodeToSingleAddressValueAndStmts(node) {
         const allStmts = [];
         let { value, valueOriginalPositions, stmts } = this.tsNodeToValueAndStmts(node);
-        allStmts.push(...stmts);
+        stmts.forEach(stmt => allStmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(value)) {
             ({ value, valueOriginalPositions, stmts } =
                 this.arkIRTransformer.generateAssignStmtForValue(value, valueOriginalPositions));
-            allStmts.push(...stmts);
+            stmts.forEach(stmt => allStmts.push(stmt));
         }
         return { value, valueOriginalPositions, stmts: allStmts };
     }
@@ -210,13 +213,13 @@ class ArkValueTransformer {
         const stmts = [];
         const currConditionalOperatorIndex = this.conditionalOperatorNo++;
         const { value: conditionValue, valueOriginalPositions: conditionPositions, stmts: conditionStmts, } = this.conditionToValueAndStmts(conditionalExpression.condition);
-        stmts.push(...conditionStmts);
+        conditionStmts.forEach(stmt => stmts.push(stmt));
         const ifStmt = new Stmt_1.ArkIfStmt(conditionValue);
         ifStmt.setOperandOriginalPositions(conditionPositions);
         stmts.push(ifStmt);
         stmts.push(new ArkIRTransformer_1.DummyStmt(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_IF_TRUE_STMT + currConditionalOperatorIndex));
         const { value: whenTrueValue, valueOriginalPositions: whenTruePositions, stmts: whenTrueStmts, } = this.tsNodeToValueAndStmts(conditionalExpression.whenTrue);
-        stmts.push(...whenTrueStmts);
+        whenTrueStmts.forEach(stmt => stmts.push(stmt));
         const resultLocal = this.generateTempLocal();
         const assignStmtWhenTrue = new Stmt_1.ArkAssignStmt(resultLocal, whenTrueValue);
         const resultLocalPosition = [whenTruePositions[0]];
@@ -224,7 +227,7 @@ class ArkValueTransformer {
         stmts.push(assignStmtWhenTrue);
         stmts.push(new ArkIRTransformer_1.DummyStmt(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_IF_FALSE_STMT + currConditionalOperatorIndex));
         const { value: whenFalseValue, valueOriginalPositions: whenFalsePositions, stmts: whenFalseStmts, } = this.tsNodeToValueAndStmts(conditionalExpression.whenFalse);
-        stmts.push(...whenFalseStmts);
+        whenFalseStmts.forEach(stmt => stmts.push(stmt));
         const assignStmt = new Stmt_1.ArkAssignStmt(resultLocal, whenFalseValue);
         assignStmt.setOperandOriginalPositions([...resultLocalPosition, ...whenFalsePositions]);
         stmts.push(assignStmt);
@@ -250,7 +253,7 @@ class ArkValueTransformer {
         const anonymousClassType = new Type_1.ClassType(anonymousClassSignature);
         const newExpr = new Expr_1.ArkNewExpr(anonymousClassType);
         const { value: newExprLocal, valueOriginalPositions: newExprLocalPositions, stmts: newExprStmts, } = this.arkIRTransformer.generateAssignStmtForValue(newExpr, [objectLiteralExpressionPosition]);
-        stmts.push(...newExprStmts);
+        newExprStmts.forEach(stmt => stmts.push(stmt));
         const constructorMethodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(TSConst_1.CONSTRUCTOR_NAME);
         const constructorMethodSignature = new ArkSignature_1.MethodSignature(anonymousClassSignature, constructorMethodSubSignature);
         const constructorInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(newExprLocal, constructorMethodSignature, []);
@@ -264,10 +267,10 @@ class ArkValueTransformer {
         const stmts = [...currStmts];
         const componentExpressionPosition = Position_1.FullPosition.buildFromNode(componentExpression, this.sourceFile);
         const { value: componentValue, valueOriginalPositions: componentPositions, stmts: componentStmts, } = this.generateComponentCreationStmts(componentName, args, componentExpressionPosition, argPositionsAllFlat);
-        stmts.push(...componentStmts);
+        componentStmts.forEach(stmt => stmts.push(stmt));
         if (ts.isEtsComponentExpression(componentExpression) && componentExpression.body) {
             for (const statement of componentExpression.body.statements) {
-                stmts.push(...this.arkIRTransformer.tsNodeToStmts(statement));
+                this.arkIRTransformer.tsNodeToStmts(statement).forEach(stmt => stmts.push(stmt));
             }
         }
         stmts.push(this.generateComponentPopStmts(componentName, componentExpressionPosition));
@@ -280,7 +283,7 @@ class ArkValueTransformer {
         const classType = new Type_1.ClassType(classSignature);
         const newExpr = new Expr_1.ArkNewExpr(classType);
         const { value: newExprLocal, valueOriginalPositions: newExprPositions, stmts: newExprStmts, } = this.arkIRTransformer.generateAssignStmtForValue(newExpr, [componentExpressionPosition]);
-        stmts.push(...newExprStmts);
+        newExprStmts.forEach(stmt => stmts.push(stmt));
         const constructorMethodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(TSConst_1.CONSTRUCTOR_NAME);
         const constructorMethodSignature = new ArkSignature_1.MethodSignature(classSignature, constructorMethodSubSignature);
         const instanceInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(newExprLocal, constructorMethodSignature, args);
@@ -301,7 +304,7 @@ class ArkValueTransformer {
             createViewArgPositionsAll.push(builderMethodPositions);
         }
         const { value: componentValue, valueOriginalPositions: componentPositions, stmts: componentStmts, } = this.generateComponentCreationStmts(EtsConst_1.COMPONENT_CUSTOMVIEW, createViewArgs, componentExpressionPosition, createViewArgPositionsAll.flat());
-        stmts.push(...componentStmts);
+        componentStmts.forEach(stmt => stmts.push(stmt));
         stmts.push(this.generateComponentPopStmts(EtsConst_1.COMPONENT_CUSTOMVIEW, componentExpressionPosition));
         return { value: componentValue, valueOriginalPositions: componentPositions, stmts: stmts };
     }
@@ -323,12 +326,11 @@ class ArkValueTransformer {
     etsComponentExpressionToValueAndStmts(etsComponentExpression) {
         const stmts = [];
         const componentName = etsComponentExpression.expression.text;
-        const { args: args, argPositionsAll: argPositionsAll } = this.parseArguments(stmts, etsComponentExpression.arguments);
-        const argPositionsAllFlat = argPositionsAll.flat();
+        const { args: args, argPositions: argPositions } = this.parseArguments(stmts, etsComponentExpression.arguments);
         if ((0, EtsConst_1.isEtsSystemComponent)(componentName)) {
-            return this.generateSystemComponentStmt(componentName, args, argPositionsAllFlat, etsComponentExpression, stmts);
+            return this.generateSystemComponentStmt(componentName, args, argPositions, etsComponentExpression, stmts);
         }
-        return this.generateCustomViewStmt(componentName, args, argPositionsAllFlat, etsComponentExpression, stmts);
+        return this.generateCustomViewStmt(componentName, args, argPositions, etsComponentExpression, stmts);
     }
     classExpressionToValueAndStmts(classExpression) {
         const declaringArkClass = this.declaringMethod.getDeclaringArkClass();
@@ -351,50 +353,110 @@ class ArkValueTransformer {
         };
     }
     templateExpressionToValueAndStmts(templateExpression) {
-        const stmts = [];
-        const head = templateExpression.head;
-        const templateValues = [];
-        const templatePositions = [];
-        if (head.rawText) {
-            templateValues.push(ValueUtil_1.ValueUtil.createStringConst(head.rawText));
-            templatePositions.push([Position_1.FullPosition.buildFromNode(head, this.sourceFile)]);
-        }
-        this.collectTemplateValues(templateExpression, templateValues, templatePositions, stmts);
-        let currTemplateValue = ValueUtil_1.ValueUtil.getUndefinedConst();
-        let currTemplatePositions = [Position_1.FullPosition.DEFAULT];
-        const templateValueCnt = templateValues.length;
-        if (templateValueCnt > 0) {
-            currTemplateValue = templateValues[0];
-            currTemplatePositions = templatePositions[0];
-            for (let i = 1; i < templateValueCnt; i++) {
-                const nextTemplatePositions = templatePositions[i];
-                const normalBinopExpr = new Expr_1.ArkNormalBinopExpr(currTemplateValue, templateValues[i], Expr_1.NormalBinaryOperator.Addition);
-                const normalBinopExprPositions = [Position_1.FullPosition.merge(currTemplatePositions[0], nextTemplatePositions[0]), ...currTemplatePositions, ...nextTemplatePositions];
-                const { value: combinationValue, valueOriginalPositions: combinationPositions, stmts: combinationStmts, } = this.arkIRTransformer.generateAssignStmtForValue(normalBinopExpr, normalBinopExprPositions);
-                stmts.push(...combinationStmts);
-                currTemplateValue = combinationValue;
-                currTemplatePositions = combinationPositions;
+        const { stmts, stringTextValues, placeholderValues, stringTextPositions, placeholderPositions } = this.collectTemplateValues(templateExpression);
+        const { placeholderStringLocals, placeholderStringLocalPositions, newStmts } = this.processTemplatePlaceholders(placeholderValues, placeholderPositions, stmts);
+        return this.combineTemplateParts(stringTextValues, stringTextPositions, placeholderStringLocals, placeholderStringLocalPositions, newStmts);
+    }
+    processTemplatePlaceholders(placeholderValues, placeholderPositions, currStmts) {
+        const placeholderStringLocals = [];
+        const placeholderStringLocalPositions = [];
+        const newStmts = [...currStmts];
+        for (let i = 0; i < placeholderValues.length; i++) {
+            let placeholderValue = placeholderValues[i];
+            let placeholderPosition = [placeholderPositions[i]];
+            let placeholderStmts = [];
+            if (!(placeholderValue instanceof Local_1.Local)) {
+                ({ value: placeholderValue, valueOriginalPositions: placeholderPosition, stmts: placeholderStmts } =
+                    this.arkIRTransformer.generateAssignStmtForValue(placeholderValue, placeholderPosition));
             }
-        }
-        return { value: currTemplateValue, valueOriginalPositions: currTemplatePositions, stmts: stmts };
+            placeholderStmts.forEach(stmt => newStmts.push(stmt));
+            const toStringExpr = new Expr_1.ArkInstanceInvokeExpr(placeholderValue, Builtin_1.Builtin.TO_STRING_METHOD_SIGNATURE, []);
+            const toStringExprPosition = [placeholderPosition[0], placeholderPosition[0]];
+            const { value: placeholderStringLocal, valueOriginalPositions: placeholderStringPositions, stmts: toStringStmts, } = this.arkIRTransformer.generateAssignStmtForValue(toStringExpr, toStringExprPosition);
+            placeholderStringLocals.push(placeholderStringLocal);
+            placeholderStringLocalPositions.push(placeholderStringPositions[0]);
+            toStringStmts.forEach(stmt => newStmts.push(stmt));
+        }
+        return { placeholderStringLocals, placeholderStringLocalPositions, newStmts };
+    }
+    combineTemplateParts(stringTextValues, stringTextPositions, placeholderStringLocals, placeholderStringLocalPositions, currStmts) {
+        const templateParts = [];
+        const templatePartPositions = [];
+        for (let i = 0; i < placeholderStringLocals.length; i++) {
+            if (stringTextValues[i] !== ValueUtil_1.ValueUtil.EMPTY_STRING_CONSTANT) {
+                templateParts.push(stringTextValues[i]);
+                templatePartPositions.push(stringTextPositions[i]);
+            }
+            templateParts.push(placeholderStringLocals[i]);
+            templatePartPositions.push(placeholderStringLocalPositions[i]);
+        }
+        if (stringTextValues[stringTextValues.length - 1] !== ValueUtil_1.ValueUtil.EMPTY_STRING_CONSTANT) {
+            templateParts.push(stringTextValues[stringTextValues.length - 1]);
+            templatePartPositions.push(stringTextPositions[stringTextPositions.length - 1]);
+        }
+        let currTemplateResult = templateParts[0];
+        let currTemplateResultPosition = templatePartPositions[0];
+        const finalStmts = [...currStmts];
+        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 { 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 };
+    }
+    taggedTemplateExpressionToValueAndStmts(taggedTemplateExpression) {
+        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);
+        const stringTextArrayLenPosition = Position_1.FullPosition.DEFAULT;
+        const { value: templateObjectLocal, valueOriginalPositions: templateObjectLocalPositions, stmts: templateObjectStmts, } = this.generateArrayExprAndStmts(stringTextBaseType, stringTextArrayLenValue, stringTextArrayLenPosition, stringTextArrayLen, stringTextValues, stringTextPositions, stmts, Position_1.FullPosition.DEFAULT, true);
+        const placeholderBaseType = Type_1.AnyType.getInstance();
+        const placeholdersArrayLen = placeholderValues.length;
+        const placeholdersArrayLenValue = ValueUtil_1.ValueUtil.getOrCreateNumberConst(placeholdersArrayLen);
+        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],
+            argPositions: [templateObjectLocalPositions[0], placeholdersLocalPositions[0]],
+        };
+        return this.generateInvokeValueAndStmts(taggedTemplateExpression.tag, taggedFuncArgus, placeholdersStmts, taggedTemplateExpression);
     }
-    collectTemplateValues(templateExpression, currTemplateValues, currTemplatePositions, currStmts) {
-        for (const templateSpan of templateExpression.templateSpans) {
+    collectTemplateValues(templateLiteral) {
+        const stmts = [];
+        if (ts.isNoSubstitutionTemplateLiteral(templateLiteral)) {
+            const templateLiteralString = templateLiteral.getText(this.sourceFile);
+            return {
+                stmts: [], stringTextValues: [ValueUtil_1.ValueUtil.createStringConst(templateLiteralString)],
+                placeholderValues: [],
+                stringTextPositions: [Position_1.FullPosition.buildFromNode(templateLiteral, this.sourceFile)],
+                placeholderPositions: [],
+            };
+        }
+        const head = templateLiteral.head;
+        const stringTextValues = [ValueUtil_1.ValueUtil.createStringConst(head.rawText || '')];
+        const placeholderValues = [];
+        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);
-            currStmts.push(...exprStmts);
+            exprStmts.forEach(stmt => stmts.push(stmt));
             if (IRUtils_1.IRUtils.moreThanOneAddress(exprValue)) {
                 ({ value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts } =
                     this.arkIRTransformer.generateAssignStmtForValue(exprValue, exprPositions));
-                currStmts.push(...exprStmts);
-            }
-            currTemplateValues.push(exprValue);
-            currTemplatePositions.push(exprPositions);
-            const literalRawText = templateSpan.literal.rawText;
-            if (literalRawText) {
-                currTemplateValues.push(ValueUtil_1.ValueUtil.createStringConst(literalRawText));
-                currTemplatePositions.push([Position_1.FullPosition.buildFromNode(templateSpan.literal, this.sourceFile)]);
+                exprStmts.forEach(stmt => stmts.push(stmt));
             }
+            placeholderValues.push(exprValue);
+            placeholderPositions.push(exprPositions[0]);
+            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 };
     }
     identifierToValueAndStmts(identifier, variableDefFlag = false) {
         let identifierValue;
@@ -415,16 +477,16 @@ class ArkValueTransformer {
     propertyAccessExpressionToValue(propertyAccessExpression) {
         const stmts = [];
         let { value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts, } = this.tsNodeToValueAndStmts(propertyAccessExpression.expression);
-        stmts.push(...baseStmts);
+        baseStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(baseValue)) {
             ({ value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } =
                 this.arkIRTransformer.generateAssignStmtForValue(baseValue, basePositions));
-            stmts.push(...baseStmts);
+            baseStmts.forEach(stmt => stmts.push(stmt));
         }
         if (!(baseValue instanceof Local_1.Local)) {
             ({ value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } =
                 this.arkIRTransformer.generateAssignStmtForValue(baseValue, basePositions));
-            stmts.push(...baseStmts);
+            baseStmts.forEach(stmt => stmts.push(stmt));
         }
         const fieldSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildFieldSignatureFromFieldName(propertyAccessExpression.name.getText(this.sourceFile));
         const fieldRef = new Ref_1.ArkInstanceFieldRef(baseValue, fieldSignature);
@@ -434,18 +496,18 @@ class ArkValueTransformer {
     elementAccessExpressionToValueAndStmts(elementAccessExpression) {
         const stmts = [];
         let { value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } = this.tsNodeToValueAndStmts(elementAccessExpression.expression);
-        stmts.push(...baseStmts);
+        baseStmts.forEach(stmt => stmts.push(stmt));
         if (!(baseValue instanceof Local_1.Local)) {
             ({ value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } =
                 this.arkIRTransformer.generateAssignStmtForValue(baseValue, basePositions));
-            stmts.push(...baseStmts);
+            baseStmts.forEach(stmt => stmts.push(stmt));
         }
         let { value: argumentValue, valueOriginalPositions: arguPositions, stmts: argumentStmts, } = this.tsNodeToValueAndStmts(elementAccessExpression.argumentExpression);
-        stmts.push(...argumentStmts);
+        argumentStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(argumentValue)) {
             ({ value: argumentValue, valueOriginalPositions: arguPositions, stmts: argumentStmts } =
                 this.arkIRTransformer.generateAssignStmtForValue(argumentValue, arguPositions));
-            stmts.push(...argumentStmts);
+            argumentStmts.forEach(stmt => stmts.push(stmt));
         }
         let elementAccessExpr;
         if (baseValue.getType() instanceof Type_1.ArrayType) {
@@ -463,30 +525,36 @@ class ArkValueTransformer {
     }
     callExpressionToValueAndStmts(callExpression) {
         const stmts = [];
-        const { realGenericTypes: realGenericTypes, args: args, argPositionsAllFlat: argPositionsAllFlat, } = this.parseArgumentsOfCallExpression(stmts, callExpression);
-        let { value: callerValue, valueOriginalPositions: callerPositions, stmts: callerStmts, } = this.tsNodeToValueAndStmts(callExpression.expression);
-        stmts.push(...callerStmts);
+        const argus = this.parseArgumentsOfCallExpression(stmts, callExpression);
+        return this.generateInvokeValueAndStmts(callExpression.expression, argus, stmts, callExpression);
+    }
+    generateInvokeValueAndStmts(functionNameNode, argus, currStmts, callExpression) {
+        const stmts = [...currStmts];
+        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)];
+        const { args, argPositions, realGenericTypes } = argus;
         if (callerValue instanceof Ref_1.ArkInstanceFieldRef) {
             const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(callerValue.getFieldName());
             invokeValue = new Expr_1.ArkInstanceInvokeExpr(callerValue.getBase(), methodSignature, args, realGenericTypes);
-            invokeValuePositions.push(...callerPositions.slice(1), ...argPositionsAllFlat);
+            invokeValuePositions.push(...callerPositions.slice(1), ...argPositions);
         }
         else if (callerValue instanceof Ref_1.ArkStaticFieldRef) {
             const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(callerValue.getFieldName());
             invokeValue = new Expr_1.ArkStaticInvokeExpr(methodSignature, args, realGenericTypes);
-            invokeValuePositions.push(...argPositionsAllFlat);
+            invokeValuePositions.push(...argPositions);
         }
         else if (callerValue instanceof Local_1.Local) {
             const callerName = callerValue.getName();
             let classSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildClassSignatureFromClassName(callerName);
             let cls = ModelUtils_1.ModelUtils.getClass(this.declaringMethod, classSignature);
-            if (cls === null || cls === void 0 ? void 0 : cls.hasComponentDecorator()) {
-                return this.generateCustomViewStmt(callerName, args, argPositionsAllFlat, callExpression, stmts);
+            if ((cls === null || cls === void 0 ? void 0 : cls.hasComponentDecorator()) && ts.isCallExpression(callExpression)) {
+                return this.generateCustomViewStmt(callerName, args, argPositions, callExpression, stmts);
             }
-            else if (callerName === EtsConst_1.COMPONENT_FOR_EACH || callerName === EtsConst_1.COMPONENT_LAZY_FOR_EACH) { // foreach/lazyforeach will be parsed as ts.callExpression
-                return this.generateSystemComponentStmt(callerName, args, argPositionsAllFlat, callExpression, stmts);
+            else if ((callerName === EtsConst_1.COMPONENT_FOR_EACH || callerName === EtsConst_1.COMPONENT_LAZY_FOR_EACH) &&
+                ts.isCallExpression(callExpression)) { // foreach/lazyforeach will be parsed as ts.callExpression
+                return this.generateSystemComponentStmt(callerName, args, argPositions, callExpression, stmts);
             }
             const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(callerName);
             if (callerValue.getType() instanceof Type_1.FunctionType) {
@@ -495,15 +563,15 @@ class ArkValueTransformer {
             else {
                 invokeValue = new Expr_1.ArkStaticInvokeExpr(methodSignature, args, realGenericTypes);
             }
-            invokeValuePositions.push(...argPositionsAllFlat);
+            invokeValuePositions.push(...argPositions);
         }
         else {
             ({ value: callerValue, valueOriginalPositions: callerPositions, stmts: callerStmts } =
                 this.arkIRTransformer.generateAssignStmtForValue(callerValue, callerPositions));
-            stmts.push(...callerStmts);
+            callerStmts.forEach(stmt => stmts.push(stmt));
             const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(callerValue.getName());
             invokeValue = new Expr_1.ArkStaticInvokeExpr(methodSignature, args, realGenericTypes);
-            invokeValuePositions.push(...argPositionsAllFlat);
+            invokeValuePositions.push(...argPositions);
         }
         return { value: invokeValue, valueOriginalPositions: invokeValuePositions, stmts: stmts };
     }
@@ -522,12 +590,12 @@ class ArkValueTransformer {
                 builderMethodIndexes = new Set([1]);
             }
         }
-        const { args: args, argPositionsAll: argPositionsAll } = this.parseArguments(currStmts, callExpression.arguments, builderMethodIndexes);
-        return { realGenericTypes: realGenericTypes, args: args, argPositionsAllFlat: argPositionsAll.flat() };
+        const { args: args, argPositions: argPositions } = this.parseArguments(currStmts, callExpression.arguments, builderMethodIndexes);
+        return { realGenericTypes: realGenericTypes, args: args, argPositions: argPositions };
     }
     parseArguments(currStmts, argumentNodes, builderMethodIndexes) {
         const args = [];
-        const argPositionsAll = [];
+        const argPositions = [];
         if (argumentNodes) {
             for (let i = 0; i < argumentNodes.length; i++) {
                 const argument = argumentNodes[i];
@@ -536,20 +604,20 @@ class ArkValueTransformer {
                     this.builderMethodContextFlag = true;
                     this.arkIRTransformer.setBuilderMethodContextFlag(true);
                 }
-                let { value: argValue, valueOriginalPositions: argPositions, 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: argPositions, stmts: argStmts } =
+                    ({ value: argValue, valueOriginalPositions: argPositionsSingle, stmts: argStmts } =
                         this.arkIRTransformer.generateAssignStmtForValue(argValue, argPositions));
                     argStmts.forEach(s => currStmts.push(s));
                 }
                 args.push(argValue);
-                argPositionsAll.push(argPositions);
+                argPositions.push(argPositionsSingle[0]);
             }
         }
-        return { args: args, argPositionsAll: argPositionsAll };
+        return { args: args, argPositions: argPositions };
     }
     callableNodeToValueAndStmts(callableNode) {
         const declaringClass = this.declaringMethod.getDeclaringArkClass();
@@ -589,12 +657,12 @@ class ArkValueTransformer {
         const classType = new Type_1.ClassType(classSignature, realGenericTypes);
         const newExpr = new Expr_1.ArkNewExpr(classType);
         const { value: newLocal, valueOriginalPositions: newLocalPositions, stmts: newExprStmts, } = this.arkIRTransformer.generateAssignStmtForValue(newExpr, [Position_1.FullPosition.buildFromNode(newExpression, this.sourceFile)]);
-        stmts.push(...newExprStmts);
+        newExprStmts.forEach(stmt => stmts.push(stmt));
         const constructorMethodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(TSConst_1.CONSTRUCTOR_NAME);
         const constructorMethodSignature = new ArkSignature_1.MethodSignature(classSignature, constructorMethodSubSignature);
-        const { args: argValues, argPositionsAll: argPositionsAll } = this.parseArguments(stmts, newExpression.arguments);
+        const { args: argValues, argPositions: argPositions } = this.parseArguments(stmts, newExpression.arguments);
         const instanceInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(newLocal, constructorMethodSignature, argValues);
-        const instanceInvokeExprPositions = [newLocalPositions[0], ...newLocalPositions, ...argPositionsAll.flat()];
+        const instanceInvokeExprPositions = [newLocalPositions[0], ...newLocalPositions, ...argPositions];
         const invokeStmt = new Stmt_1.ArkInvokeStmt(instanceInvokeExpr);
         invokeStmt.setOperandOriginalPositions(instanceInvokeExprPositions);
         stmts.push(invokeStmt);
@@ -609,57 +677,49 @@ class ArkValueTransformer {
             }
         }
         const stmts = [];
-        const { args: argumentValues, argPositionsAll: argPositionsAll } = this.parseArguments(stmts, newArrayExpression.arguments);
-        let arrayLength = newArrayExpression.arguments ? newArrayExpression.arguments.length : 0;
-        let arrayLengthValue = ValueUtil_1.ValueUtil.getOrCreateNumberConst(arrayLength);
+        const { args: argumentValues, argPositions: argPositions } = this.parseArguments(stmts, newArrayExpression.arguments);
+        let argumentsLength = newArrayExpression.arguments ? newArrayExpression.arguments.length : 0;
+        let arrayLengthValue;
+        let arrayLength = -1;
         let arrayLengthPosition = Position_1.FullPosition.DEFAULT;
-        let arrayLengthFlag = false;
-        if ((arrayLength === 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 = argPositionsAll[0][0];
-            arrayLengthFlag = true;
+            arrayLengthPosition = argPositions[0];
+        }
+        else {
+            arrayLengthValue = ValueUtil_1.ValueUtil.getOrCreateNumberConst(argumentsLength);
+            arrayLength = argumentsLength;
         }
         if (baseType instanceof Type_1.UnknownType) {
-            if ((arrayLength > 1) && !(argumentValues[0].getType() instanceof Type_1.UnknownType)) {
+            if ((argumentsLength > 1) && !(argumentValues[0].getType() instanceof Type_1.UnknownType)) {
                 baseType = argumentValues[0].getType();
             }
             else {
                 baseType = Type_1.AnyType.getInstance();
             }
         }
-        const newArrayExpr = new Expr_1.ArkNewArrayExpr(baseType, arrayLengthValue);
-        const newArrayExprPositions = [Position_1.FullPosition.buildFromNode(newArrayExpression, this.sourceFile),
-            arrayLengthPosition];
-        const { value: arrayLocal, valueOriginalPositions: arrayLocalPositions, stmts: arrayStmts, } = this.arkIRTransformer.generateAssignStmtForValue(newArrayExpr, newArrayExprPositions);
-        stmts.push(...arrayStmts);
-        if (!arrayLengthFlag) {
-            for (let i = 0; i < arrayLength; i++) {
-                const arrayRef = new Ref_1.ArkArrayRef(arrayLocal, ValueUtil_1.ValueUtil.getOrCreateNumberConst(i));
-                const arrayRefPositions = [arrayLocalPositions[0], ...arrayLocalPositions, Position_1.FullPosition.DEFAULT];
-                const assignStmt = new Stmt_1.ArkAssignStmt(arrayRef, argumentValues[i]);
-                assignStmt.setOperandOriginalPositions([...arrayRefPositions, ...argPositionsAll[i]]);
-                stmts.push(assignStmt);
-            }
-        }
-        return { value: arrayLocal, valueOriginalPositions: arrayLocalPositions, stmts: stmts };
+        const newArrayExprPosition = Position_1.FullPosition.buildFromNode(newArrayExpression, this.sourceFile);
+        return this.generateArrayExprAndStmts(baseType, arrayLengthValue, arrayLengthPosition, arrayLength, argumentValues, argPositions, stmts, newArrayExprPosition, false);
     }
     arrayLiteralExpressionToValueAndStmts(arrayLiteralExpression) {
         const stmts = [];
         const elementTypes = new Set();
         const elementValues = [];
-        const elementPositonsAll = [];
+        const elementPositions = [];
         const arrayLength = arrayLiteralExpression.elements.length;
         for (const element of arrayLiteralExpression.elements) {
             let { value: elementValue, valueOriginalPositions: elementPosition, stmts: elementStmts, } = this.tsNodeToValueAndStmts(element);
-            stmts.push(...elementStmts);
+            elementStmts.forEach(stmt => stmts.push(stmt));
             if (IRUtils_1.IRUtils.moreThanOneAddress(elementValue)) {
                 ({ value: elementValue, valueOriginalPositions: elementPosition, stmts: elementStmts } =
                     this.arkIRTransformer.generateAssignStmtForValue(elementValue, elementPosition));
-                stmts.push(...elementStmts);
+                elementStmts.forEach(stmt => stmts.push(stmt));
             }
             elementValues.push(elementValue);
             elementTypes.add(elementValue.getType());
-            elementPositonsAll.push(elementPosition);
+            elementPositions.push(elementPosition[0]);
         }
         let baseType = Type_1.AnyType.getInstance();
         if (elementTypes.size === 1) {
@@ -668,28 +728,33 @@ class ArkValueTransformer {
         else if (elementTypes.size > 1) {
             baseType = new Type_1.UnionType(Array.from(elementTypes));
         }
-        const newArrayExpr = new Expr_1.ArkNewArrayExpr(baseType, ValueUtil_1.ValueUtil.getOrCreateNumberConst(arrayLength), true);
-        const newArrayExprPositions = [Position_1.FullPosition.buildFromNode(arrayLiteralExpression, this.sourceFile),
-            Position_1.FullPosition.DEFAULT];
-        const { value: newArrayLocal, valueOriginalPositions: newArrayPositions, stmts: elementStmts, } = this.arkIRTransformer.generateAssignStmtForValue(newArrayExpr, newArrayExprPositions);
-        stmts.push(...elementStmts);
+        const newArrayExprPosition = Position_1.FullPosition.buildFromNode(arrayLiteralExpression, this.sourceFile);
+        return this.generateArrayExprAndStmts(baseType, ValueUtil_1.ValueUtil.getOrCreateNumberConst(arrayLength), Position_1.FullPosition.DEFAULT, arrayLength, elementValues, elementPositions, stmts, newArrayExprPosition, true);
+    }
+    generateArrayExprAndStmts(baseType, arrayLengthValue, arrayLengthPosition, arrayLength, initializerValues, initializerPositions, currStmts, newArrayExprPosition, fromLiteral) {
+        const stmts = [...currStmts];
+        const newArrayExpr = new Expr_1.ArkNewArrayExpr(baseType, arrayLengthValue, fromLiteral);
+        const newArrayExprPositions = [newArrayExprPosition, arrayLengthPosition];
+        const { value: arrayLocal, valueOriginalPositions: arrayLocalPositions, stmts: arrayStmts, } = this.arkIRTransformer.generateAssignStmtForValue(newArrayExpr, newArrayExprPositions);
+        arrayStmts.forEach(stmt => stmts.push(stmt));
         for (let i = 0; i < arrayLength; i++) {
-            const arrayRef = new Ref_1.ArkArrayRef(newArrayLocal, ValueUtil_1.ValueUtil.getOrCreateNumberConst(i));
-            const arrayRefPositions = [newArrayPositions[0], ...newArrayPositions, Position_1.FullPosition.DEFAULT];
-            const assignStmt = new Stmt_1.ArkAssignStmt(arrayRef, elementValues[i]);
-            assignStmt.setOperandOriginalPositions([...arrayRefPositions, ...elementPositonsAll[i]]);
+            const indexValue = ValueUtil_1.ValueUtil.getOrCreateNumberConst(i);
+            const arrayRef = new Ref_1.ArkArrayRef(arrayLocal, indexValue);
+            const arrayRefPositions = [arrayLocalPositions[0], ...arrayLocalPositions, Position_1.FullPosition.DEFAULT];
+            const assignStmt = new Stmt_1.ArkAssignStmt(arrayRef, initializerValues[i]);
+            assignStmt.setOperandOriginalPositions([...arrayRefPositions, initializerPositions[i]]);
             stmts.push(assignStmt);
         }
-        return { value: newArrayLocal, valueOriginalPositions: newArrayPositions, stmts: stmts };
+        return { value: arrayLocal, valueOriginalPositions: arrayLocalPositions, stmts: stmts };
     }
     prefixUnaryExpressionToValueAndStmts(prefixUnaryExpression) {
         const stmts = [];
         let { value: operandValue, valueOriginalPositions: operandPositions, stmts: operandStmts, } = this.tsNodeToValueAndStmts(prefixUnaryExpression.operand);
-        stmts.push(...operandStmts);
+        operandStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(operandValue)) {
             ({ value: operandValue, valueOriginalPositions: operandPositions, stmts: operandStmts } =
                 this.arkIRTransformer.generateAssignStmtForValue(operandValue, operandPositions));
-            stmts.push(...operandStmts);
+            operandStmts.forEach(stmt => stmts.push(stmt));
         }
         const operatorToken = prefixUnaryExpression.operator;
         let exprPositions = [Position_1.FullPosition.buildFromNode(prefixUnaryExpression, this.sourceFile)];
@@ -722,11 +787,11 @@ class ArkValueTransformer {
     postfixUnaryExpressionToValueAndStmts(postfixUnaryExpression) {
         const stmts = [];
         let { value: operandValue, valueOriginalPositions: operandPositions, stmts: exprStmts, } = this.tsNodeToValueAndStmts(postfixUnaryExpression.operand);
-        stmts.push(...exprStmts);
+        exprStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(operandValue)) {
             ({ value: operandValue, valueOriginalPositions: operandPositions, stmts: exprStmts } =
                 this.arkIRTransformer.generateAssignStmtForValue(operandValue, operandPositions));
-            stmts.push(...exprStmts);
+            exprStmts.forEach(stmt => stmts.push(stmt));
         }
         let value;
         let exprPositions = [Position_1.FullPosition.buildFromNode(postfixUnaryExpression, this.sourceFile)];
@@ -749,11 +814,11 @@ class ArkValueTransformer {
     awaitExpressionToValueAndStmts(awaitExpression) {
         const stmts = [];
         let { value: promiseValue, valueOriginalPositions: promisePositions, stmts: promiseStmts, } = this.tsNodeToValueAndStmts(awaitExpression.expression);
-        stmts.push(...promiseStmts);
+        promiseStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(promiseValue)) {
             ({ value: promiseValue, valueOriginalPositions: promisePositions, stmts: promiseStmts } =
                 this.arkIRTransformer.generateAssignStmtForValue(promiseValue, promisePositions));
-            stmts.push(...promiseStmts);
+            promiseStmts.forEach(stmt => stmts.push(stmt));
         }
         const awaitExpr = new Expr_1.ArkAwaitExpr(promiseValue);
         const awaitExprPositions = [Position_1.FullPosition.buildFromNode(awaitExpression, this.sourceFile), ...promisePositions];
@@ -779,7 +844,9 @@ class ArkValueTransformer {
         return { value: deleteExpr, valueOriginalPositions: deleteExprPositions, stmts: stmts };
     }
     voidExpressionToValueAndStmts(voidExpression) {
-        const stmts = this.arkIRTransformer.expressionToStmts(voidExpression.expression);
+        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 };
     }
     nonNullExpressionToValueAndStmts(nonNullExpression) {
@@ -797,11 +864,11 @@ class ArkValueTransformer {
     asExpressionToValueAndStmts(asExpression) {
         const stmts = [];
         let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts } = this.tsNodeToValueAndStmts(asExpression.expression);
-        stmts.push(...exprStmts);
+        exprStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(exprValue)) {
             ({ value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts } =
                 this.arkIRTransformer.generateAssignStmtForValue(exprValue, exprPositions));
-            stmts.push(...exprStmts);
+            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];
@@ -860,10 +927,14 @@ class ArkValueTransformer {
             assignStmt.setOperandOriginalPositions([...leftPositions, ...rightPositions]);
             if (ts.isArrayBindingPattern(leftOpNode) || ts.isArrayLiteralExpression(leftOpNode) ||
                 ts.isObjectBindingPattern(leftOpNode) || ts.isObjectLiteralExpression(leftOpNode)) {
-                stmts.push(...rightStmts, assignStmt, ...leftStmts);
+                rightStmts.forEach(stmt => stmts.push(stmt));
+                stmts.push(assignStmt);
+                leftStmts.forEach(stmt => stmts.push(stmt));
             }
             else {
-                stmts.push(...rightStmts, ...leftStmts, assignStmt);
+                rightStmts.forEach(stmt => stmts.push(stmt));
+                leftStmts.forEach(stmt => stmts.push(stmt));
+                stmts.push(assignStmt);
             }
         }
         else {
@@ -879,7 +950,7 @@ class ArkValueTransformer {
         if (rightOpNode) {
             ({ value: rightValue, valueOriginalPositions: rightPositions, stmts: tempRightStmts } =
                 this.tsNodeToValueAndStmts(rightOpNode));
-            rightStmts.push(...tempRightStmts);
+            tempRightStmts.forEach(stmt => rightStmts.push(stmt));
         }
         else {
             rightValue = ValueUtil_1.ValueUtil.getUndefinedConst();
@@ -888,7 +959,7 @@ class ArkValueTransformer {
         if (IRUtils_1.IRUtils.moreThanOneAddress(leftValue) && IRUtils_1.IRUtils.moreThanOneAddress(rightValue)) {
             ({ value: rightValue, valueOriginalPositions: rightPositions, stmts: tempRightStmts } =
                 this.arkIRTransformer.generateAssignStmtForValue(rightValue, rightPositions));
-            rightStmts.push(...tempRightStmts);
+            tempRightStmts.forEach(stmt => rightStmts.push(stmt));
         }
         return { value: rightValue, valueOriginalPositions: rightPositions, stmts: rightStmts };
     }
@@ -959,20 +1030,20 @@ class ArkValueTransformer {
             const declarationType = Type_1.UnknownType.getInstance();
             return this.assignmentToValueAndStmts(leftOpNode, rightOpNode, false, false, declarationType, true);
         }
-        else if (ArkValueTransformer.compoundAssignmentOperators.has(operatorToken.kind)) {
+        else if (ArkValueTransformer.isCompoundAssignmentOperator(operatorToken.kind)) {
             return this.compoundAssignmentToValueAndStmts(binaryExpression);
         }
         const stmts = [];
         const binaryExpressionPosition = Position_1.FullPosition.buildFromNode(binaryExpression, this.sourceFile);
         const { value: opValue1, valueOriginalPositions: opPositions1, stmts: opStmts1, } = this.tsNodeToSingleAddressValueAndStmts(binaryExpression.left);
-        stmts.push(...opStmts1);
+        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];
             return { value: instanceOfExpr, valueOriginalPositions: instanceOfExprPositions, stmts: stmts };
         }
         const { value: opValue2, valueOriginalPositions: opPositions2, stmts: opStmts2, } = this.tsNodeToSingleAddressValueAndStmts(binaryExpression.right);
-        stmts.push(...opStmts2);
+        opStmts2.forEach(stmt => stmts.push(stmt));
         let exprValue;
         let exprValuePositions = [binaryExpressionPosition];
         if (operatorToken.kind === ts.SyntaxKind.CommaToken) {
@@ -999,14 +1070,14 @@ class ArkValueTransformer {
     compoundAssignmentToValueAndStmts(binaryExpression) {
         const stmts = [];
         let { value: leftValue, valueOriginalPositions: leftPositions, stmts: leftStmts, } = this.tsNodeToValueAndStmts(binaryExpression.left);
-        stmts.push(...leftStmts);
+        leftStmts.forEach(stmt => stmts.push(stmt));
         let { value: rightValue, valueOriginalPositions: rightPositions, stmts: rightStmts, } = this.tsNodeToValueAndStmts(binaryExpression.right);
-        stmts.push(...rightStmts);
+        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);
             rightValue = newRightValue;
             rightPositions = newRightPositions;
-            stmts.push(...rightStmts);
+            rightStmts.forEach(stmt => stmts.push(stmt));
         }
         let leftOpValue;
         let leftOpPositions;
@@ -1066,7 +1137,7 @@ class ArkValueTransformer {
     conditionToValueAndStmts(condition) {
         const stmts = [];
         let { value: conditionValue, valueOriginalPositions: conditionPositions, stmts: conditionStmts, } = this.tsNodeToValueAndStmts(condition);
-        stmts.push(...conditionStmts);
+        conditionStmts.forEach(stmt => stmts.push(stmt));
         let conditionExpr;
         if ((conditionValue instanceof Expr_1.AbstractBinopExpr) && this.isRelationalOperator(conditionValue.getOperator())) {
             const operator = conditionValue.getOperator();
@@ -1079,7 +1150,7 @@ class ArkValueTransformer {
                     valueOriginalPositions: conditionPositions,
                     stmts: conditionStmts,
                 } = this.arkIRTransformer.generateAssignStmtForValue(conditionValue, conditionPositions));
-                stmts.push(...conditionStmts);
+                conditionStmts.forEach(stmt => stmts.push(stmt));
             }
             conditionExpr = new Expr_1.ArkConditionExpr(conditionValue, ValueUtil_1.ValueUtil.getOrCreateNumberConst(0), Expr_1.RelationalBinaryOperator.InEquality);
             conditionPositions = [conditionPositions[0], ...conditionPositions, Position_1.FullPosition.DEFAULT];
@@ -1333,20 +1404,25 @@ class ArkValueTransformer {
         (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(functionTypeNode, declaringClass, anonymousMethod, this.sourceFile);
         return new Type_1.FunctionType(anonymousMethod.getSignature());
     }
+    static isCompoundAssignmentOperator(operator) {
+        const compoundAssignmentOperators = [
+            ts.SyntaxKind.PlusEqualsToken,
+            ts.SyntaxKind.MinusEqualsToken,
+            ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+            ts.SyntaxKind.AsteriskEqualsToken,
+            ts.SyntaxKind.SlashEqualsToken,
+            ts.SyntaxKind.PercentEqualsToken,
+            ts.SyntaxKind.AmpersandEqualsToken,
+            ts.SyntaxKind.BarEqualsToken,
+            ts.SyntaxKind.CaretEqualsToken,
+            ts.SyntaxKind.LessThanLessThanEqualsToken,
+            ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+            ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+            ts.SyntaxKind.BarBarEqualsToken,
+            ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+            ts.SyntaxKind.QuestionQuestionEqualsToken,
+        ];
+        return compoundAssignmentOperators.includes(operator);
+    }
 }
 exports.ArkValueTransformer = ArkValueTransformer;
-ArkValueTransformer.compoundAssignmentOperators = new Set([ts.SyntaxKind.PlusEqualsToken,
-    ts.SyntaxKind.MinusEqualsToken,
-    ts.SyntaxKind.AsteriskAsteriskEqualsToken,
-    ts.SyntaxKind.AsteriskEqualsToken,
-    ts.SyntaxKind.SlashEqualsToken,
-    ts.SyntaxKind.PercentEqualsToken,
-    ts.SyntaxKind.AmpersandEqualsToken,
-    ts.SyntaxKind.BarEqualsToken,
-    ts.SyntaxKind.CaretEqualsToken,
-    ts.SyntaxKind.LessThanLessThanEqualsToken,
-    ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
-    ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
-    ts.SyntaxKind.BarBarEqualsToken,
-    ts.SyntaxKind.AmpersandAmpersandEqualsToken,
-    ts.SyntaxKind.QuestionQuestionEqualsToken]);