arkanalyzer 1.0.93 → 2.0.0-beta1

package/lib/core/model/ArkSignature.js

@@ -13,24 +13,53 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.genSignature4ImportClause = exports.fileSignatureCompare = exports.classSignatureCompare = exports.methodSubSignatureCompare = exports.methodSignatureCompare = exports.fieldSignatureCompare = exports.AliasTypeSignature = exports.LocalSignature = exports.MethodSignature = exports.MethodSubSignature = exports.FieldSignature = exports.AliasClassSignature = exports.ClassSignature = exports.NamespaceSignature = exports.FileSignature = void 0;
-const path_1 = __importDefault(require("path"));
+exports.genSignature4ImportClause = exports.fileSignatureCompare = exports.classSignatureCompare = exports.methodSubSignatureCompare = exports.methodSignatureCompare = exports.fieldSignatureCompare = exports.AliasTypeSignature = exports.LocalSignature = exports.MethodSignature = exports.MethodSubSignature = exports.FieldSignature = exports.internAliasMethodSignature = exports.AliasClassSignature = exports.ClassSignature = exports.NamespaceSignature = exports.FileSignature = void 0;
 const pathTransfer_1 = require("../../utils/pathTransfer");
 const Type_1 = require("../base/Type");
 const Const_1 = require("../common/Const");
-const crypto_utils_1 = require("../../utils/crypto_utils");
+const SignatureCanonicalizerRegistry_1 = require("../common/SignatureCanonicalizerRegistry");
+const SignatureCanonicalizer_1 = require("../common/SignatureCanonicalizer");
+const HashUtils_1 = require("../../utils/HashUtils");
+const logger_1 = __importStar(require("../../utils/logger"));
 /**
  * @category core/model
  */
 class FileSignature {
+    /** The canonical DEFAULT signature (formal sigID 0 in the registry). */
+    static get DEFAULT() {
+        return SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().fileSigCanonicalizer.get(0);
+    }
     constructor(projectName, fileName) {
         this.projectName = projectName;
         this.fileName = (0, pathTransfer_1.transfer2UnixPath)(fileName);
-        this.hashcode = crypto_utils_1.CryptoUtils.hashcode(this.toString());
+        let h = 0xdeadbeef;
+        h = (0, HashUtils_1.hashCombineU32)(h, (0, HashUtils_1.hashString32)(this.projectName));
+        h = (0, HashUtils_1.hashCombineU32)(h, (0, HashUtils_1.hashString32)(this.fileName));
+        this.hashCode = h >>> 0;
     }
     getProjectName() {
         return this.projectName;
@@ -41,65 +70,245 @@ class FileSignature {
     toString() {
         return `@${this.projectName}/${this.fileName}: `;
     }
+    /**
+     * @deprecated No longer used internally since the ID refactor: identity comparison
+     * uses {@link signatureEquals} (hash + equals), indexing uses the canonicalizer.
+     * Kept for backward compatibility only — for identity checks use `equals()`
+     * (with `getHashCode()` fast reject), for debug output use `toString()`.
+     *
+     * Implementation note: identity projection (= toString, projectName + fileName are the complete identity fields) — collision-free.
+     */
     toMapKey() {
-        return `${this.hashcode}${path_1.default.basename(this.fileName)}`;
+        return this.toString();
+    }
+    getHashCode() {
+        return this.hashCode;
+    }
+    equals(other) {
+        if (this === other) {
+            return true;
+        }
+        return this.projectName === other.projectName && this.fileName === other.fileName;
+    }
+    /** @internal FileSignature is never unclear (it is the identity root). */
+    isUnclear() {
+        return false;
     }
 }
 exports.FileSignature = FileSignature;
-FileSignature.DEFAULT = new FileSignature(Const_1.UNKNOWN_PROJECT_NAME, Const_1.UNKNOWN_FILE_NAME);
 class NamespaceSignature {
-    constructor(namespaceName, declaringFileSignature, declaringNamespaceSignature = null) {
+    /** The canonical DEFAULT signature (formal sigID 0 in the registry). */
+    static get DEFAULT() {
+        return SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().namespaceSigCanonicalizer.get(0);
+    }
+    constructor(namespaceName, declaringFileOrID, declaringNSOrID) {
+        function computeHashCode(fileId, namespaceName, declaringNSId) {
+            let h = 0xdeadbeef;
+            h = (0, HashUtils_1.hashCombineU32)(h, fileId);
+            h = (0, HashUtils_1.hashCombineU32)(h, (0, HashUtils_1.hashString32)(namespaceName));
+            h = (0, HashUtils_1.hashCombineU32)(h, declaringNSId !== null && declaringNSId !== void 0 ? declaringNSId : 0);
+            return h >>> 0;
+        }
         this.namespaceName = namespaceName;
-        this.declaringFileSignature = declaringFileSignature;
-        this.declaringNamespaceSignature = declaringNamespaceSignature;
+        if (typeof declaringFileOrID === 'number') {
+            this.declaringFileSigID = declaringFileOrID;
+            this.declaringNamespaceSigID = typeof declaringNSOrID === 'number' ? declaringNSOrID : undefined;
+            this.hashCode = computeHashCode(this.declaringFileSigID, this.namespaceName, this.declaringNamespaceSigID);
+            return;
+        }
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        let fileSigID;
+        let nsSigID;
+        // FileSignature 永不 unclear——身份根。
+        const fileExistingId = reg.fileSigCanonicalizer.getExistingId(declaringFileOrID);
+        if (fileExistingId !== -1) {
+            fileSigID = fileExistingId;
+        }
+        else {
+            NamespaceSignature.logger.error(`Clear FileSignature declaring not interned — defaulting to ID 0: ${declaringFileOrID.toString()}`);
+            fileSigID = 0;
+        }
+        // namespace 无 temp 空间。
+        if (declaringNSOrID instanceof NamespaceSignature) {
+            if (declaringNSOrID.isUnclear()) {
+                NamespaceSignature.logger.error(`Unclear NamespaceSignature — marking -1: ${declaringNSOrID.toString()}`);
+                nsSigID = -1;
+            }
+            else {
+                const nsExistingId = reg.namespaceSigCanonicalizer.getExistingId(declaringNSOrID);
+                if (nsExistingId !== -1) {
+                    nsSigID = nsExistingId;
+                }
+                else {
+                    NamespaceSignature.logger.error(`Clear NamespaceSignature declaring not interned — marking -1: ${declaringNSOrID.toString()}`);
+                    nsSigID = -1;
+                }
+            }
+        }
+        this.declaringFileSigID = fileSigID;
+        this.declaringNamespaceSigID = nsSigID;
+        this.hashCode = computeHashCode(this.declaringFileSigID, this.namespaceName, this.declaringNamespaceSigID);
     }
     getNamespaceName() {
         return this.namespaceName;
     }
+    /** @internal Get the formal NamespaceSigID of this signature (interning it if needed). */
+    getNamespaceSigID() {
+        return SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().namespaceSigCanonicalizer.getExistingId(this);
+    }
     getDeclaringFileSignature() {
-        return this.declaringFileSignature;
+        const sig = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().fileSigCanonicalizer.get(this.declaringFileSigID);
+        if (sig !== undefined) {
+            return sig;
+        }
+        // Stale SigID (registry disposed and rebuilt): degrade to DEFAULT instead of crashing.
+        NamespaceSignature.logger.error(`NamespaceSignature '${this.namespaceName}' has a stale declaring file SigID ${this.declaringFileSigID}; returning DEFAULT.`);
+        return FileSignature.DEFAULT;
+    }
+    /** @internal Get the formal FileSigID of the declaring file. (Renamed from
+     * getDeclaringFileSigId to align the casing with ClassSignature/getFileSigID.) */
+    getDeclaringFileSigID() {
+        return this.declaringFileSigID;
+    }
+    /** @internal Get the formal NamespaceSigID of the declaring namespace. undefined = top-level. */
+    getDeclaringNamespaceSigID() {
+        return this.declaringNamespaceSigID;
     }
     getDeclaringNamespaceSignature() {
-        return this.declaringNamespaceSignature;
+        if (this.declaringNamespaceSigID === undefined) {
+            return null;
+        }
+        const sig = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().namespaceSigCanonicalizer.get(this.declaringNamespaceSigID);
+        if (sig !== undefined) {
+            return sig;
+        }
+        // Stale SigID (registry disposed and rebuilt): degrade to DEFAULT instead of crashing.
+        NamespaceSignature.logger.error(`NamespaceSignature '${this.namespaceName}' has a stale declaring namespace SigID ${this.declaringNamespaceSigID}; returning DEFAULT.`);
+        return NamespaceSignature.DEFAULT;
     }
     toString() {
-        if (this.declaringNamespaceSignature) {
-            return this.declaringNamespaceSignature.toString() + '.' + this.namespaceName;
-        }
-        else {
-            return this.declaringFileSignature.toString() + this.namespaceName;
+        const declaringNS = this.getDeclaringNamespaceSignature();
+        if (declaringNS !== null) {
+            return declaringNS.toString() + '.' + this.namespaceName;
         }
+        return this.getDeclaringFileSignature().toString() + this.namespaceName;
     }
+    /**
+     * @deprecated No longer used internally since the ID refactor: identity comparison
+     * uses {@link signatureEquals} (hash + equals), indexing uses the canonicalizer.
+     * Kept for backward compatibility only — for identity checks use `equals()`
+     * (with `getHashCode()` fast reject), for debug output use `toString()`.
+     */
     toMapKey() {
-        if (this.declaringNamespaceSignature) {
-            return this.declaringNamespaceSignature.toMapKey() + '.' + this.namespaceName;
+        const declaringNS = this.getDeclaringNamespaceSignature();
+        if (declaringNS !== null) {
+            return declaringNS.toMapKey() + '.' + this.namespaceName;
         }
-        else {
-            return this.declaringFileSignature.toMapKey() + this.namespaceName;
+        return this.getDeclaringFileSignature().toMapKey() + this.namespaceName;
+    }
+    getHashCode() {
+        return this.hashCode;
+    }
+    equals(other) {
+        if (this === other) {
+            return true;
         }
+        if (this.namespaceName !== other.namespaceName) {
+            return false;
+        }
+        if (this.declaringFileSigID !== other.declaringFileSigID) {
+            return false;
+        }
+        return this.declaringNamespaceSigID === other.declaringNamespaceSigID;
+    }
+    /** Whether this signature's declaring file is unknown (FileSignature.DEFAULT). */
+    isUnclear() {
+        return this.declaringFileSigID === 0 && this.namespaceName !== Const_1.UNKNOWN_NAMESPACE_NAME;
     }
 }
 exports.NamespaceSignature = NamespaceSignature;
-NamespaceSignature.DEFAULT = new NamespaceSignature(Const_1.UNKNOWN_NAMESPACE_NAME, FileSignature.DEFAULT, null);
+NamespaceSignature.logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'NamespaceSignature');
 class ClassSignature {
-    constructor(className, declaringFileSignature, declaringNamespaceSignature = null) {
+    /** The canonical DEFAULT signature (formal sigID 0 in the registry). */
+    static get DEFAULT() {
+        return SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().classSigCanonicalizer.get(0);
+    }
+    constructor(className, declaringFileOrID, declaringNSOrID) {
         this.className = className;
-        this.declaringFileSignature = declaringFileSignature;
-        this.declaringNamespaceSignature = declaringNamespaceSignature;
+        if (typeof declaringFileOrID === 'number') {
+            this.declaringFileSigID = declaringFileOrID;
+            this.declaringNamespaceSigID = typeof declaringNSOrID === 'number' ? declaringNSOrID : undefined;
+            this.recomputeHashCode();
+            return;
+        }
+        let fileSigID;
+        let nsSigID;
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        // FileSignature 永不 unclear——身份根。
+        const fileExistingId = reg.fileSigCanonicalizer.getExistingId(declaringFileOrID);
+        if (fileExistingId !== -1) {
+            fileSigID = fileExistingId;
+        }
+        else {
+            ClassSignature.logger.error(`Clear FileSignature declaring not interned — defaulting to ID 0: ${declaringFileOrID.toString()}`);
+            fileSigID = 0;
+        }
+        // namespace 无 temp 空间。
+        if (declaringNSOrID instanceof NamespaceSignature) {
+            if (declaringNSOrID.isUnclear()) {
+                nsSigID = -1;
+            }
+            else {
+                const nsExistingId = reg.namespaceSigCanonicalizer.getExistingId(declaringNSOrID);
+                if (nsExistingId !== -1) {
+                    nsSigID = nsExistingId;
+                }
+                else {
+                    ClassSignature.logger.error(`Clear NamespaceSignature declaring not interned — marking -1: ${declaringNSOrID.toString()}`);
+                    nsSigID = -1;
+                }
+            }
+        }
+        this.declaringFileSigID = fileSigID;
+        this.declaringNamespaceSigID = nsSigID;
+        this.recomputeHashCode();
     }
     /**
      * Returns the declaring file signature.
      * @returns The declaring file signature.
      */
     getDeclaringFileSignature() {
-        return this.declaringFileSignature;
+        const sig = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().fileSigCanonicalizer.get(this.declaringFileSigID);
+        if (sig !== undefined) {
+            return sig;
+        }
+        // Stale SigID (registry disposed and rebuilt): degrade to DEFAULT instead of crashing.
+        ClassSignature.logger.error(`ClassSignature '${this.className}' has a stale declaring file SigID ${this.declaringFileSigID}; returning DEFAULT.`);
+        return FileSignature.DEFAULT;
     }
     /**
      * Get the declaring namespace's signature.
      * @returns the declaring namespace's signature.
      */
     getDeclaringNamespaceSignature() {
-        return this.declaringNamespaceSignature;
+        if (this.declaringNamespaceSigID === undefined) {
+            return null;
+        }
+        const sig = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().namespaceSigCanonicalizer.get(this.declaringNamespaceSigID);
+        if (sig !== undefined) {
+            return sig;
+        }
+        // Stale SigID (registry disposed and rebuilt): degrade to DEFAULT instead of crashing.
+        ClassSignature.logger.error(`ClassSignature '${this.className}' has a stale declaring namespace SigID ${this.declaringNamespaceSigID}; returning DEFAULT.`);
+        return NamespaceSignature.DEFAULT;
+    }
+    /** @internal Get the formal FileSigID of the declaring file. */
+    getDeclaringFileSigID() {
+        return this.declaringFileSigID;
+    }
+    /** @internal Get the formal NamespaceSigID of the declaring namespace. Returns undefined for top-level classes. */
+    getDeclaringNamespaceSigID() {
+        return this.declaringNamespaceSigID;
     }
     /**
      * Get the **string** name of class from the the class signature. The default value is `""`.
@@ -108,6 +317,34 @@ class ClassSignature {
     getClassName() {
         return this.className;
     }
+    /** @internal Recompute the cached hash from the current parts (constructor and probe). */
+    recomputeHashCode() {
+        var _a;
+        let h = 0xdeadbeef;
+        h = (0, HashUtils_1.hashCombineU32)(h, this.declaringFileSigID);
+        h = (0, HashUtils_1.hashCombineU32)(h, (0, HashUtils_1.hashString32)(this.className));
+        h = (0, HashUtils_1.hashCombineU32)(h, (_a = this.declaringNamespaceSigID) !== null && _a !== void 0 ? _a : 0);
+        this.hashCode = h >>> 0;
+    }
+    /**
+     * @internal Shared mutable probe for existence-check lookups (getClassWithName and
+     * friends), which built a throwaway ClassSignature - object plus string hash - on every
+     * probe (~1.5GB per full build). Consume the result in a single expression: the next
+     * probe call rewrites the parts. Never store or intern the returned instance.
+     */
+    static probe(className, declaringFileSigID, declaringNamespaceSigID) {
+        let p = ClassSignature.probeInstance;
+        if (p === undefined) {
+            p = new ClassSignature(className, declaringFileSigID, declaringNamespaceSigID);
+            ClassSignature.probeInstance = p;
+            return p;
+        }
+        p.className = className;
+        p.declaringFileSigID = declaringFileSigID;
+        p.declaringNamespaceSigID = declaringNamespaceSigID;
+        p.recomputeHashCode();
+        return p;
+    }
     /**
      *
      * @returns The name of the declare class.
@@ -122,6 +359,11 @@ class ClassSignature {
         }
         return this.className;
     }
+    /**
+     * @deprecated Mutating the class name breaks the cached hash (the signature would intern
+     * to a different SigID than a freshly built one with the new name). Build a new
+     * ClassSignature instead.
+     */
     setClassName(className) {
         this.className = className;
     }
@@ -129,31 +371,82 @@ class ClassSignature {
         return new Type_1.ClassType(this);
     }
     toString() {
-        if (this.declaringNamespaceSignature) {
-            return this.declaringNamespaceSignature.toString() + '.' + this.className;
-        }
-        else {
-            return this.declaringFileSignature.toString() + this.className;
+        const declaringNS = this.getDeclaringNamespaceSignature();
+        if (declaringNS !== null) {
+            return declaringNS.toString() + '.' + this.getClassName();
         }
+        return this.getDeclaringFileSignature().toString() + this.getClassName();
     }
+    /**
+     * @deprecated No longer used internally since the ID refactor: identity comparison
+     * uses {@link signatureEquals} (hash + equals), indexing uses the canonicalizer.
+     * Kept for backward compatibility only — for identity checks use `equals()`
+     * (with `getHashCode()` fast reject), for debug output use `toString()`.
+     */
     toMapKey() {
-        if (this.declaringNamespaceSignature) {
-            return this.declaringNamespaceSignature.toMapKey() + '.' + this.className;
+        const declaringNS = this.getDeclaringNamespaceSignature();
+        if (declaringNS !== null) {
+            return declaringNS.toMapKey() + '.' + this.getClassName();
         }
-        else {
-            return this.declaringFileSignature.toMapKey() + this.className;
+        return this.getDeclaringFileSignature().toMapKey() + this.getClassName();
+    }
+    getHashCode() {
+        return this.hashCode;
+    }
+    equals(other) {
+        if (this === other) {
+            return true;
         }
+        // display 归一化：alias 与任何普通签名值不等——alias 的身份含 aliasName 维度（见 AliasClassSignature.equals）。对称性由子类 equals 对非
+        // alias 返回 false 共同保证。
+        if (other instanceof AliasClassSignature) {
+            return false;
+        }
+        if (this.className !== other.className) {
+            return false;
+        }
+        if (this.declaringFileSigID !== other.declaringFileSigID) {
+            return false;
+        }
+        return this.declaringNamespaceSigID === other.declaringNamespaceSigID;
+    }
+    /**
+     * @internal Whether this signature's declaring file is unknown (FileSignature.DEFAULT).
+     * Direct field check (no registry lookup): unclear iff declaring file is DEFAULT (FileSigID 0)
+     * and this is not the DEFAULT placeholder itself (distinguished by the '%unk' name).
+     * This is a hot path in Method/FieldSignature constructor temp/formal branching.
+     */
+    isUnclear() {
+        return this.declaringFileSigID === 0 && this.className !== Const_1.UNKNOWN_CLASS_NAME;
     }
 }
 exports.ClassSignature = ClassSignature;
-ClassSignature.DEFAULT = new ClassSignature(Const_1.UNKNOWN_CLASS_NAME, FileSignature.DEFAULT, null);
+ClassSignature.logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ClassSignature');
 /**
  * `AliasClassSignature` is used to extend `ClassSignature`, preserving the actual name used during invocation.
  */
 class AliasClassSignature extends ClassSignature {
     constructor(aliasName, signature) {
-        super(signature.getClassName(), signature.getDeclaringFileSignature(), signature.getDeclaringNamespaceSignature());
+        var _a;
+        super(signature.getClassName(), signature.getDeclaringFileSigID(), signature.getDeclaringNamespaceSigID());
         this.aliasName = aliasName;
+        let h = 0xdeadbeef;
+        h = (0, HashUtils_1.hashCombineU32)(h, this.getDeclaringFileSigID());
+        h = (0, HashUtils_1.hashCombineU32)(h, (0, HashUtils_1.hashString32)(aliasName));
+        h = (0, HashUtils_1.hashCombineU32)(h, (_a = this.getDeclaringNamespaceSigID()) !== null && _a !== void 0 ? _a : 0);
+        this.aliasHashCode = h >>> 0;
+        // formal 直存 + 双注册 origin model。前置：origin 必已在 formal（两个产生点
+        // ——组件 pop 构建、Interface 替换——的前提都是真实类已注册）；origin model
+        // 缺失时 alias 条目暂无 model（Validator M3 将暴露该形态）。
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        const aliasID = reg.classSigCanonicalizer.getOrCreateId(this);
+        const originID = reg.classSigCanonicalizer.getExistingId(signature);
+        if (originID !== -1) {
+            const originModel = reg.classSigCanonicalizer.getModel(originID);
+            if (originModel !== undefined) {
+                reg.classSigCanonicalizer.setModel(aliasID, originModel);
+            }
+        }
     }
     /**
      * Returns the name used in the code.
@@ -167,20 +460,206 @@ class AliasClassSignature extends ClassSignature {
     getOriginName() {
         return super.getClassName();
     }
+    /** alias 身份 hash（aliasName 替代 origin className 参与）。 */
+    getHashCode() {
+        return this.aliasHashCode;
+    }
+    /** 比较 aliasName + origin 维度；alias 与普通签名永不相等。 */
+    equals(other) {
+        if (this === other) {
+            return true;
+        }
+        if (!(other instanceof AliasClassSignature)) {
+            return false;
+        }
+        if (this.aliasName !== other.aliasName) {
+            return false;
+        }
+        if (this.getDeclaringFileSigID() !== other.getDeclaringFileSigID()) {
+            return false;
+        }
+        return this.getDeclaringNamespaceSigID() === other.getDeclaringNamespaceSigID();
+    }
 }
 exports.AliasClassSignature = AliasClassSignature;
+/**
+ * @internal
+ * display 归一化：将 alias MethodSignature intern 进 methodSig formal 空间并双注册 origin 的 ArkMethod model（与 AliasClassSignature 构造器的 class 侧双注册
+ * 对称）。产生点（组件 pop 构建 / Interface 替换）在把签名交给 expr 之前调用——expr 的 route() formal 命中持 SigID，scene.getMethod 经 getModel 直命中
+ * 真实方法（callgraph/ViewTree findMethod 全链路无需 fallback）。
+ */
+function internAliasMethodSignature(aliasSignature, originSignature) {
+    const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+    const aliasID = reg.methodSigCanonicalizer.getOrCreateId(aliasSignature);
+    const originID = reg.methodSigCanonicalizer.getExistingId(originSignature);
+    if (originID === -1) {
+        return;
+    }
+    const originModel = reg.methodSigCanonicalizer.getModel(originID);
+    if (originModel !== undefined) {
+        reg.methodSigCanonicalizer.setModel(aliasID, originModel);
+    }
+}
+exports.internAliasMethodSignature = internAliasMethodSignature;
 class FieldSignature {
-    constructor(fieldName, declaringSignature, type, staticFlag = false) {
+    /** The canonical DEFAULT signature (formal sigID 0 in the registry). */
+    static get DEFAULT() {
+        return SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().fieldSigCanonicalizer.get(0);
+    }
+    constructor(fieldName, declaringOrID, type, staticFlag = false, namespaceDeclared, declaringClassTempSigID) {
         this.fieldName = fieldName;
-        this.declaringSignature = declaringSignature;
         this.type = type;
         this.staticFlag = staticFlag;
+        if (typeof declaringOrID === 'number' && !namespaceDeclared) {
+            // Class-side SigID path: direct field assignment (formal or temp via optional param).
+            this.declaringClassSigID = declaringOrID;
+            this.declaringClassTempSigID = declaringClassTempSigID;
+            this.declaringNamespaceSigID = undefined;
+        }
+        else {
+            this.setDeclaringFields(declaringOrID, namespaceDeclared !== null && namespaceDeclared !== void 0 ? namespaceDeclared : false);
+        }
+        this.recomputeHashCode();
+    }
+    /**
+     * @internal 解析 declaring 并写入三个 SigID 字段（构造器与 {@link applyFields}共用）：
+     * 数字重载直存；
+     * 对象重载按 isUnclear 分流（unclear class → temp 登记；clear → formal 只读命中；unclear ns → 仅标记 -1）。
+     */
+    setDeclaringFields(declaringOrID, namespaceDeclared = false) {
+        if (typeof declaringOrID === 'number') {
+            this.declaringClassSigID = undefined;
+            this.declaringClassTempSigID = undefined;
+            this.declaringNamespaceSigID = undefined;
+            if (namespaceDeclared) {
+                this.declaringNamespaceSigID = declaringOrID;
+            }
+            else {
+                this.declaringClassSigID = declaringOrID;
+            }
+            return;
+        }
+        this.declaringClassSigID = undefined;
+        this.declaringClassTempSigID = undefined;
+        this.declaringNamespaceSigID = undefined;
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        if (declaringOrID instanceof ClassSignature) {
+            if (declaringOrID.isUnclear()) {
+                this.declaringClassSigID = -1;
+                this.declaringClassTempSigID = reg.tempClassSigCanonicalizer.register(declaringOrID);
+            }
+            else {
+                const existingId = reg.classSigCanonicalizer.getExistingId(declaringOrID);
+                if (existingId !== -1) {
+                    this.declaringClassSigID = existingId;
+                }
+                else {
+                    FieldSignature.logger.error(`Clear ClassSignature declaring not interned — routing to temp: ${declaringOrID.toString()}`);
+                    this.declaringClassSigID = -1;
+                    this.declaringClassTempSigID = reg.tempClassSigCanonicalizer.register(declaringOrID);
+                }
+            }
+        }
+        else {
+            // namespace 无 temp 空间。
+            if (declaringOrID.isUnclear()) {
+                FieldSignature.logger.error(`Clear ClassSignature declaring not interned — routing to temp: ${declaringOrID.toString()}`);
+                this.declaringNamespaceSigID = -1;
+            }
+            else {
+                const existingNsId = reg.namespaceSigCanonicalizer.getExistingId(declaringOrID);
+                if (existingNsId !== -1) {
+                    this.declaringNamespaceSigID = existingNsId;
+                }
+                else {
+                    FieldSignature.logger.error(`Clear NamespaceSignature declaring not interned — marking -1: ${declaringOrID.toString()}`);
+                    this.declaringNamespaceSigID = -1;
+                }
+            }
+        }
+    }
+    /**
+     * @internal Shared mutable probe for existence-check lookups (getFieldWithName and
+     * friends). Consume the result in a single expression; never store or intern it.
+     */
+    static probe(fieldName, declaringClassSigID, type, staticFlag) {
+        let p = FieldSignature.probeInstance;
+        if (p === undefined) {
+            p = new FieldSignature(fieldName, declaringClassSigID, type, staticFlag);
+            FieldSignature.probeInstance = p;
+            return p;
+        }
+        p.applyFields(fieldName, declaringClassSigID, type, staticFlag, false);
+        return p;
+    }
+    /** @internal 按当前字段值重算 hash（applyFields 就地演进后调用，值与 hash 保持一致）。 */
+    recomputeHashCode() {
+        var _a, _b, _c;
+        let h = 0xdeadbeef;
+        h = (0, HashUtils_1.hashCombineU32)(h, (_a = this.declaringClassSigID) !== null && _a !== void 0 ? _a : 0);
+        h = (0, HashUtils_1.hashCombineU32)(h, (_b = this.declaringNamespaceSigID) !== null && _b !== void 0 ? _b : 0);
+        h = (0, HashUtils_1.hashCombineU32)(h, (_c = this.declaringClassTempSigID) !== null && _c !== void 0 ? _c : 0);
+        h = (0, HashUtils_1.hashCombineU32)(h, (0, HashUtils_1.hashString32)(this.fieldName));
+        h = (0, HashUtils_1.hashCombineU32)(h, this.staticFlag ? 1 : 0);
+        this.hashCode = h >>> 0;
+    }
+    /**
+     * @internal 参数式就地演进原语——不经过中间实例 N，直接按参数赋值字段 + 解析 declaring + 重算 hash（编号不变）。供持有者更新入口的参数式路径
+     * （决策表"未毕业抄写"分支的零分配版）使用。
+     */
+    applyFields(fieldName, declaringOrID, type, staticFlag, namespaceDeclared = false) {
+        this.fieldName = fieldName;
+        this.type = type;
+        this.staticFlag = staticFlag;
+        this.setDeclaringFields(declaringOrID, namespaceDeclared);
+        this.recomputeHashCode();
     }
     getDeclaringSignature() {
-        return this.declaringSignature;
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        if (this.declaringClassSigID !== undefined && this.declaringClassSigID >= 0) {
+            const sig = reg.classSigCanonicalizer.get(this.declaringClassSigID);
+            if (sig !== undefined) {
+                return sig;
+            }
+        }
+        else if (this.declaringNamespaceSigID !== undefined && this.declaringNamespaceSigID >= 0) {
+            const sig = reg.namespaceSigCanonicalizer.get(this.declaringNamespaceSigID);
+            if (sig !== undefined) {
+                return sig;
+            }
+        }
+        else if (this.declaringClassTempSigID !== undefined) {
+            const sig = reg.tempClassSigCanonicalizer.get(this.declaringClassTempSigID);
+            if (sig !== undefined) {
+                return sig;
+            }
+            const formalId = reg.tempClassSigCanonicalizer.getReplacement(this.declaringClassTempSigID);
+            if (formalId !== -1) {
+                const formalSig = reg.classSigCanonicalizer.get(formalId);
+                if (formalSig !== undefined) {
+                    return formalSig;
+                }
+            }
+        }
+        // Stale SigID (registry disposed and rebuilt): degrade to DEFAULT instead of crashing.
+        FieldSignature.logger.error(`FieldSignature '${this.fieldName}' has a stale declaring SigID (class=${this.declaringClassSigID}, namespace=${this.declaringNamespaceSigID}, temp=${this.declaringClassTempSigID}); returning ClassSignature.DEFAULT.`);
+        return ClassSignature.DEFAULT;
+    }
+    /** @internal Get the formal ClassSigID of the declaring class. Returns -1 if unclear (temp-held), undefined if declared by namespace. */
+    getDeclaringClassSigID() {
+        return this.declaringClassSigID;
+    }
+    /** @internal Get the formal NamespaceSigID of the declaring namespace. Returns -1 if unclear (temp-held), undefined if declared by class. */
+    getDeclaringNamespaceSigID() {
+        return this.declaringNamespaceSigID;
+    }
+    /** @internal Get the temp ClassSigID of the unclear declaring class. Returns undefined if clear or declared by namespace. */
+    getDeclaringClassTempSigID() {
+        return this.declaringClassTempSigID;
     }
     getBaseName() {
-        return this.declaringSignature instanceof ClassSignature ? this.declaringSignature.getClassName() : this.declaringSignature.getNamespaceName();
+        const declaringSignature = this.getDeclaringSignature();
+        return declaringSignature instanceof ClassSignature ? declaringSignature.getClassName() : declaringSignature.getNamespaceName();
     }
     getFieldName() {
         return this.fieldName;
@@ -206,8 +685,52 @@ class FieldSignature {
         }
         return this.getDeclaringSignature().toString() + '.' + tmpSig;
     }
+    /**
+     * @deprecated No longer used internally since the ID refactor: identity comparison
+     * uses {@link signatureEquals} (hash + equals), indexing uses the canonicalizer.
+     * Kept for backward compatibility only — for identity checks use `equals()`
+     * (with `getHashCode()` fast reject), for debug output use `toString()`.
+     */
+    toMapKey() {
+        let tmpSig = this.fieldName;
+        if (this.isStatic()) {
+            tmpSig = '[static]' + tmpSig;
+        }
+        return this.getDeclaringSignature().toMapKey() + '.' + tmpSig;
+    }
+    getHashCode() {
+        return this.hashCode;
+    }
+    equals(other) {
+        if (this === other) {
+            return true;
+        }
+        if (this.fieldName !== other.fieldName) {
+            return false;
+        }
+        if (this.staticFlag !== other.staticFlag) {
+            return false;
+        }
+        return this.declaringClassSigID === other.declaringClassSigID &&
+            this.declaringNamespaceSigID === other.declaringNamespaceSigID &&
+            this.declaringClassTempSigID === other.declaringClassTempSigID;
+    }
+    /**
+     * @internal Whether the declaring signature is unclear (temp-held, unresolved).
+     * Direct field check (no registry lookup, no declaring signature chain traversal):
+     * class-side unclear = declaringClassSigID is non-positive — -1 (temp-held) or 0
+     * (DEFAULT class as declaring, i.e. "method on an unknown class" — stub builders
+     * like ArkSignatureBuilder.buildMethodSignatureFromMethodName pass 0 directly);
+     * namespace-side unclear = declaringNamespaceSigID === -1.
+     * A positive formal declaring ID implies the declaring entity went through the
+     * formal path — no chain check needed.
+     */
+    isUnclear() {
+        return this.declaringClassSigID === -1 || this.declaringClassSigID === 0 || this.declaringNamespaceSigID === -1;
+    }
 }
 exports.FieldSignature = FieldSignature;
+FieldSignature.logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'FieldSignature');
 class MethodSubSignature {
     constructor(methodName, parameters, returnType, staticFlag = false) {
         this.methodName = methodName;
@@ -221,6 +744,17 @@ class MethodSubSignature {
     getParameters() {
         return this.parameters;
     }
+    /**
+     * @internal Replace the parameter list.
+     *
+     * Parameter NAMES are not part of the signature identity (hash/equals/toString only use
+     * parameter types), so distinct declarations/implementations of the same method share one
+     * canonical signature instance. The implementation side is the authority for body-local
+     * generation, so its parameter names are refreshed onto the canonical instance.
+     */
+    setParameters(parameters) {
+        this.parameters = parameters;
+    }
     getParameterTypes() {
         const parameterTypes = [];
         this.parameters.forEach(parameter => {
@@ -241,7 +775,9 @@ class MethodSubSignature {
         let paraStr = '';
         this.getParameterTypes().forEach(parameterType => {
             const typeStr = parameterType
-                ? (visited ? parameterType.toStringWithVisited(visited) : parameterType.toString())
+                ? visited
+                    ? parameterType.toStringWithVisited(visited)
+                    : parameterType.toString()
                 : Type_1.UnknownType.getInstance().toString();
             paraStr += typeStr + ', ';
         });
@@ -254,13 +790,80 @@ class MethodSubSignature {
     }
 }
 exports.MethodSubSignature = MethodSubSignature;
+/**
+ * @internal Value-semantic equality between two MethodSubSignatures, semantically equivalent to `a.toString() === b.toString()` plus return-type equality,
+ * but short-circuits from cheap to expensive with NO string building in the common mismatch cases.
+ */
+function methodSubSignatureValueEquals(a, b) {
+    var _a, _b, _c, _d;
+    if (a === b) {
+        return true;
+    }
+    if (a.isStatic() !== b.isStatic()) {
+        return false;
+    }
+    if (a.getMethodName() !== b.getMethodName()) {
+        return false;
+    }
+    const ap = a.getParameters();
+    const bp = b.getParameters();
+    if (ap.length !== bp.length) {
+        return false;
+    }
+    for (let i = 0; i < ap.length; i++) {
+        const at = (_a = ap[i]) === null || _a === void 0 ? void 0 : _a.getType();
+        const bt = (_b = bp[i]) === null || _b === void 0 ? void 0 : _b.getType();
+        if (at === bt) {
+            continue;
+        }
+        if (((_c = at === null || at === void 0 ? void 0 : at.toString()) !== null && _c !== void 0 ? _c : Type_1.UnknownType.getInstance().toString()) !== ((_d = bt === null || bt === void 0 ? void 0 : bt.toString()) !== null && _d !== void 0 ? _d : Type_1.UnknownType.getInstance().toString())) {
+            return false;
+        }
+    }
+    return a.getReturnType().toString() === b.getReturnType().toString();
+}
 /**
  * @category core/model
  */
 class MethodSignature {
-    constructor(declaringClassSignature, methodSubSignature) {
-        this.declaringClassSignature = declaringClassSignature;
+    /** The canonical DEFAULT signature (formal sigID 0 in the registry). */
+    static get DEFAULT() {
+        return SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().methodSigCanonicalizer.get(0);
+    }
+    constructor(declaringClassOrID, methodSubSignature, declaringClassTempSigID) {
+        var _a;
         this.methodSubSignature = methodSubSignature;
+        if (typeof declaringClassOrID === 'number') {
+            this.declaringClassSigID = declaringClassOrID;
+            this.declaringClassTempSigID = declaringClassTempSigID;
+        }
+        else {
+            const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+            if (declaringClassOrID.isUnclear()) {
+                this.declaringClassSigID = -1;
+                this.declaringClassTempSigID = reg.tempClassSigCanonicalizer.register(declaringClassOrID);
+            }
+            else {
+                const existingId = reg.classSigCanonicalizer.getExistingId(declaringClassOrID);
+                if (existingId !== -1) {
+                    this.declaringClassSigID = existingId;
+                }
+                else {
+                    MethodSignature.logger.error(`Clear ClassSignature declaring not interned — routing to temp: ${declaringClassOrID.toString()}`);
+                    this.declaringClassSigID = -1;
+                    this.declaringClassTempSigID = reg.tempClassSigCanonicalizer.register(declaringClassOrID);
+                }
+            }
+        }
+        // Hash inputs are lifetime-stable identity fields ONLY: declaring SigIDs, method name, parameter count, static flag.
+        // Parameter TYPES and the return type are deliberately excluded — they are mutable in place during inference.
+        let h = 0xdeadbeef;
+        h = (0, HashUtils_1.hashCombineU32)(h, this.declaringClassSigID);
+        h = (0, HashUtils_1.hashCombineU32)(h, (_a = this.declaringClassTempSigID) !== null && _a !== void 0 ? _a : 0);
+        h = (0, HashUtils_1.hashCombineU32)(h, (0, HashUtils_1.hashString32)(methodSubSignature.getMethodName()));
+        h = (0, HashUtils_1.hashCombineU32)(h, methodSubSignature.getParameters().length);
+        h = (0, HashUtils_1.hashCombineU32)(h, methodSubSignature.isStatic() ? 1 : 0);
+        this.hashCode = h >>> 0;
     }
     /**
      * Return the declaring class signature.
@@ -271,17 +874,39 @@ class MethodSignature {
      * A namespace signature can indicate its **string** name of namespace and its file signature.
      * - Class Name: the **string** name of this class.
      * @returns The declaring class signature.
-     * @example
-     * 1. get class signature from ArkMethod.
-
-     ```typescript
-     let methodSignature = expr.getMethodSignature();
-     let name = methodSignature.getDeclaringClassSignature().getClassName();
-     ```
-     *
      */
     getDeclaringClassSignature() {
-        return this.declaringClassSignature;
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        if (this.declaringClassSigID >= 0) {
+            const sig = reg.classSigCanonicalizer.get(this.declaringClassSigID);
+            if (sig !== undefined) {
+                return sig;
+            }
+        }
+        else if (this.declaringClassTempSigID !== undefined) {
+            const sig = reg.tempClassSigCanonicalizer.get(this.declaringClassTempSigID);
+            if (sig !== undefined) {
+                return sig;
+            }
+            const formalId = reg.tempClassSigCanonicalizer.getReplacement(this.declaringClassTempSigID);
+            if (formalId !== -1) {
+                const formalSig = reg.classSigCanonicalizer.get(formalId);
+                if (formalSig !== undefined) {
+                    return formalSig;
+                }
+            }
+        }
+        // Stale SigID (registry disposed and rebuilt): degrade to DEFAULT instead of crashing.
+        MethodSignature.logger.error(`MethodSignature '${this.methodSubSignature.getMethodName()}' has a stale declaring class SigID ${this.declaringClassSigID} (temp=${this.declaringClassTempSigID}); returning DEFAULT.`);
+        return ClassSignature.DEFAULT;
+    }
+    /** @internal Get the formal ClassSigID of the declaring class. Returns -1 if unclear (temp-held). */
+    getDeclaringClassSigID() {
+        return this.declaringClassSigID;
+    }
+    /** @internal Get the temp ClassSigID of the unclear declaring class. Returns undefined if clear. */
+    getDeclaringClassTempSigID() {
+        return this.declaringClassTempSigID;
     }
     /**
      * Returns the sub-signature of this method signature.
@@ -296,20 +921,49 @@ class MethodSignature {
         return this.methodSubSignature.getReturnType();
     }
     toString(ptrName, visited) {
-        return this.declaringClassSignature.toString() + '.' +
-            this.methodSubSignature.toString(ptrName, visited);
+        return this.getDeclaringClassSignature().toString() + '.' + this.methodSubSignature.toString(ptrName, visited);
     }
+    /**
+     * @deprecated No longer used internally since the ID refactor: identity comparison
+     * uses {@link signatureEquals} (hash + equals), indexing uses the canonicalizer.
+     * Kept for backward compatibility only — for identity checks use `equals()`
+     * (with `getHashCode()` fast reject), for debug output use `toString()`.
+     */
     toMapKey() {
-        return this.declaringClassSignature.toMapKey() + '.' + this.methodSubSignature.toString();
+        return this.getDeclaringClassSignature().toMapKey() + '.' + this.methodSubSignature.toString();
+    }
+    getHashCode() {
+        return this.hashCode;
+    }
+    equals(other) {
+        if (this === other) {
+            return true;
+        }
+        if (this.declaringClassSigID !== other.declaringClassSigID) {
+            return false;
+        }
+        if (this.declaringClassTempSigID !== other.declaringClassTempSigID) {
+            return false;
+        }
+        return methodSubSignatureValueEquals(this.methodSubSignature, other.methodSubSignature);
+    }
+    isUnclear() {
+        return this.declaringClassSigID === -1 || this.declaringClassSigID === 0;
     }
     isMatch(signature) {
-        return this.toString() === signature.toString() && this.getType().toString() === signature.getType().toString();
+        if (!(0, SignatureCanonicalizer_1.signatureEquals)(this.getDeclaringClassSignature(), signature.getDeclaringClassSignature())) {
+            return false;
+        }
+        // Sub-signature comparison shares the field-level path with equals (was: full
+        // MethodSignature.toString() building ×2 + returnType.toString() ×2 per call).
+        return methodSubSignatureValueEquals(this.methodSubSignature, signature.methodSubSignature);
     }
     getParamLength() {
         return this.methodSubSignature.getParameters().filter(p => !p.getName().startsWith(Const_1.LEXICAL_ENV_NAME_PREFIX)).length;
     }
 }
 exports.MethodSignature = MethodSignature;
+MethodSignature.logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'MethodSignature');
 class LocalSignature {
     constructor(name, declaringMethodSignature) {
         this.name = name;
@@ -342,57 +996,33 @@ class AliasTypeSignature {
     }
 }
 exports.AliasTypeSignature = AliasTypeSignature;
-//TODO, reconstruct
+/**
+ * Legacy free-function comparators — kept for API compatibility (external callers may exist).
+ * Behavior aligns with the corresponding signature classes' `equals()`:
+ * - classSignatureCompare compares the declaring namespace (silently ignoring it misjudges same-name classes in different namespaces as equal);
+ * - methodSubSignatureCompare compares parameter/return types by value (`===` reference comparison misjudges value-equal distinct Type instances as different).
+ */
 function fieldSignatureCompare(leftSig, rightSig) {
-    if (leftSig.getDeclaringSignature().toString() === rightSig.getDeclaringSignature().toString() && leftSig.getFieldName() === rightSig.getFieldName()) {
-        return true;
-    }
-    return false;
+    return (0, SignatureCanonicalizer_1.signatureEquals)(leftSig.getDeclaringSignature(), rightSig.getDeclaringSignature()) && leftSig.getFieldName() === rightSig.getFieldName();
 }
 exports.fieldSignatureCompare = fieldSignatureCompare;
 function methodSignatureCompare(leftSig, rightSig) {
-    if (classSignatureCompare(leftSig.getDeclaringClassSignature(), rightSig.getDeclaringClassSignature()) &&
-        methodSubSignatureCompare(leftSig.getMethodSubSignature(), rightSig.getMethodSubSignature())) {
-        return true;
-    }
-    return false;
+    return (0, SignatureCanonicalizer_1.signatureEquals)(leftSig.getDeclaringClassSignature(), rightSig.getDeclaringClassSignature()) &&
+        methodSubSignatureValueEquals(leftSig.getMethodSubSignature(), rightSig.getMethodSubSignature());
 }
 exports.methodSignatureCompare = methodSignatureCompare;
 function methodSubSignatureCompare(leftSig, rightSig) {
-    if (leftSig.getMethodName() === rightSig.getMethodName() &&
-        arrayCompare(leftSig.getParameterTypes(), rightSig.getParameterTypes()) &&
-        leftSig.getReturnType() === rightSig.getReturnType() &&
-        leftSig.isStatic() === rightSig.isStatic()) {
-        return true;
-    }
-    return false;
+    return methodSubSignatureValueEquals(leftSig, rightSig);
 }
 exports.methodSubSignatureCompare = methodSubSignatureCompare;
 function classSignatureCompare(leftSig, rightSig) {
-    if (fileSignatureCompare(leftSig.getDeclaringFileSignature(), rightSig.getDeclaringFileSignature()) && leftSig.getClassName() === rightSig.getClassName()) {
-        return true;
-    }
-    return false;
+    return (0, SignatureCanonicalizer_1.signatureEquals)(leftSig, rightSig);
 }
 exports.classSignatureCompare = classSignatureCompare;
 function fileSignatureCompare(leftSig, rightSig) {
-    if (leftSig.getFileName() === rightSig.getFileName() && leftSig.getProjectName() === rightSig.getProjectName()) {
-        return true;
-    }
-    return false;
+    return leftSig.equals(rightSig);
 }
 exports.fileSignatureCompare = fileSignatureCompare;
-function arrayCompare(leftArray, rightArray) {
-    if (leftArray.length !== rightArray.length) {
-        return false;
-    }
-    for (let i = 0; i < leftArray.length; i++) {
-        if (leftArray[i] !== rightArray[i]) {
-            return false;
-        }
-    }
-    return true;
-}
 function genSignature4ImportClause(arkFileName, importClauseName) {
     return `<${arkFileName}>.<${importClauseName}>`;
 }