arkanalyzer 1.0.93 → 2.0.0-beta1

package/lib/core/model/ArkClass.js

@@ -40,15 +40,47 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArkClass = exports.CLASS_CATEGORY_MASK = exports.CLASS_CATEGORY_SHIFT = exports.ClassCategory = void 0;
 const Type_1 = require("../base/Type");
 const ArkMethod_1 = require("./ArkMethod");
+const ArkSignature_1 = require("./ArkSignature");
 const ArkExport_1 = require("./ArkExport");
 const TypeInference_1 = require("../common/TypeInference");
 const Const_1 = require("../common/Const");
 const Position_1 = require("../base/Position");
 const ArkBaseModel_1 = require("./ArkBaseModel");
 const ModelUtils_1 = require("../common/ModelUtils");
-const StringUtils_1 = require("../common/StringUtils");
+const SignatureCanonicalizerRegistry_1 = require("../common/SignatureCanonicalizerRegistry");
 const logger_1 = __importStar(require("../../utils/logger"));
 const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ArkClass');
+const forEachMethodSeenScratch = [];
+let forEachMethodSeenTop = 0;
+const forEachMethodOverflow = [];
+let forEachMethodDepth = 0;
+const SEEN_LINEAR_LIMIT = 32;
+function markSeen(base, depth, method) {
+    const overflow = forEachMethodOverflow[depth];
+    if (overflow !== undefined) {
+        if (overflow.has(method)) {
+            return true;
+        }
+        overflow.add(method);
+        return false;
+    }
+    for (let i = base; i < forEachMethodSeenTop; i++) {
+        if (forEachMethodSeenScratch[i] === method) {
+            return true;
+        }
+    }
+    if (forEachMethodSeenTop - base >= SEEN_LINEAR_LIMIT) {
+        const promoted = new Set();
+        for (let i = base; i < forEachMethodSeenTop; i++) {
+            promoted.add(forEachMethodSeenScratch[i]);
+        }
+        promoted.add(method);
+        forEachMethodOverflow[depth] = promoted;
+        return false;
+    }
+    forEachMethodSeenScratch[forEachMethodSeenTop++] = method;
+    return false;
+}
 var ClassCategory;
 (function (ClassCategory) {
     ClassCategory[ClassCategory["CLASS"] = 0] = "CLASS";
@@ -74,27 +106,38 @@ exports.CLASS_CATEGORY_MASK = 0x7 << exports.CLASS_CATEGORY_SHIFT;
  * @category core/model
  */
 class ArkClass extends ArkBaseModel_1.ArkBaseModel {
-    constructor() {
+    /** @internal Get the Registry singleton. */
+    get registry() {
+        return SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+    }
+    constructor(declaringFileID, declaringNamespaceSigID, classSig) {
         super();
+        /** @internal Formal FileSigID for the declaring file. -1 = not yet interned. */
+        this.declaringFileID = -1;
+        /** @internal Formal ClassSigID of this class. -1 = not yet set. */
+        this.classSigID = -1;
         /**
          * The keys of the `heritageClasses` map represent the names of superclass and interfaces.
          * The superclass name is placed first; if it does not exist, an empty string `''` will occupy this position.
          * The values of the `heritageClasses` map will be replaced with `ArkClass` or `null` during type inference.
          */
         this.heritageClasses = new Map();
-        this.defaultMethod = null;
-        // name to model
-        this.methods = new Map();
-        this.fields = new Map();
-        this.extendedClasses = new Map();
-        this.staticMethods = new Map();
-        this.staticFields = new Map();
-        this.instanceInitMethod = new ArkMethod_1.ArkMethod();
-        this.staticInitMethod = new ArkMethod_1.ArkMethod();
+        this.extendedClassCount = 0;
+        this.topFieldCount = 0;
+        this.topStaticFieldCount = 0;
         this.anonymousMethodNumber = 0;
         this.indexSignatureNumber = 0;
         // In order to record the mapping between arkTS and CPP functions
         this.ts2cxxFuncMap = new Map();
+        if (declaringFileID !== undefined) {
+            this.declaringFileID = declaringFileID;
+        }
+        if (declaringNamespaceSigID !== undefined) {
+            this.declaringNamespaceSigID = declaringNamespaceSigID;
+        }
+        if (classSig) {
+            this.setSignature(classSig);
+        }
     }
     /**
      * Returns the program language of the file where this class defined.
@@ -107,7 +150,7 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
      * @returns The name of this class.
      */
     getName() {
-        return this.classSignature.getClassName();
+        return this.getSignature().getClassName();
     }
     /**
      * Returns the source text of the class extracted from the declaring ArkFile
@@ -118,7 +161,7 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
         if (this.sourceCode !== undefined) {
             return this.sourceCode;
         }
-        const code = (0, StringUtils_1.extractSourceTextByFullPosition)(this.getDeclaringArkFile().getCode(), this.originFullPosition);
+        const code = this.getDeclaringArkFile().getSourceTextByFullPosition(this.originFullPosition);
         if (code !== undefined) {
             this.sourceCode = code;
         }
@@ -128,8 +171,7 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
      * @deprecated Source text is now stored on ArkFile only. This method has no effect.
      * @param _code - The source code (ignored).
      */
-    setCode(_code) {
-    }
+    setCode(_code) { }
     /**
      * Returns the full position (start/end line/col) of this class in the source file.
      * @returns The full position of this class in the source code, or undefined if this class
@@ -205,20 +247,43 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
      ```
      */
     getDeclaringArkFile() {
-        return this.declaringArkFile;
+        if (this.declaringFileID !== -1) {
+            return this.registry.fileSigCanonicalizer.getModel(this.declaringFileID);
+        }
+        return undefined;
     }
+    /** @deprecated Use {@link constructor} instead. */
     setDeclaringArkFile(declaringArkFile) {
-        this.declaringArkFile = declaringArkFile;
+        this.declaringFileID = declaringArkFile.getFileSigID();
+    }
+    /** @internal Get the formal FileSigID of the declaring file. Returns -1 if not interned. */
+    getDeclaringFileID() {
+        return this.declaringFileID;
     }
     /**
      * Returns the declaring namespace of this class, which may also be an **undefined**.
      * @returns The declaring namespace (may be **undefined**) of this class.
      */
     getDeclaringArkNamespace() {
-        return this.declaringArkNamespace;
+        var _a;
+        if (this.declaringNamespaceSigID !== undefined) {
+            return (_a = this.registry.namespaceSigCanonicalizer.getModel(this.declaringNamespaceSigID)) !== null && _a !== void 0 ? _a : undefined;
+        }
+        return undefined;
     }
+    getDeclaringArkNamespaceID() {
+        if (this.declaringNamespaceSigID !== undefined) {
+            return this.declaringNamespaceSigID;
+        }
+        return undefined;
+    }
+    /**
+     * @deprecated Use the ID-injecting constructor
+     * {@link constructor(declaringFileID, declaringNamespaceSigID, classSig)} or
+     * {@link setDeclaringArkNamespaceID} instead.
+     */
     setDeclaringArkNamespace(declaringArkNamespace) {
-        this.declaringArkNamespace = declaringArkNamespace;
+        this.declaringNamespaceSigID = declaringArkNamespace === null || declaringArkNamespace === void 0 ? void 0 : declaringArkNamespace.getNamespaceSigID();
     }
     isDefaultArkClass() {
         return this.getName() === Const_1.DEFAULT_ARK_CLASS_NAME;
@@ -236,10 +301,29 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
      * @returns The class signature.
      */
     getSignature() {
-        return this.classSignature;
+        return this.registry.classSigCanonicalizer.get(this.classSigID);
     }
     setSignature(classSig) {
-        this.classSignature = classSig;
+        const existing = this.registry.classSigCanonicalizer.getExistingId(classSig);
+        this.classSigID = existing >= 0 ? existing : this.registry.classSigCanonicalizer.getOrCreateId(classSig);
+        // 新值首建 → 注册；
+        // 驱逐态恢复（sig 值残留、model 已被 removeClass 删除）→ 补注册（否则 reload 时 getDeclaringArkClass 查不到 model，genDefaultArkMethod 链 NPE）；
+        // 已有别的 model 持有该签名 → 不覆盖（防"后 setSignature 者顶替"写穿）。
+        if (existing < 0 || this.registry.classSigCanonicalizer.getModel(existing) === undefined) {
+            this.registry.registerClass(this);
+        }
+    }
+    /** @internal Get the formal ClassSigID of this class. */
+    getClassSigID() {
+        return this.classSigID;
+    }
+    /**
+     * Returns the unique ID of this model — the ClassSigID in the canonicalizer.
+     * The signature table and the model table share one dense ID space, so this ID
+     * resolves both the signature and the model.
+     */
+    getId() {
+        return this.classSigID;
     }
     getSuperClassName() {
         return this.heritageClasses.keys().next().value || '';
@@ -280,7 +364,7 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
             if (type) {
                 type = TypeInference_1.TypeInference.replaceAliasType(type);
             }
-            if (type instanceof Type_1.ClassType && (superClass = this.declaringArkFile.getScene().getClass(type.getClassSignature()))) {
+            if (type instanceof Type_1.ClassType && (superClass = this.getDeclaringArkFile().getScene().getClass(type.getClassSignature()))) {
                 superClass.addExtendedClass(this);
                 const realGenericTypes = type.getRealGenericTypes();
                 if (realGenericTypes) {
@@ -313,11 +397,56 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
         });
         return result;
     }
+    /**
+     * Returns the direct subclasses (parent→child back-references) of this class.
+     * The returned Map is a rebuilt view keyed by class name; mutating it does not
+     * affect the internal storage.
+     */
     getExtendedClasses() {
-        return this.extendedClasses;
+        const result = new Map();
+        const arr = this.extendedClassSigIDs;
+        if (!arr) {
+            return result;
+        }
+        const reg = this.registry;
+        for (let i = 0; i < this.extendedClassCount; i++) {
+            const cls = reg.classSigCanonicalizer.getModel(arr[i]);
+            if (cls) {
+                result.set(cls.getName(), cls);
+            }
+        }
+        return result;
+    }
+    /**
+     * @internal Returns the direct subclasses as an array, or **null** if this class
+     * has no extended classes. Preferred over {@link getExtendedClasses} in hot paths
+     * to avoid rebuilding a Map. Stale SigIDs (whose classes were removed) are skipped.
+     */
+    getExtendedClassList() {
+        const arr = this.extendedClassSigIDs;
+        if (!arr || this.extendedClassCount === 0) {
+            return null;
+        }
+        const result = [];
+        const reg = this.registry;
+        for (let i = 0; i < this.extendedClassCount; i++) {
+            const cls = reg.classSigCanonicalizer.getModel(arr[i]);
+            if (cls) {
+                result.push(cls);
+            }
+        }
+        return result;
     }
     addExtendedClass(extendedClass) {
-        this.extendedClasses.set(extendedClass.getName(), extendedClass);
+        const id = extendedClass.getClassSigID();
+        if (id <= 0 || this.hasExtendedClassWithID(id)) {
+            return;
+        }
+        this.addExtendedClassSigID(id);
+    }
+    /** @internal Removes a direct subclass back-reference (by ClassSigID, swap-remove). */
+    removeExtendedClass(extendedClass) {
+        this.removeExtendedClassSigID(extendedClass.getClassSigID());
     }
     getImplementedInterfaceNames() {
         if (this.getCategory() === ClassCategory.INTERFACE) {
@@ -325,9 +454,11 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
         }
         return Array.from(this.heritageClasses.keys()).slice(1);
     }
+    /** @deprecated No callers remain in the codebase; no replacement. */
     hasImplementedInterface(interfaceName) {
         return this.heritageClasses.has(interfaceName) && this.getSuperClassName() !== interfaceName;
     }
+    /** @deprecated No callers remain in the codebase; no replacement. */
     getImplementedInterface(interfaceName) {
         const heritageClass = this.getHeritageClass(interfaceName);
         if (heritageClass && heritageClass.getCategory() === ClassCategory.INTERFACE) {
@@ -342,36 +473,74 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
      * @returns A field. If there is no field in this class, the return will be a **null**.
      */
     getField(fieldSignature) {
-        const fieldName = fieldSignature.getFieldName();
-        let fieldSearched = this.getFieldWithName(fieldName);
-        if (!fieldSearched) {
-            fieldSearched = this.getStaticFieldWithName(fieldName);
+        const id = this.registry.fieldSigCanonicalizer.getExistingId(fieldSignature);
+        if (id !== -1) {
+            const fld = this.registry.fieldSigCanonicalizer.getModel(id);
+            if (fld !== undefined && fld.getDeclaringClassID() === this.classSigID) {
+                return fld;
+            }
         }
-        return fieldSearched;
+        return null;
     }
     getFieldWithName(fieldName) {
-        return this.fields.get(fieldName) || null;
+        var _a;
+        const id = this.registry.fieldSigCanonicalizer.getExistingId(ArkSignature_1.FieldSignature.probe(fieldName, this.classSigID, Type_1.UnknownType.getInstance(), false));
+        if (id !== -1) {
+            return (_a = this.registry.fieldSigCanonicalizer.getModel(id)) !== null && _a !== void 0 ? _a : null;
+        }
+        return null;
     }
     getStaticFieldWithName(fieldName) {
-        return this.staticFields.get(fieldName) || null;
+        var _a;
+        // 同 getFieldWithName，staticFlag = true。
+        const id = this.registry.fieldSigCanonicalizer.getExistingId(ArkSignature_1.FieldSignature.probe(fieldName, this.classSigID, Type_1.UnknownType.getInstance(), true));
+        if (id !== -1) {
+            return (_a = this.registry.fieldSigCanonicalizer.getModel(id)) !== null && _a !== void 0 ? _a : null;
+        }
+        return null;
     }
     /**
      * Returns an **array** of fields in the class.
      * @returns an **array** of fields in the class.
      */
     getFields() {
-        const allFields = Array.from(this.staticFields.values());
-        allFields.push(...this.fields.values());
-        return allFields;
+        const result = [];
+        const sArr = this.topStaticFieldSigIDs;
+        if (sArr) {
+            const reg = this.registry;
+            for (let i = 0; i < this.topStaticFieldCount; i++) {
+                const fld = reg.fieldSigCanonicalizer.getModel(sArr[i]);
+                if (fld) {
+                    result.push(fld);
+                }
+            }
+        }
+        const arr = this.topFieldSigIDs;
+        if (arr) {
+            const reg = this.registry;
+            for (let i = 0; i < this.topFieldCount; i++) {
+                const fld = reg.fieldSigCanonicalizer.getModel(arr[i]);
+                if (fld) {
+                    result.push(fld);
+                }
+            }
+        }
+        return result;
     }
     addField(field) {
+        const id = field.getFieldSigID();
         if (field.isStatic()) {
-            this.staticFields.set(field.getName(), field);
+            if (!this.hasTopStaticFieldWithID(id)) {
+                this.addTopStaticFieldSigID(id);
+            }
         }
         else {
-            this.fields.set(field.getName(), field);
+            if (!this.hasTopFieldWithID(id)) {
+                this.addTopFieldSigID(id);
+            }
         }
     }
+    /** @deprecated No callers remain in the codebase; use {@link addField} per field instead. */
     addFields(fields) {
         fields.forEach(field => {
             this.addField(field);
@@ -406,27 +575,159 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
      ```
      */
     getMethods(generated) {
-        const seen = new WeakSet();
+        var _a, _b, _c, _d;
+        const ids = new Set();
+        for (const entry of (_b = (_a = this.methodNameIndex) === null || _a === void 0 ? void 0 : _a.values()) !== null && _b !== void 0 ? _b : []) {
+            for (const id of entry) {
+                ids.add(id);
+            }
+        }
+        for (const entry of (_d = (_c = this.staticMethodNameIndex) === null || _c === void 0 ? void 0 : _c.values()) !== null && _d !== void 0 ? _d : []) {
+            for (const id of entry) {
+                ids.add(id);
+            }
+        }
+        const seen = new Set();
         const result = [];
-        const addIfNeeded = (m) => {
-            if (!seen.has(m) && (generated || !m.isGenerated())) {
+        for (const id of ids) {
+            const m = this.registry.methodSigCanonicalizer.getModel(id);
+            if (m !== undefined && (generated || !m.isGenerated()) && !seen.has(m)) {
                 seen.add(m);
                 result.push(m);
             }
-        };
-        for (const methods of this.methods.values()) {
-            for (const m of methods) {
-                addIfNeeded(m);
+        }
+        return result;
+    }
+    /**
+     * @internal Iterates the class methods in {@link getMethods} order without building the
+     * result array. Dedup uses a module-level scratch segment with base/top discipline instead
+     * of a per-call Set: each invocation appends its yielded methods above the current top and
+     * pops (nulling) its segment on exit, which keeps the walk reentrant - a callback may call
+     * forEachMethod again without disturbing the outer dedup - and allocation-free per call.
+     * Return false from the callback to stop early. Use getMethods when the caller needs the
+     * array itself (e.g. to sort it).
+     */
+    forEachMethod(callback, generated) {
+        const canonicalizer = this.registry.methodSigCanonicalizer;
+        const base = forEachMethodSeenTop;
+        const depth = forEachMethodDepth++;
+        try {
+            let earlyExit = false;
+            const index = this.methodNameIndex;
+            if (index !== undefined) {
+                for (const entry of index.values()) {
+                    for (let i = 0; i < entry.length; i++) {
+                        const m = canonicalizer.getModel(entry[i]);
+                        if (m !== undefined && (generated || !m.isGenerated()) && !markSeen(base, depth, m)) {
+                            if (!callback(m)) {
+                                earlyExit = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (earlyExit) {
+                        break;
+                    }
+                }
+            }
+            const staticIndex = this.staticMethodNameIndex;
+            if (!earlyExit && staticIndex !== undefined) {
+                for (const entry of staticIndex.values()) {
+                    for (let i = 0; i < entry.length; i++) {
+                        const m = canonicalizer.getModel(entry[i]);
+                        if (m !== undefined && (generated || !m.isGenerated()) && !markSeen(base, depth, m)) {
+                            if (!callback(m)) {
+                                earlyExit = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (earlyExit) {
+                        break;
+                    }
+                }
             }
         }
-        for (const methods of this.staticMethods.values()) {
-            for (const m of methods) {
-                addIfNeeded(m);
+        finally {
+            forEachMethodDepth = depth;
+            if (forEachMethodOverflow[depth] !== undefined) {
+                forEachMethodOverflow[depth] = undefined;
             }
+            const nullMethod = null;
+            for (let i = base; i < forEachMethodSeenTop; i++) {
+                forEachMethodSeenScratch[i] = nullMethod;
+            }
+            forEachMethodSeenTop = base;
+        }
+    }
+    /**
+     * @internal Iterates the methods whose names mark them as nested inside `outerMethodName`
+     * (NAME_PREFIX ... NAME_DELIMITER + outerMethodName), in the same order and with the same
+     * dedup as an equivalent filtered {@link forEachMethod} walk, but scanning the name-index
+     * keys as strings and resolving models only for hits - no per-call Set and no O(class)
+     * model resolution, which mattered for large SDK classes walked once per outer method.
+     */
+    forEachNestedMethodOf(outerMethodName, callback) {
+        const suffix = Const_1.NAME_DELIMITER + outerMethodName;
+        const canonicalizer = this.registry.methodSigCanonicalizer;
+        const base = forEachMethodSeenTop;
+        const depth = forEachMethodDepth++;
+        try {
+            let stop = false;
+            for (let pass = 0; pass < 2 && !stop; pass++) {
+                const index = pass === 0 ? this.methodNameIndex : this.staticMethodNameIndex;
+                if (index === undefined) {
+                    continue;
+                }
+                for (const name of index.keys()) {
+                    if (!name.startsWith(Const_1.NAME_PREFIX) || !name.endsWith(suffix)) {
+                        continue;
+                    }
+                    const ids = index.get(name);
+                    for (let i = 0; i < ids.length; i++) {
+                        const m = canonicalizer.getModel(ids[i]);
+                        if (m !== undefined && !m.isGenerated() && !markSeen(base, depth, m)) {
+                            if (!callback(m)) {
+                                stop = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (stop) {
+                        break;
+                    }
+                }
+            }
+        }
+        finally {
+            forEachMethodDepth = depth;
+            if (forEachMethodOverflow[depth] !== undefined) {
+                forEachMethodOverflow[depth] = undefined;
+            }
+            const nullMethod = null;
+            for (let i = base; i < forEachMethodSeenTop; i++) {
+                forEachMethodSeenScratch[i] = nullMethod;
+            }
+            forEachMethodSeenTop = base;
         }
-        return result;
     }
     getMethod(methodSignature) {
+        const canonicalizer = this.registry.methodSigCanonicalizer;
+        const id = canonicalizer.getExistingId(methodSignature);
+        if (id !== -1) {
+            const mtd = canonicalizer.getModel(id);
+            if (mtd !== undefined && mtd.getDeclaringClassID() === this.classSigID) {
+                return mtd;
+            }
+        }
+        // Fallback: class-local traversal with signature matching.
+        // 不能删除（结构性缺口承载者）：
+        // ① declare[k>0] 无 model——addMethod 只注册 impl ?? declare[0]，而
+        //    matchMethodSignature 为可选参数/重载调用点选出的非首选声明签名
+        //    （callgraph callee 解析主链路，PagBuilder/CallGraph/RTA 等）只能在此命中；
+        //    → 全槽注册后 declare 槽已注册，此缺口关闭；
+        // ② 闭包 declare 重建签名（updateNestedMethodWithClosures 只 intern 不注册）；
+        // ③ C++ 跨类借用（声明方法借实现侧签名，fast path 归属校验失败后在此命中）。
         const methodName = methodSignature.getMethodSubSignature().getMethodName();
         const methodsWithSameName = this.getAllMethodsWithName(methodName);
         if (methodsWithSameName.length === 0) {
@@ -462,65 +763,127 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
         return null;
     }
     getMethodWithName(methodName) {
-        const sameNameMethods = this.methods.get(methodName);
-        if (!sameNameMethods) {
+        var _a;
+        const ids = (_a = this.methodNameIndex) === null || _a === void 0 ? void 0 : _a.get(methodName);
+        if (ids === undefined || ids.length === 0) {
             return null;
         }
-        if (sameNameMethods.length > 1) {
+        const reg = this.registry;
+        let first = null;
+        let resolved = 0;
+        for (let i = 0; i < ids.length; i++) {
+            const m = reg.methodSigCanonicalizer.getModel(ids[i]);
+            if (m) {
+                resolved++;
+                if (first === null) {
+                    first = m;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        if (resolved > 1) {
             logger.warn("There are multiple non-static methods with the same name, and the interface 'getMethodWithName' only returns one of them. " +
                 "If you want to obtain all non-static methods with the same name, please use the interface 'getMethodsWithName'.");
         }
-        return sameNameMethods[0];
+        return first;
     }
     getStaticMethodWithName(methodName) {
-        const sameNameStaticMethods = this.staticMethods.get(methodName);
-        if (!sameNameStaticMethods) {
+        var _a;
+        const ids = (_a = this.staticMethodNameIndex) === null || _a === void 0 ? void 0 : _a.get(methodName);
+        if (ids === undefined || ids.length === 0) {
             return null;
         }
-        if (sameNameStaticMethods.length > 1) {
+        const reg = this.registry;
+        let first = null;
+        let resolved = 0;
+        for (let i = 0; i < ids.length; i++) {
+            const m = reg.methodSigCanonicalizer.getModel(ids[i]);
+            if (m) {
+                resolved++;
+                if (first === null) {
+                    first = m;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        if (resolved > 1) {
             logger.warn("There are multiple static methods with the same name, and the interface 'getStaticMethodWithName' only returns one of them. " +
                 "If you want to obtain all static methods with the same name, please use the interface 'getStaticMethodsWithName'.");
         }
-        return sameNameStaticMethods[0];
+        return first;
     }
     /**
      * add a method in class.
-     * when a nested method with declare name, add both the declare origin name and signature name
-     * %${declare name}$${outer method name} in class.
      */
-    addMethod(method, originName) {
-        const name = originName !== null && originName !== void 0 ? originName : method.getName();
-        this.updateMethodMap(method, name);
-        if (!originName && !method.isAnonymousMethod() && name.startsWith(Const_1.NAME_PREFIX)) {
-            const index = name.indexOf(Const_1.NAME_DELIMITER);
-            if (index > 1) {
-                const originName = name.substring(1, index);
-                this.addMethod(method, originName);
+    addMethod(method) {
+        var _a, _b;
+        const id = (_a = method.getMethodSigID()) !== null && _a !== void 0 ? _a : (_b = method.getDeclareSigIDs()) === null || _b === void 0 ? void 0 : _b[0];
+        if (id === undefined || id <= 0) {
+            logger.error(`Cannot add method (SigID=${method.getMethodSigID()}) to class (SigID=${this.getClassSigID()}): it has no interned signature.`);
+            return;
+        }
+        const canonicalizer = this.registry.methodSigCanonicalizer;
+        // The class index is authoritative: registering here (unconditionally) marks the final
+        // winner of any same-signature merge chain performed by builders.
+        canonicalizer.setModel(id, method);
+        const declareSigIDs = method.getDeclareSigIDs();
+        if (declareSigIDs !== null && declareSigIDs !== undefined) {
+            for (let i = 0; i < declareSigIDs.length; i++) {
+                const declareID = declareSigIDs[i];
+                if (declareID > 0 && declareID !== id) {
+                    this.registerDeclareSlotWithArbitration(canonicalizer, declareID, method);
+                }
+            }
+        }
+        this.updateMethodIndex(method, id);
+    }
+    /**
+     * @internal Register a method as the model of one of its non-primary declare slots.
+     *
+     * Arbitration (single rule, no same-class sibling protection — addMethod is the
+     * terminal registration point where the merge winner must take over same-class
+     * declare slots; compare registerImplModelWithArbitration in ArkMethod for the
+     * construction-time rules):
+     * - a slot already held by a body-carrying method is never taken over by a
+     *   body-less one (C++ decl/impl split added in reverse order).
+     */
+    registerDeclareSlotWithArbitration(canonicalizer, declareID, method) {
+        const existing = canonicalizer.getModel(declareID);
+        if (existing !== undefined && existing !== method) {
+            if (existing.getBody() !== undefined && method.getBody() === undefined) {
+                return;
             }
         }
+        canonicalizer.setModel(declareID, method);
     }
     /**
-     * Update the new method to the corresponding Map.
+     * Update the new method in the corresponding SigID index.
      *
      * @param newMethod - the new method
-     * @param methodName - name of new method
+     * @param sigID - the formal MethodSigID (or first declare SigID) indexing the method
      */
-    updateMethodMap(newMethod, methodName) {
-        const methodMap = newMethod.isStatic() ? this.staticMethods : this.methods;
-        const methodsWithSameName = methodMap.get(methodName);
-        if (!methodsWithSameName || !ModelUtils_1.ModelUtils.isLanguageOverloadSupport(this.getLanguage())) {
-            methodMap.set(methodName, [newMethod]);
+    updateMethodIndex(newMethod, sigID) {
+        if (newMethod.isStatic()) {
+            if (!ModelUtils_1.ModelUtils.isLanguageOverloadSupport(this.getLanguage())) {
+                // Non-overload languages: same-name methods replace each other. set() on an
+                // existing key keeps its insertion position, so the first-occurrence order
+                // of getMethods is stable across same-name re-adds.
+                this.setStaticMethodNameEntry(newMethod.getName(), sigID);
+            }
+            else if (!this.replaceTopStaticMethodSigIDByMatch(newMethod)) {
+                this.appendStaticMethodNameEntry(newMethod.getName(), sigID);
+            }
             return;
         }
-        const newMethodSignature = newMethod.getSignature();
-        const matchIndex = methodsWithSameName.findIndex(
-        // CXXTodo: After the subsequent abstraction of BodyBuilder, this conditions need to be refactored.
-        preMtd => preMtd.getSignature().isMatch(newMethodSignature));
-        if (matchIndex === -1) {
-            methodsWithSameName.push(newMethod);
+        if (!ModelUtils_1.ModelUtils.isLanguageOverloadSupport(this.getLanguage())) {
+            this.setMethodNameEntry(newMethod.getName(), sigID);
         }
-        else {
-            methodsWithSameName[matchIndex] = newMethod;
+        else if (!this.replaceTopMethodSigIDByMatch(newMethod)) {
+            this.appendMethodNameEntry(newMethod.getName(), sigID);
         }
     }
     /**
@@ -531,7 +894,19 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
      */
     getMethodsWithName(methodName) {
         var _a;
-        return (_a = this.methods.get(methodName)) !== null && _a !== void 0 ? _a : [];
+        const ids = (_a = this.methodNameIndex) === null || _a === void 0 ? void 0 : _a.get(methodName);
+        if (ids === undefined || ids.length === 0) {
+            return [];
+        }
+        const reg = this.registry;
+        const result = [];
+        for (let i = 0; i < ids.length; i++) {
+            const m = reg.methodSigCanonicalizer.getModel(ids[i]);
+            if (m) {
+                result.push(m);
+            }
+        }
+        return result;
     }
     /**
      * Get all static methods with the same name.
@@ -541,7 +916,19 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
      */
     getStaticMethodsWithName(methodName) {
         var _a;
-        return (_a = this.staticMethods.get(methodName)) !== null && _a !== void 0 ? _a : [];
+        const ids = (_a = this.staticMethodNameIndex) === null || _a === void 0 ? void 0 : _a.get(methodName);
+        if (ids === undefined || ids.length === 0) {
+            return [];
+        }
+        const reg = this.registry;
+        const result = [];
+        for (let i = 0; i < ids.length; i++) {
+            const m = reg.methodSigCanonicalizer.getModel(ids[i]);
+            if (m) {
+                result.push(m);
+            }
+        }
+        return result;
     }
     /**
      * Get all non-static and static methods with the same name.
@@ -554,11 +941,15 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
         return [...new Set(allMethods)];
     }
     setDefaultArkMethod(defaultMethod) {
-        this.defaultMethod = defaultMethod;
+        this.defaultMethodSigID = defaultMethod.getMethodSigID();
         this.addMethod(defaultMethod);
     }
     getDefaultArkMethod() {
-        return this.defaultMethod;
+        var _a;
+        if (this.defaultMethodSigID === undefined) {
+            return null;
+        }
+        return (_a = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().methodSigCanonicalizer.getModel(this.defaultMethodSigID)) !== null && _a !== void 0 ? _a : null;
     }
     setViewTree(viewTree) {
         this.viewTree = viewTree;
@@ -603,54 +994,383 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
         return this.viewTree !== undefined;
     }
     getStaticFields(_classMap) {
-        return Array.from(this.staticFields.values());
+        const arr = this.topStaticFieldSigIDs;
+        if (!arr) {
+            return [];
+        }
+        const reg = this.registry;
+        const result = [];
+        for (let i = 0; i < this.topStaticFieldCount; i++) {
+            const fld = reg.fieldSigCanonicalizer.getModel(arr[i]);
+            if (fld) {
+                result.push(fld);
+            }
+        }
+        return result;
     }
+    /** @deprecated No callers remain in the codebase; no replacement. */
     getGlobalVariable(globalMap) {
-        if (this.declaringArkNamespace) {
-            return globalMap.get(this.declaringArkNamespace.getNamespaceSignature());
+        const ns = this.getDeclaringArkNamespace();
+        if (ns) {
+            return globalMap.get(ns.getNamespaceSignature());
         }
-        return globalMap.get(this.declaringArkFile.getFileSignature());
+        return globalMap.get(this.getDeclaringArkFile().getFileSignature());
     }
     getAnonymousMethodNumber() {
         return this.anonymousMethodNumber++;
     }
+    /** @deprecated No callers remain in the codebase; no replacement. */
     getIndexSignatureNumber() {
         return this.indexSignatureNumber++;
     }
     getExportType() {
         return ArkExport_1.ExportType.CLASS;
     }
+    /** @internal Returns the instance init method, or null if not set. */
+    getInstanceInitMethodOrNull() {
+        var _a;
+        if (this.instanceInitMethodSigID === undefined) {
+            return null;
+        }
+        return (_a = this.registry.methodSigCanonicalizer.getModel(this.instanceInitMethodSigID)) !== null && _a !== void 0 ? _a : null;
+    }
+    /** @internal Returns the static init method, or null if not set. */
+    getStaticInitMethodOrNull() {
+        var _a;
+        if (this.staticInitMethodSigID === undefined) {
+            return null;
+        }
+        return (_a = this.registry.methodSigCanonicalizer.getModel(this.staticInitMethodSigID)) !== null && _a !== void 0 ? _a : null;
+    }
+    /** @deprecated Use {@link getInstanceInitMethodOrNull} instead. */
     getInstanceInitMethod() {
-        return this.instanceInitMethod;
+        var _a;
+        return (_a = this.getInstanceInitMethodOrNull()) !== null && _a !== void 0 ? _a : new ArkMethod_1.ArkMethod();
     }
+    /** @deprecated Use {@link getStaticInitMethodOrNull} instead. */
     getStaticInitMethod() {
-        return this.staticInitMethod;
+        var _a;
+        return (_a = this.getStaticInitMethodOrNull()) !== null && _a !== void 0 ? _a : new ArkMethod_1.ArkMethod();
     }
     setInstanceInitMethod(arkMethod) {
-        this.instanceInitMethod = arkMethod;
+        this.instanceInitMethodSigID = arkMethod.getMethodSigID();
     }
     setStaticInitMethod(arkMethod) {
-        this.staticInitMethod = arkMethod;
+        this.staticInitMethodSigID = arkMethod.getMethodSigID();
+    }
+    // --- Instance/static method name index ---
+    /** @internal Returns the instance method name index, or undefined if no instance methods exist. */
+    getMethodNameIndex() {
+        return this.methodNameIndex;
+    }
+    /** @internal Returns the static method name index, or undefined if no static methods exist. */
+    getStaticMethodNameIndex() {
+        return this.staticMethodNameIndex;
+    }
+    /** @internal Appends the SigID under the method name in the instance index. */
+    appendMethodNameEntry(name, id) {
+        var _a, _b;
+        const ids = (_a = this.methodNameIndex) === null || _a === void 0 ? void 0 : _a.get(name);
+        if (ids !== undefined) {
+            ids.push(id);
+            return;
+        }
+        ((_b = this.methodNameIndex) !== null && _b !== void 0 ? _b : (this.methodNameIndex = new Map())).set(name, [id]);
+    }
+    /** @internal Appends the SigID under the method name in the static index. */
+    appendStaticMethodNameEntry(name, id) {
+        var _a, _b;
+        const ids = (_a = this.staticMethodNameIndex) === null || _a === void 0 ? void 0 : _a.get(name);
+        if (ids !== undefined) {
+            ids.push(id);
+            return;
+        }
+        ((_b = this.staticMethodNameIndex) !== null && _b !== void 0 ? _b : (this.staticMethodNameIndex = new Map())).set(name, [id]);
+    }
+    /**
+     * @internal Sets the instance method name entry to a single SigID. Overwrites any
+     * previous same-name entry; set() on an existing key preserves its insertion position
+     * (non-overload same-name replacement keeps the first-occurrence order).
+     */
+    setMethodNameEntry(name, id) {
+        var _a;
+        ((_a = this.methodNameIndex) !== null && _a !== void 0 ? _a : (this.methodNameIndex = new Map())).set(name, [id]);
+    }
+    /**
+     * @internal Sets the static method name entry to a single SigID. See {@link setMethodNameEntry}.
+     */
+    setStaticMethodNameEntry(name, id) {
+        var _a;
+        ((_a = this.staticMethodNameIndex) !== null && _a !== void 0 ? _a : (this.staticMethodNameIndex = new Map())).set(name, [id]);
+    }
+    /**
+     * @internal For overload-supported languages: replace the SigID of the same-signature
+     * instance method in place. Returns true if replaced.
+     */
+    replaceTopMethodSigIDByMatch(newMethod) {
+        var _a, _b;
+        const index = this.methodNameIndex;
+        if (!index) {
+            return false;
+        }
+        const reg = this.registry;
+        const newSig = newMethod.getSignature();
+        const newID = (_a = newMethod.getMethodSigID()) !== null && _a !== void 0 ? _a : (_b = newMethod.getDeclareSigIDs()) === null || _b === void 0 ? void 0 : _b[0];
+        if (newID === undefined) {
+            return false;
+        }
+        for (const ids of index.values()) {
+            for (let i = 0; i < ids.length; i++) {
+                const m = reg.methodSigCanonicalizer.getModel(ids[i]);
+                if (m && m.getSignature().isMatch(newSig)) {
+                    ids[i] = newID;
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * @internal For overload-supported languages: replace the SigID of the same-signature
+     * static method in place. Returns true if replaced.
+     */
+    replaceTopStaticMethodSigIDByMatch(newMethod) {
+        var _a, _b;
+        const index = this.staticMethodNameIndex;
+        if (!index) {
+            return false;
+        }
+        const reg = this.registry;
+        const newSig = newMethod.getSignature();
+        const newID = (_a = newMethod.getMethodSigID()) !== null && _a !== void 0 ? _a : (_b = newMethod.getDeclareSigIDs()) === null || _b === void 0 ? void 0 : _b[0];
+        if (newID === undefined) {
+            return false;
+        }
+        for (const ids of index.values()) {
+            for (let i = 0; i < ids.length; i++) {
+                const m = reg.methodSigCanonicalizer.getModel(ids[i]);
+                if (m && m.getSignature().isMatch(newSig)) {
+                    ids[i] = newID;
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /** @internal Removes the SigID of one instance method from the index (exact ID match). Returns true if it was held. */
+    removeTopMethodSigID(id) {
+        const index = this.methodNameIndex;
+        if (!index) {
+            return false;
+        }
+        for (const [name, ids] of index) {
+            const i = ids.indexOf(id);
+            if (i >= 0) {
+                if (ids.length === 1) {
+                    index.delete(name);
+                }
+                else {
+                    ids.splice(i, 1);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    /** @internal Removes the SigID of one static method from the index (exact ID match). Returns true if it was held. */
+    removeTopStaticMethodSigID(id) {
+        const index = this.staticMethodNameIndex;
+        if (!index) {
+            return false;
+        }
+        for (const [name, ids] of index) {
+            const i = ids.indexOf(id);
+            if (i >= 0) {
+                if (ids.length === 1) {
+                    index.delete(name);
+                }
+                else {
+                    ids.splice(i, 1);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    // --- Instance field SigID index ---
+    /** @internal Checks whether a field with the given SigID is a direct instance field. */
+    hasTopFieldWithID(id) {
+        const arr = this.topFieldSigIDs;
+        if (!arr) {
+            return false;
+        }
+        const count = this.topFieldCount;
+        for (let i = 0; i < count; i++) {
+            if (arr[i] === id) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** @internal Ensures the instance field Int32Array has at least minCapacity slots. */
+    ensureTopFieldCapacity(minCapacity) {
+        if (!this.topFieldSigIDs) {
+            this.topFieldSigIDs = new Int32Array(Math.max(minCapacity, 8));
+            return;
+        }
+        if (this.topFieldSigIDs.length < minCapacity) {
+            const newCapacity = Math.max(minCapacity, this.topFieldSigIDs.length * 2);
+            const newArray = new Int32Array(newCapacity);
+            newArray.set(this.topFieldSigIDs.subarray(0, this.topFieldCount));
+            this.topFieldSigIDs = newArray;
+        }
+    }
+    /** @internal Appends an instance field SigID to the index. */
+    addTopFieldSigID(id) {
+        this.ensureTopFieldCapacity(this.topFieldCount + 1);
+        this.topFieldSigIDs[this.topFieldCount++] = id;
+    }
+    /** @internal Removes an instance field SigID from the index (swap-remove). */
+    removeTopFieldSigID(id) {
+        const arr = this.topFieldSigIDs;
+        if (!arr) {
+            return;
+        }
+        const count = this.topFieldCount;
+        for (let i = 0; i < count; i++) {
+            if (arr[i] === id) {
+                arr[i] = arr[--this.topFieldCount];
+                return;
+            }
+        }
+    }
+    // --- Static field SigID index ---
+    /** @internal Checks whether a field with the given SigID is a direct static field. */
+    hasTopStaticFieldWithID(id) {
+        const arr = this.topStaticFieldSigIDs;
+        if (!arr) {
+            return false;
+        }
+        const count = this.topStaticFieldCount;
+        for (let i = 0; i < count; i++) {
+            if (arr[i] === id) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** @internal Ensures the static field Int32Array has at least minCapacity slots. */
+    ensureTopStaticFieldCapacity(minCapacity) {
+        if (!this.topStaticFieldSigIDs) {
+            this.topStaticFieldSigIDs = new Int32Array(Math.max(minCapacity, 8));
+            return;
+        }
+        if (this.topStaticFieldSigIDs.length < minCapacity) {
+            const newCapacity = Math.max(minCapacity, this.topStaticFieldSigIDs.length * 2);
+            const newArray = new Int32Array(newCapacity);
+            newArray.set(this.topStaticFieldSigIDs.subarray(0, this.topStaticFieldCount));
+            this.topStaticFieldSigIDs = newArray;
+        }
+    }
+    /** @internal Appends a static field SigID to the index. */
+    addTopStaticFieldSigID(id) {
+        this.ensureTopStaticFieldCapacity(this.topStaticFieldCount + 1);
+        this.topStaticFieldSigIDs[this.topStaticFieldCount++] = id;
+    }
+    /** @internal Removes a static field SigID from the index (swap-remove). */
+    removeTopStaticFieldSigID(id) {
+        const arr = this.topStaticFieldSigIDs;
+        if (!arr) {
+            return;
+        }
+        const count = this.topStaticFieldCount;
+        for (let i = 0; i < count; i++) {
+            if (arr[i] === id) {
+                arr[i] = arr[--this.topStaticFieldCount];
+                return;
+            }
+        }
+    }
+    // --- Extended class (subclass back-reference) SigID index ---
+    /** @internal Checks whether a class with the given ClassSigID is a direct subclass. */
+    hasExtendedClassWithID(id) {
+        const arr = this.extendedClassSigIDs;
+        if (!arr) {
+            return false;
+        }
+        const count = this.extendedClassCount;
+        for (let i = 0; i < count; i++) {
+            if (arr[i] === id) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** @internal Ensures the extended class Int32Array has at least minCapacity slots. */
+    ensureExtendedClassCapacity(minCapacity) {
+        if (!this.extendedClassSigIDs) {
+            this.extendedClassSigIDs = new Int32Array(Math.max(minCapacity, 8));
+            return;
+        }
+        if (this.extendedClassSigIDs.length < minCapacity) {
+            const newCapacity = Math.max(minCapacity, this.extendedClassSigIDs.length * 2);
+            const newArray = new Int32Array(newCapacity);
+            newArray.set(this.extendedClassSigIDs.subarray(0, this.extendedClassCount));
+            this.extendedClassSigIDs = newArray;
+        }
+    }
+    /** @internal Appends a subclass ClassSigID to the index. */
+    addExtendedClassSigID(id) {
+        this.ensureExtendedClassCapacity(this.extendedClassCount + 1);
+        this.extendedClassSigIDs[this.extendedClassCount++] = id;
+    }
+    /** @internal Removes a subclass ClassSigID from the index (swap-remove). */
+    removeExtendedClassSigID(id) {
+        const arr = this.extendedClassSigIDs;
+        if (!arr) {
+            return;
+        }
+        const count = this.extendedClassCount;
+        for (let i = 0; i < count; i++) {
+            if (arr[i] === id) {
+                arr[i] = arr[--this.extendedClassCount];
+                return;
+            }
+        }
     }
     removeField(field) {
+        const id = field.getFieldSigID();
         if (field.isStatic()) {
-            return this.staticFields.delete(field.getName());
+            const rtn = this.hasTopStaticFieldWithID(id);
+            if (rtn) {
+                this.removeTopStaticFieldSigID(id);
+                this.registry.removeField(field);
+            }
+            return rtn;
+        }
+        const rtn = this.hasTopFieldWithID(id);
+        if (rtn) {
+            this.removeTopFieldSigID(id);
+            this.registry.removeField(field);
         }
-        return this.fields.delete(field.getName());
+        return rtn;
     }
     removeMethod(method) {
+        var _a, _b, _c;
+        // Remove exactly this method (by its index SigID), not all same-name siblings.
+        const id = (_c = (_a = method.getMethodSigID()) !== null && _a !== void 0 ? _a : (_b = method.getDeclareSigIDs()) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : -1;
         let rtn = false;
         if (method.isStatic()) {
-            rtn = this.staticMethods.delete(method.getName());
+            rtn = this.removeTopStaticMethodSigID(id);
         }
         else {
-            rtn = this.methods.delete(method.getName());
+            rtn = this.removeTopMethodSigID(id);
         }
-        rtn && (rtn = this.getDeclaringArkFile().getScene().removeMethod(method));
+        rtn && (rtn = this.registry.removeMethod(method));
         return rtn;
     }
     validate() {
-        return this.validateFields(['declaringArkFile', 'classSignature']);
+        return this.validateFields(['declaringFileID']);
     }
     addTs2cxxFuncMapElement(funcName, methods) {
         this.ts2cxxFuncMap.set(funcName, methods);
@@ -665,41 +1385,51 @@ class ArkClass extends ArkBaseModel_1.ArkBaseModel {
         this.classDeclareSignature = classSig;
     }
     clearAllReferences() {
-        for (const methods of this.methods.values()) {
-            for (const mtd of methods) {
-                mtd.clearAllReferences();
+        var _a, _b;
+        const reg = this.registry;
+        const index = this.methodNameIndex;
+        if (index) {
+            for (const ids of index.values()) {
+                for (let i = 0; i < ids.length; i++) {
+                    (_a = reg.methodSigCanonicalizer.getModel(ids[i])) === null || _a === void 0 ? void 0 : _a.clearAllReferences();
+                }
             }
         }
-        for (const methods of this.staticMethods.values()) {
-            for (const mtd of methods) {
-                mtd.clearAllReferences();
+        const staticIndex = this.staticMethodNameIndex;
+        if (staticIndex) {
+            for (const ids of staticIndex.values()) {
+                for (let i = 0; i < ids.length; i++) {
+                    (_b = reg.methodSigCanonicalizer.getModel(ids[i])) === null || _b === void 0 ? void 0 : _b.clearAllReferences();
+                }
             }
         }
-        for (const fld of this.fields.values()) {
-            fld.clearAllReferences();
-        }
-        for (const fld of this.staticFields.values()) {
+        for (const fld of this.getFields()) {
             fld.clearAllReferences();
         }
-        if (this.instanceInitMethod) {
-            this.instanceInitMethod.clearAllReferences();
+        const instanceInit = this.getInstanceInitMethodOrNull();
+        if (instanceInit) {
+            instanceInit.clearAllReferences();
         }
-        if (this.staticInitMethod) {
-            this.staticInitMethod.clearAllReferences();
+        const staticInit = this.getStaticInitMethodOrNull();
+        if (staticInit) {
+            staticInit.clearAllReferences();
         }
-        this.methods.clear();
-        this.staticMethods.clear();
-        this.fields.clear();
-        this.staticFields.clear();
-        this.extendedClasses.clear();
+        this.methodNameIndex = undefined;
+        this.staticMethodNameIndex = undefined;
+        this.topFieldSigIDs = undefined;
+        this.topFieldCount = 0;
+        this.topStaticFieldSigIDs = undefined;
+        this.topStaticFieldCount = 0;
+        this.extendedClassSigIDs = undefined;
+        this.extendedClassCount = 0;
         this.heritageClasses.clear();
         this.ts2cxxFuncMap.clear();
-        this.defaultMethod = null;
-        this.instanceInitMethod = undefined;
-        this.staticInitMethod = undefined;
+        this.defaultMethodSigID = undefined;
+        this.instanceInitMethodSigID = undefined;
+        this.staticInitMethodSigID = undefined;
         this.viewTree = undefined;
-        this.declaringArkFile = undefined;
-        this.declaringArkNamespace = undefined;
+        this.declaringFileID = -1;
+        this.declaringNamespaceSigID = undefined;
     }
 }
 exports.ArkClass = ArkClass;