arkanalyzer 1.0.93 → 2.0.0-beta1

package/lib/core/common/IRInference.js

@@ -39,6 +39,7 @@ exports.IRInference = void 0;
  * limitations under the License.
  */
 const ArkMethod_1 = require("../model/ArkMethod");
+const ArkSignatureBuilder_1 = require("../model/builder/ArkSignatureBuilder");
 const Type_1 = require("../base/Type");
 const Local_1 = require("../base/Local");
 const TypeInference_1 = require("./TypeInference");
@@ -58,7 +59,10 @@ const ValueUtil_1 = require("./ValueUtil");
 const TypeExpr_1 = require("../base/TypeExpr");
 const ArkBaseModel_1 = require("../model/ArkBaseModel");
 const SdkUtils_1 = require("./SdkUtils");
+const SignatureCanonicalizerRegistry_1 = require("./SignatureCanonicalizerRegistry");
 const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'IRInference');
+const IS_GENERIC_OR_ANY = (t) => t instanceof Type_1.GenericType || t instanceof Type_1.AnyType;
+const IS_GENERIC = (t) => t instanceof Type_1.GenericType;
 class IRInference {
     static inferExportInfos(file) {
         file.getExportInfos().forEach(exportInfo => {
@@ -107,14 +111,13 @@ class IRInference {
         this.inferExportInfos(file);
     }
     static needInfer(fileSignature) {
-        if (fileSignature === Builtin_1.Builtin.BUILT_IN_CLASSES_FILE_SIGNATURE) {
-            return true;
-        }
+        // Builtin stub signatures carry FileSignature.DEFAULT (fileName '%unk') and are
+        // covered by the UNKNOWN_FILE_NAME check below.
         return fileSignature.getFileName() === Const_1.UNKNOWN_FILE_NAME;
     }
     static inferStaticInvokeExpr(expr, arkMethod) {
-        const fileSignature = expr.getMethodSignature().getDeclaringClassSignature().getDeclaringFileSignature();
-        if (fileSignature !== ArkSignature_1.FileSignature.DEFAULT && fileSignature !== Builtin_1.Builtin.BUILT_IN_CLASSES_FILE_SIGNATURE) {
+        const fileSigID = expr.getMethodSignature().getDeclaringClassSignature().getDeclaringFileSigID();
+        if (fileSigID !== 0) {
             return expr;
         }
         const arkClass = arkMethod.getDeclaringArkClass();
@@ -134,7 +137,7 @@ class IRInference {
         else if (methodName === TSConst_1.SUPER_NAME) {
             const superClass = arkClass.getSuperClass();
             if (superClass !== null) {
-                const newMethodSignature = new ArkSignature_1.MethodSignature(superClass.getSignature(), expr.getMethodSignature().getMethodSubSignature());
+                const newMethodSignature = new ArkSignature_1.MethodSignature(superClass.getClassSigID(), expr.getMethodSignature().getMethodSubSignature());
                 expr.setMethodSignature(newMethodSignature);
             }
             return expr;
@@ -154,9 +157,10 @@ class IRInference {
         return this.inferStaticInvokeExprByMethodName(methodName, arkMethod, expr);
     }
     static inferStaticInvokeExprByMethodName(methodName, arkMethod, expr) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
+        const registry = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
         const arkClass = arkMethod.getDeclaringArkClass();
-        const arkExport = (_d = (_c = (_b = (_a = ModelUtils_1.ModelUtils.getStaticMethodWithName(methodName, arkClass)) !== null && _a !== void 0 ? _a : arkMethod.getFunctionLocal(methodName)) !== null && _b !== void 0 ? _b : ModelUtils_1.ModelUtils.findDeclaredLocal(new Local_1.Local(methodName), arkMethod)) !== null && _c !== void 0 ? _c : ModelUtils_1.ModelUtils.getArkExportInImportInfoWithName(methodName, arkClass.getDeclaringArkFile())) !== null && _d !== void 0 ? _d : arkClass.getDeclaringArkFile().getScene().getSdkGlobal(methodName);
+        const arkExport = (_e = (_d = (_c = (_b = (_a = ModelUtils_1.ModelUtils.getStaticMethodWithName(methodName, arkClass)) !== null && _a !== void 0 ? _a : IRInference.getNestedMethodInScopeChain(methodName, arkMethod)) !== null && _b !== void 0 ? _b : arkMethod.getFunctionLocal(methodName)) !== null && _c !== void 0 ? _c : ModelUtils_1.ModelUtils.findDeclaredLocal(new Local_1.Local(methodName), arkMethod)) !== null && _d !== void 0 ? _d : ModelUtils_1.ModelUtils.getArkExportInImportInfoWithName(methodName, arkClass.getDeclaringArkFile())) !== null && _e !== void 0 ? _e : SdkUtils_1.SdkUtils.getSdkGlobal(methodName);
         let method;
         let signature;
         if (arkExport instanceof ArkMethod_1.ArkMethod) {
@@ -172,7 +176,7 @@ class IRInference {
             }
             const type = TypeInference_1.TypeInference.replaceAliasType(arkExportType);
             if (type instanceof Type_1.ClassType) {
-                const cls = arkClass.getDeclaringArkFile().getScene().getClass(type.getClassSignature());
+                const cls = registry.getClassBySig(type.getClassSignature());
                 method = cls === null || cls === void 0 ? void 0 : cls.getMethodWithName(Const_1.CALL_SIGNATURE_NAME);
             }
             else if (type instanceof Type_1.FunctionType) {
@@ -194,6 +198,18 @@ class IRInference {
         }
         return expr;
     }
+    static getNestedMethodInScopeChain(methodName, arkMethod) {
+        let scope = arkMethod;
+        while (scope !== undefined && scope !== null) {
+            const composedName = Const_1.NAME_PREFIX + methodName + Const_1.NAME_DELIMITER + scope.getName();
+            const nested = scope.getDeclaringArkClass().getMethodWithName(composedName);
+            if (nested !== null) {
+                return nested;
+            }
+            scope = scope.getOuterMethod();
+        }
+        return null;
+    }
     static inferInstanceInvokeExpr(expr, arkMethod) {
         var _a, _b;
         const arkClass = arkMethod.getDeclaringArkClass();
@@ -230,27 +246,82 @@ class IRInference {
         this.inferBase(ref, arkMethod);
         const baseType = TypeInference_1.TypeInference.replaceAliasType(ref.getBase().getType());
         if (baseType instanceof Type_1.ArrayType && ref.getFieldName() !== 'length') {
+            // 本 ref 即将被 ArkArrayRef 替换——temp 行随之 retire（数组访问无字段归宿，纯 retire；dynamic ref 独占行无共享者）。
+            ref.retireTemp();
             return new Ref_1.ArkArrayRef(ref.getBase(), ValueUtil_1.ValueUtil.createConst(ref.getFieldName()));
         }
-        let newFieldSignature = this.generateNewFieldSignature(ref, arkMethod.getDeclaringArkClass(), baseType);
-        if (newFieldSignature) {
-            if (newFieldSignature.isStatic()) {
-                return new Ref_1.ArkStaticFieldRef(newFieldSignature);
+        // 判别联合消费——定义点（终点确定）走 graduateToFormal 快路径，新构造值（终点不确定）走 updateFieldSignature 决策表；static 为新建持有者
+        // 保留构造（formal 分支持 canonical，params 分支构造实例）。
+        const res = this.generateNewFieldSignature(ref, arkMethod.getDeclaringArkClass(), baseType);
+        return this.applyFieldResolution(ref, res);
+    }
+    /**
+     * @internal 终态执行——formal 分支（graduateToFormal 快路径 / static 形态替换）与
+     * params 分支（static probe 转换 / 就地演进）的统一收敛。static params 转换前
+     * probe 字段空间：miss 时 params 携带值空间成员（ns 导出的 class/enum、字段式
+     * static 方法引用），无 formal 归宿——直接转换会走 clear+miss error 路由并
+     * 多占一个 slot；miss 落入 updateFieldSignature（就地演进，上下文保留）。
+     */
+    static applyFieldResolution(ref, res) {
+        var _a;
+        if (res === null) {
+            return ref;
+        }
+        if (res.kind === 'formal') {
+            const formalId = (_a = res.formalId) !== null && _a !== void 0 ? _a : 0;
+            if (formalId <= 0) {
+                return ref;
+            }
+            if (res.staticFlag) {
+                ref.retireTempTo(formalId);
+                const canonical = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().fieldSigCanonicalizer.get(formalId);
+                return new Ref_1.ArkStaticFieldRef(canonical);
             }
-            ref.setFieldSignature(newFieldSignature);
+            ref.graduateToFormal(formalId);
+            return ref;
         }
+        if (res.staticFlag) {
+            return IRInference.applyStaticParamsResolution(ref, res);
+        }
+        ref.updateFieldSignature(res.fieldName, res.declaringOrID, res.type, res.staticFlag, res.namespaceDeclared);
         return ref;
     }
+    /** params+static 分支的统一收敛（applyFieldResolution 与 updateRefSignature 共用）。 */
+    static applyStaticParamsResolution(ref, resolution) {
+        let staticSig;
+        if (typeof resolution.declaringOrID === 'number') {
+            staticSig = resolution.namespaceDeclared
+                ? new ArkSignature_1.FieldSignature(resolution.fieldName, resolution.declaringOrID, resolution.type, resolution.staticFlag, true)
+                : new ArkSignature_1.FieldSignature(resolution.fieldName, resolution.declaringOrID, resolution.type, resolution.staticFlag);
+        }
+        else {
+            staticSig = new ArkSignature_1.FieldSignature(resolution.fieldName, resolution.declaringOrID, resolution.type, resolution.staticFlag);
+        }
+        const registry = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        const existingId = registry.fieldSigCanonicalizer.getExistingId(staticSig);
+        if (existingId !== -1) {
+            // 替换埋葬：static params 形态（新 ref 自走首路径，旧 ref 纯 retire）。
+            ref.retireTemp();
+            return new Ref_1.ArkStaticFieldRef(registry.fieldSigCanonicalizer.get(existingId));
+        }
+        // formal miss：unclear stub 经 route 干净注册 temp，再就地演进（clear declaring/type 入 temp 行，不入 formal），形态与 formal 命中路径统一。
+        const staticRef = new Ref_1.ArkStaticFieldRef(ArkSignatureBuilder_1.ArkSignatureBuilder.buildFieldSignatureFromFieldName(resolution.fieldName, true));
+        staticRef.updateFieldSignature(resolution.fieldName, resolution.declaringOrID, resolution.type, resolution.staticFlag, resolution.namespaceDeclared);
+        ref.retireTemp();
+        return staticRef;
+    }
     static inferBase(instance, arkMethod) {
         const base = instance.getBase();
         if (base.getName() === TSConst_1.THIS_NAME) {
-            const name = instance instanceof Ref_1.ArkInstanceFieldRef ? instance.getFieldName() :
-                instance.getMethodSignature().getMethodSubSignature().getMethodName();
+            const name = instance instanceof Ref_1.ArkInstanceFieldRef ? instance.getFieldName() : instance.getMethodSignature().getMethodSubSignature().getMethodName();
             if (name.includes('.')) {
                 return;
             }
             const declaringArkClass = arkMethod.getDeclaringArkClass();
-            if (declaringArkClass.isAnonymousClass()) {
+            // this-semantic guard (same as ArkTSLocalInference.infer): only the AC's
+            // %instInit rebinds this to the enclosing (host) this; the AC's own methods
+            // (constructor, named method properties) keep the build-time this — ClassType(AC).
+            if (declaringArkClass.isAnonymousClass() && arkMethod.getName() === Const_1.INSTANCE_INIT_METHOD_NAME) {
                 let newBase = this.inferThisLocal(arkMethod);
                 if (newBase) {
                     instance.setBase(newBase);
@@ -292,7 +363,7 @@ class IRInference {
     static inferArgs(expr, arkMethod) {
         const scene = arkMethod.getDeclaringArkFile().getScene();
         const parameters = expr.getMethodSignature().getMethodSubSignature().getParameters();
-        let realTypes = [];
+        let realTypes;
         const len = expr.getArgs().length;
         for (let index = 0; index < len; index++) {
             const arg = expr.getArg(index);
@@ -301,48 +372,61 @@ class IRInference {
             }
             const argType = arg.getType();
             const paramType = parameters[index].getType();
-            this.inferArg(expr, argType, paramType, scene, realTypes);
+            realTypes = this.inferArg(expr, argType, paramType, scene, realTypes);
         }
-        if (realTypes.length > 0 && !expr.getRealGenericTypes()) {
+        if (realTypes !== undefined && realTypes.length > 0 && !expr.getRealGenericTypes()) {
             expr.setRealGenericTypes(realTypes);
         }
     }
     static inferArg(expr, argType, paramType, scene, realTypes) {
         if (paramType instanceof Type_1.UnionType) {
-            paramType.getTypes().forEach(t => this.inferArg(expr, argType, t, scene, realTypes));
+            const unionTypes = paramType.getTypes();
+            for (let i = 0; i < unionTypes.length; i++) {
+                realTypes = this.inferArg(expr, argType, unionTypes[i], scene, realTypes);
+            }
         }
         else if (paramType instanceof Type_1.AliasType) {
-            this.inferArg(expr, argType, paramType.getOriginalType(), scene, realTypes);
+            realTypes = this.inferArg(expr, argType, paramType.getOriginalType(), scene, realTypes);
         }
         else if (paramType instanceof Type_1.ArrayType && argType instanceof Type_1.ArrayType) {
-            this.inferArg(expr, argType.getBaseType(), paramType.getBaseType(), scene, realTypes);
+            realTypes = this.inferArg(expr, argType.getBaseType(), paramType.getBaseType(), scene, realTypes);
         }
         else if (expr instanceof Expr_1.ArkInstanceInvokeExpr && expr.getBase().getType() instanceof Type_1.ArrayType) {
             if (paramType instanceof Type_1.ArrayType && paramType.getBaseType() instanceof Type_1.GenericType) {
-                this.inferArg(expr, argType, expr.getBase().getType().getBaseType(), scene, realTypes);
+                realTypes = this.inferArg(expr, argType, expr.getBase().getType().getBaseType(), scene, realTypes);
             }
         }
         if (paramType instanceof Type_1.ClassType && scene.getProjectSdkMap().has(paramType.getClassSignature().getDeclaringFileSignature().getProjectName())) {
             this.inferArgTypeWithSdk(paramType, scene, argType);
         }
         else if (paramType instanceof Type_1.GenericType) {
+            if (realTypes === undefined) {
+                realTypes = [];
+            }
             if (!realTypes[paramType.getIndex()]) {
                 realTypes[paramType.getIndex()] = argType;
             }
         }
         else if (paramType instanceof Type_1.AnyType) {
+            if (realTypes === undefined) {
+                realTypes = [];
+            }
             realTypes.push(argType);
         }
         else if (paramType instanceof Type_1.FunctionType && argType instanceof Type_1.FunctionType) {
             TypeInference_1.TypeInference.inferFunctionType(argType, paramType.getMethodSignature().getMethodSubSignature(), expr.getRealGenericTypes());
         }
+        return realTypes;
     }
     static inferRightWithSdkType(leftType, rightType, ackClass) {
         if (leftType instanceof Type_1.AliasType) {
             this.inferRightWithSdkType(TypeInference_1.TypeInference.replaceAliasType(leftType), rightType, ackClass);
         }
         else if (leftType instanceof Type_1.UnionType) {
-            leftType.getTypes().forEach(t => this.inferRightWithSdkType(t, rightType, ackClass));
+            const unionTypes = leftType.getTypes();
+            for (let i = 0; i < unionTypes.length; i++) {
+                this.inferRightWithSdkType(unionTypes[i], rightType, ackClass);
+            }
         }
         else if (leftType instanceof Type_1.ClassType) {
             IRInference.inferArgTypeWithSdk(leftType, ackClass.getDeclaringArkFile().getScene(), rightType);
@@ -398,7 +482,8 @@ class IRInference {
         else if (baseType instanceof Type_1.AnnotationNamespaceType) {
             const namespace = scene.getNamespace(baseType.getNamespaceSignature());
             if (namespace) {
-                const foundMethod = ModelUtils_1.ModelUtils.findPropertyInNamespace(methodName, namespace);
+                // 多实体探测：跨文件同名 ns（Intl 系）的后续文件实体持有该文件声明的成员
+                const foundMethod = ModelUtils_1.ModelUtils.findPropertyInNamespaces(methodName, namespace);
                 if (foundMethod instanceof ArkMethod_1.ArkMethod) {
                     let signature = foundMethod.matchMethodSignature(expr.getArgs());
                     TypeInference_1.TypeInference.inferSignatureReturnType(signature, foundMethod);
@@ -416,7 +501,7 @@ class IRInference {
         return null;
     }
     static inferInvokeExprWithArray(methodName, expr, baseType, scene) {
-        const arrayInterface = scene.getSdkGlobal(Builtin_1.Builtin.ARRAY);
+        const arrayInterface = SdkUtils_1.SdkUtils.getSdkGlobal(Builtin_1.Builtin.ARRAY);
         if (arrayInterface instanceof ArkClass_1.ArkClass) {
             return this.inferInvokeExpr(expr, new Type_1.ClassType(arrayInterface.getSignature(), [baseType.getBaseType()]), methodName, scene);
         }
@@ -432,7 +517,7 @@ class IRInference {
             expr.setMethodSignature(baseType.getMethodSignature());
             return expr;
         }
-        const funcInterface = scene.getSdkGlobal(TSConst_1.FUNCTION);
+        const funcInterface = SdkUtils_1.SdkUtils.getSdkGlobal(TSConst_1.FUNCTION);
         if (funcInterface instanceof ArkClass_1.ArkClass) {
             const method = ModelUtils_1.ModelUtils.findPropertyInClass(methodName, funcInterface);
             if (method instanceof ArkMethod_1.ArkMethod) {
@@ -444,47 +529,118 @@ class IRInference {
         return null;
     }
     static inferInvokeExprWithDeclaredClass(expr, baseType, methodName, scene) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b;
         const result = this.inferSpecialMethod(expr, baseType, methodName);
         if (result) {
             return result;
         }
-        let declaredClass = (_a = scene.getClass(baseType.getClassSignature())) !== null && _a !== void 0 ? _a : scene.getSdkGlobal(baseType.getClassSignature().getClassName());
-        if (!(declaredClass instanceof ArkClass_1.ArkClass)) {
-            return null;
+        // 候选 declaredClass 序：签名归属实体优先（scene.getClass 值直查），再补该名字的全部全局成员提供者。
+        const declaredClasses = new Set();
+        const bySig = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().getClassById(baseType.getClassSigID());
+        if (bySig instanceof ArkClass_1.ArkClass) {
+            declaredClasses.add(bySig);
         }
-        let method;
-        if (methodName === TSConst_1.CONSTRUCTOR_NAME) {
-            method = (_c = (_b = declaredClass === null || declaredClass === void 0 ? void 0 : declaredClass.getMethodWithName(Const_1.CONSTRUCT_SIGNATURE_NAME)) !== null && _b !== void 0 ? _b : declaredClass.getMethodWithName(Const_1.CALL_SIGNATURE_NAME)) !== null && _c !== void 0 ? _c : declaredClass === null || declaredClass === void 0 ? void 0 : declaredClass.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME);
-            if (!method) {
-                const subSignature = new ArkSignature_1.MethodSubSignature(methodName, [], new Type_1.ClassType(baseType.getClassSignature()));
-                expr.setMethodSignature(new ArkSignature_1.MethodSignature(baseType.getClassSignature(), subSignature));
-                return expr;
+        for (const c of SdkUtils_1.SdkUtils.getSdkGlobalMemberClasses(baseType.getClassSignature().getClassName())) {
+            declaredClasses.add(c);
+        }
+        // ns 兄弟类候选：跨文件同名 namespace（Intl 系）中后续文件的同名类持有该文件
+        // 声明的成员（等价旧 copyNamespace 互拷可见性；登记序 = DFS 文件序）。
+        if (bySig instanceof ArkClass_1.ArkClass) {
+            for (const sibling of SdkUtils_1.SdkUtils.getNamespacedSiblingClasses(bySig)) {
+                declaredClasses.add(sibling);
             }
         }
-        else {
+        if (methodName === TSConst_1.CONSTRUCTOR_NAME) {
+            return this.invokeConstructorOnClasses(expr, declaredClasses, baseType, methodName);
+        }
+        // 成员聚合：跨实体收集同名 method/field 候选（方法重载分散在各实体的场景，
+        // 如 ObjectConstructor.keys 的 es5/es2015.core 重载）。方法候选按"实参精确
+        // 匹配"优先——对齐旧胖类 matchMethodSignature 的 find(isMatched) ?? [0] 语义。
+        const methodCandidates = [];
+        const fieldCandidates = [];
+        for (const declaredClass of declaredClasses) {
             const member = ModelUtils_1.ModelUtils.findPropertyInClass(methodName, declaredClass);
-            method = member instanceof ArkClass_1.ArkClass ? (_d = member.getMethodWithName(Const_1.CALL_SIGNATURE_NAME)) !== null && _d !== void 0 ? _d : member.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME) : member;
+            if (member instanceof ArkClass_1.ArkClass) {
+                const m = (_a = member.getMethodWithName(Const_1.CALL_SIGNATURE_NAME)) !== null && _a !== void 0 ? _a : member.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME);
+                if (m) {
+                    methodCandidates.push({ method: m, declaredClass });
+                }
+            }
+            else if (member instanceof ArkMethod_1.ArkMethod) {
+                methodCandidates.push({ method: member, declaredClass });
+            }
+            else if (member instanceof ArkField_1.ArkField || member instanceof Local_1.Local) {
+                fieldCandidates.push({ member, declaredClass });
+            }
         }
-        if (method instanceof ArkMethod_1.ArkMethod) {
-            const methodSignature = method.matchMethodSignature(expr.getArgs());
-            TypeInference_1.TypeInference.inferSignatureReturnType(methodSignature, method);
-            expr.setMethodSignature(this.replaceMethodSignature(expr.getMethodSignature(), methodSignature));
-            expr.setRealGenericTypes(IRInference.getRealTypes(expr, declaredClass, baseType, method));
-            if (expr instanceof Expr_1.ArkInstanceInvokeExpr && (method.isStatic() || method.getDeclaringArkClass().isDefaultArkClass())) {
-                return new Expr_1.ArkStaticInvokeExpr(methodSignature, expr.getArgs(), expr.getRealGenericTypes());
+        for (const c of methodCandidates) {
+            if (this.methodMatchesArgs(c.method, expr.getArgs(), scene)) {
+                return this.invokeMatchedMethod(expr, c.method, c.declaredClass, baseType);
             }
-            return expr;
         }
-        else if (method instanceof ArkField_1.ArkField || method instanceof Local_1.Local) {
-            expr.setRealGenericTypes(IRInference.getRealTypes(expr, declaredClass, baseType));
-            return (_e = this.changePtrInvokeExpr(method, scene, expr)) !== null && _e !== void 0 ? _e : expr;
+        if (methodCandidates.length > 0) {
+            const c = methodCandidates[0];
+            return this.invokeMatchedMethod(expr, c.method, c.declaredClass, baseType);
+        }
+        for (const f of fieldCandidates) {
+            expr.setRealGenericTypes(IRInference.getRealTypes(expr, f.declaredClass, baseType));
+            return (_b = this.changePtrInvokeExpr(f.member, scene, expr)) !== null && _b !== void 0 ? _b : expr;
         }
         return null;
     }
+    /** Whether any declaration of the method matches the given args precisely (arg-count window + type match). */
+    static methodMatchesArgs(method, args, scene) {
+        var _a;
+        return ((_a = method.getDeclareSignatures()) !== null && _a !== void 0 ? _a : []).some((f) => {
+            const parameters = f.getMethodSubSignature().getParameters();
+            const max = parameters.length;
+            let min = 0;
+            while (min < max && !parameters[min].isOptional()) {
+                min++;
+            }
+            return args.length >= min && args.length <= max && ModelUtils_1.ModelUtils.isMatched(parameters, args, scene);
+        });
+    }
+    /** Bind the matched method onto the invoke expr (signature + generics + static conversion). */
+    static invokeMatchedMethod(expr, method, declaredClass, baseType) {
+        const methodSignature = method.matchMethodSignature(expr.getArgs());
+        TypeInference_1.TypeInference.inferSignatureReturnType(methodSignature, method);
+        expr.setMethodSignature(this.replaceMethodSignature(expr.getMethodSignature(), methodSignature));
+        expr.setRealGenericTypes(IRInference.getRealTypes(expr, declaredClass, baseType, method));
+        if (expr instanceof Expr_1.ArkInstanceInvokeExpr && (method.isStatic() || method.getDeclaringArkClass().isDefaultArkClass())) {
+            return new Expr_1.ArkStaticInvokeExpr(methodSignature, expr.getArgs(), expr.getRealGenericTypes());
+        }
+        return expr;
+    }
+    /**
+     * Constructor-call handling across candidate classes: the first candidate owning a
+     * real construct-signature / call / constructor method wins; when none does, the
+     * legacy stub signature (over the base type) is kept.
+     */
+    static invokeConstructorOnClasses(expr, declaredClasses, baseType, methodName) {
+        var _a, _b;
+        for (const declaredClass of declaredClasses) {
+            const method = (_b = (_a = declaredClass.getMethodWithName(Const_1.CONSTRUCT_SIGNATURE_NAME)) !== null && _a !== void 0 ? _a : declaredClass.getMethodWithName(Const_1.CALL_SIGNATURE_NAME)) !== null && _b !== void 0 ? _b : declaredClass.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME);
+            if (method) {
+                return this.invokeMatchedMethod(expr, method, declaredClass, baseType);
+            }
+        }
+        // No-constructor fallback (built-in lib classes behind the var-side XxxConstructor
+        // pattern, declare-only classes, C++ structs with an implicit default constructor, ...):
+        // swap in the resolved-sh signature unconditionally — the declaring side is the
+        // resolved baseType's class signature, so the MethodSignature object overload routes
+        // the declaring class through the formal hit path (no clear+miss error route), and
+        // no model registration happens here. Guarding this with a formal probe would strand
+        // the expr on its build-time %unk stub whenever the constructor has no declaration
+        // (C++ includeInScope MyStruct regression).
+        const subSignature = new ArkSignature_1.MethodSubSignature(methodName, [], new Type_1.ClassType(baseType.getClassSignature()));
+        expr.setMethodSignature(new ArkSignature_1.MethodSignature(baseType.getClassSignature(), subSignature));
+        return expr;
+    }
     static inferSpecialMethod(expr, baseType, methodName) {
-        if (methodName === Builtin_1.Builtin.ITERATOR_NEXT &&
-            baseType.getClassSignature().getDeclaringFileSignature().getProjectName() === Builtin_1.Builtin.DUMMY_PROJECT_NAME) {
+        // Fires only on the UNRESOLVED iterator stub (old: virtual 'ES2015' project check).
+        // Resolved SDK IterableIterator types take the normal declared-class path below.
+        if (methodName === Builtin_1.Builtin.ITERATOR_NEXT && baseType.getClassSigID() === -1 && baseType.getClassSignature().getClassName() === Builtin_1.Builtin.ITERATOR) {
             expr.getMethodSignature().getMethodSubSignature().setReturnType(Builtin_1.Builtin.ITERATOR_RESULT_CLASS_TYPE);
             expr.setRealGenericTypes(baseType.getRealGenericTypes());
             return expr;
@@ -494,7 +650,7 @@ class IRInference {
     static changePtrInvokeExpr(method, scene, expr) {
         var _a;
         let type = method.getType();
-        if (expr.getRealGenericTypes() && TypeInference_1.TypeInference.checkType(type, t => t instanceof Type_1.GenericType || t instanceof Type_1.AnyType)) {
+        if (expr.getRealGenericTypes() && TypeInference_1.TypeInference.checkType(type, IS_GENERIC_OR_ANY)) {
             type = TypeInference_1.TypeInference.replaceTypeWithReal(type, expr.getRealGenericTypes());
         }
         if (type instanceof Type_1.UnionType) {
@@ -518,8 +674,9 @@ class IRInference {
             }
         }
         if (methodSignature) {
-            const ptr = method instanceof Local_1.Local ? method :
-                expr instanceof Expr_1.ArkInstanceInvokeExpr
+            const ptr = method instanceof Local_1.Local
+                ? method
+                : expr instanceof Expr_1.ArkInstanceInvokeExpr
                     ? new Ref_1.ArkInstanceFieldRef(expr.getBase(), method.getSignature())
                     : new Ref_1.ArkStaticFieldRef(method.getSignature());
             return new Expr_1.ArkPtrInvokeExpr(methodSignature, ptr, expr.getArgs(), expr.getRealGenericTypes());
@@ -531,10 +688,12 @@ class IRInference {
         let realTypes;
         const tmp = [];
         if (method === null || method === void 0 ? void 0 : method.getGenericTypes()) {
-            expr.getMethodSignature().getMethodSubSignature().getParameters()
+            expr.getMethodSignature()
+                .getMethodSubSignature()
+                .getParameters()
                 .filter(p => !p.getName().startsWith(Const_1.LEXICAL_ENV_NAME_PREFIX))
                 .forEach((p, i) => {
-                if (TypeInference_1.TypeInference.checkType(p.getType(), t => t instanceof Type_1.GenericType)) {
+                if (TypeInference_1.TypeInference.checkType(p.getType(), IS_GENERIC)) {
                     tmp.push(expr.getArg(i).getType());
                 }
             });
@@ -553,12 +712,20 @@ class IRInference {
     static replaceMethodSignature(init, declared) {
         const className = init.getDeclaringClassSignature().getClassName();
         let classSignature;
-        if (declared.getDeclaringClassSignature().getClassName().endsWith('Interface')) {
+        // display 归一化：仅当 init 类名有信息量（非 %unk——组件 create/pop 的 init 由组件名直构）时包 alias。普通 interface 解析（init 为 %unk stub，
+        // 如 TestInterface.callf）直接用 declared——alias 会把显示退化为 %unk。
+        if (className !== Const_1.UNKNOWN_CLASS_NAME && declared.getDeclaringClassSignature().getClassName().endsWith('Interface')) {
             classSignature = new ArkSignature_1.AliasClassSignature(className, declared.getDeclaringClassSignature());
         }
         let newSubSignature;
         if (classSignature || newSubSignature) {
-            return new ArkSignature_1.MethodSignature(classSignature !== null && classSignature !== void 0 ? classSignature : declared.getDeclaringClassSignature(), newSubSignature !== null && newSubSignature !== void 0 ? newSubSignature : declared.getMethodSubSignature());
+            const result = new ArkSignature_1.MethodSignature(classSignature !== null && classSignature !== void 0 ? classSignature : declared.getDeclaringClassSignature(), newSubSignature !== null && newSubSignature !== void 0 ? newSubSignature : declared.getMethodSubSignature());
+            // display 归一化：alias 产物 intern formal + 双注册 declared 的 ArkMethod model——expr 的 route() formal 命中持 SigID（display 由 formal
+            // canonical 自持，不再依赖 expr 锚定传入实例）。
+            if (classSignature !== undefined) {
+                (0, ArkSignature_1.internAliasMethodSignature)(result, declared);
+            }
+            return result;
         }
         return declared;
     }
@@ -585,7 +752,7 @@ class IRInference {
         }
     }
     static inferLocal(base, arkMethod) {
-        var _a, _b;
+        var _a;
         const arkClass = arkMethod.getDeclaringArkClass();
         let baseType = base.getType();
         if (baseType instanceof Type_1.UnclearReferenceType) {
@@ -594,7 +761,7 @@ class IRInference {
         else if (TypeInference_1.TypeInference.isUnclearType(baseType)) {
             const declaringStmt = base.getDeclaringStmt();
             if (!declaringStmt) {
-                baseType = (_b = (_a = ModelUtils_1.ModelUtils.findDeclaredLocal(base, arkMethod)) === null || _a === void 0 ? void 0 : _a.getType()) !== null && _b !== void 0 ? _b : TypeInference_1.TypeInference.inferBaseType(base.getName(), arkClass);
+                baseType = (_a = ModelUtils_1.ModelUtils.findDeclaredLocalType(base.getName(), arkMethod)) !== null && _a !== void 0 ? _a : TypeInference_1.TypeInference.inferBaseType(base.getName(), arkClass);
             }
         }
         if (baseType instanceof Type_1.UnionType || (baseType && !TypeInference_1.TypeInference.isUnclearType(baseType))) {
@@ -607,7 +774,7 @@ class IRInference {
             // Convert primitive types to their wrapper class types
             const name = baseType instanceof Type_1.LiteralType ? typeof baseType.getLiteralName() : baseType.getName();
             const className = baseType instanceof Type_1.BigIntType ? Builtin_1.Builtin.BIGINT : name.charAt(0).toUpperCase() + name.slice(1);
-            const arrayClass = arkMethod.getDeclaringArkFile().getScene().getSdkGlobal(className);
+            const arrayClass = SdkUtils_1.SdkUtils.getSdkGlobal(className);
             if (arrayClass instanceof ArkClass_1.ArkClass) {
                 return inferMember(new Type_1.ClassType(arrayClass.getSignature(), arrayClass.getRealTypes()), value, arkMethod);
             }
@@ -642,9 +809,10 @@ class IRInference {
                 if (type instanceof Type_1.UndefinedType || type instanceof Type_1.NullType) {
                     continue;
                 }
-                let newFieldSignature = this.generateNewFieldSignature(ref, arkClass, type);
-                if (!TypeInference_1.TypeInference.isUnclearType(newFieldSignature === null || newFieldSignature === void 0 ? void 0 : newFieldSignature.getType())) {
-                    return newFieldSignature;
+                let resolution = this.generateNewFieldSignature(ref, arkClass, type);
+                // Union 试探按 resolution.type 判 unclear（formal 分支带定义点 type，params 分支即构造 type——零实例读取）。
+                if (resolution !== null && !TypeInference_1.TypeInference.isUnclearType(resolution.type)) {
+                    return resolution;
                 }
             }
             return null;
@@ -653,7 +821,7 @@ class IRInference {
             return this.generateNewFieldSignature(ref, arkClass, baseType.getOriginalType());
         }
         else if (baseType instanceof Type_1.ArrayType) {
-            const arrayClass = arkClass.getDeclaringArkFile().getScene().getSdkGlobal(Builtin_1.Builtin.ARRAY);
+            const arrayClass = SdkUtils_1.SdkUtils.getSdkGlobal(Builtin_1.Builtin.ARRAY);
             if (arrayClass instanceof ArkClass_1.ArkClass) {
                 baseType = new Type_1.ClassType(arrayClass.getSignature(), [baseType.getBaseType()]);
             }
@@ -661,77 +829,104 @@ class IRInference {
         return IRInference.getFieldSignature(ref, baseType, arkClass);
     }
     static updateRefSignature(baseType, ref, arkMethod) {
+        var _a, _b, _c;
         const fieldName = ref.getFieldName().replace(/[\"|\']/g, '');
         if (baseType instanceof Type_1.TupleType) {
-            const n = Number(fieldName);
-            if (!isNaN(n) && n < baseType.getTypes().length) {
-                ref.getFieldSignature().setType(baseType.getTypes()[n]);
-            }
-            return ref;
+            return this.updateTupleElementType(ref, fieldName, baseType);
         }
-        else if (baseType instanceof Type_1.ArrayType) {
+        if (baseType instanceof Type_1.ArrayType) {
             if (ref instanceof Ref_1.ArkInstanceFieldRef && ref.isDynamic()) {
-                const index = TypeInference_1.TypeInference.getLocalFromMethodBody(fieldName, arkMethod);
-                return new Ref_1.ArkArrayRef(ref.getBase(), index !== null && index !== void 0 ? index : ValueUtil_1.ValueUtil.createConst(fieldName));
+                // dynamic ref 被 ArkArrayRef 替换——纯 retire。
+                ref.retireTemp();
+                return new Ref_1.ArkArrayRef(ref.getBase(), (_a = TypeInference_1.TypeInference.getLocalFromMethodBody(fieldName, arkMethod)) !== null && _a !== void 0 ? _a : ValueUtil_1.ValueUtil.createConst(fieldName));
             }
-            else {
-                const arrayClass = arkMethod.getDeclaringArkFile().getScene().getSdkGlobal(Builtin_1.Builtin.ARRAY);
-                if (arrayClass instanceof ArkClass_1.ArkClass) {
-                    baseType = new Type_1.ClassType(arrayClass.getSignature(), [baseType.getBaseType()]);
-                }
+            const arrayClass = SdkUtils_1.SdkUtils.getSdkGlobal(Builtin_1.Builtin.ARRAY);
+            if (arrayClass instanceof ArkClass_1.ArkClass) {
+                baseType = new Type_1.ClassType(arrayClass.getSignature(), [baseType.getBaseType()]);
             }
         }
         else if (baseType instanceof Type_1.FunctionType) {
-            const arrayClass = arkMethod.getDeclaringArkFile().getScene().getSdkGlobal(Builtin_1.Builtin.FUNCTION);
+            const arrayClass = SdkUtils_1.SdkUtils.getSdkGlobal(Builtin_1.Builtin.FUNCTION);
             if (arrayClass instanceof ArkClass_1.ArkClass) {
                 baseType = new Type_1.ClassType(arrayClass.getSignature());
             }
         }
-        let { staticFlag, signature, value } = IRInference.genFieldSignature(fieldName, baseType, ref, arkMethod);
-        if (value) {
-            return value;
-        }
-        if (!signature) {
+        const resolution = IRInference.genFieldSignature(fieldName, baseType, ref, arkMethod);
+        if (resolution === null || (resolution.kind === 'formal' && ((_b = resolution.formalId) !== null && _b !== void 0 ? _b : 0) <= 0)) {
             return null;
         }
-        if (staticFlag) {
-            return new Ref_1.ArkStaticFieldRef(signature);
+        if (resolution.kind === 'getter') {
+            // 替换埋葬：getter 裸引用被 invokeExpr 替换——纯 retire（产物无字段归宿）。
+            ref.retireTemp();
+            return resolution.value;
         }
-        else {
-            ref.setFieldSignature(signature);
+        if (resolution.kind === 'params') {
+            if (resolution.staticFlag) {
+                return IRInference.applyStaticParamsResolution(ref, resolution);
+            }
+            ref.updateFieldSignature(resolution.fieldName, resolution.declaringOrID, resolution.type, resolution.staticFlag, resolution.namespaceDeclared);
             return ref;
         }
+        const formalId = (_c = resolution.formalId) !== null && _c !== void 0 ? _c : 0;
+        if (resolution.staticFlag) {
+            ref.retireTempTo(formalId);
+            return new Ref_1.ArkStaticFieldRef(SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().fieldSigCanonicalizer.get(formalId));
+        }
+        ref.graduateToFormal(formalId);
+        return ref;
+    }
+    /** TupleType 前置：元组索引字段的类型直写（'0'/'1' → 对应元素类型）。 */
+    static updateTupleElementType(ref, fieldName, baseType) {
+        const n = Number(fieldName);
+        if (!isNaN(n) && n < baseType.getTypes().length) {
+            ref.getFieldSignature().setType(baseType.getTypes()[n]);
+        }
+        return ref;
     }
     static genFieldSignature(fieldName, baseType, ref, arkMethod) {
         var _a;
         const arkClass = arkMethod.getDeclaringArkClass();
         const propertyAndType = TypeInference_1.TypeInference.inferFieldType(baseType, fieldName, arkClass);
         let propertyType = IRInference.repairType(propertyAndType === null || propertyAndType === void 0 ? void 0 : propertyAndType[1], fieldName, arkClass);
-        let staticFlag = false;
-        let signature = null;
         if (baseType instanceof Type_1.ClassType) {
             const property = (_a = propertyAndType === null || propertyAndType === void 0 ? void 0 : propertyAndType[0]) !== null && _a !== void 0 ? _a : IRInference.findPropertyFormChildrenClass(fieldName, arkClass, baseType);
             if (property instanceof ArkMethod_1.ArkMethod && property.getName().startsWith(Const_1.GETTER_PREFIX) && ref instanceof Ref_1.ArkInstanceFieldRef) {
-                const expr = property.isStatic() ? new Expr_1.ArkStaticInvokeExpr(property.getSignature(), [])
+                const expr = property.isStatic()
+                    ? new Expr_1.ArkStaticInvokeExpr(property.getSignature(), [])
                     : new Expr_1.ArkInstanceInvokeExpr(ref.getBase(), property.getSignature(), []);
-                return { staticFlag: staticFlag, signature: signature, value: expr };
+                return { kind: 'getter', value: expr };
             }
-            staticFlag = baseType.getClassSignature().getClassName() === Const_1.DEFAULT_ARK_CLASS_NAME ||
+            const staticFlag = baseType.getClassSignature().getClassName() === Const_1.DEFAULT_ARK_CLASS_NAME ||
                 ((property instanceof ArkField_1.ArkField || property instanceof ArkMethod_1.ArkMethod) && property.isStatic());
-            if (property instanceof ArkField_1.ArkField && property.getCategory() !== ArkField_1.FieldCategory.ENUM_MEMBER &&
-                !(property.getType() instanceof Type_1.GenericType)) {
-                signature = property.getSignature();
-            }
-            else {
-                const baseSignature = property instanceof ArkMethod_1.ArkMethod ? property.getSignature().getDeclaringClassSignature() : baseType.getClassSignature();
-                signature = new ArkSignature_1.FieldSignature(fieldName, baseSignature, propertyType !== null && propertyType !== void 0 ? propertyType : ref.getType(), staticFlag);
+            if (property instanceof ArkField_1.ArkField && property.getCategory() !== ArkField_1.FieldCategory.ENUM_MEMBER) {
+                // 非泛型与泛型字段统一用定义点签名（formal 身份）。泛型字段（定义点 type 为 GenericType）的使用点实例化由 ref.realFieldTypes 承载
+                // （Expr.realGenericTypes 同构，getType() 动态组合）。实参表从 baseType 提取（与 inferFieldType 的 replaceTypeWithReal 同源）。
+                // 实参表残留无害：getType 的 Generic/Any 守卫使非泛型 type 不受影响。
+                if (property.getType() instanceof Type_1.GenericType) {
+                    ref.setRealFieldTypes(baseType.getRealGenericTypes());
+                }
+                let fieldType = property.getType();
+                if (TypeInference_1.TypeInference.isUnclearType(fieldType)) {
+                    fieldType = this.refineFieldTypeFromBaseInitializer(ref, property, fieldName, fieldType, arkMethod);
+                }
+                return { kind: 'formal', formalId: property.getFieldSigID(), staticFlag, type: fieldType };
             }
+            // getClassSignature() (not getClassSigID()): the class may still be unclear and
+            // live in the temp canonicalizer; the object overload interns it properly.
+            const baseSignature = property instanceof ArkMethod_1.ArkMethod ? property.getSignature().getDeclaringClassSignature() : baseType.getClassSignature();
+            return { kind: 'params', fieldName, declaringOrID: baseSignature, type: propertyType !== null && propertyType !== void 0 ? propertyType : ref.getType(), staticFlag, namespaceDeclared: false };
         }
         else if (baseType instanceof Type_1.AnnotationNamespaceType) {
-            staticFlag = true;
-            signature = new ArkSignature_1.FieldSignature(fieldName, baseType.getNamespaceSignature(), propertyType !== null && propertyType !== void 0 ? propertyType : ref.getType(), staticFlag);
+            return {
+                kind: 'params',
+                fieldName,
+                declaringOrID: baseType.getNamespaceSignature().getNamespaceSigID(),
+                type: propertyType !== null && propertyType !== void 0 ? propertyType : ref.getType(),
+                staticFlag: true,
+                namespaceDeclared: true,
+            };
         }
-        return { staticFlag, signature };
+        return null;
     }
     static getFieldSignature(ref, baseType, arkClass) {
         const fieldName = ref.getFieldName().replace(/[\"|\']/g, '');
@@ -747,17 +942,33 @@ class IRInference {
                     property = subField;
                 }
             }
-            else if (property instanceof ArkField_1.ArkField && property.getCategory() !== ArkField_1.FieldCategory.ENUM_MEMBER &&
-                !(property.getType() instanceof Type_1.GenericType)) {
-                return property.getSignature();
-            }
-            staticFlag = baseType.getClassSignature().getClassName() === Const_1.DEFAULT_ARK_CLASS_NAME ||
-                ((property instanceof ArkField_1.ArkField || property instanceof ArkMethod_1.ArkMethod) && property.isStatic());
+            else if (property instanceof ArkField_1.ArkField && property.getCategory() !== ArkField_1.FieldCategory.ENUM_MEMBER) {
+                // 非泛型与泛型字段统一返回定义点签名；泛型字段的使用点实例化由 ref.realFieldTypes 承载（与 genFieldSignature 分支同构）。
+                if (property.getType() instanceof Type_1.GenericType) {
+                    ref.setRealFieldTypes(baseType.getRealGenericTypes());
+                }
+                let fieldType = property.getType();
+                if (TypeInference_1.TypeInference.isUnclearType(fieldType)) {
+                    fieldType = this.refineFieldTypeFromBaseInitializer(ref, property, fieldName, fieldType);
+                }
+                // 定义点 canonical——formalId 直读（终点确定）。
+                return { kind: 'formal', formalId: property.getFieldSigID(), staticFlag: property.isStatic(), type: fieldType };
+            }
+            staticFlag =
+                baseType.getClassSignature().getClassName() === Const_1.DEFAULT_ARK_CLASS_NAME ||
+                    ((property instanceof ArkField_1.ArkField || property instanceof ArkMethod_1.ArkMethod) && property.isStatic());
+            // Note: baseType.getClassSignature() (not getClassSigID()) — the class may still be
+            // unclear and live in the temp canonicalizer (classSigID === -1); the object overload
+            // interns it properly.
             signature = property instanceof ArkMethod_1.ArkMethod ? property.getSignature().getDeclaringClassSignature() : baseType.getClassSignature();
         }
         else if (baseType instanceof Type_1.ArrayType) {
             const property = propertyAndType === null || propertyAndType === void 0 ? void 0 : propertyAndType[0];
-            return property instanceof ArkField_1.ArkField ? property.getSignature() : null;
+            if (property instanceof ArkField_1.ArkField) {
+                // 定义点 canonical（Array 字段）。
+                return { kind: 'formal', formalId: property.getFieldSigID(), staticFlag: property.isStatic(), type: property.getType() };
+            }
+            return null;
         }
         else if (baseType instanceof Type_1.AnnotationNamespaceType) {
             staticFlag = true;
@@ -766,24 +977,80 @@ class IRInference {
         else {
             return null;
         }
-        return new ArkSignature_1.FieldSignature(fieldName, signature, propertyType !== null && propertyType !== void 0 ? propertyType : ref.getType(), staticFlag);
+        // 新构造值（终点不确定）——参数元组。
+        return signature instanceof ArkSignature_1.NamespaceSignature
+            ? {
+                kind: 'params',
+                fieldName,
+                declaringOrID: signature.getNamespaceSigID(),
+                type: propertyType !== null && propertyType !== void 0 ? propertyType : ref.getType(),
+                staticFlag,
+                namespaceDeclared: true,
+            }
+            : { kind: 'params', fieldName, declaringOrID: signature, type: propertyType !== null && propertyType !== void 0 ? propertyType : ref.getType(), staticFlag, namespaceDeclared: false };
+    }
+    /**
+     * 声明类型路径的字段类型 unclear（如 interface 无标注字段的声明类型路径）时的值类型精化：
+     * base local 的初始化 stmt（declaringStmt）右值类型是 clear ClassType（对象字面量匿名类等）
+     * 时，取值类型上同名字段的定义点类型回填。fieldSig 保持声明锚定不变，仅经精度栅栏单向
+     * 精化 formal canonical 的类型（unclear → clear，与 AbstractFieldRef.route 的栅栏同语义）。
+     * base 是全局变量的使用点 local（无方法内定义 stmt）时，经 findDeclaredLocal 桥接文件级
+     * def local（顶层 const 的初始化在 default 方法中）。
+     */
+    static refineFieldTypeFromBaseInitializer(ref, property, fieldName, unclearType, arkMethod) {
+        if (!(ref instanceof Ref_1.ArkInstanceFieldRef)) {
+            return unclearType;
+        }
+        const base = ref.getBase();
+        if (!(base instanceof Local_1.Local)) {
+            return unclearType;
+        }
+        let declaringStmt = base.getDeclaringStmt();
+        if (!(declaringStmt instanceof Stmt_1.ArkAssignStmt) && arkMethod !== undefined) {
+            const declaredLocal = ModelUtils_1.ModelUtils.findDeclaredLocal(base, arkMethod, 1);
+            const declaredStmt = declaredLocal === null || declaredLocal === void 0 ? void 0 : declaredLocal.getDeclaringStmt();
+            if (declaredStmt instanceof Stmt_1.ArkAssignStmt) {
+                declaringStmt = declaredStmt;
+            }
+        }
+        if (!(declaringStmt instanceof Stmt_1.ArkAssignStmt)) {
+            return unclearType;
+        }
+        const valueType = declaringStmt.getRightOp().getType();
+        if (!(valueType instanceof Type_1.ClassType) || TypeInference_1.TypeInference.isUnclearType(valueType)) {
+            return unclearType;
+        }
+        const registry = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        const valueClass = registry.getClassById(valueType.getClassSigID());
+        const valueField = valueClass === null || valueClass === void 0 ? void 0 : valueClass.getFieldWithName(fieldName);
+        if (!valueField) {
+            return unclearType;
+        }
+        const refinedType = valueField.getType();
+        if (TypeInference_1.TypeInference.isUnclearType(refinedType)) {
+            return unclearType;
+        }
+        const canonical = registry.fieldSigCanonicalizer.get(property.getFieldSigID());
+        if (canonical !== undefined && canonical.getType().isUnclear()) {
+            canonical.setType(refinedType);
+        }
+        return refinedType;
     }
     static findPropertyFormChildrenClass(fieldName, arkClass, baseType) {
         var _a;
-        if (baseType.getClassSignature().getClassName() !== Const_1.DEFAULT_ARK_CLASS_NAME &&
-            baseType.getClassSignature().getDeclaringFileSignature().getProjectName() !== Builtin_1.Builtin.DUMMY_PROJECT_NAME) {
-            const iterator = (_a = arkClass.getDeclaringArkFile().getScene().getClass(baseType.getClassSignature())) === null || _a === void 0 ? void 0 : _a.getExtendedClasses().values();
-            if (!iterator) {
+        const registry = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        if (baseType.getClassSignature().getClassName() !== Const_1.DEFAULT_ARK_CLASS_NAME) {
+            // Unclear stubs have no formal model, so getClassBySig returns undefined for
+            // them — the extended-class lookup below is naturally skipped (read-only lookup).
+            const extendedClasses = (_a = registry.getClassBySig(baseType.getClassSignature())) === null || _a === void 0 ? void 0 : _a.getExtendedClassList();
+            if (!extendedClasses) {
                 return null;
             }
-            let next = iterator.next();
-            while (!next.done) {
-                const subClass = next.value;
+            for (const subClass of extendedClasses) {
                 const property = TypeInference_1.TypeInference.inferFieldType(new Type_1.ClassType(subClass.getSignature(), subClass.getRealTypes()), fieldName, subClass);
                 if (property && property[0]) {
                     return property[0];
                 }
-                next = iterator.next();
             }
         }
         return null;
@@ -830,7 +1097,9 @@ class IRInference {
                     this.assignAnonMethod(scene.getMethod(type.getMethodSignature()), property);
                 }
                 if (type instanceof Type_1.UnknownType) {
-                    anonField.setSignature(new ArkSignature_1.FieldSignature(anonField.getName(), property.getDeclaringArkClass().getSignature(), new Type_1.FunctionType(property.getSignature())));
+                    // 类型对齐而非签名过户：同 assignAnonField——只补类型，不把匿名字段
+                    // intern 到声明类名下（防 model 顶替写穿）。
+                    anonField.getSignature().setType(new Type_1.FunctionType(property.getSignature()));
                 }
             }
         }
@@ -872,10 +1141,22 @@ class IRInference {
             }
             const leftOp = lastStmt.getLeftOp();
             if (leftOp instanceof Ref_1.AbstractFieldRef) {
-                leftOp.setFieldSignature(property.getSignature());
-            }
+                // A2 快路径：定义点 canonical 回写（property 为 ArkField，ID 直读）。
+                leftOp.graduateToFormal(property.getFieldSigID());
+            }
+        }
+        // 类型对齐而非签名过户：只把声明侧类型拷贝到匿名类字段的自有 canonical 签名
+        //（type 不参与 FieldSignature 的 hash/equals，改动无 ID 影响）。不再
+        // setSignature(property.getSignature())——那会把匿名字段注册到 SDK 字段的
+        // FieldSigID 名下、顶替其全局 model，导致 SDK 类字段视图读到匿名字段实例
+        //（initializer 写穿，见对象字面量赋值 SDK 类型的回归用例）。
+        // 精确类型优先（narrowing）：initializer 已推导出的精确类型（枚举成员
+        // EnumValueType、number、string 等）保留；SDK 声明类型仅在匿名字段自身
+        // 类型仍 unclear/unknown 时兜底（对齐 resolveLeftOp 对 localDef 的
+        // "只增强、不覆盖"守卫模式）。
+        if (TypeInference_1.TypeInference.isUnclearType(anonField.getSignature().getType())) {
+            anonField.getSignature().setType(property.getSignature().getType());
         }
-        anonField.setSignature(property.getSignature());
     }
     static inferAliasTypeExpr(expr, arkMethod) {
         const originalObject = expr.getOriginalObject();