arkanalyzer 1.0.94 → 2.0.0-beta1

package/lib/core/common/TypeInference.js

@@ -44,7 +44,6 @@ const Local_1 = require("../base/Local");
 const Ref_1 = require("../base/Ref");
 const Stmt_1 = require("../base/Stmt");
 const Type_1 = require("../base/Type");
-const Type_2 = require("../../frontend/cppFrontend/base/Type");
 const ArkMethod_1 = require("../model/ArkMethod");
 const ArkClass_1 = require("../model/ArkClass");
 const ArkField_1 = require("../model/ArkField");
@@ -61,8 +60,25 @@ const IRInference_1 = require("./IRInference");
 const TypeExpr_1 = require("../base/TypeExpr");
 const SdkUtils_1 = require("./SdkUtils");
 const ArkBaseModel_1 = require("../model/ArkBaseModel");
+const SignatureCanonicalizerRegistry_1 = require("./SignatureCanonicalizerRegistry");
+const SignatureCanonicalizer_1 = require("./SignatureCanonicalizer");
 const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'TypeInference');
-const unknownFileName = [Const_1.UNKNOWN_FILE_NAME, Builtin_1.Builtin.DUMMY_FILE_NAME];
+const resolveUsesScratch = [null];
+const inferVisited = new Type_1.ArrayUnclearVisited();
+// Builtin stub signatures carry FileSignature.DEFAULT whose fileName is UNKNOWN_FILE_NAME,
+// so a single entry covers both unresolved references and builtin stubs.
+const unknownFileName = [Const_1.UNKNOWN_FILE_NAME];
+const IS_ANY = (t) => t instanceof Type_1.AnyType;
+const IS_UNCLEAR_REF_OR_GENERIC = (t) => t instanceof Type_1.UnclearReferenceType || t instanceof Type_1.GenericType;
+const CAN_RECURSE = (t) => t instanceof Type_1.ClassType ||
+    t instanceof Type_1.FunctionType ||
+    t instanceof Type_1.UnionType ||
+    t instanceof Type_1.IntersectionType ||
+    t instanceof Type_1.TupleType ||
+    t instanceof Type_1.ArrayType ||
+    t instanceof Type_1.AliasType ||
+    t instanceof TypeExpr_1.KeyofTypeExpr ||
+    t instanceof TypeExpr_1.TypeQueryExpr;
 class TypeInference {
     static inferTypeInArkField(arkField) {
         var _a, _b;
@@ -93,11 +109,11 @@ class TypeInference {
         }
         if (fieldType) {
             arkField.getSignature().setType(fieldType);
-            fieldRef === null || fieldRef === void 0 ? void 0 : fieldRef.setFieldSignature(arkField.getSignature());
+            fieldRef === null || fieldRef === void 0 ? void 0 : fieldRef.graduateToFormal(arkField.getFieldSigID());
         }
         else if (rightType && this.isUnclearType(beforeType) && !this.isUnclearType(rightType)) {
             arkField.getSignature().setType(rightType);
-            fieldRef === null || fieldRef === void 0 ? void 0 : fieldRef.setFieldSignature(arkField.getSignature());
+            fieldRef === null || fieldRef === void 0 ? void 0 : fieldRef.graduateToFormal(arkField.getFieldSigID());
         }
     }
     /**
@@ -108,9 +124,23 @@ class TypeInference {
      * @param leftOpType
      * @param declaringArkClass
      * @param visited
+     * @param arkMethod - optional; propagated to unclear-name resolution so classes declared
+     *        inside the method scope chain resolve deterministically (local-class lookup).
      * @returns
      */
-    static inferUnclearedType(leftOpType, declaringArkClass, visited = new Set()) {
+    static inferUnclearedType(leftOpType, declaringArkClass, visited, arkMethod) {
+        if (visited !== undefined) {
+            return this.inferUnclearedTypeWithVisited(leftOpType, declaringArkClass, visited, arkMethod);
+        }
+        const prevBase = inferVisited.enter();
+        try {
+            return this.inferUnclearedTypeWithVisited(leftOpType, declaringArkClass, inferVisited, arkMethod);
+        }
+        finally {
+            inferVisited.leave(prevBase);
+        }
+    }
+    static inferUnclearedTypeWithVisited(leftOpType, declaringArkClass, visited, arkMethod) {
         if (visited.has(leftOpType)) {
             return leftOpType;
         }
@@ -121,7 +151,7 @@ class TypeInference {
         if (leftOpType instanceof Type_1.ClassType && unknownFileName.includes(leftOpType.getClassSignature().getDeclaringFileSignature().getFileName())) {
             const realTypes = leftOpType.getRealGenericTypes();
             this.inferRealGenericTypes(realTypes, declaringArkClass);
-            let newType = TypeInference.inferUnclearRefName(leftOpType.getClassSignature().getClassName(), declaringArkClass);
+            let newType = TypeInference.inferUnclearRefName(leftOpType.getClassSignature().getClassName(), declaringArkClass, arkMethod);
             type = newType ? this.replaceTypeWithReal(newType, realTypes) : null;
         }
         else if (leftOpType instanceof TypeExpr_1.TypeQueryExpr) {
@@ -140,20 +170,20 @@ class TypeInference {
             type = this.inferBaseType(leftOpType.getOriginType(), declaringArkClass);
         }
         else if (leftOpType instanceof Type_1.UnclearReferenceType) {
-            type = this.inferUnclearRefType(leftOpType, declaringArkClass);
+            type = this.inferUnclearRefType(leftOpType, declaringArkClass, arkMethod);
         }
         if (type) {
             return type;
         }
-        return TypeInference.inferUnclearComplexType(leftOpType, declaringArkClass, visited);
+        return TypeInference.inferUnclearComplexType(leftOpType, declaringArkClass, visited, arkMethod);
     }
-    static inferUnclearComplexType(leftOpType, declaringArkClass, visited) {
-        var _a;
+    static inferUnclearComplexType(leftOpType, declaringArkClass, visited, arkMethod) {
+        const registry = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
         let type;
         if (leftOpType instanceof Type_1.UnionType || leftOpType instanceof Type_1.IntersectionType || leftOpType instanceof Type_1.TupleType) {
             let types = leftOpType.getTypes();
             for (let i = 0; i < types.length; i++) {
-                let newType = this.inferUnclearedType(types[i], declaringArkClass, visited);
+                let newType = this.inferUnclearedType(types[i], declaringArkClass, visited, arkMethod);
                 if (newType) {
                     types[i] = newType;
                 }
@@ -161,22 +191,23 @@ class TypeInference {
             type = leftOpType;
         }
         else if (leftOpType instanceof Type_1.ArrayType) {
-            let baseType = this.inferUnclearedType(leftOpType.getBaseType(), declaringArkClass, visited);
+            let baseType = this.inferUnclearedType(leftOpType.getBaseType(), declaringArkClass, visited, arkMethod);
             if (baseType) {
                 leftOpType.setBaseType(baseType);
                 type = leftOpType;
             }
         }
         else if (leftOpType instanceof Type_1.AliasType) {
-            const defArkClass = (_a = declaringArkClass.getDeclaringArkFile().getScene().getMethod(leftOpType.getSignature().getDeclaringMethodSignature())) === null || _a === void 0 ? void 0 : _a.getDeclaringArkClass();
-            let baseType = this.inferUnclearedType(leftOpType.getOriginalType(), defArkClass !== null && defArkClass !== void 0 ? defArkClass : declaringArkClass, visited);
+            const defArkMethod = registry.getMethodBySig(leftOpType.getSignature().getDeclaringMethodSignature());
+            const defArkClass = defArkMethod === null || defArkMethod === void 0 ? void 0 : defArkMethod.getDeclaringArkClass();
+            let baseType = this.inferUnclearedType(leftOpType.getOriginalType(), defArkClass !== null && defArkClass !== void 0 ? defArkClass : declaringArkClass, visited, defArkMethod);
             if (baseType) {
                 leftOpType.setOriginalType(baseType);
                 type = leftOpType;
             }
         }
         else if (leftOpType instanceof TypeExpr_1.KeyofTypeExpr) {
-            let baseType = this.inferUnclearedType(leftOpType.getOpType(), declaringArkClass, visited);
+            let baseType = this.inferUnclearedType(leftOpType.getOpType(), declaringArkClass, visited, arkMethod);
             if (baseType) {
                 leftOpType.setOpType(baseType);
                 type = leftOpType;
@@ -210,7 +241,10 @@ class TypeInference {
             if (value instanceof Ref_1.GlobalRef && !value.getRef()) {
                 const arkExport = ModelUtils_1.ModelUtils.findGlobalRef(key, arkMethod);
                 if (arkExport instanceof Local_1.Local) {
-                    arkExport.getUsedStmts().push(...value.getUsedStmts());
+                    const usedStmts = value.getUsedStmts();
+                    for (let i = 0; i < usedStmts.length; i++) {
+                        arkExport.addUsedStmt(usedStmts[i]);
+                    }
                     value.setRef(arkExport);
                 }
             }
@@ -232,7 +266,9 @@ class TypeInference {
             this.resolveArkReturnStmt(stmt, arkMethod);
         }
         catch (e) {
-            logger.warn('stmt is not correct: ' + stmt.toString());
+            if (logger_1.default.isWarnEnabled(logger)) {
+                logger.warn('stmt is not correct: ' + stmt.toString());
+            }
         }
     }
     /**
@@ -261,21 +297,12 @@ class TypeInference {
      * such as ArkInstanceInvokeExpr ArkStaticInvokeExpr ArkNewExpr
      */
     static resolveExprsInStmt(stmt, arkMethod) {
-        var _a;
         for (const expr of stmt.getExprs()) {
             const newExpr = expr.inferType(arkMethod);
             if (stmt.containsInvokeExpr() &&
                 ((expr instanceof Expr_1.ArkInstanceInvokeExpr && newExpr instanceof Expr_1.ArkStaticInvokeExpr) || newExpr instanceof Expr_1.ArkPtrInvokeExpr)) {
                 stmt.replaceUse(expr, newExpr);
             }
-            // After infer the invoke method, it should replace the super.foo() to this.foo() while the foo is with super class as declaring class.
-            if (newExpr instanceof Expr_1.ArkInstanceInvokeExpr && newExpr.getBase().getName() === TSConst_1.SUPER_NAME) {
-                const thisLocal = (_a = arkMethod.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals().get(TSConst_1.THIS_NAME);
-                if (thisLocal) {
-                    newExpr.setBase(thisLocal);
-                    thisLocal.addUsedStmt(stmt);
-                }
-            }
         }
         if (stmt instanceof Stmt_1.ArkAliasTypeDefineStmt && this.isUnclearType(stmt.getAliasType().getOriginalType())) {
             stmt.getAliasType().setOriginalType(stmt.getAliasTypeExpr().getType());
@@ -293,7 +320,12 @@ class TypeInference {
      * infer type for fieldRefs in stmt.
      */
     static resolveFieldRefsInStmt(stmt, arkMethod) {
-        for (const use of stmt.getUses()) {
+        while (resolveUsesScratch.length > 1) {
+            resolveUsesScratch.pop();
+        }
+        stmt.getUses(resolveUsesScratch);
+        for (let i = 1; i < resolveUsesScratch.length; i++) {
+            const use = resolveUsesScratch[i];
             if (use instanceof Ref_1.AbstractRef) {
                 this.processRef(use, stmt, arkMethod);
             }
@@ -394,7 +426,7 @@ class TypeInference {
         }
         let rightType = rightOp.getType();
         if (this.isUnclearType(rightType)) {
-            rightType = this.inferUnclearedType(rightType, arkClass);
+            rightType = this.inferUnclearedType(rightType, arkClass, new Set(), arkMethod);
             if (rightType) {
                 this.setValueType(rightOp, rightType);
             }
@@ -427,7 +459,7 @@ class TypeInference {
         const leftOp = stmt.getLeftOp();
         let leftType = leftOp.getType();
         if (this.isUnclearType(leftType)) {
-            const newLeftType = this.inferUnclearedType(leftType, arkClass);
+            const newLeftType = this.inferUnclearedType(leftType, arkClass, new Set(), arkMethod);
             if (!newLeftType && !this.isUnclearType(rightType)) {
                 leftType = rightType;
             }
@@ -444,7 +476,8 @@ class TypeInference {
                 leftType = rightType;
             }
         }
-        else if (leftType instanceof Type_1.FunctionType && !this.isUnclearType(rightType) &&
+        else if (leftType instanceof Type_1.FunctionType &&
+            !this.isUnclearType(rightType) &&
             leftType.getMethodSignature().getMethodSubSignature().getMethodName().startsWith(Const_1.ANONYMOUS_METHOD_PREFIX)) {
             leftType = rightType;
         }
@@ -459,56 +492,56 @@ class TypeInference {
         }
     }
     static isUnclearType(type) {
-        var _a;
-        // TODO: For UnionType, IntersectionType and TupleType, it should recurse check every item of them.
-        if (!type || type instanceof Type_1.UnknownType || type instanceof Type_1.UnclearReferenceType || type instanceof Type_1.NullType ||
-            type instanceof Type_1.UndefinedType || type instanceof Type_1.GenericType) {
-            return true;
-        }
-        else if (type instanceof Type_1.ClassType &&
-            (unknownFileName.includes(type.getClassSignature().getDeclaringFileSignature().getFileName()) ||
-                (type.getClassSignature().getClassName() === TSConst_1.PROMISE && !type.getRealGenericTypes()))) {
-            return true;
-        }
-        else if (type instanceof Type_1.UnionType || type instanceof Type_1.IntersectionType || type instanceof Type_1.TupleType) {
-            return !!type.getTypes().find(t => this.checkType(t, e => e instanceof Type_1.UnclearReferenceType || e instanceof Type_1.GenericType));
+        // Thin delegate to the polymorphic Type.isUnclear() (each subclass owns its own criteria).
+        // Null/undefined inputs stay unclear.
+        return type === null || type === undefined ? true : type.isUnclear();
+    }
+    // This is the temporal function to check Type recursively and can be removed after typeInfer supports multiple candidate types.
+    static checkType(type, check, visited) {
+        if (visited !== undefined) {
+            if (visited.has(type)) {
+                return false;
+            }
+            visited.add(type);
         }
-        else if (type instanceof Type_1.ArrayType) {
-            const baseType = type.getBaseType();
-            return this.checkType(baseType, t => t instanceof Type_1.UnclearReferenceType || baseType instanceof Type_1.GenericType);
+        else if (!CAN_RECURSE(type)) {
+            return check(type);
         }
-        else if (type instanceof Type_1.AliasType) {
-            return this.isUnclearType(type.getOriginalType());
+        if (check(type)) {
+            return true;
         }
-        else if (type instanceof TypeExpr_1.KeyofTypeExpr) {
-            return this.isUnclearType(type.getOpType());
+        if (visited !== undefined) {
+            return this.checkTypeRecursion(type, check, visited);
         }
-        else if (type instanceof TypeExpr_1.TypeQueryExpr) {
-            return this.isUnclearType(type.getType()) ||
-                !!((_a = type.getGenerateTypes()) === null || _a === void 0 ? void 0 : _a.find(t => this.checkType(t, e => e instanceof Type_1.UnclearReferenceType || e instanceof Type_1.GenericType)));
+        const prevBase = inferVisited.enter();
+        inferVisited.add(type);
+        try {
+            return this.checkTypeRecursion(type, check, inferVisited);
         }
-        else if (type instanceof Type_2.PointerType || type instanceof Type_2.ReferenceType) {
-            return this.isUnclearType(type.getBaseType());
+        finally {
+            inferVisited.leave(prevBase);
         }
-        return false;
     }
-    // This is the temporal function to check Type recursively and can be removed after typeInfer supports multiple candidate types.
-    static checkType(type, check, visited = new Set()) {
-        var _a;
-        if (visited.has(type)) {
+    static checkTypeRecursion(type, check, visited) {
+        if (type instanceof Type_1.ClassType || type instanceof Type_1.FunctionType) {
+            const realGenericTypes = type.getRealGenericTypes();
+            if (realGenericTypes !== undefined) {
+                for (let i = 0; i < realGenericTypes.length; i++) {
+                    if (this.checkType(realGenericTypes[i], check, visited)) {
+                        return true;
+                    }
+                }
+            }
             return false;
         }
-        else {
-            visited.add(type);
-        }
-        if (check(type)) {
-            return true;
-        }
-        else if (type instanceof Type_1.ClassType || type instanceof Type_1.FunctionType) {
-            return !!((_a = type.getRealGenericTypes()) === null || _a === void 0 ? void 0 : _a.find(t => this.checkType(t, check, visited)));
-        }
         else if (type instanceof Type_1.UnionType || type instanceof Type_1.IntersectionType || type instanceof Type_1.TupleType) {
-            return !!type.getTypes().find(t => this.checkType(t, check, visited));
+            const types = type.getTypes();
+            for (let i = 0; i < types.length; i++) {
+                if (this.checkType(types[i], check, visited)) {
+                    return true;
+                }
+            }
+            return false;
         }
         else if (type instanceof Type_1.ArrayType) {
             return this.checkType(type.getBaseType(), check, visited);
@@ -636,9 +669,9 @@ class TypeInference {
             returnType = Type_1.VoidType.getInstance();
         }
         // If the method is async and the return type is not Promise, wrap it with Promise
-        if (arkMethod.containsModifier(ArkBaseModel_1.ModifierType.ASYNC) && (!(returnType instanceof Type_1.ClassType) ||
-            returnType.getClassSignature().getClassName() !== TSConst_1.PROMISE)) {
-            const promise = arkMethod.getDeclaringArkFile().getScene().getSdkGlobal(TSConst_1.PROMISE);
+        if (arkMethod.containsModifier(ArkBaseModel_1.ModifierType.ASYNC) &&
+            (!(returnType instanceof Type_1.ClassType) || returnType.getClassSignature().getClassName() !== TSConst_1.PROMISE)) {
+            const promise = SdkUtils_1.SdkUtils.getSdkGlobal(TSConst_1.PROMISE);
             if (promise instanceof ArkClass_1.ArkClass) {
                 return new Type_1.ClassType(promise.getSignature(), [returnType]);
             }
@@ -671,13 +704,13 @@ class TypeInference {
      * @param arkClass
      * @returns
      */
-    static inferUnclearRefType(urType, arkClass) {
+    static inferUnclearRefType(urType, arkClass, arkMethod) {
         const realTypes = urType.getGenericTypes();
         this.inferRealGenericTypes(realTypes, arkClass);
         if (urType.getName() === Builtin_1.Builtin.ARRAY && realTypes.length > 0) {
             return new Type_1.ArrayType(realTypes[0], 1);
         }
-        const type = this.inferUnclearRefName(urType.getName(), arkClass);
+        const type = this.inferUnclearRefName(urType.getName(), arkClass, arkMethod);
         return type ? this.replaceTypeWithReal(type, realTypes) : null;
     }
     /**
@@ -686,24 +719,37 @@ class TypeInference {
      * The original type is null if it failed to infer the type.
      * @param refName
      * @param arkClass
+     * @param arkMethod - optional; when provided, classes declared inside the method
+     *        scope chain are resolved first (deterministic local-class lookup) before
+     *        the generic file-level name search.
      * @returns
      */
-    static inferUnclearRefName(refName, arkClass) {
+    static inferUnclearRefName(refName, arkClass, arkMethod) {
         var _a;
         if (!refName) {
             return null;
         }
+        if (refName.indexOf('.') < 0 && refName.indexOf(':') < 0 && refName.indexOf('-') < 0 && refName.indexOf('<') < 0) {
+            return this.inferFirstNameType(refName, false, arkClass, arkMethod);
+        }
         //split and iterate to infer each type. In C++, the operators used to access members also include :: and ->
-        const singleNames = refName.split(/\.|::|->/);
+        const singleNames = refName.indexOf(':') < 0 && refName.indexOf('-') < 0 ? refName.split('.') : refName.split(/\.|::|->/);
         let type = null;
         for (let i = 0; i < singleNames.length; i++) {
+            const singleName = singleNames[i];
             let genericName = ValueUtil_1.EMPTY_STRING;
-            const name = singleNames[i].replace(/<(.+)>/, (match, group1) => {
-                genericName = group1;
-                return ValueUtil_1.EMPTY_STRING;
-            });
+            let name;
+            const openIdx = singleName.indexOf('<');
+            const closeIdx = singleName.lastIndexOf('>');
+            if (openIdx >= 0 && closeIdx - openIdx >= 2) {
+                name = singleName.slice(0, openIdx) + singleName.slice(closeIdx + 1);
+                genericName = singleName.slice(openIdx + 1, closeIdx);
+            }
+            else {
+                name = singleName;
+            }
             if (i === 0) {
-                type = singleNames.length > 1 ? this.inferBaseType(name, arkClass) : this.inferTypeByName(name, arkClass);
+                type = this.inferFirstNameType(name, singleNames.length > 1, arkClass, arkMethod);
             }
             else if (type) {
                 type = (_a = this.inferFieldType(type, name, arkClass)) === null || _a === void 0 ? void 0 : _a[1];
@@ -713,7 +759,7 @@ class TypeInference {
             }
             if (genericName) {
                 const realTypes = genericName.split(',').map(generic => {
-                    const realType = this.inferUnclearRefName(generic, arkClass);
+                    const realType = this.inferUnclearRefName(generic, arkClass, arkMethod);
                     return realType !== null && realType !== void 0 ? realType : new Type_1.UnclearReferenceType(generic);
                 });
                 if (type instanceof Type_1.ClassType) {
@@ -726,6 +772,18 @@ class TypeInference {
         }
         return type;
     }
+    /** 首段名解析：方法作用域链局部类优先（确定性查找），未命中回落限定名/单名的通用解析。 */
+    static inferFirstNameType(name, isQualifiedName, arkClass, arkMethod) {
+        if (arkMethod) {
+            // Local-class references resolve deterministically along the method
+            // scope chain before falling back to the file-level name search.
+            const localClass = ModelUtils_1.ModelUtils.findLocalClassInMethodChain(name, arkMethod);
+            if (localClass) {
+                return new Type_1.ClassType(localClass.getSignature());
+            }
+        }
+        return isQualifiedName ? this.inferBaseType(name, arkClass) : this.inferTypeByName(name, arkClass);
+    }
     /**
      * Find out the original object and type for a given base type and the field name.
      * It returns an array with 2 items, original object and original type.
@@ -737,6 +795,7 @@ class TypeInference {
      * @returns
      */
     static inferFieldType(baseType, fieldName, declareClass) {
+        const registry = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
         if (baseType instanceof Type_1.AliasType) {
             baseType = baseType.getOriginalType();
         }
@@ -746,7 +805,8 @@ class TypeInference {
         let propertyAndType = null;
         if (baseType instanceof Type_1.ClassType) {
             if (fieldName === Builtin_1.Builtin.ITERATOR_RESULT_VALUE &&
-                baseType.getClassSignature().getDeclaringFileSignature().getProjectName() === Builtin_1.Builtin.DUMMY_PROJECT_NAME) {
+                baseType.getClassSigID() === -1 &&
+                baseType.getClassSignature().getClassName() === Builtin_1.Builtin.ITERATOR_RESULT) {
                 const types = baseType.getRealGenericTypes();
                 if (types && types.length > 0) {
                     return [null, types[0]];
@@ -759,9 +819,10 @@ class TypeInference {
             propertyAndType = this.inferArrayFieldType(declareClass, fieldName);
         }
         else if (baseType instanceof Type_1.AnnotationNamespaceType) {
-            const namespace = declareClass.getDeclaringArkFile().getScene().getNamespace(baseType.getNamespaceSignature());
+            const namespace = registry.getNamespaceBySig(baseType.getNamespaceSignature());
             if (namespace) {
-                const property = ModelUtils_1.ModelUtils.findPropertyInNamespace(fieldName, namespace);
+                // 多实体探测：跨文件同名 ns（Intl 系）的后续文件实体持有该文件声明的成员
+                const property = ModelUtils_1.ModelUtils.findPropertyInNamespaces(fieldName, namespace);
                 const propertyType = this.parseArkExport2Type(property);
                 if (propertyType) {
                     propertyAndType = [property, propertyType];
@@ -769,23 +830,53 @@ class TypeInference {
             }
         }
         else {
-            logger.warn('infer unclear reference type fail: ' + fieldName);
+            if (logger_1.default.isWarnEnabled(logger)) {
+                logger.warn('infer unclear reference type fail: ' + fieldName);
+            }
         }
         return propertyAndType;
     }
     static inferClassFieldType(declareClass, baseType, fieldName) {
-        const arkClass = declareClass.getDeclaringArkFile().getScene().getClass(baseType.getClassSignature());
+        const registry = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        const arkClass = registry.getClassBySig(baseType.getClassSignature());
         if (!arkClass) {
             return null;
         }
-        const property = ModelUtils_1.ModelUtils.findPropertyInClass(fieldName, arkClass);
+        let property = ModelUtils_1.ModelUtils.findPropertyInClass(fieldName, arkClass);
+        let ownerClass = arkClass;
+        if (!property) {
+            // 多实体探测：字段在同名其他全局实体（跨文件 interface 增补 / var 构造器
+            // 侧类）上时逐实体查找——命中者签名自然归属真实声明类（等价旧 copyMembers
+            // 合并的成员可见性，但成员物理留在声明类）。
+            for (const e of SdkUtils_1.SdkUtils.getSdkGlobalMemberClasses(arkClass.getName())) {
+                if (e === arkClass) {
+                    continue;
+                }
+                property = ModelUtils_1.ModelUtils.findPropertyInClass(fieldName, e);
+                if (property) {
+                    ownerClass = e;
+                    break;
+                }
+            }
+        }
+        // ns 兄弟类探测：跨文件同名 namespace（Intl 系）中，后续文件的同名类持有
+        // 该文件声明的成员（等价旧 copyNamespace 互拷的可见性）。
+        if (!property) {
+            for (const sibling of SdkUtils_1.SdkUtils.getNamespacedSiblingClasses(arkClass)) {
+                property = ModelUtils_1.ModelUtils.findPropertyInClass(fieldName, sibling);
+                if (property) {
+                    ownerClass = sibling;
+                    break;
+                }
+            }
+        }
         let propertyType = null;
         if (property instanceof ArkField_1.ArkField) {
-            if (arkClass.getCategory() === ArkClass_1.ClassCategory.ENUM) {
+            if (ownerClass.getCategory() === ArkClass_1.ClassCategory.ENUM) {
                 propertyType = this.getEnumValueType(property);
             }
             else {
-                this.repairFieldType(property, arkClass);
+                this.repairFieldType(property, ownerClass);
                 propertyType = this.replaceTypeWithReal(property.getType(), baseType.getRealGenericTypes());
             }
         }
@@ -830,7 +921,7 @@ class TypeInference {
         return enumValueType;
     }
     static inferArrayFieldType(declareClass, fieldName) {
-        const arrayClass = declareClass.getDeclaringArkFile().getScene().getSdkGlobal(Builtin_1.Builtin.ARRAY);
+        const arrayClass = SdkUtils_1.SdkUtils.getSdkGlobal(Builtin_1.Builtin.ARRAY);
         if (arrayClass instanceof ArkClass_1.ArkClass) {
             const property = ModelUtils_1.ModelUtils.findPropertyInClass(fieldName, arrayClass);
             if (property instanceof ArkField_1.ArkField) {
@@ -858,10 +949,46 @@ class TypeInference {
         }
         let arkExport = (_b = ModelUtils_1.ModelUtils.findSymbolInFileWithName(baseName, arkClass)) !== null && _b !== void 0 ? _b : ModelUtils_1.ModelUtils.getArkExportInImportInfoWithName(baseName, arkClass.getDeclaringArkFile());
         if (!arkExport && !arkClass.getDeclaringArkFile().getImportInfoBy(baseName)) {
-            arkExport = arkClass.getDeclaringArkFile().getScene().getSdkGlobal(baseName);
+            arkExport = SdkUtils_1.SdkUtils.getSdkGlobal(baseName);
         }
         return this.parseArkExport2Type(arkExport);
     }
+    /**
+     * Multi-candidate variant of {@link inferBaseType}: expands the SDK-global tier
+     * into ALL entities registered under the name (same-name multi-declaration, e.g.
+     * `interface Object` + `declare var Object: ObjectConstructor`, or an interface
+     * augmented across lib.es20XX files). Member resolution should probe each
+     * candidate until a member is found — the hit entity's signature carries the
+     * real declaring file. The file-local / import tiers stay single-valued (they
+     * resolve to one symbol by scope semantics).
+     */
+    static inferBaseTypes(baseName, arkClass) {
+        var _a, _b;
+        if (TSConst_1.SUPER_NAME === baseName) {
+            const t = this.parseArkExport2Type(arkClass.getSuperClass());
+            return t ? [t] : [];
+        }
+        else if (TSConst_1.DEFAULT === baseName) {
+            const t = this.parseArkExport2Type((_a = arkClass.getDeclaringArkFile().getExportInfoBy(TSConst_1.DEFAULT)) === null || _a === void 0 ? void 0 : _a.getArkExport());
+            return t ? [t] : [];
+        }
+        let arkExport = (_b = ModelUtils_1.ModelUtils.findSymbolInFileWithName(baseName, arkClass)) !== null && _b !== void 0 ? _b : ModelUtils_1.ModelUtils.getArkExportInImportInfoWithName(baseName, arkClass.getDeclaringArkFile());
+        if (arkExport) {
+            const t = this.parseArkExport2Type(arkExport);
+            return t ? [t] : [];
+        }
+        if (arkClass.getDeclaringArkFile().getImportInfoBy(baseName)) {
+            return [];
+        }
+        const types = [];
+        for (const entity of SdkUtils_1.SdkUtils.getSdkGlobals(baseName)) {
+            const t = this.parseArkExport2Type(entity);
+            if (t) {
+                types.push(t);
+            }
+        }
+        return types;
+    }
     static inferTypeByName(typeName, arkClass) {
         var _a, _b;
         //look up from declared file, if not found then from imports
@@ -870,7 +997,7 @@ class TypeInference {
         //if not found or local in built-in then look up global in sdks
         if ((!arkExport || (arkExport instanceof Local_1.Local && declaredArkFile.getProjectName() === SdkUtils_1.SdkUtils.BUILT_IN_NAME)) &&
             !declaredArkFile.getImportInfoBy(typeName)) {
-            const globalVal = arkClass.getDeclaringArkFile().getScene().getSdkGlobal(typeName);
+            const globalVal = SdkUtils_1.SdkUtils.getSdkGlobal(typeName);
             if (globalVal) {
                 arkExport = globalVal;
             }
@@ -882,7 +1009,7 @@ class TypeInference {
         return ((_b = arkClass.getGenericsTypes()) === null || _b === void 0 ? void 0 : _b.find(g => g.getName() === typeName)) || null;
     }
     static getTypeByGlobalName(globalName, arkMethod) {
-        const arkExport = arkMethod.getDeclaringArkFile().getScene().getSdkGlobal(globalName);
+        const arkExport = SdkUtils_1.SdkUtils.getSdkGlobal(globalName);
         return this.parseArkExport2Type(arkExport);
     }
     static inferRealGenericTypes(realTypes, arkClass) {
@@ -908,12 +1035,12 @@ class TypeInference {
         importInfo.setDeclaringArkFile(arkClass.getDeclaringArkFile());
         return TypeInference.parseArkExport2Type((_a = importInfo.getLazyExportInfo()) === null || _a === void 0 ? void 0 : _a.getArkExport());
     }
-    static replaceTypeWithReal(type, realTypes, visited = new Set()) {
+    static replaceTypeWithReal(type, realTypes, visited) {
         var _a, _b;
-        if (visited.has(type)) {
-            return type;
-        }
-        else {
+        if (visited !== undefined) {
+            if (visited.has(type)) {
+                return type;
+            }
             visited.add(type);
         }
         if (type instanceof Type_1.GenericType) {
@@ -924,7 +1051,9 @@ class TypeInference {
             const realType = realTypes === null || realTypes === void 0 ? void 0 : realTypes[0];
             return realType !== null && realType !== void 0 ? realType : type;
         }
-        return this.replaceRecursiveType(type, visited, realTypes);
+        const childVisited = visited !== null && visited !== void 0 ? visited : new Set();
+        childVisited.add(type);
+        return this.replaceRecursiveType(type, childVisited, realTypes);
     }
     static replaceRecursiveType(type, visited, realTypes) {
         var _a, _b, _c, _d, _e, _f;
@@ -1022,20 +1151,17 @@ class TypeInference {
         if (isAnonClassType) {
             return true;
         }
-        return argType instanceof Type_1.FunctionType &&
+        return (argType instanceof Type_1.FunctionType &&
             argType.getMethodSignature().getMethodSubSignature().getMethodName().startsWith(Const_1.ANONYMOUS_METHOD_PREFIX) &&
-            argType.getMethodSignature().getDeclaringClassSignature().getDeclaringFileSignature().getProjectName() === projectName;
-    }
-    static isDummyClassType(rightType) {
-        var _a;
-        return rightType instanceof Type_1.ClassType &&
-            rightType.getClassSignature().getDeclaringFileSignature().getFileName() === Builtin_1.Builtin.DUMMY_FILE_NAME &&
-            !!((_a = rightType.getRealGenericTypes()) === null || _a === void 0 ? void 0 : _a.find(t => !(t instanceof Type_1.GenericType)));
+            argType.getMethodSignature().getDeclaringClassSignature().getDeclaringFileSignature().getProjectName() === projectName);
     }
     static isTypeCanBeOverride(type) {
         var _a, _b;
-        if (type instanceof Type_1.UnknownType || type instanceof Type_1.NullType || type instanceof Type_1.UndefinedType ||
-            type instanceof Type_1.UnclearReferenceType || type instanceof Type_1.GenericType) {
+        if (type instanceof Type_1.UnknownType ||
+            type instanceof Type_1.NullType ||
+            type instanceof Type_1.UndefinedType ||
+            type instanceof Type_1.UnclearReferenceType ||
+            type instanceof Type_1.GenericType) {
             return true;
         }
         else if (type instanceof Type_1.ClassType) {
@@ -1045,15 +1171,15 @@ class TypeInference {
             return this.isTypeCanBeOverride(type.getOriginalType()) || !!((_b = type.getRealGenericTypes()) === null || _b === void 0 ? void 0 : _b.find(r => this.isTypeCanBeOverride(r)));
         }
         else if (type instanceof Type_1.ArrayType) {
-            return TypeInference.checkType(type.getBaseType(), t => t instanceof Type_1.UnclearReferenceType || t instanceof Type_1.GenericType);
+            return TypeInference.checkType(type.getBaseType(), IS_UNCLEAR_REF_OR_GENERIC);
         }
         return false;
     }
     static union(type1, type2) {
         const leftType = TypeInference.replaceAliasType(type1);
         const rightType = TypeInference.replaceAliasType(type2);
-        if (this.isSameType(leftType, rightType) || TypeInference.checkType(rightType, t => t instanceof Type_1.AnyType ||
-            (rightType instanceof Type_1.ClassType && rightType.getClassSignature().getClassName().startsWith(Const_1.ANONYMOUS_CLASS_PREFIX)))) {
+        if (this.isSameType(leftType, rightType) ||
+            TypeInference.checkType(rightType, t => t instanceof Type_1.AnyType || (rightType instanceof Type_1.ClassType && rightType.getClassSignature().getClassName().startsWith(Const_1.ANONYMOUS_CLASS_PREFIX)))) {
             return type1;
         }
         else if (leftType instanceof Type_1.FunctionType) {
@@ -1076,7 +1202,7 @@ class TypeInference {
     }
     static isSameType(type1, type2) {
         if (type1 instanceof Type_1.ClassType && type2 instanceof Type_1.ClassType) {
-            return type1.getClassSignature() === type2.getClassSignature();
+            return (0, SignatureCanonicalizer_1.signatureEquals)(type1.getClassSignature(), type2.getClassSignature());
         }
         else if (type1 instanceof Type_1.LiteralType) {
             return typeof type1.getLiteralName() === type2.toString();
@@ -1102,7 +1228,7 @@ class TypeInference {
             return rightType;
         }
         let leftType = value.getType();
-        if (rightType && this.checkType(leftType, t => t instanceof Type_1.AnyType)) {
+        if (rightType && this.checkType(leftType, IS_ANY)) {
             return rightType;
         }
         if (!rightType || this.isAnonType(rightType, scene.getProjectName())) {
@@ -1133,7 +1259,7 @@ class TypeInference {
             }
             childClass = childClass === null || childClass === void 0 ? void 0 : childClass.getSuperClass();
         }
-        const objectClass = scene.getSdkGlobal(Builtin_1.Builtin.OBJECT);
+        const objectClass = SdkUtils_1.SdkUtils.getSdkGlobal(Builtin_1.Builtin.OBJECT);
         return fatherClass === objectClass;
     }
     static unwrapPromiseType(type) {