arkanalyzer 1.0.93 → 2.0.0-beta1

package/lib/core/common/ArkValueTransformer.js

@@ -39,14 +39,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArkValueTransformer = void 0;
 const ts = __importStar(require("ohos-typescript"));
+const SdkUtils_1 = require("./SdkUtils");
 const Local_1 = require("../base/Local");
 const Position_1 = require("../base/Position");
 const Stmt_1 = require("../base/Stmt");
 const Expr_1 = require("../base/Expr");
 const ArkClass_1 = require("../model/ArkClass");
+const SignatureCanonicalizerRegistry_1 = require("./SignatureCanonicalizerRegistry");
 const ArkClassBuilder_1 = require("../model/builder/ArkClassBuilder");
+const ArkMethodBuilder_1 = require("../model/builder/ArkMethodBuilder");
 const Type_1 = require("../base/Type");
 const ArkSignatureBuilder_1 = require("../model/builder/ArkSignatureBuilder");
+const builderUtils_1 = require("../model/builder/builderUtils");
 const StringUtils_1 = require("./StringUtils");
 const TSConst_1 = require("./TSConst");
 const ArkSignature_1 = require("../model/ArkSignature");
@@ -56,7 +60,7 @@ const IRUtils_1 = require("./IRUtils");
 const Ref_1 = require("../base/Ref");
 const ModelUtils_1 = require("./ModelUtils");
 const ArkMethod_1 = require("../model/ArkMethod");
-const ArkMethodBuilder_1 = require("../model/builder/ArkMethodBuilder");
+const ArkMethodBuilder_2 = require("../model/builder/ArkMethodBuilder");
 const Builtin_1 = require("./Builtin");
 const Constant_1 = require("../base/Constant");
 const Const_1 = require("./Const");
@@ -77,6 +81,9 @@ class ArkValueTransformer {
         this.thisLocal = new Local_1.Local(TSConst_1.THIS_NAME, declaringMethod.getDeclaringArkClass().getSignature().getType());
         this.locals.set(this.thisLocal.getName(), this.thisLocal);
         this.declaringMethod = declaringMethod;
+        this.declaringClass = arkIRTransformer.declaringClass;
+        this.declaringNamespace = arkIRTransformer.declaringNamespace;
+        this.declaringFile = arkIRTransformer.declaringFile;
     }
     getLocals() {
         return new Set(this.locals.values());
@@ -201,11 +208,11 @@ class ArkValueTransformer {
         };
     }
     tsNodeToSingleAddressValueAndStmts(node) {
-        const allStmts = [];
-        const { value, valueOriginalPositions, stmts } = this.tsNodeToValueAndStmts(node);
-        stmts.forEach(stmt => allStmts.push(stmt));
-        const { value: processedValue, positions: processedPositions } = this.arkIRTransformer.handleExpressionValueWithTempVarIfNeeded(value, valueOriginalPositions, allStmts);
-        return { value: processedValue, valueOriginalPositions: processedPositions, stmts: allStmts };
+        const result = this.tsNodeToValueAndStmts(node);
+        const processed = this.arkIRTransformer.handleExpressionValueWithTempVarIfNeeded(result.value, result.valueOriginalPositions, result.stmts);
+        result.value = processed.value;
+        result.valueOriginalPositions = processed.positions;
+        return result;
     }
     thisExpressionToValueAndStmts(thisExpression) {
         return {
@@ -222,6 +229,9 @@ class ArkValueTransformer {
         };
     }
     conditionalExpressionToValueAndStmts(conditionalExpression) {
+        if (ModelUtils_1.ModelUtils.isArkUIBuilderMethod(this.declaringMethod)) {
+            return this.builderConditionalExpressionToValueAndStmts(conditionalExpression);
+        }
         const stmts = [];
         const currConditionalOperatorIndex = this.conditionalOperatorNo++;
         const { value: conditionValue, valueOriginalPositions: conditionPositions, stmts: conditionStmts, } = this.conditionToValueAndStmts(conditionalExpression.condition);
@@ -250,17 +260,58 @@ class ArkValueTransformer {
             stmts: stmts,
         };
     }
+    /**
+     * In ArkUI builder methods, lower `a ? b : c` like statement if:
+     * If.create / If.branch(0) / true / If.branch(1) / false / If.pop, still yielding a result local.
+     * Stays linear (no CFG diamond); ViewTree reads the If.create protocol.
+     */
+    builderConditionalExpressionToValueAndStmts(conditionalExpression) {
+        const stmts = [];
+        const { value: conditionExpr, valueOriginalPositions: conditionExprPositions, stmts: conditionStmts, } = this.conditionToValueAndStmts(conditionalExpression.condition);
+        conditionStmts.forEach(stmt => stmts.push(stmt));
+        const { value: conditionLocal, valueOriginalPositions: conditionLocalPositions, stmts: assignConditionStmts, } = this.arkIRTransformer.generateAssignStmtForValue(conditionExpr, conditionExprPositions);
+        assignConditionStmts.forEach(stmt => stmts.push(stmt));
+        const { stmts: createStmts } = this.generateComponentCreationStmts(EtsConst_1.COMPONENT_IF, [conditionLocal], conditionLocalPositions[0], conditionLocalPositions);
+        createStmts.forEach(stmt => stmts.push(stmt));
+        stmts.push(this.generateBuilderIfBranch(0, conditionLocalPositions[0]));
+        const { value: whenTrueValue, valueOriginalPositions: whenTruePositions, stmts: whenTrueStmts, } = this.tsNodeToValueAndStmts(conditionalExpression.whenTrue);
+        whenTrueStmts.forEach(stmt => stmts.push(stmt));
+        const resultLocal = this.generateTempLocal();
+        const resultLocalPosition = [whenTruePositions[0]];
+        const assignStmtWhenTrue = new Stmt_1.ArkAssignStmt(resultLocal, whenTrueValue);
+        assignStmtWhenTrue.setOperandOriginalPositions([...resultLocalPosition, ...whenTruePositions]);
+        stmts.push(assignStmtWhenTrue);
+        stmts.push(this.generateBuilderIfBranch(1, Position_1.FullPosition.buildFromNode(conditionalExpression.whenFalse, this.sourceFile)));
+        const { value: whenFalseValue, valueOriginalPositions: whenFalsePositions, stmts: whenFalseStmts, } = this.tsNodeToValueAndStmts(conditionalExpression.whenFalse);
+        whenFalseStmts.forEach(stmt => stmts.push(stmt));
+        const assignStmtWhenFalse = new Stmt_1.ArkAssignStmt(resultLocal, whenFalseValue);
+        assignStmtWhenFalse.setOperandOriginalPositions([...resultLocalPosition, ...whenFalsePositions]);
+        stmts.push(assignStmtWhenFalse);
+        stmts.push(this.generateComponentPopStmts(EtsConst_1.COMPONENT_IF));
+        return {
+            value: resultLocal,
+            valueOriginalPositions: resultLocalPosition,
+            stmts: stmts,
+        };
+    }
     objectLiteralExpresionToValueAndStmts(objectLiteralExpression) {
-        const declaringArkClass = this.declaringMethod.getDeclaringArkClass();
-        const declaringArkNamespace = declaringArkClass.getDeclaringArkNamespace();
-        const anonymousClass = new ArkClass_1.ArkClass();
+        var _a;
+        const declaringArkNamespace = this.declaringNamespace;
+        const anonymousClass = new ArkClass_1.ArkClass(this.declaringFile.getFileSigID(), declaringArkNamespace === null || declaringArkNamespace === void 0 ? void 0 : declaringArkNamespace.getNamespaceSigID());
         if (declaringArkNamespace) {
-            (0, ArkClassBuilder_1.buildNormalArkClassFromArkNamespace)(objectLiteralExpression, declaringArkNamespace, anonymousClass, this.sourceFile, this.declaringMethod);
+            (0, ArkClassBuilder_1.buildNormalArkClassFromArkNamespace)(objectLiteralExpression, anonymousClass, this.sourceFile, this.declaringMethod);
+            declaringArkNamespace.addArkClass(anonymousClass);
         }
         else {
-            const declaringArkFile = declaringArkClass.getDeclaringArkFile();
-            (0, ArkClassBuilder_1.buildNormalArkClassFromArkFile)(objectLiteralExpression, declaringArkFile, anonymousClass, this.sourceFile, this.declaringMethod);
-        }
+            (0, ArkClassBuilder_1.buildNormalArkClassFromArkFile)(objectLiteralExpression, this.declaringFile, anonymousClass, this.sourceFile, this.declaringMethod);
+        }
+        // Build the default constructor at creation time so the constructor invoke expr
+        // below probes the formal space with a real (value-equal) signature — a missing
+        // probe falls into the temp defensive route with an error log. The on-demand
+        // variant (isLibraryClass guard lifted) also covers SDK-file object literals:
+        // the registration happens inside the host file's own build stage, so the SDK /
+        // project ID-boundary invariant is preserved either way.
+        (0, ArkMethodBuilder_1.ensureDefaultConstructor)(anonymousClass);
         const objectLiteralExpressionPosition = Position_1.FullPosition.buildFromNode(objectLiteralExpression, this.sourceFile);
         const stmts = [];
         const anonymousClassSignature = anonymousClass.getSignature();
@@ -269,7 +320,11 @@ class ArkValueTransformer {
         const { value: newExprLocal, valueOriginalPositions: newExprLocalPositions, stmts: newExprStmts, } = this.arkIRTransformer.generateAssignStmtForValue(newExpr, [objectLiteralExpressionPosition]);
         newExprStmts.forEach(stmt => stmts.push(stmt));
         const constructorMethodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(TSConst_1.CONSTRUCTOR_NAME);
-        const constructorMethodSignature = new ArkSignature_1.MethodSignature(anonymousClassSignature, constructorMethodSubSignature);
+        // Prefer the real (just-built) default constructor signature so the invoke expr's
+        // route hits the formal space directly; the fallback is an unclear (%unk) stub —
+        // never a clear unregistered shape (that would hit the clear+miss error route).
+        const realConstructor = anonymousClass.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME);
+        const constructorMethodSignature = (_a = realConstructor === null || realConstructor === void 0 ? void 0 : realConstructor.getSignature()) !== null && _a !== void 0 ? _a : new ArkSignature_1.MethodSignature(0, constructorMethodSubSignature);
         const constructorInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(newExprLocal, constructorMethodSignature, []);
         const assignStmt = new Stmt_1.ArkAssignStmt(newExprLocal, constructorInvokeExpr);
         const assignStmtPositions = [newExprLocalPositions[0], newExprLocalPositions[0], ...newExprLocalPositions];
@@ -294,11 +349,14 @@ class ArkValueTransformer {
             return;
         }
         const fieldInitStmts = [];
-        let { value: initValue, valueOriginalPositions: initPositions, stmts: initStmts, } = this.tsNodeToValueAndStmts(valueNode);
+        let { value: initValue, valueOriginalPositions: initPositions, stmts: initStmts } = this.tsNodeToValueAndStmts(valueNode);
         this.appendInitStmts(stmts, fieldInitStmts, initStmts);
         if (IRUtils_1.IRUtils.moreThanOneAddress(initValue)) {
-            ({ value: initValue, valueOriginalPositions: initPositions, stmts: initStmts } =
-                this.arkIRTransformer.generateAssignStmtForValue(initValue, initPositions));
+            ({
+                value: initValue,
+                valueOriginalPositions: initPositions,
+                stmts: initStmts,
+            } = this.arkIRTransformer.generateAssignStmtForValue(initValue, initPositions));
             this.appendInitStmts(stmts, fieldInitStmts, initStmts);
         }
         const fieldRef = new Ref_1.ArkInstanceFieldRef(objectLocal, fieldSignature);
@@ -311,7 +369,9 @@ class ArkValueTransformer {
     appendInitStmts(stmts, fieldInitStmts, initStmts) {
         initStmts.forEach(stmt => {
             stmts.push(stmt);
-            fieldInitStmts.push(stmt);
+            if (!(stmt instanceof ArkIRTransformer_1.DummyStmt)) {
+                fieldInitStmts.push(stmt);
+            }
         });
     }
     setFieldInitializerWithPosition(field, fieldInitStmts, initValue) {
@@ -373,6 +433,8 @@ class ArkValueTransformer {
         const { value: newExprLocal, valueOriginalPositions: newExprPositions, stmts: newExprStmts, } = this.arkIRTransformer.generateAssignStmtForValue(newExpr, [componentExpressionPosition]);
         newExprStmts.forEach(stmt => stmts.push(stmt));
         const constructorMethodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(TSConst_1.CONSTRUCTOR_NAME);
+        // Object path: a stub class signature (unclear) is routed to the temp canonicalizer
+        // inside the constructor — no formal interning without a model.
         const constructorMethodSignature = new ArkSignature_1.MethodSignature(classSignature, constructorMethodSubSignature);
         const instanceInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(newExprLocal, constructorMethodSignature, args);
         const assignStmt = new Stmt_1.ArkAssignStmt(newExprLocal, instanceInvokeExpr);
@@ -387,7 +449,7 @@ 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);
         }
@@ -400,8 +462,10 @@ class ArkValueTransformer {
             stmts: stmts,
         };
     }
+    /** @internal Emit a component create invocation assigned to a temporary local. */
     generateComponentCreationStmts(componentName, createArgs, componentExpressionPosition, createArgsPositionsAllFlat) {
-        const createMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(componentName, EtsConst_1.COMPONENT_CREATE_FUNCTION);
+        // 组件 create stub 签名 per-(name, method) 缓存。
+        const createMethodSignature = ModelUtils_1.ModelUtils.getOrCreateComponentMethodSig(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);
@@ -411,16 +475,30 @@ class ArkValueTransformer {
             stmts: componentStmts,
         };
     }
+    /** @internal Emit an If.branch invocation for the given branch index. */
+    generateBuilderIfBranch(index, position = Position_1.FullPosition.DEFAULT) {
+        // If.branch stub per-key 缓存
+        const branchMethodSignature = ModelUtils_1.ModelUtils.getOrCreateComponentMethodSig(EtsConst_1.COMPONENT_IF, EtsConst_1.COMPONENT_BRANCH_FUNCTION);
+        const branchInvokeExpr = new Expr_1.ArkStaticInvokeExpr(branchMethodSignature, [ValueUtil_1.ValueUtil.getOrCreateNumberConst(index)]);
+        const branchInvokeStmt = new Stmt_1.ArkInvokeStmt(branchInvokeExpr);
+        branchInvokeStmt.setOperandOriginalPositions([position, Position_1.FullPosition.DEFAULT]);
+        return branchInvokeStmt;
+    }
+    /** @internal Emit a component pop invocation that closes the matching create. */
     generateComponentPopStmts(componentName, componentExpressionPosition) {
         var _a;
         let popMethodSignature = ModelUtils_1.ModelUtils.popMethodSignatureCache.get(componentName);
         if (!popMethodSignature) {
-            const cls = this.declaringMethod.getDeclaringArkFile().getScene().getSdkGlobal(EtsConst_1.COMMON_METHOD);
+            const cls = SdkUtils_1.SdkUtils.getSdkGlobal(EtsConst_1.COMMON_METHOD);
             if (cls instanceof ArkClass_1.ArkClass) {
                 const commonSignature = (_a = cls.getMethodWithName(EtsConst_1.COMPONENT_POP_FUNCTION)) === null || _a === void 0 ? void 0 : _a.getSignature();
                 if (commonSignature) {
+                    // display 归一化：AliasClassSignature 构造即 intern formal + 双注册 origin ArkClass model（display 由 formal canonical 自持）。
                     const classSignature = new ArkSignature_1.AliasClassSignature(componentName, commonSignature.getDeclaringClassSignature());
                     popMethodSignature = new ArkSignature_1.MethodSignature(classSignature, commonSignature.getMethodSubSignature());
+                    // methodSig 侧同款 intern + 双注册——expr 的 route() formal 命中持
+                    // SigID，scene.getMethod 经 getModel 直命中 CommonMethod.pop。
+                    (0, ArkSignature_1.internAliasMethodSignature)(popMethodSignature, commonSignature);
                 }
             }
             popMethodSignature = popMethodSignature !== null && popMethodSignature !== void 0 ? popMethodSignature : ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(componentName, EtsConst_1.COMPONENT_POP_FUNCTION);
@@ -436,22 +514,21 @@ class ArkValueTransformer {
     etsComponentExpressionToValueAndStmts(etsComponentExpression) {
         const stmts = [];
         const componentName = (0, StringUtils_1.cloneText)(etsComponentExpression.expression.text);
-        const { argValues: argValues, argPositions: argPositions, } = this.parseArguments(stmts, etsComponentExpression.arguments);
+        const { argValues: argValues, argPositions: argPositions } = this.parseArguments(stmts, etsComponentExpression.arguments);
         if ((0, EtsConst_1.isEtsSystemComponent)(componentName)) {
             return this.generateSystemComponentStmt(componentName, argValues, argPositions, etsComponentExpression, stmts);
         }
         return this.generateCustomViewStmt(componentName, argValues, argPositions, etsComponentExpression, stmts);
     }
     classExpressionToValueAndStmts(classExpression) {
-        const declaringArkClass = this.declaringMethod.getDeclaringArkClass();
-        const declaringArkNamespace = declaringArkClass.getDeclaringArkNamespace();
-        const newClass = new ArkClass_1.ArkClass();
+        const declaringArkNamespace = this.declaringNamespace;
+        const newClass = new ArkClass_1.ArkClass(this.declaringFile.getFileSigID(), declaringArkNamespace === null || declaringArkNamespace === void 0 ? void 0 : declaringArkNamespace.getNamespaceSigID());
         if (declaringArkNamespace) {
-            (0, ArkClassBuilder_1.buildNormalArkClassFromArkNamespace)(classExpression, declaringArkNamespace, newClass, this.sourceFile, this.declaringMethod);
+            (0, ArkClassBuilder_1.buildNormalArkClassFromArkNamespace)(classExpression, newClass, this.sourceFile, this.declaringMethod);
+            declaringArkNamespace.addArkClass(newClass);
         }
         else {
-            const declaringArkFile = declaringArkClass.getDeclaringArkFile();
-            (0, ArkClassBuilder_1.buildNormalArkClassFromArkFile)(classExpression, declaringArkFile, newClass, this.sourceFile, this.declaringMethod);
+            (0, ArkClassBuilder_1.buildNormalArkClassFromArkFile)(classExpression, this.declaringFile, newClass, this.sourceFile, this.declaringMethod);
         }
         const classValue = this.addNewLocal(newClass.getName(), new Type_1.ClassType(newClass.getSignature()));
         return {
@@ -461,7 +538,7 @@ class ArkValueTransformer {
         };
     }
     templateExpressionToValueAndStmts(templateExpression) {
-        const { stmts, stringTextValues, placeholderValues, stringTextPositions, placeholderPositions, } = this.collectTemplateValues(templateExpression);
+        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);
     }
@@ -532,7 +609,7 @@ class ArkValueTransformer {
         };
     }
     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);
@@ -544,7 +621,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, argValues: [templateObjectLocal, placeholdersLocal],
+            realGenericTypes: undefined,
+            argValues: [templateObjectLocal, placeholdersLocal],
             argPositions: [templateObjectLocalPositions[0], placeholdersLocalPositions[0]],
         };
         return this.generateInvokeValueAndStmts(taggedTemplateExpression.tag, taggedFuncArgus, placeholdersStmts, taggedTemplateExpression);
@@ -567,7 +645,7 @@ 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)) {
                 ({
@@ -611,72 +689,78 @@ class ArkValueTransformer {
         };
     }
     propertyAccessExpressionToValue(propertyAccessExpression) {
-        const stmts = [];
-        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));
-            baseStmts.forEach(stmt => stmts.push(stmt));
-        }
-        if (!(baseValue instanceof Local_1.Local)) {
-            ({
-                value: baseValue,
-                valueOriginalPositions: basePositions,
-                stmts: baseStmts,
-            } = this.arkIRTransformer.generateAssignStmtForValue(baseValue, basePositions));
-            baseStmts.forEach(stmt => stmts.push(stmt));
+        var _a;
+        const inner = this.tsNodeToValueAndStmts(propertyAccessExpression.expression);
+        const stmts = inner.stmts;
+        let value = inner.value;
+        let positions = inner.valueOriginalPositions;
+        if (IRUtils_1.IRUtils.moreThanOneAddress(value)) {
+            const temp = this.arkIRTransformer.generateAssignStmtForValueInto(value, positions, stmts);
+            value = temp.value;
+            positions = temp.positions;
+        }
+        if (!(value instanceof Local_1.Local)) {
+            const temp = this.arkIRTransformer.generateAssignStmtForValueInto(value, positions, stmts);
+            value = temp.value;
+            positions = temp.positions;
+        }
+        const fieldRefPositions = new Array(1 + positions.length);
+        fieldRefPositions[0] = Position_1.FullPosition.buildFromNode(propertyAccessExpression, this.sourceFile);
+        for (let i = 0; i < positions.length; i++) {
+            fieldRefPositions[i + 1] = positions[i];
         }
-        const fieldRefPositions = [Position_1.FullPosition.buildFromNode(propertyAccessExpression, this.sourceFile), ...basePositions];
         // this if for the case: const obj: Object = Object.create(Object.prototype);
-        if (baseValue instanceof Local_1.Local && baseValue.getName() === Builtin_1.Builtin.OBJECT) {
-            this.locals.delete(baseValue.getName());
+        if (value instanceof Local_1.Local && value.getName() === Builtin_1.Builtin.OBJECT) {
+            this.locals.delete(value.getName());
+            // Object path: the Object stub is unclear and is routed to the temp
+            // canonicalizer inside the constructor — no formal interning without a model.
             const fieldSignature = new ArkSignature_1.FieldSignature((0, StringUtils_1.cloneText)(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) {
-            fieldSignature = new ArkSignature_1.FieldSignature((0, StringUtils_1.cloneText)(propertyAccessExpression.name.getText(this.sourceFile)), baseValue.getType().getClassSignature(), Type_1.UnknownType.getInstance());
+        if (value instanceof Local_1.Local && value.getType() instanceof Type_1.ClassType) {
+            const baseType = value.getType();
+            const fieldName = (0, StringUtils_1.cloneText)(propertyAccessExpression.name.getText(this.sourceFile));
+            // Model-level direct lookup: resolve the base type's class and probe its field
+            // by name — a hit (the field really is declared on this class) reuses its formal
+            // signature directly (route hits formal, zero probe). A miss (field on a base
+            // class / static / actually a method / not yet registered due to build order —
+            // buildArkClassMembers builds method bodies before fields) builds a %unk stub
+            // (declaring 0, unclear semantics) routed to temp without the clear+miss error;
+            // inference is base-driven and corrects it via updateFieldSignature (formal hit
+            // retires the temp row) once the field is registered / resolved along the base
+            // type + heritage chain.
+            const baseClass = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().getClassById(baseType.getClassSigID());
+            const field = baseClass === null || baseClass === void 0 ? void 0 : baseClass.getFieldWithName(fieldName);
+            fieldSignature = (_a = field === null || field === void 0 ? void 0 : field.getSignature()) !== null && _a !== void 0 ? _a : new ArkSignature_1.FieldSignature(fieldName, 0, Type_1.UnknownType.getInstance());
         }
         else {
             fieldSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildFieldSignatureFromFieldName((0, StringUtils_1.cloneText)(propertyAccessExpression.name.getText(this.sourceFile)));
         }
-        const fieldRef = new Ref_1.ArkInstanceFieldRef(baseValue, fieldSignature);
-        return {
-            value: fieldRef,
-            valueOriginalPositions: fieldRefPositions,
-            stmts: stmts,
-        };
+        const fieldRef = new Ref_1.ArkInstanceFieldRef(value, fieldSignature);
+        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));
+        const baseResult = this.tsNodeToValueAndStmts(elementAccessExpression.expression);
+        const stmts = baseResult.stmts;
+        let baseValue = baseResult.value;
+        let basePositions = baseResult.valueOriginalPositions;
         if (!(baseValue instanceof Local_1.Local)) {
-            ({
-                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));
+            const temp = this.arkIRTransformer.generateAssignStmtForValueInto(baseValue, basePositions, stmts);
+            baseValue = temp.value;
+            basePositions = temp.positions;
+        }
+        const argResult = this.tsNodeToValueAndStmts(elementAccessExpression.argumentExpression);
+        for (let i = 0; i < argResult.stmts.length; i++) {
+            stmts.push(argResult.stmts[i]);
+        }
+        let argumentValue = argResult.value;
+        let arguPositions = argResult.valueOriginalPositions;
         if (IRUtils_1.IRUtils.moreThanOneAddress(argumentValue)) {
-            ({
-                value: argumentValue,
-                valueOriginalPositions: arguPositions,
-                stmts: argumentStmts,
-            } = this.arkIRTransformer.generateAssignStmtForValue(argumentValue, arguPositions));
-            argumentStmts.forEach(stmt => stmts.push(stmt));
+            const temp = this.arkIRTransformer.generateAssignStmtForValueInto(argumentValue, arguPositions, stmts);
+            argumentValue = temp.value;
+            arguPositions = temp.positions;
         }
         let elementAccessExpr;
         const baseType = baseValue.getType();
@@ -689,7 +773,15 @@ class ArkValueTransformer {
             elementAccessExpr = new Ref_1.ArkInstanceFieldRef(baseValue, fieldSignature, true);
         }
         // reserve positions for field name
-        const exprPositions = [Position_1.FullPosition.buildFromNode(elementAccessExpression, this.sourceFile), ...basePositions, ...arguPositions];
+        const exprPositions = new Array(1 + basePositions.length + arguPositions.length);
+        exprPositions[0] = Position_1.FullPosition.buildFromNode(elementAccessExpression, this.sourceFile);
+        let exprPosIdx = 1;
+        for (let i = 0; i < basePositions.length; i++) {
+            exprPositions[exprPosIdx++] = basePositions[i];
+        }
+        for (let i = 0; i < arguPositions.length; i++) {
+            exprPositions[exprPosIdx++] = arguPositions[i];
+        }
         return {
             value: elementAccessExpr,
             valueOriginalPositions: exprPositions,
@@ -702,52 +794,169 @@ class ArkValueTransformer {
         return this.generateInvokeValueAndStmts(callExpression.expression, argus, stmts, callExpression);
     }
     generateInvokeValueAndStmts(functionNameNode, args, currStmts, callExpression) {
-        const stmts = [...currStmts];
-        const { value: calleeValue, valueOriginalPositions: calleePositions, stmts: calleeStmts } = this.tsNodeToValueAndStmts(functionNameNode);
-        stmts.push(...calleeStmts);
+        const stmts = currStmts;
         const invokeExprPosition = Position_1.FullPosition.buildFromNode(callExpression, this.sourceFile);
-        if (calleeValue instanceof Ref_1.AbstractFieldRef) {
-            return this.handleFieldRefInvoke(calleeValue, args, invokeExprPosition, calleePositions, stmts);
+        let result;
+        let calleeNode = functionNameNode;
+        while (ts.isParenthesizedExpression(calleeNode)) {
+            calleeNode = calleeNode.expression;
         }
-        if (calleeValue instanceof Local_1.Local) {
-            return this.handleLocalInvoke(calleeValue, callExpression, args, invokeExprPosition, calleePositions, stmts);
+        if (ts.isPropertyAccessExpression(calleeNode)) {
+            result = this.propertyAccessCalleeToInvoke(calleeNode, args, invokeExprPosition, stmts);
         }
-        if (calleeValue instanceof Ref_1.ArkArrayRef && ts.isElementAccessExpression(functionNameNode)) {
-            return this.handleArrayRefInvoke(calleeValue, functionNameNode, args, invokeExprPosition, calleePositions, stmts);
+        else if (ts.isElementAccessExpression(calleeNode)) {
+            result = this.elementAccessCalleeToInvoke(calleeNode, args, invokeExprPosition, stmts);
         }
-        return this.handleDefaultInvoke(calleeValue, args, invokeExprPosition, calleePositions, stmts);
+        else {
+            const { value: calleeValue, valueOriginalPositions: calleePositions, stmts: calleeStmts } = this.tsNodeToValueAndStmts(functionNameNode);
+            for (let i = 0; i < calleeStmts.length; i++) {
+                stmts.push(calleeStmts[i]);
+            }
+            if (calleeValue instanceof Local_1.Local) {
+                result = this.handleLocalInvoke(calleeValue, callExpression, args, invokeExprPosition, calleePositions, stmts);
+            }
+            else {
+                result = this.handleDefaultInvoke(calleeValue, args, invokeExprPosition, calleePositions, stmts);
+            }
+        }
+        if (result.value instanceof Expr_1.AbstractInvokeExpr) {
+            result.value.setInvokeFullPosition(this.buildInvokeFullPosition(functionNameNode, callExpression));
+        }
+        return result;
+    }
+    buildInvokeFullPosition(calleeNode, callExpression) {
+        const nameNode = this.getCallNameNode(calleeNode);
+        const namePos = Position_1.FullPosition.buildFromNode(nameNode, this.sourceFile);
+        const callPos = Position_1.FullPosition.buildFromNode(callExpression, this.sourceFile);
+        return new Position_1.FullPosition(namePos.getFirstLine(), namePos.getFirstCol(), callPos.getLastLine(), callPos.getLastCol());
     }
-    handleFieldRefInvoke(calleeValue, args, invokeExprPosition, calleePositions, currStmts) {
+    getCallNameNode(callee) {
+        let expr = callee;
+        while (true) {
+            if (ts.isParenthesizedExpression(expr) || ts.isNonNullExpression(expr) ||
+                ts.isAsExpression(expr) || ts.isTypeAssertionExpression(expr)) {
+                expr = expr.expression;
+                continue;
+            }
+            break;
+        }
+        if (ts.isPropertyAccessExpression(expr)) {
+            return expr.name;
+        }
+        if (ts.isElementAccessExpression(expr)) {
+            return expr.argumentExpression;
+        }
+        return expr;
+    }
+    propertyAccessCalleeToInvoke(propertyAccessExpression, args, invokeExprPosition, currStmts) {
+        // base 转换 + 物化——照搬 propertyAccessExpressionToValue。物化后必为 temp Local，故两个物化条件可并。
+        const stmts = currStmts;
+        const baseInner = this.tsNodeToValueAndStmts(propertyAccessExpression.expression);
+        for (let i = 0; i < baseInner.stmts.length; i++) {
+            stmts.push(baseInner.stmts[i]);
+        }
+        let baseValue = baseInner.value;
+        let basePositions = baseInner.valueOriginalPositions;
+        if (IRUtils_1.IRUtils.moreThanOneAddress(baseValue) || !(baseValue instanceof Local_1.Local)) {
+            const temp = this.arkIRTransformer.generateAssignStmtForValueInto(baseValue, basePositions, stmts);
+            baseValue = temp.value;
+            basePositions = temp.positions;
+        }
+        const methodName = (0, StringUtils_1.cloneText)(propertyAccessExpression.name.getText(this.sourceFile));
         let methodSignature;
-        const declareSignature = calleeValue.getFieldSignature().getDeclaringSignature();
-        if (declareSignature instanceof ArkSignature_1.ClassSignature) {
-            methodSignature =
-                new ArkSignature_1.MethodSignature(declareSignature, ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(calleeValue.getFieldName()));
+        let invokeExpr;
+        let invokeExprPositions;
+        const argPositions = args.argPositions;
+        if (baseValue instanceof Local_1.Local && baseValue.getName() === Builtin_1.Builtin.OBJECT) {
+            // Object.xxx() 特判（照搬 propertyAccessExpressionToValue：含 locals.delete 副作用）。
+            this.locals.delete(baseValue.getName());
+            methodSignature = new ArkSignature_1.MethodSignature(Builtin_1.Builtin.OBJECT_CLASS_SIGNATURE, ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(methodName));
+            invokeExpr = new Expr_1.ArkStaticInvokeExpr(methodSignature, args.argValues, args.realGenericTypes, args.spreadFlags);
+            invokeExprPositions = new Array(1 + argPositions.length);
+            invokeExprPositions[0] = invokeExprPosition;
         }
         else {
-            methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(calleeValue.getFieldName());
+            methodSignature = new ArkSignature_1.MethodSignature(0, ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(methodName));
+            if (baseValue instanceof Local_1.Local && baseValue.getType() instanceof Type_1.ClassType) {
+                const baseType = baseValue.getType();
+                const sameClass = baseType.getClassSigID() === this.declaringClass.getClassSigID();
+                const sameNameMethods = sameClass ? this.declaringClass.getMethodsWithName(methodName) : [];
+                const declared = sameNameMethods.length === 1 && sameNameMethods[0].getDeclareSigIDs() === undefined;
+                if (declared && sameNameMethods[0].getImplementationSignature() !== null) {
+                    methodSignature = sameNameMethods[0].getSignature();
+                }
+            }
+            invokeExpr = new Expr_1.ArkInstanceInvokeExpr(baseValue, methodSignature, args.argValues, args.realGenericTypes, args.spreadFlags);
+            invokeExprPositions = new Array(1 + basePositions.length + argPositions.length);
+            invokeExprPositions[0] = invokeExprPosition;
+            for (let i = 0; i < basePositions.length; i++) {
+                invokeExprPositions[1 + i] = basePositions[i];
+            }
         }
-        let invokeExpr;
-        const invokeExprPositions = [invokeExprPosition];
-        if (calleeValue instanceof Ref_1.ArkInstanceFieldRef) {
-            invokeExpr =
-                new Expr_1.ArkInstanceInvokeExpr(calleeValue.getBase(), methodSignature, args.argValues, args.realGenericTypes, args.spreadFlags);
-            invokeExprPositions.push(...calleePositions.slice(1));
+        for (let i = 0; i < argPositions.length; i++) {
+            invokeExprPositions[invokeExprPositions.length - argPositions.length + i] = argPositions[i];
+        }
+        return { value: invokeExpr, valueOriginalPositions: invokeExprPositions, stmts };
+    }
+    elementAccessCalleeToInvoke(elementAccessExpression, args, invokeExprPosition, currStmts) {
+        // base 转换 + 物化——照搬 elementAccessExpressionToValueAndStmts。物化后必为 temp Local，故两个物化条件可并。
+        const baseInner = this.tsNodeToValueAndStmts(elementAccessExpression.expression);
+        for (let i = 0; i < baseInner.stmts.length; i++) {
+            currStmts.push(baseInner.stmts[i]);
+        }
+        let baseValue = baseInner.value;
+        let basePositions = baseInner.valueOriginalPositions;
+        if (IRUtils_1.IRUtils.moreThanOneAddress(baseValue) || !(baseValue instanceof Local_1.Local)) {
+            const temp = this.arkIRTransformer.generateAssignStmtForValueInto(baseValue, basePositions, currStmts);
+            baseValue = temp.value;
+            basePositions = temp.positions;
+        }
+        // argument 转换 + 物化——照搬同函数后半。
+        const argInner = this.tsNodeToValueAndStmts(elementAccessExpression.argumentExpression);
+        for (let i = 0; i < argInner.stmts.length; i++) {
+            currStmts.push(argInner.stmts[i]);
+        }
+        let indexArgValue = argInner.value;
+        let indexArgPositions = argInner.valueOriginalPositions;
+        if (IRUtils_1.IRUtils.moreThanOneAddress(indexArgValue)) {
+            const temp = this.arkIRTransformer.generateAssignStmtForValueInto(indexArgValue, indexArgPositions, currStmts);
+            indexArgValue = temp.value;
+            indexArgPositions = temp.positions;
+        }
+        let methodSignature;
+        const argPositions = args.argPositions;
+        let invokeExprPositions;
+        if (baseValue.getType() instanceof Type_1.ArrayType || baseValue.getType() instanceof Type_1.StringType) {
+            // Array/String 分支——复刻 handleArrayRefInvoke（含 stmts.pop() quirk：
+            // 方法名用源码文本，argument 物化 stmt 丢弃）。
+            const indexText = (0, StringUtils_1.cloneText)(elementAccessExpression.argumentExpression.getText(this.sourceFile));
+            methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(indexText);
+            currStmts.pop();
+            invokeExprPositions = new Array(2 + argPositions.length);
+            invokeExprPositions[0] = invokeExprPosition;
+            invokeExprPositions[1] = basePositions[0];
         }
         else {
-            invokeExpr = new Expr_1.ArkStaticInvokeExpr(methodSignature, args.argValues, args.realGenericTypes, args.spreadFlags);
+            // dynamic 分支——复刻原 handleFieldRefInvoke instance 路径。
+            methodSignature = new ArkSignature_1.MethodSignature(0, ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(indexArgValue.toString()));
+            invokeExprPositions = new Array(1 + basePositions.length + indexArgPositions.length + argPositions.length);
+            invokeExprPositions[0] = invokeExprPosition;
+            for (let i = 0; i < basePositions.length; i++) {
+                invokeExprPositions[1 + i] = basePositions[i];
+            }
+            for (let i = 0; i < indexArgPositions.length; i++) {
+                invokeExprPositions[1 + basePositions.length + i] = indexArgPositions[i];
+            }
         }
-        invokeExprPositions.push(...args.argPositions);
-        return {
-            value: invokeExpr,
-            valueOriginalPositions: invokeExprPositions,
-            stmts: currStmts,
-        };
+        const invokeExpr = new Expr_1.ArkInstanceInvokeExpr(baseValue, methodSignature, args.argValues, args.realGenericTypes, args.spreadFlags);
+        for (let i = 0; i < argPositions.length; i++) {
+            invokeExprPositions[invokeExprPositions.length - argPositions.length + i] = argPositions[i];
+        }
+        return { value: invokeExpr, valueOriginalPositions: invokeExprPositions, stmts: currStmts };
     }
     handleLocalInvoke(calleeValue, callExpression, args, invokeExprPosition, calleePositions, currStmts) {
         var _a;
         let invokeExpr;
-        const invokeExprPositions = [invokeExprPosition];
         const calleeName = calleeValue.getName();
         if (this.isCustomViewCall(calleeName, callExpression)) {
             return this.generateCustomViewStmt(calleeName, args.argValues, args.argPositions, callExpression, currStmts);
@@ -755,16 +964,25 @@ class ArkValueTransformer {
         else if (this.isSystemComponentCall(calleeName, callExpression)) {
             return this.generateSystemComponentStmt(calleeName, args.argValues, args.argPositions, callExpression, currStmts);
         }
+        const argPositions = args.argPositions;
+        const isPtrInvoke = !((_a = this.getGlobals()) === null || _a === void 0 ? void 0 : _a.has(calleeName)) || calleeValue.getType() instanceof Type_1.FunctionType;
+        const invokeExprPositions = new Array(1 + (isPtrInvoke ? Math.max(calleePositions.length - 1, 0) : 0) + argPositions.length);
+        let writeIdx = 0;
+        invokeExprPositions[writeIdx++] = invokeExprPosition;
         const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(calleeName);
-        if (!((_a = this.getGlobals()) === null || _a === void 0 ? void 0 : _a.has(calleeName)) || calleeValue.getType() instanceof Type_1.FunctionType) {
+        if (isPtrInvoke) {
             // the call to the left value or a value of function type should be ptr invoke expr.
             invokeExpr = new Expr_1.ArkPtrInvokeExpr(methodSignature, calleeValue, args.argValues, args.realGenericTypes, args.spreadFlags);
-            invokeExprPositions.push(...calleePositions.slice(1));
+            for (let i = 1; i < calleePositions.length; i++) {
+                invokeExprPositions[writeIdx++] = calleePositions[i];
+            }
         }
         else {
             invokeExpr = new Expr_1.ArkStaticInvokeExpr(methodSignature, args.argValues, args.realGenericTypes, args.spreadFlags);
         }
-        invokeExprPositions.push(...args.argPositions);
+        for (let i = 0; i < argPositions.length; i++) {
+            invokeExprPositions[writeIdx++] = argPositions[i];
+        }
         return {
             value: invokeExpr,
             valueOriginalPositions: invokeExprPositions,
@@ -776,34 +994,25 @@ class ArkValueTransformer {
         if (!ts.isCallExpression(callExpression)) {
             return false;
         }
-        const classSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildClassSignatureFromClassName(callerName);
+        const classSignature = new ArkSignature_1.ClassSignature(callerName, this.declaringFile.getFileSigID());
         const cls = ModelUtils_1.ModelUtils.getClass(this.declaringMethod, classSignature);
         return (_a = cls === null || cls === void 0 ? void 0 : cls.hasComponentDecorator()) !== null && _a !== void 0 ? _a : false;
     }
     isSystemComponentCall(calleeName, callExpression) {
-        return (calleeName === EtsConst_1.COMPONENT_FOR_EACH || calleeName === EtsConst_1.COMPONENT_LAZY_FOR_EACH) &&
-            ts.isCallExpression(callExpression);
-    }
-    handleArrayRefInvoke(calleeValue, functionNameNode, args, invokeExprPosition, calleePositions, currStmts) {
-        const stmts = [...currStmts];
-        const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName((0, StringUtils_1.cloneText)(functionNameNode.argumentExpression.getText()));
-        stmts.pop();
-        const invokeExpr = new Expr_1.ArkInstanceInvokeExpr(calleeValue.getBase(), methodSignature, args.argValues, args.realGenericTypes, args.spreadFlags);
-        const invokeExprPositions = [invokeExprPosition, calleePositions.slice(1)[0],
-            ...args.argPositions];
-        return {
-            value: invokeExpr,
-            valueOriginalPositions: invokeExprPositions,
-            stmts: stmts,
-        };
+        return (calleeName === EtsConst_1.COMPONENT_FOR_EACH || calleeName === EtsConst_1.COMPONENT_LAZY_FOR_EACH) && ts.isCallExpression(callExpression);
     }
     handleDefaultInvoke(calleeValue, args, invokeExprPosition, calleePositions, currStmts) {
-        const stmts = [...currStmts];
-        const { value: newCalleeValue, stmts: newStmts } = this.arkIRTransformer.generateAssignStmtForValue(calleeValue, calleePositions);
-        stmts.push(...newStmts);
+        const stmts = currStmts;
+        const temp = this.arkIRTransformer.generateAssignStmtForValueInto(calleeValue, calleePositions, stmts);
+        const newCalleeValue = temp.value;
         const invokeExpr = new Expr_1.ArkPtrInvokeExpr(ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(newCalleeValue.getName()), newCalleeValue, args.argValues, args.realGenericTypes, args.spreadFlags);
-        const invokeExprPositions = [invokeExprPosition, calleePositions.slice(1)[0],
-            ...args.argPositions];
+        const argPositions = args.argPositions;
+        const invokeExprPositions = new Array(2 + argPositions.length);
+        invokeExprPositions[0] = invokeExprPosition;
+        invokeExprPositions[1] = calleePositions[1];
+        for (let i = 0; i < argPositions.length; i++) {
+            invokeExprPositions[2 + i] = argPositions[i];
+        }
         return {
             value: invokeExpr,
             valueOriginalPositions: invokeExprPositions,
@@ -825,16 +1034,17 @@ class ArkValueTransformer {
                 builderMethodIndexes = new Set([1]);
             }
         }
-        const { argValues, argPositions, spreadFlags, } = this.parseArguments(currStmts, callExpression.arguments, builderMethodIndexes);
+        const { argValues, argPositions, spreadFlags } = this.parseArguments(currStmts, callExpression.arguments, builderMethodIndexes);
         return { realGenericTypes, argValues, argPositions, spreadFlags };
     }
     parseArguments(currStmts, argumentNodes, builderMethodIndexes) {
-        const argValues = [];
-        const argPositions = [];
+        const argCount = argumentNodes ? argumentNodes.length : 0;
+        const argValues = argCount === 0 ? [] : new Array(argCount);
+        const argPositions = argCount === 0 ? [] : new Array(argCount);
         let spreadFlags = [];
         if (argumentNodes) {
-            spreadFlags = new Array(argumentNodes.length).fill(false);
-            for (let i = 0; i < argumentNodes.length; i++) {
+            spreadFlags = new Array(argCount).fill(false);
+            for (let i = 0; i < argCount; i++) {
                 spreadFlags[i] = ts.isSpreadElement(argumentNodes[i]);
                 const argument = argumentNodes[i];
                 const prevBuilderMethodContextFlag = this.builderMethodContextFlag;
@@ -842,27 +1052,28 @@ class ArkValueTransformer {
                     this.builderMethodContextFlag = true;
                     this.arkIRTransformer.setBuilderMethodContextFlag(true);
                 }
-                let { value: argValue, valueOriginalPositions: argPositionsSingle, stmts: argStmts, } = this.tsNodeToSingleAddressValueAndStmts(argument);
+                let { value: argValue, valueOriginalPositions: argPositionsSingle, stmts: argStmts } = this.tsNodeToSingleAddressValueAndStmts(argument);
                 this.builderMethodContextFlag = prevBuilderMethodContextFlag;
                 this.arkIRTransformer.setBuilderMethodContextFlag(prevBuilderMethodContextFlag);
-                argStmts.forEach(s => currStmts.push(s));
-                argValues.push(argValue);
-                argPositions.push(argPositionsSingle[0]);
+                for (let j = 0; j < argStmts.length; j++) {
+                    currStmts.push(argStmts[j]);
+                }
+                argValues[i] = argValue;
+                argPositions[i] = argPositionsSingle[0];
             }
         }
         return {
             argValues,
             argPositions,
-            spreadFlags: spreadFlags.every((f) => f === false) ? undefined : spreadFlags,
+            spreadFlags: spreadFlags.every(f => f === false) ? undefined : spreadFlags,
         };
     }
     callableNodeToValueAndStmts(callableNode) {
-        const declaringClass = this.declaringMethod.getDeclaringArkClass();
-        const arrowArkMethod = new ArkMethod_1.ArkMethod();
+        const arrowArkMethod = new ArkMethod_1.ArkMethod(this.declaringClass.getClassSigID());
         if (this.builderMethodContextFlag) {
             ModelUtils_1.ModelUtils.implicitArkUIBuilderMethods.add(arrowArkMethod);
         }
-        (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(callableNode, declaringClass, arrowArkMethod, this.sourceFile, this.declaringMethod);
+        (0, ArkMethodBuilder_2.buildArkMethodFromArkClass)(callableNode, this.declaringClass, arrowArkMethod, this.sourceFile, this.declaringMethod);
         const callableType = new Type_1.FunctionType(arrowArkMethod.getSignature());
         const callableValue = this.addNewLocal(arrowArkMethod.getName(), callableType);
         return {
@@ -900,6 +1111,8 @@ class ArkValueTransformer {
         const { value: newLocal, valueOriginalPositions: newLocalPositions, stmts: newExprStmts, } = this.arkIRTransformer.generateAssignStmtForValue(newExpr, [Position_1.FullPosition.buildFromNode(newExpression, this.sourceFile)]);
         newExprStmts.forEach(stmt => stmts.push(stmt));
         const constructorMethodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(TSConst_1.CONSTRUCTOR_NAME);
+        // Object path: a stub class signature (unclear) is routed to the temp canonicalizer
+        // inside the constructor — no formal interning without a model.
         const constructorMethodSignature = new ArkSignature_1.MethodSignature(classSignature, constructorMethodSubSignature);
         const { argValues: argValues, argPositions: argPositions, } = this.parseArguments(stmts, newExpression.arguments);
         const instanceInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(newLocal, constructorMethodSignature, argValues);
@@ -953,7 +1166,7 @@ class ArkValueTransformer {
             if (ts.isSpreadElement(arrayLiteralExpression.elements[i]) && firstSpreadIdx === -1) {
                 firstSpreadIdx = i;
             }
-            const { value: elementValue, valueOriginalPositions: elementPosition, stmts: elementStmts } = this.tsNodeToSingleAddressValueAndStmts(arrayLiteralExpression.elements[i]);
+            const { value: elementValue, valueOriginalPositions: elementPosition, stmts: elementStmts, } = this.tsNodeToSingleAddressValueAndStmts(arrayLiteralExpression.elements[i]);
             elementStmts.forEach(stmt => stmts.push(stmt));
             elementValues.push(elementValue);
             elementTypes.push(elementValue.getType());
@@ -964,7 +1177,7 @@ class ArkValueTransformer {
             return this.generateArrayExprFromLiteral(elementValues, elementTypes, elementPositions, wholePosition, 0, arrayLength, stmts);
         }
         else if (firstSpreadIdx === 0) {
-            const scene = this.declaringMethod.getDeclaringArkFile().getScene();
+            const scene = this.declaringFile.getScene();
             if (arrayLength === 1) { // only spread element
                 const sliceMethodSignature = Builtin_1.Builtin.buildArrayMethodSignature(Builtin_1.Builtin.SLICE, scene);
                 const sliceInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(elementValues[0], sliceMethodSignature, []);
@@ -980,7 +1193,7 @@ class ArkValueTransformer {
         }
         else { // contains spread elements and begins with literal elements.
             const beginLiteralValueAndStmts = this.generateArrayExprFromLiteral(elementValues, elementTypes, elementPositions, wholePosition, 0, firstSpreadIdx, stmts);
-            const scene = this.declaringMethod.getDeclaringArkFile().getScene();
+            const scene = this.declaringFile.getScene();
             const concatMethodSignature = Builtin_1.Builtin.buildArrayMethodSignature(Builtin_1.Builtin.CONCAT, scene);
             const concatInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(beginLiteralValueAndStmts.value, concatMethodSignature, elementValues.slice(firstSpreadIdx));
             const concatInvokeExprPositions = [wholePosition, beginLiteralValueAndStmts.valueOriginalPositions[0],
@@ -997,8 +1210,7 @@ class ArkValueTransformer {
         else if (elementTypesSet.size > 1) {
             baseType = new Type_1.UnionType(Array.from(elementTypesSet));
         }
-        const newArrayExprPosition = (start === end || (end - start) === elementPositions.length)
-            ? wholePosition : Position_1.FullPosition.merge(elementPositions[0], elementPositions[end - 1]);
+        const newArrayExprPosition = start === end || end - start === elementPositions.length ? wholePosition : Position_1.FullPosition.merge(elementPositions[0], elementPositions[end - 1]);
         return this.generateArrayExprAndStmts(baseType, ValueUtil_1.ValueUtil.getOrCreateNumberConst(end - start), Position_1.FullPosition.DEFAULT, end - start, elementValues.slice(start, end), elementPositions.slice(start, end), currStmts, newArrayExprPosition, true);
     }
     generateArrayExprAndStmts(baseType, arrayLengthValue, arrayLengthPosition, arrayLength, initializerValues, initializerPositions, currStmts, newArrayExprPosition, fromLiteral) {
@@ -1146,7 +1358,7 @@ class ArkValueTransformer {
     }
     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)) {
             ({
@@ -1169,11 +1381,7 @@ class ArkValueTransformer {
         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];
@@ -1184,7 +1392,7 @@ class ArkValueTransformer {
         };
     }
     deleteExpressionToValueAndStmts(deleteExpression) {
-        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: stmts, } = this.tsNodeToValueAndStmts(deleteExpression.expression);
+        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 {
@@ -1194,7 +1402,7 @@ class ArkValueTransformer {
         };
     }
     voidExpressionToValueAndStmts(voidExpression) {
-        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: stmts, } = this.tsNodeToValueAndStmts(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 {
@@ -1210,7 +1418,7 @@ 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 {
@@ -1221,7 +1429,7 @@ class ArkValueTransformer {
     }
     asExpressionToValueAndStmts(asExpression) {
         const stmts = [];
-        let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts, } = this.tsNodeToValueAndStmts(asExpression.expression);
+        let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts } = this.tsNodeToValueAndStmts(asExpression.expression);
         exprStmts.forEach(stmt => stmts.push(stmt));
         if (IRUtils_1.IRUtils.moreThanOneAddress(exprValue)) {
             ({
@@ -1240,7 +1448,7 @@ class ArkValueTransformer {
         };
     }
     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 {
@@ -1269,82 +1477,76 @@ class ArkValueTransformer {
         return this.assignmentToValueAndStmts(leftOpNode, rightOpNode, true, isConst, declarationType, needRightOp);
     }
     assignmentToValueAndStmts(leftOpNode, rightOpNode, variableDefFlag, isConst, declarationType, needRightOp = true) {
-        let leftValueAndStmts;
-        if (ts.isIdentifier(leftOpNode)) {
-            leftValueAndStmts = this.identifierToValueAndStmts(leftOpNode, variableDefFlag);
+        const isArrayDestructuring = ts.isArrayBindingPattern(leftOpNode) || ts.isArrayLiteralExpression(leftOpNode);
+        const isObjectDestructuring = ts.isObjectBindingPattern(leftOpNode) || ts.isObjectLiteralExpression(leftOpNode);
+        // In declarations the destructuring target is a binding pattern, in assignments an array/object literal.
+        const leftResult = ts.isIdentifier(leftOpNode)
+            ? this.identifierToValueAndStmts(leftOpNode, variableDefFlag)
+            : isArrayDestructuring
+                ? this.arrayDestructuringToValueAndStmts(leftOpNode, isConst)
+                : isObjectDestructuring
+                    ? this.objectDestructuringToValueAndStmts(leftOpNode, isConst)
+                    : this.tsNodeToValueAndStmts(leftOpNode);
+        if (!needRightOp) {
+            return { value: leftResult.value, valueOriginalPositions: leftResult.valueOriginalPositions, stmts: leftResult.stmts };
+        }
+        const rightResult = this.assignmentRightOpToValueAndStmts(rightOpNode, leftResult.value);
+        if (leftResult.value instanceof Local_1.Local) {
+            if (variableDefFlag) {
+                leftResult.value.setConstFlag(isConst);
+                leftResult.value.setType(declarationType);
+            }
+            const rightType = rightResult.value.getType();
+            if (leftResult.value.getType() instanceof Type_1.UnknownType && !(rightType instanceof Type_1.UnknownType) && !(rightType instanceof Type_1.UndefinedType)) {
+                leftResult.value.setType(rightType);
+            }
+            const unifiedType = (0, builderUtils_1.unifyDeclaredTypeWithInitializer)(leftResult.value.getType(), rightType);
+            if (unifiedType !== leftResult.value.getType()) {
+                leftResult.value.setType(unifiedType);
+            }
         }
-        else if (ts.isArrayBindingPattern(leftOpNode) || ts.isArrayLiteralExpression(leftOpNode)) {
-            // In declaration, it is ArrayBindingPattern. And in assignment, it is ArrayLiteralExpression.
-            leftValueAndStmts = this.arrayDestructuringToValueAndStmts(leftOpNode, isConst);
+        const assignStmt = new Stmt_1.ArkAssignStmt(leftResult.value, rightResult.value);
+        const leftPositions = leftResult.valueOriginalPositions;
+        const operandPositions = new Array(leftPositions.length + rightResult.valueOriginalPositions.length);
+        for (let i = 0; i < leftPositions.length; i++) {
+            operandPositions[i] = leftPositions[i];
         }
-        else if (ts.isObjectBindingPattern(leftOpNode) || ts.isObjectLiteralExpression(leftOpNode)) {
-            // In declaration, it is ObjectBindingPattern. And in assignment, it is ObjectLiteralExpression.
-            leftValueAndStmts = this.objectDestructuringToValueAndStmts(leftOpNode, isConst);
+        const rightPositions = rightResult.valueOriginalPositions;
+        for (let i = 0; i < rightPositions.length; i++) {
+            operandPositions[leftPositions.length + i] = rightPositions[i];
         }
-        else {
-            leftValueAndStmts = this.tsNodeToValueAndStmts(leftOpNode);
+        assignStmt.setOperandOriginalPositions(operandPositions);
+        const destructuring = isArrayDestructuring || isObjectDestructuring;
+        if (destructuring) {
+            rightResult.stmts.push(assignStmt);
         }
-        const { value: leftValue, valueOriginalPositions: leftPositions, stmts: leftStmts } = leftValueAndStmts;
-        let stmts = [];
-        if (needRightOp) {
-            const { value: rightValue, valueOriginalPositions: rightPositions, stmts: rightStmts, } = this.assignmentRightOpToValueAndStmts(rightOpNode, leftValue);
-            if (leftValue instanceof Local_1.Local) {
-                if (variableDefFlag) {
-                    leftValue.setConstFlag(isConst);
-                    leftValue.setType(declarationType);
-                }
-                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)) {
-                rightStmts.forEach(stmt => stmts.push(stmt));
-                stmts.push(assignStmt);
-                leftStmts.forEach(stmt => stmts.push(stmt));
-            }
-            else {
-                rightStmts.forEach(stmt => stmts.push(stmt));
-                leftStmts.forEach(stmt => stmts.push(stmt));
-                stmts.push(assignStmt);
-            }
+        for (let i = 0; i < leftResult.stmts.length; i++) {
+            rightResult.stmts.push(leftResult.stmts[i]);
         }
-        else {
-            stmts = leftStmts;
+        if (!destructuring) {
+            rightResult.stmts.push(assignStmt);
         }
-        return {
-            value: leftValue,
-            valueOriginalPositions: leftPositions,
-            stmts: stmts,
-        };
+        return { value: leftResult.value, valueOriginalPositions: leftResult.valueOriginalPositions, stmts: rightResult.stmts };
     }
     assignmentRightOpToValueAndStmts(rightOpNode, leftValue) {
         let rightValue;
         let rightPositions;
-        let tempRightStmts = [];
-        const rightStmts = [];
+        let rightStmts;
         if (rightOpNode) {
-            ({
-                value: rightValue,
-                valueOriginalPositions: rightPositions,
-                stmts: tempRightStmts,
-            } = this.tsNodeToValueAndStmts(rightOpNode));
-            tempRightStmts.forEach(stmt => rightStmts.push(stmt));
+            const rightResult = this.tsNodeToValueAndStmts(rightOpNode);
+            rightValue = rightResult.value;
+            rightPositions = rightResult.valueOriginalPositions;
+            rightStmts = rightResult.stmts;
         }
         else {
             rightValue = ValueUtil_1.ValueUtil.getUndefinedConst();
             rightPositions = [Position_1.FullPosition.DEFAULT];
+            rightStmts = [];
         }
         if (IRUtils_1.IRUtils.moreThanOneAddress(leftValue) && IRUtils_1.IRUtils.moreThanOneAddress(rightValue)) {
-            ({
-                value: rightValue,
-                valueOriginalPositions: rightPositions,
-                stmts: tempRightStmts,
-            } = this.arkIRTransformer.generateAssignStmtForValue(rightValue, rightPositions));
-            tempRightStmts.forEach(stmt => rightStmts.push(stmt));
+            const temp = this.arkIRTransformer.generateAssignStmtForValueInto(rightValue, rightPositions, rightStmts);
+            rightValue = temp.value;
+            rightPositions = temp.positions;
         }
         return {
             value: rightValue,
@@ -1376,8 +1578,7 @@ class ArkValueTransformer {
                     const elementName = (0, StringUtils_1.cloneText)(nodeInsideRest.getText(this.sourceFile));
                     targetLocal = ts.isBindingElement(element) ? this.addNewLocal(elementName) : this.getOrCreateLocal(elementName);
                 }
-                const sliceMethodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(Builtin_1.Builtin.SLICE);
-                const sliceMethodSignature = new ArkSignature_1.MethodSignature(Builtin_1.Builtin.ARRAY_CLASS_SIGNATURE, sliceMethodSubSignature);
+                const sliceMethodSignature = Builtin_1.Builtin.getOrCreateArrayStubMethodSignature(Builtin_1.Builtin.SLICE);
                 const sliceInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(arrayTempLocal, sliceMethodSignature, [ValueUtil_1.ValueUtil.getOrCreateNumberConst(i)]);
                 const sliceInvokeExprPositions = [wholePosition, targetLocalPosition];
                 const assignStmt = new Stmt_1.ArkAssignStmt(targetLocal, sliceInvokeExpr);
@@ -1452,47 +1653,39 @@ class ArkValueTransformer {
         }
         const stmts = [];
         const binaryExpressionPosition = Position_1.FullPosition.buildFromNode(binaryExpression, this.sourceFile);
-        const { value: opValue1, valueOriginalPositions: opPositions1, stmts: opStmts1, } = this.tsNodeToSingleAddressValueAndStmts(binaryExpression.left);
-        opStmts1.forEach(stmt => stmts.push(stmt));
+        const leftResult = this.tsNodeToSingleAddressValueAndStmts(binaryExpression.left);
+        leftResult.stmts.forEach(stmt => stmts.push(stmt));
         if (operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword) {
-            const instanceOfExpr = new Expr_1.ArkInstanceOfExpr(opValue1, new Type_1.UnclearReferenceType((0, StringUtils_1.cloneText)(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,
-            };
-        }
-        const { value: opValue2, valueOriginalPositions: opPositions2, stmts: opStmts2, } = this.tsNodeToSingleAddressValueAndStmts(binaryExpression.right);
-        opStmts2.forEach(stmt => stmts.push(stmt));
+            const instOfExpr = new Expr_1.ArkInstanceOfExpr(leftResult.value, new Type_1.UnclearReferenceType((0, StringUtils_1.cloneText)(binaryExpression.right.getText(this.sourceFile))));
+            const instOfExprPositions = [binaryExpressionPosition, ...leftResult.valueOriginalPositions];
+            const instOfResult = this.arkIRTransformer.generateAssignStmtForValue(instOfExpr, instOfExprPositions);
+            instOfResult.stmts.forEach(stmt => stmts.push(stmt));
+            return { value: instOfResult.value, valueOriginalPositions: instOfResult.valueOriginalPositions, stmts: stmts };
+        }
+        const rightResult = this.tsNodeToSingleAddressValueAndStmts(binaryExpression.right);
+        rightResult.stmts.forEach(stmt => stmts.push(stmt));
         let exprValue;
         let exprValuePositions = [binaryExpressionPosition];
         if (operatorToken.kind === ts.SyntaxKind.CommaToken) {
-            exprValue = opValue2;
+            exprValue = rightResult.value;
         }
         else {
             const operator = ArkIRTransformer_1.ArkIRTransformer.tokenToBinaryOperator(operatorToken.kind);
             if (operator) {
                 if (this.isRelationalOperator(operator)) {
-                    exprValue = new Expr_1.ArkConditionExpr(opValue1, opValue2, operator);
+                    exprValue = new Expr_1.ArkConditionExpr(leftResult.value, rightResult.value, operator);
                 }
                 else {
-                    exprValue = new Expr_1.ArkNormalBinopExpr(opValue1, opValue2, operator);
+                    exprValue = new Expr_1.ArkNormalBinopExpr(leftResult.value, rightResult.value, operator);
                 }
-                exprValuePositions.push(...opPositions1, ...opPositions2);
+                exprValuePositions.push(...leftResult.valueOriginalPositions, ...rightResult.valueOriginalPositions);
             }
             else {
                 exprValue = ValueUtil_1.ValueUtil.getUndefinedConst();
                 exprValuePositions.push(binaryExpressionPosition);
             }
         }
-        return {
-            value: exprValue,
-            valueOriginalPositions: exprValuePositions,
-            stmts: stmts,
-        };
+        return { value: exprValue, valueOriginalPositions: exprValuePositions, stmts: stmts };
     }
     compoundAssignmentToValueAndStmts(binaryExpression) {
         const stmts = [];
@@ -1511,7 +1704,7 @@ class ArkValueTransformer {
             leftValue = leftValueOrig;
             leftPositions = leftPositionsOrig;
         }
-        const { value: rightValue, valueOriginalPositions: rightPositions, stmts: rightStmts } = this.tsNodeToSingleAddressValueAndStmts(binaryExpression.right);
+        const { value: rightValue, valueOriginalPositions: rightPositions, stmts: rightStmts, } = this.tsNodeToSingleAddressValueAndStmts(binaryExpression.right);
         rightStmts.forEach(stmt => stmts.push(stmt));
         const operator = this.compoundAssignmentTokenToBinaryOperator(binaryExpression.operatorToken.kind);
         if (operator) {
@@ -1523,14 +1716,14 @@ class ArkValueTransformer {
                 ...(assignTarget === leftValueOrig ? leftPositionsOrig : leftPositions),
                 exprValuePosition,
                 ...leftPositions,
-                ...rightPositions
+                ...rightPositions,
             ]);
             stmts.push(assignStmt);
         }
         return {
             value: leftValueOrig,
             valueOriginalPositions: leftPositionsOrig,
-            stmts: stmts
+            stmts: stmts,
         };
     }
     compoundAssignmentTokenToBinaryOperator(token) {
@@ -1571,7 +1764,7 @@ class ArkValueTransformer {
     }
     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())) {
@@ -1754,8 +1947,8 @@ class ArkValueTransformer {
         if (ts.isQualifiedName(exprNameNode)) {
             if ((0, StringUtils_1.cloneText)(exprNameNode.left.getText(this.sourceFile)) === TSConst_1.THIS_NAME) {
                 const fieldName = (0, StringUtils_1.cloneText)(exprNameNode.right.getText(this.sourceFile));
-                const fieldSignature = (_b = (_a = this.declaringMethod.getDeclaringArkClass().getFieldWithName(fieldName)) === null || _a === void 0 ? void 0 : _a.getSignature()) !== null && _b !== void 0 ? _b : ArkSignatureBuilder_1.ArkSignatureBuilder.buildFieldSignatureFromFieldName(fieldName);
-                const baseLocal = (_c = this.locals.get(TSConst_1.THIS_NAME)) !== null && _c !== void 0 ? _c : new Local_1.Local(TSConst_1.THIS_NAME, new Type_1.ClassType(this.declaringMethod.getDeclaringArkClass().getSignature(), genericTypes));
+                const fieldSignature = (_b = (_a = this.declaringClass.getFieldWithName(fieldName)) === null || _a === void 0 ? void 0 : _a.getSignature()) !== null && _b !== void 0 ? _b : ArkSignatureBuilder_1.ArkSignatureBuilder.buildFieldSignatureFromFieldName(fieldName);
+                const baseLocal = (_c = this.locals.get(TSConst_1.THIS_NAME)) !== null && _c !== void 0 ? _c : new Local_1.Local(TSConst_1.THIS_NAME, new Type_1.ClassType(this.declaringClass.getSignature(), genericTypes));
                 opValue = new Ref_1.ArkInstanceFieldRef(baseLocal, fieldSignature);
             }
             else {
@@ -1877,21 +2070,20 @@ class ArkValueTransformer {
         }
     }
     resolveTypeLiteralNode(typeLiteralNode) {
-        const anonymousClass = new ArkClass_1.ArkClass();
-        const declaringClass = this.declaringMethod.getDeclaringArkClass();
-        const declaringNamespace = declaringClass.getDeclaringArkNamespace();
+        const declaringNamespace = this.declaringNamespace;
+        const anonymousClass = new ArkClass_1.ArkClass(this.declaringFile.getFileSigID(), declaringNamespace === null || declaringNamespace === void 0 ? void 0 : declaringNamespace.getNamespaceSigID());
         if (declaringNamespace) {
-            (0, ArkClassBuilder_1.buildNormalArkClassFromArkNamespace)(typeLiteralNode, declaringNamespace, anonymousClass, this.sourceFile);
+            (0, ArkClassBuilder_1.buildNormalArkClassFromArkNamespace)(typeLiteralNode, anonymousClass, this.sourceFile);
+            declaringNamespace.addArkClass(anonymousClass);
         }
         else {
-            (0, ArkClassBuilder_1.buildNormalArkClassFromArkFile)(typeLiteralNode, declaringClass.getDeclaringArkFile(), anonymousClass, this.sourceFile);
+            (0, ArkClassBuilder_1.buildNormalArkClassFromArkFile)(typeLiteralNode, this.declaringFile, anonymousClass, this.sourceFile);
         }
         return new Type_1.ClassType(anonymousClass.getSignature());
     }
     resolveFunctionTypeNode(functionTypeNode) {
-        const anonymousMethod = new ArkMethod_1.ArkMethod();
-        const declaringClass = this.declaringMethod.getDeclaringArkClass();
-        (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(functionTypeNode, declaringClass, anonymousMethod, this.sourceFile);
+        const anonymousMethod = new ArkMethod_1.ArkMethod(this.declaringClass.getClassSigID());
+        (0, ArkMethodBuilder_2.buildArkMethodFromArkClass)(functionTypeNode, this.declaringClass, anonymousMethod, this.sourceFile);
         return new Type_1.FunctionType(anonymousMethod.getSignature());
     }
     static isCompoundAssignmentOperator(operator) {