@lcap/nasl-language-server-core 4.4.0-beta.3 → 4.4.0-beta.31

package/out/reference-manager/reference-manager.js

@@ -7,7 +7,7 @@ const fp_macros_1 = require("../utils/fp-macros");
 const console_1 = require("console");
 const builtin_q_name_1 = require("./builtin-q-name");
 const build_q_name_def_1 = require("./build-q-name-def");
-const get_q_name_1 = require("./get-q-name");
+const def_key_helpers_1 = require("./def-key-helpers");
 const typer_1 = require("../typer");
 const type_predicate_1 = require("../typer/type-predicate");
 const helper_1 = require("../typer/helper");
@@ -21,7 +21,6 @@ const type_manager_1 = require("../typer/type-manager");
 const oql_1 = require("../utils/oql");
 const string_2 = require("../utils/string");
 const traverse_util_1 = require("../utils/traverse-util");
-const view_elem_logic_1 = require("./view-elem-logic");
 const helper_2 = require("./helper");
 const misc_1 = require("../utils/misc");
 const asserts_1 = require("@lcap/nasl-concepts/asserts");
@@ -46,7 +45,7 @@ class ReferenceManager {
     static { this.defConcept = symbol_type_1.defConcept; } /** imported */
     static { this.compositeNodeConcept = symbol_type_1.compositeNodeConcept; } /** imported */
     static { this.connectionNsp = 'app.connections'; }
-    // gQNameDefs 和 symbolRefs 的构建时机不一样，所以不放在构造器中
+    // gQNameDefs 和 globalRefs 的构建时机不一样，所以不放在构造器中
     constructor() {
         // qualified names to definition memory address for GLOBAL DEFINITIONS
         this.gQNameDefs = new Map();
@@ -65,33 +64,26 @@ class ReferenceManager {
          *
          * 将实体看成 namespace，所有引用实体逻辑的地方也算引用了实体？
          */
-        this.gSymbolRefs = new Map; // 手动管理，小心内存泄漏
-        // Accessor methods for symbolRefs to normalize input later
+        this.globalRefs = new Map; // 手动管理，小心内存泄漏
+        // Accessor methods for globalRefs to normalize input later
         this.getSymbolRefs = (__def) => {
             const def = this.normaliseEntityLogic(__def);
-            return this.gSymbolRefs.get(def);
+            return this.globalRefs.get(def);
         };
         this.setSymbolRefs = (__def, refs) => {
             const def = this.normaliseEntityLogic(__def);
-            this.gSymbolRefs.set(def, refs);
+            this.globalRefs.set(def, refs);
         };
         this.deleteSymbolRefs = (__def) => {
             const def = this.normaliseEntityLogic(__def);
-            return this.gSymbolRefs.delete(def);
+            return this.globalRefs.delete(def);
         };
-        this.clearSymbolRefs = () => {
-            this.gSymbolRefs.clear();
+        this.clearGlobalRefs = () => {
+            this.globalRefs.clear();
         };
-        this.getSymbolRefsSize = () => {
-            return this.gSymbolRefs.size;
+        this.getGlobalRefsSize = () => {
+            return this.globalRefs.size;
         };
-        // 辅助 map
-        this.veQNameDefs = new Map();
-        /**
-         * @warning ViewElement 和 Logic 都是局部符号，可以重名，qName 重复时会出错，不要搞这种例子谢谢
-         * key 是 memory addr 而不是 string 的原因：点查找引用时，不好高效获取 qName（如 Logic 没有 namespace 但调用处其实有，对的就是 elements.）
-         */
-        this.veRefs = new Map();
         // 当前的 collectRefs 是增加还是删除引用。先这样吧，没时间重构了……
         this.modeForCollect = null;
         /**
@@ -115,14 +107,26 @@ class ReferenceManager {
             // 暂无"局部类型"，所以简化处理：
             return this.gSymbolImplicitRefs.get(nd) ?? emptySet;
         };
-        // 删除一个 def 时，缓存其 qName 到引用符号的关系，为了方便之后还能 relink 恢复
-        this.gCachedQNameSymbolRefs = new Map();
+        /**
+         * 待恢复引用缓存：删除节点时保存引用，创建同名节点时恢复引用后立即删除
+         * key: qName, value: Set<PendingRefInfo>
+         * 只在删除和创建之间临时使用，使用后立即清除，避免内存泄漏
+         *
+         * 使用场景：
+         * 1. 删除节点时：通过 cacheRefsForRecreation 保存引用节点
+         * 2. 创建同名节点时：通过 restoreRefsFromCache 恢复引用并清除缓存
+         *
+         * 设计说明：
+         * - 只存储引用节点本身
+         * - 恢复时会检查引用节点是否仍在 app 树上且仍引用原来的 qName
+         */
+        this.pendingRefsForRecreation = new Map();
         this.compDefMgr = new component_def_manager_1.ComponentDefManager();
         // 上一次查找引用局部符号建立的 cache
         this.lastBoundary = undefined;
         this.isLocalCacheValid = true;
-        /** local qName refs 局部符号的引用 */
-        this.lQNameRefs = new Map();
+        /** 局部符号的引用，key 为 getLocalDefKey 返回值（作用域内简单名或完整路径） */
+        this.localRefs = new Map();
         // 当前文件节点
         this.curFileNode = undefined;
         /**
@@ -146,14 +150,26 @@ class ReferenceManager {
         /**
          * Remove all recorded local scope variable bindings under a file node.
          * Used by incremental type checking to invalidate stale scope allocations.
+         * @param options.skipDescendantFileNodes 为 true 时遇到子级「文件节点」则不再向下遍历，避免误清子 View 等，增量阶段 2 重算前用此选项
+         * @param options.isFileNode 与 skipDescendantFileNodes 搭配使用，用于判断某节点是否为文件节点（如 checkNodeIsFileModuleInIdeWithCache）
          */
-        this.clearLocalSymBindingsForFile = (file) => {
+        this.clearLocalSymBindingsForFile = (file, options) => {
             if (!file)
                 return;
-            file.traverseStrictChildren((nd) => {
-                this.localSymBindings.delete(nd);
-            });
-            // also clear the file node itself
+            const { skipDescendantFileNodes, isFileNode } = options ?? {};
+            if (skipDescendantFileNodes && isFileNode) {
+                file.traverseStrictChildrenWithPruning?.((nd) => {
+                    const prune = nd !== file && isFileNode(nd);
+                    if (!prune)
+                        this.localSymBindings.delete(nd);
+                    return prune;
+                });
+            }
+            else {
+                file.traverseStrictChildren((nd) => {
+                    this.localSymBindings.delete(nd);
+                });
+            }
             this.localSymBindings.delete(file);
         };
         this.clearAllLocalSymBindings = () => {
@@ -167,7 +183,7 @@ class ReferenceManager {
          * declaration for each variable name is returned (nearest-first ordering).
          *
          * Implementation notes:
-         * - We intentionally DO NOT depend on the (ephemeral) lexicalVarStacks in SemEnv so
+         * - We intentionally DO NOT depend on the (ephemeral) localDefStacks in SemEnv so
          *   this works post-typing (e.g. in reference / rename / hover providers) without
          *   re-running the typer.
          * - Order:
@@ -194,20 +210,21 @@ class ReferenceManager {
             const localSyms = this.getVisibleLocalSyms(node, options);
             const localVars = localSyms.filter(service_1.isLocalVar);
             const collected = Array.from(localVars);
-            const seen = new Set(localSyms.map(v => (0, get_q_name_1.getTokenQualifiedName)(v)));
+            // 用于 shadowing 去重，需用 getLocalDefKey 与引用时的 key 一致
+            const seen = new Set(localSyms.map(v => (0, def_key_helpers_1.getLocalDefKey)(v) ?? (0, def_key_helpers_1.getGlobalDefKey)(v)));
             const seenNames = new Set(localVars.map(v => v?.name).filter(Boolean));
             // View-specific: stitch in process variables allocated during typing
             this.stitchProcessVarsForView(node, env, includeShadowed, predicate, collected, seenNames);
             this.stitchValidationVarsForView(node, env, includeShadowed, predicate, collected, seenNames);
             const feVars = getNearestFrontendVars(node);
             for (const v of feVars) {
-                const vQName = (0, get_q_name_1.getTokenQualifiedName)(v);
-                if (!vQName)
+                const vKey = (0, def_key_helpers_1.getLocalDefKey)(v) ?? (0, def_key_helpers_1.getGlobalDefKey)(v);
+                if (!vKey)
                     continue;
                 if (!includeShadowed) {
-                    if (seen.has(vQName))
+                    if (seen.has(vKey))
                         continue;
-                    seen.add(vQName);
+                    seen.add(vKey);
                 }
                 if (predicate && !predicate(v))
                     continue;
@@ -266,7 +283,7 @@ class ReferenceManager {
                 const vars = this.localSymBindings.get(cur);
                 if (vars && vars.length > 0) {
                     for (const v of vars) {
-                        const vQName = (0, get_q_name_1.getTokenQualifiedName)(v);
+                        const vQName = (0, def_key_helpers_1.getGlobalDefKey)(v);
                         if (!vQName)
                             continue;
                         if (!includeShadowed) {
@@ -332,8 +349,10 @@ class ReferenceManager {
             for (const triggerLauncher of app.triggerLaunchers) {
                 allRefs.push(...this.collectRefs(env, triggerLauncher));
             }
-            for (const metadataType of app.metadataTypes) {
-                allRefs.push(...this.collectRefs(env, metadataType));
+            if (String(app?.preferenceMap?.metadataTypeEnable) === 'true') {
+                for (const metadataType of app.metadataTypes) {
+                    allRefs.push(...this.collectRefs(env, metadataType));
+                }
             }
             // for (const preference of app.preferenceMap) {
             //     allRefs.push(...this.collectRefs(env, preference as any as ValidExtInp));
@@ -347,13 +366,13 @@ class ReferenceManager {
                 const def = this.gQNameDefs.get(qName);
                 if (def) {
                     // Add reference to existing definition
-                    (0, helper_1.createSetOnPush)(this.gSymbolRefs, def, ref);
+                    (0, helper_1.createSetOnPush)(this.globalRefs, def, ref);
                 }
                 else {
                     // Cache reference for future relinking
                     // FIXME:这里有问题，脏脏的，比如局部变量、入参等都扔到这里面了，虽然暂时可能没有太大的正确性问题，但有内存泄漏
                     if (!(0, helper_2.cheapTestLocalSymbol)(qName)) {
-                        (0, helper_1.createSetOnPush)(this.gCachedQNameSymbolRefs, qName, ref);
+                        this.addRefToPendingCache(qName, ref);
                     }
                 }
             });
@@ -385,10 +404,6 @@ class ReferenceManager {
             this.modeForCollect = null;
         };
         this.addQNameDefs = (0, build_q_name_def_1.mkAddQNameDefs)(this.gQNameDefs, this.compDefMgr);
-        /** 注释见具体实现 */
-        this.addViewElementLogicQNameDefs = (0, view_elem_logic_1.mkAddViewElementLogicQNameDefs)(this.veQNameDefs, this.gQNameDefs);
-        /** 注释见具体实现 */
-        this.addViewElementLogicRefs = (0, view_elem_logic_1.mkAddViewElementBindLogicRefs)(this.veQNameDefs, this.veRefs);
         this.queryQNameDef = (qName) => {
             const res = this.gQNameDefs.get(qName);
             if (!res) {
@@ -448,12 +463,10 @@ class ReferenceManager {
             }
         };
         /**
-         * 重要对外接口，查找符号的定义
-         * @param ref
-         * @returns
+         * 查找符号的定义（含全局符号、View/BC 内 logics 等，均已在 gQNameDefs 中注册）
          */
         this.getNodeDef = (ref) => {
-            const qName = (0, get_q_name_1.getTokenQualifiedName)(ref);
+            const qName = (0, def_key_helpers_1.getGlobalDefKey)(ref);
             return qName ? this.gQNameDefs.get(qName) : undefined;
         };
         /**
@@ -464,9 +477,25 @@ class ReferenceManager {
         this.getReferences = (env, __nd) => {
             let nd = this.normaliseEntityLogic((0, misc_1.toRaw)(__nd));
             let res = new Set();
+            // 逻辑/页面参数：外部引用在 globalRefs（CallLogic 实参），内部引用在 localRefs（Logic 体内同名标识符）
+            if (nd.concept === 'Param' || nd.concept === 'ParamWithGroup') {
+                const paramQName = (0, def_key_helpers_1.getGlobalDefKey)(nd);
+                const isParamOfLogicOrView = (0, symbol_type_1.isLogicViewLike)(nd.parentNode);
+                const def = isParamOfLogicOrView && paramQName ? this.gQNameDefs.get(paramQName) : undefined;
+                const externalRefs = def ? this.getSymbolRefs(def) ?? new Set() : new Set();
+                const boundary = (0, helper_2.getBoundary)(nd);
+                if (boundary && (this.lastBoundary !== boundary || !this.isLocalCacheValid)) {
+                    this.localRefs.clear();
+                    this.timeAndLog('Get reference: collect local refs for Param', this.buildLocalRefs, env, nd);
+                }
+                const localKey = (0, def_key_helpers_1.getLocalDefKey)(nd) ?? nd.name;
+                const internalRefs = (localKey && this.localRefs.get(localKey)) ?? new Set();
+                res = mnemonist_1.set.union(externalRefs, internalRefs);
+                return Array.from(res);
+            }
             // 比如 OverriddenLogic 和对应的 Logic 名字一样，但引用挂在 Logic 上
             // 比如 实体对应的实体逻辑可能有多份内存地址，归结到现存的一份上
-            // nd = this.gQNameDefs.get(getTokenQualifiedName(nd)!)!;
+            // nd = this.gQNameDefs.get(getGlobalDefKey(nd)!)!;
             // ==> 好像也不行，很多依赖库逻辑调用又挂了
             const boundary = (0, helper_2.getBoundary)(nd);
             // 全局符号直接查找
@@ -477,7 +506,7 @@ class ReferenceManager {
                 if (pConn && boundary) {
                     // 那么它也就是个连接器下的局部符号
                     const qNameRefs = this.collectRefs(env, boundary); // 注意，从 boundary 开始就行，不是从 connector 开始
-                    const ndQName = (0, get_q_name_1.getTokenQualifiedName)(nd);
+                    const ndQName = (0, def_key_helpers_1.getGlobalDefKey)(nd);
                     for (const [ref, qName] of qNameRefs) {
                         qName === ndQName && res.add(ref);
                     }
@@ -488,27 +517,28 @@ class ReferenceManager {
                 // 局部符号需要即时获取
                 // 从缓存中获取
                 if (this.lastBoundary === boundary && this.isLocalCacheValid) {
-                    res = this.lQNameRefs.get((0, get_q_name_1.getTokenQualifiedName)(nd)) ?? new Set();
-                    // 此处的 Logic 必然不是全局逻辑
-                    // @ts-expect-error 目前的 AST 设计，ViewElement 既是引用又是定义
-                    if (nd.concept === 'ViewElement' || nd.concept === 'Logic' || nd.concept === 'BusinessLogic') {
-                        res = mnemonist_1.set.union(res, this.getViewElementRefs(nd));
+                    const localKey = (0, def_key_helpers_1.getLocalDefKey)(nd) ?? (0, def_key_helpers_1.getGlobalDefKey)(nd);
+                    const lRefs = localKey ? (this.localRefs.get(localKey) ?? new Set()) : new Set();
+                    const gRefs = this.getSymbolRefs(nd) ?? new Set();
+                    if (nd.concept === 'ViewElement' || nd.concept === 'Logic' || nd.concept === 'BusinessLogic' || nd.concept === 'Event') {
+                        res = mnemonist_1.set.union(lRefs, gRefs);
+                    }
+                    else {
+                        res = lRefs;
                     }
                 }
                 else {
                     // 局部扫描，建立所有局部引用
-                    this.lQNameRefs.clear();
-                    this.veQNameDefs.clear();
-                    this.veRefs.clear();
-                    this.timeAndLog('Get reference: collect local refs', this.buildMinimalLocalQNameRefs, env, nd);
-                    res = mnemonist_1.set.union(res, this.lQNameRefs.get((0, get_q_name_1.getTokenQualifiedName)(nd)) ?? new Set());
-                    // @ts-expect-error 同上，并且虽然 BindEvent 本身没引用但是要触发对 view 建立引用
-                    if (nd.concept === 'ViewElement' || nd.concept === 'Logic' || nd.concept === 'BusinessLogic' || nd.concept === 'BindEvent') {
+                    this.localRefs.clear();
+                    this.timeAndLog('Get reference: collect local refs', this.buildLocalRefs, env, nd);
+                    const localKey = (0, def_key_helpers_1.getLocalDefKey)(nd) ?? (0, def_key_helpers_1.getGlobalDefKey)(nd);
+                    res = mnemonist_1.set.union(res, (localKey ? (this.localRefs.get(localKey) ?? new Set()) : new Set()));
+                    if (nd.concept === 'ViewElement' || nd.concept === 'Logic' || nd.concept === 'BusinessLogic' || nd.concept === 'BindEvent' || nd.concept === 'Event') {
                         const ctxViewLike = (0, misc_1.toRaw)((0, nasl_concepts_1.getCtxViewLike)(nd));
-                        this.timeAndLog('Get reference: build view element logic qName defs cache', this.addViewElementLogicQNameDefs, ctxViewLike);
-                        this.timeAndLog('Get reference: build view element refs cache', this.addViewElementLogicRefs, ctxViewLike);
-                        // @ts-expect-error get 出来一个 undefined 无所谓
-                        res = mnemonist_1.set.union(res ?? new Set(), this.getViewElementRefs(nd));
+                        if (ctxViewLike) {
+                            this.timeAndLog('Get reference: build view element refs cache', this.buildLocalRefs, env, ctxViewLike);
+                        }
+                        res = mnemonist_1.set.union(res ?? new Set(), this.getSymbolRefs(nd) ?? new Set());
                     }
                 }
             }
@@ -518,25 +548,24 @@ class ReferenceManager {
              * 业务逻辑在页面调用的时候，名字前缀是随着业务组件实例名字而变化的，几乎是全应用查找……
              */
             if (nd.concept === 'BusinessLogic') {
-                // 上面已经找到了业务组件内部对业务组件逻辑的内用
+                // 上面已经找到了业务组件内部对业务组件逻辑的引用（localRefs）
                 // 现在再找出所有 业务组件逻辑 所属的业务组件的外部引用
+                // buildLocalRefs 会把页面中 elements.bs-xxx.logics.myLogic 的调用写入 globalRefs(BusinessLogic)
                 const bs = (0, misc_1.toRaw)((0, nasl_concepts_1.getCtxViewLike)(nd));
                 if (bs?.concept === 'BusinessComponent') {
                     const bsRefs = this.getSymbolRefs(bs) ?? new Set();
-                    let bsRefsRefs = new Array(); // 业务组件（在页面的引用）的引用
                     /**
-                     * 再对每个实例找到所有引用
+                     * 对每个 BC 实例所在的页面扫描，buildLocalRefs 会把外部引用写入 globalRefs(nd)
                      * @warning 造孽，引用业务组件的每个 view 都要扫描一遍，应该很慢
                      */
                     const startTime = Date.now();
                     for (const bsInst of bsRefs) {
                         const ctxViewLike = (0, misc_1.toRaw)((0, nasl_concepts_1.getCtxViewLike)(bsInst));
-                        this.addViewElementLogicQNameDefs(ctxViewLike);
-                        this.addViewElementLogicRefs(ctxViewLike);
-                        bsRefsRefs.push(...this.getViewElementRefs(bsInst));
+                        if (ctxViewLike)
+                            this.buildLocalRefs(env, ctxViewLike);
                     }
-                    // 再从引用中过滤出找到当前业务逻辑的调用
-                    res = mnemonist_1.set.union(res, new Set(bsRefsRefs.filter(r => r.concept === 'CallLogic' && r.calleeName === nd.name))); // amazing!
+                    // 外部引用已写入 globalRefs(BusinessLogic)，直接取
+                    res = mnemonist_1.set.union(res, this.getSymbolRefs(nd) ?? new Set());
                     const endTime = Date.now();
                     if (endTime - startTime > 200) {
                         console.log(`Get reference: complex business logic took ${endTime - startTime}ms`);
@@ -549,7 +578,7 @@ class ReferenceManager {
                 const allLogics = [...conn.logics, ...conn.namespaces.flatMap(nsp => nsp.logics)];
                 for (const l of allLogics) {
                     // ConnectorLogic，发布态的连接器里外都有调用，真是里外不是人啊。
-                    res = mnemonist_1.set.union(res, this.gSymbolRefs.get(l) ?? new Set());
+                    res = mnemonist_1.set.union(res, this.globalRefs.get(l) ?? new Set());
                 }
             }
             // 加上所有实体逻辑调用的引用（实体逻辑可看做无定义，但要修改调用处的 namespace：实体名是 namespace 的一部分）
@@ -570,17 +599,15 @@ class ReferenceManager {
         };
         /**
          * 给类似 FileNode 级别的定义建立局部引用记录
-         * @warning 不包括 ViewElement、BindEvent 相关的引用，那个在 @link addViewElementLogicRefs
+         * @warning 不包括 ViewElement、BindEvent 相关的引用，已合并到 getLocalDefKeys 与 collectedRefs 处理
          * @warning 需要包括 SubLogics
          */
-        this.buildMinimalLocalQNameRefs = (env, __nd) => {
+        this.buildLocalRefs = (env, __nd) => {
             this.modeForCollect = "create" /* Operation.Create */;
             const nd = (0, misc_1.toRaw)(__nd);
             let logicVars = new Array();
             let viewVars = new Array();
             let processVars = new Array();
-            /** @warning v4.1 开始，view logics 不在这里处理，在 @link veQNameRefs 那里处理 */
-            let isViewLike = false;
             const boundary = (0, helper_2.getBoundary)(nd);
             if (!boundary) {
                 return new Set();
@@ -591,7 +618,33 @@ class ReferenceManager {
                 if (ctxLogic && 'variables' in ctxLogic) {
                     logicVars.push(...ctxLogic.variables?.map(misc_1.toRaw) ?? []);
                 }
-                isViewLike = true;
+                // View/BC 内 logics、events、elements 的引用走 localRefs，需预先初始化 key
+                const viewLike = boundary;
+                const viewQ = (0, def_key_helpers_1.getGlobalDefKey)(viewLike);
+                (viewLike.logics ?? []).forEach((l) => {
+                    const q = (0, def_key_helpers_1.getLocalDefKey)(l) ?? (0, def_key_helpers_1.getGlobalDefKey)(l);
+                    q && this.localRefs.set(q, new Set());
+                });
+                (viewLike.events ?? []).forEach((e) => {
+                    const q = (0, def_key_helpers_1.getLocalDefKey)(e) ?? (0, def_key_helpers_1.getGlobalDefKey)(e);
+                    q && this.localRefs.set(q, new Set());
+                });
+                for (const be of viewLike.bindEvents ?? []) {
+                    for (const l of be.logics ?? []) {
+                        this.localRefs.set(`${viewQ}.bindEvents.${be.name}.logics.${l.name}`, new Set());
+                    }
+                }
+                const initElemKeys = (ve, parentNsp, parentKey = 'elements') => {
+                    const elemKey = `${parentNsp}.${parentKey}.${ve.name}`;
+                    this.localRefs.set(elemKey, new Set());
+                    for (const be of ve.bindEvents ?? []) {
+                        for (const l of be.logics ?? []) {
+                            this.localRefs.set(`${elemKey}.bindEvents.${be.name}.logics.${l.name}`, new Set());
+                        }
+                    }
+                    ve.children?.forEach((c) => initElemKeys(c, elemKey, 'children'));
+                };
+                (viewLike.elements ?? []).forEach((ve) => initElemKeys(ve, viewQ, 'elements'));
             }
             else if (boundary.concept === 'ProcessDefinitionV2') {
                 processVars = (0, nasl_concepts_1.getProcessVars)(nd).map(misc_1.toRaw);
@@ -604,34 +657,47 @@ class ReferenceManager {
                 logicVars = (0, nasl_concepts_1.getLogicVars)(nd).map(misc_1.toRaw);
             }
             let allVars = logicVars.concat(processVars).concat(viewVars);
-            // initialize local cache
+            let collectedRefs = this.collectRefs(env, boundary, true);
+            this.lastBoundary = boundary;
+            // initialize local cache: 局部变量用 getLocalDefKey；Entity/Structure 属性用 collectRefs 返回的 qName（全局 key）
             allVars.forEach(def => {
-                const qName = (0, get_q_name_1.getTokenQualifiedName)(def);
+                const qName = (0, def_key_helpers_1.getLocalDefKey)(def) ?? (0, def_key_helpers_1.getGlobalDefKey)(def);
                 if (qName) {
-                    this.lQNameRefs.set(qName, new Set());
+                    this.localRefs.set(qName, new Set());
                 }
             });
-            let subRefs = this.collectRefs(env, boundary, true);
-            this.lastBoundary = boundary;
-            subRefs?.forEach(([rf, qName]) => {
-                // 不存在则表示不是局部符号
-                this.lQNameRefs.get(qName)?.add(rf);
+            collectedRefs?.forEach(([rf, qName]) => {
+                if (rf.concept === 'Identifier' && qName.includes('.properties.')) {
+                    this.localRefs.set(qName, this.localRefs.get(qName) ?? new Set());
+                }
+            });
+            collectedRefs?.forEach(([rf, qName]) => {
+                const isEntityOrStructPropRef = rf.concept === 'Identifier' && qName.includes('.properties.');
+                const keys = (0, def_key_helpers_1.getLocalDefKeys)(rf);
+                const keysToUse = isEntityOrStructPropRef ? [qName] : (keys.length > 0 ? keys : [qName]);
+                for (const key of keysToUse) {
+                    // 简单名 key 不加入属性名 Identifier（NewComposite/BatchAssignment 等）
+                    if (!key.includes('.') && (0, def_key_helpers_1.isIdentifierAsPropertyName)(rf))
+                        continue;
+                    this.localRefs.get(key)?.add(rf);
+                }
+                // 页面调用 BC 逻辑：外部引用 -> globalRefs
+                if (rf.concept === 'CallLogic' && rf.calleeNamespace?.startsWith('elements.') && rf.calleeNamespace?.endsWith('.logics')) {
+                    const def = this.gQNameDefs.get(qName);
+                    def && (0, fp_macros_1.createOnAdd)(this.globalRefs, def, rf);
+                }
+                // Entity/Structure 属性引用 -> globalRefs
+                if (isEntityOrStructPropRef) {
+                    const def = this.gQNameDefs.get(qName);
+                    def && (0, fp_macros_1.createOnAdd)(this.globalRefs, def, rf);
+                }
             });
             // Note: 暂不支持 BindAttr、BindDirective 里的变量的查找引用
             this.isLocalCacheValid = true;
             this.modeForCollect = null;
         };
-        /**
-         * References to view elements are calls of component logic and access of properties
-         * 'elements.uLinearLayout1.logics.openLoading'
-         *
-         * 'elements.uLinearLayout1.property.uLinearLayout1._if._if'
-         *  "concept": "Identifier",
-         *  "namespace": "elements.uLinearLayout1.property",
-         *  "name": "uLinearLayout1",
-         *
-         */
-        this.getViewElementRefs = (nd) => !nd ? new Set() : this.veRefs.get(nd) ?? new Set();
+        /** @deprecated 使用 getSymbolRefs，保留仅为兼容 */
+        this.getViewElementRefs = (nd) => !nd ? new Set() : this.getSymbolRefs(nd) ?? new Set();
         /**
          * 非常危险，但是先这样吧
          */
@@ -662,55 +728,399 @@ class ReferenceManager {
             // 重命名时不需要处理 sourceRef targetRef，好像其他逻辑已经处理掉了
             return result;
         };
+        this.updateRefsInNaslFragment = update_nasl_fragment_1.updateRefsInNaslFragment;
+        /**
+         * 添加引用到缓存（内部方法，统一管理 pendingRefsForRecreation）
+         * @param qName 节点的 qName
+         * @param ref 要缓存的引用
+         */
+        this.addRefToPendingCache = (qName, ref) => {
+            if (!this.pendingRefsForRecreation.has(qName)) {
+                this.pendingRefsForRecreation.set(qName, new Set());
+            }
+            // 只记录引用节点本身
+            const refInfo = {
+                ref,
+            };
+            this.pendingRefsForRecreation.get(qName).add(refInfo);
+        };
         /**
-         * qNameDef 中删除 oldQName ==> def
-         * qNameDef 中建立 newQName ==> def
-         * def 内存地址相同
-         * 如果 mode 是 'update'，则 newQName 的引用集合是 oldQName 在 symbolRefs 中的既存引用
-         *      合并上 新名字在 cachedQNameSymbolRefs 中的既存引用。
-         *      新名字在 cachedQNameSymbolRefs 中的引用将被删除。
+         * 缓存引用以备后续恢复（在删除节点时调用）
+         * @param qName 节点的 qName
+         * @param defNode 要删除的节点
          *
-         * 如果 mode 是其他，则 newQName 的引用集合是 newQName 在 cachedQNameSymbolRefs 中的既存引用。
-         *      oldQName 的引用将被放入 cachedQNameSymbolRefs
-         *      删除 newQName 的缓存引用
+         * 使用场景：删除节点时，保存引用节点本身到 pendingRefsForRecreation，以便后续创建同名节点时恢复引用
+         *
+         * 设计说明：
+         * - 只存储引用节点本身（因为需要它来建立引用关系）
+         * - 恢复时会检查引用节点是否仍在 app 树上且仍引用原来的 qName
+         */
+        this.cacheRefsForRecreation = (qName, defNode) => {
+            if (!(0, symbol_type_1.isGlobalDef)(defNode)) {
+                return;
+            }
+            const refs = this.getSymbolRefs(defNode);
+            if (refs && refs.size > 0) {
+                // 只记录引用节点本身
+                const refInfos = new Set();
+                for (const ref of refs) {
+                    const refInfo = {
+                        ref,
+                    };
+                    refInfos.add(refInfo);
+                }
+                this.pendingRefsForRecreation.set(qName, refInfos);
+            }
+        };
+        /**
+         * 检查引用是否仍在 app 树上
+         *
+         * 方法：
+         * 向上遍历 parentNode 链，检查每个节点是否在其父节点的子节点集合中
+         * （因为删除节点时可能不会把 parentNode 设置为 null，但会从父节点的子节点集合中移除）
+         *
+         * 如果链上的任何节点不在其父节点的子节点集合中，说明已被删除，不在 app 树上
+         * 如果能到达 App 节点，说明引用仍在 app 树上
+         */
+        this.isRefStillInAppTree = (ref) => {
+            try {
+                if (!ref || !ref.concept) {
+                    return false;
+                }
+                let currentNode = ref;
+                let depth = 0;
+                const maxDepth = 100; // 防止无限循环
+                // 向上遍历 parentNode 链，查找 App 节点
+                while (currentNode && depth < maxDepth) {
+                    if (currentNode.concept === 'App') {
+                        // 找到了 App 节点，说明引用仍在 app 树上
+                        return true;
+                    }
+                    // 检查当前节点是否在其父节点的子节点集合中
+                    // 如果节点被删除了，即使 parentNode 还存在，节点也不会在父节点的子节点集合中
+                    const parentNode = currentNode.parentNode;
+                    if (parentNode && currentNode.parentKey) {
+                        const parentProperty = parentNode[currentNode.parentKey];
+                        if (Array.isArray(parentProperty)) {
+                            // 如果是数组，检查节点是否在数组中
+                            if (parentProperty.indexOf(currentNode) === -1) {
+                                // 节点不在父节点的子节点集合中，说明已被删除
+                                return false;
+                            }
+                        }
+                        else if (parentProperty !== currentNode) {
+                            // 如果是单个属性，检查是否指向当前节点
+                            // 节点不在父节点的子节点集合中，说明已被删除
+                            return false;
+                        }
+                    }
+                    currentNode = parentNode;
+                    depth++;
+                }
+                // 无法到达 App 节点，说明引用已不在 app 树上（节点已被删除）
+                return false;
+            }
+            catch {
+                // 如果访问节点属性时出错，说明节点已被删除
+                return false;
+            }
+        };
+        /**
+         * 检查引用节点是否仍引用指定的 qName
+         * @param ref 引用节点
+         * @param qName 要检查的 qName
+         * @returns 如果引用节点仍引用指定的 qName，返回 true；否则返回 false
+         */
+        this.isRefStillReferencingQName = (ref, qName) => {
+            try {
+                // 通过 getGlobalDefKey 获取引用节点当前引用的 qName
+                const currentQName = (0, def_key_helpers_1.getGlobalDefKey)(ref);
+                // 检查是否还引用原来的 qName
+                return currentQName === qName;
+            }
+            catch {
+                // 如果获取失败，返回 false
+                return false;
+            }
+        };
+        /**
+         * 从缓存恢复引用（在创建节点时调用）
+         * @param qName 节点的 qName
+         * @param defNode 新创建的节点
+         * @returns 是否成功恢复引用
+         *
+         * 使用场景：创建节点时，如果有缓存的引用信息（来自删除操作），则恢复引用关系
+         *
+         * 恢复策略：
+         * 1. 使用引用节点本身（如果节点仍然有效）
+         * 2. 检查引用节点是否仍在 app 树上（过滤掉已删除的引用）
+         * 3. **关键**：检查引用节点是否仍引用原来的 qName（如果引用内容已改变，则不恢复）
+         * 4. 重新建立引用关系
+         */
+        this.restoreRefsFromCache = (qName, defNode) => {
+            if (!(0, symbol_type_1.isGlobalDef)(defNode)) {
+                return false;
+            }
+            const cachedRefInfos = this.pendingRefsForRecreation.get(qName);
+            if (!cachedRefInfos || cachedRefInfos.size === 0) {
+                return false;
+            }
+            const validRefs = new Set();
+            for (const refInfo of cachedRefInfos) {
+                // 检查引用节点是否仍在 app 树上
+                if (!this.isRefStillInAppTree(refInfo.ref)) {
+                    continue;
+                }
+                // 检查引用节点是否仍引用原来的 qName
+                if (this.isRefStillReferencingQName(refInfo.ref, qName)) {
+                    // 引用节点仍然有效且仍引用原来的 qName，添加到恢复集合中
+                    validRefs.add(refInfo.ref);
+                }
+            }
+            // 如果有有效的引用，恢复它们
+            if (validRefs.size > 0) {
+                this.setSymbolRefs(defNode, validRefs);
+            }
+            // 使用后立即删除缓存，避免内存泄漏
+            this.pendingRefsForRecreation.delete(qName);
+            return validRefs.size > 0;
+        };
+        /**
+         * 获取待恢复引用缓存中的引用（用于查询场景，如 getOqlFiles）
+         * @param qName 节点的 qName
+         * @param app 可选的 App 实例（保留参数以保持向后兼容，但不再使用）
+         * @returns 缓存的引用集合，如果没有则返回 undefined
+         *
+         * 注意：只使用引用节点本身，检查引用节点是否仍在 app 树上且仍引用原来的 qName
+         */
+        this.getPendingRefsForRecreation = (qName, app) => {
+            const refInfos = this.pendingRefsForRecreation.get(qName);
+            if (!refInfos) {
+                return undefined;
+            }
+            const refs = new Set();
+            for (const refInfo of refInfos) {
+                // 检查引用节点是否仍在 app 树上
+                if (!this.isRefStillInAppTree(refInfo.ref)) {
+                    continue;
+                }
+                // 检查引用节点是否仍引用原来的 qName
+                if (this.isRefStillReferencingQName(refInfo.ref, qName)) {
+                    refs.add(refInfo.ref);
+                }
+            }
+            return refs;
+        };
+        /**
+         * 获取待恢复引用缓存的大小（用于测试和调试）
+         * @returns 缓存中 qName 的数量
+         */
+        this.getPendingRefsForRecreationSize = () => {
+            return this.pendingRefsForRecreation.size;
+        };
+        /**
+         * 清除所有待恢复引用缓存
+         * 用于清理操作，避免内存泄漏
+         */
+        this.clearPendingRefsCache = () => {
+            this.pendingRefsForRecreation.clear();
+        };
+        /**
+         * 注册 Logic/View/BusinessLogic 的 params 到 gQNameDefs，便于建立「调用逻辑的参数」到「逻辑的参数」的引用
+         */
+        this.registerParamsOfLogicOrView = (defNode) => {
+            const nd = defNode;
+            if (!(0, symbol_type_1.isLogicViewLike)(nd) || !nd.params?.length) {
+                return;
+            }
+            for (const p of nd.params) {
+                const pq = (0, def_key_helpers_1.getGlobalDefKey)(p);
+                if (pq) {
+                    this.gQNameDefs.set(pq, p);
+                }
+            }
+        };
+        /**
+         * 移除 Logic/View/BusinessLogic 的 params 在 gQNameDefs 的注册及其引用
+         */
+        this.unregisterParamsOfLogicOrView = (defNode) => {
+            const nd = defNode;
+            if (!(0, symbol_type_1.isLogicViewLike)(nd) || !nd.params?.length) {
+                return;
+            }
+            for (const p of nd.params) {
+                const pq = (0, def_key_helpers_1.getGlobalDefKey)(p);
+                if (pq) {
+                    this.gQNameDefs.delete(pq);
+                    this.deleteSymbolRefs(p);
+                }
+            }
+        };
+        /**
+         * 对「调用该 Logic/View/BusinessComponent 的所有 CallLogic/Destination/ViewElement」重新收集参数引用，把参数引用加进 globalRefs。
+         * syncParamsOfLogicOrView 与 registerNewParamAndRecollectRefs 共用，避免重复逻辑。
+         * 所有 callers 均在 globalRefs。
+         */
+        this.recollectParamRefsForCallers = (env, logicQName) => {
+            const logicDef = this.gQNameDefs.get(logicQName);
+            const callers = logicDef ? this.getSymbolRefs(logicDef) : undefined;
+            if (!callers?.size)
+                return;
+            const prevMode = this.modeForCollect;
+            this.modeForCollect = "create" /* Operation.Create */;
+            try {
+                for (const ref of callers) {
+                    if (ref.concept === 'CallLogic' || ref.concept === 'Destination'
+                        || (ref.concept === 'ViewElement' && ref.tag?.startsWith('bs-'))) {
+                        this.handleCallerParamRefs(env, ref);
+                    }
+                }
+            }
+            finally {
+                this.modeForCollect = prevMode;
+            }
+        };
+        /**
+         * 对指定 Logic/View/BusinessLogic 重新收集参数引用（CallLogic 实参、Destination 实参 → params）。
+         * 增量更新「3: 按新类型添加符号」之后调用，此时 View 的 callers（Destination）已就绪，页面参数才能对应到页面跳转。
+         */
+        this.recollectParamRefsForDef = (env, defNode) => {
+            if (!(0, symbol_type_1.isLogicViewLike)(defNode))
+                return;
+            const qName = (0, def_key_helpers_1.getGlobalDefKey)(defNode);
+            if (qName)
+                this.recollectParamRefsForCallers(env, qName);
+        };
+        /**
+         * Logic/View/BusinessLogic 参数列表变更时同步 gQNameDefs 与 globalRefs。
+         * - 仅卸载「已删除」的参数，避免把内部引用清空。
+         * - 仍存在的参数：把 refs 从旧 def 迁移到新 def，并更新 gQNameDefs。
+         * - 新加参数：只做注册。
+         * - 最后对「调用该 Logic/View 的所有 CallLogic」重新收集参数引用，把新参数的引用加进 globalRefs。
+         */
+        this.syncParamsOfLogicOrView = (env, updatedDefNode, oldDefNode) => {
+            const updated = updatedDefNode;
+            const old = oldDefNode;
+            if (!(0, symbol_type_1.isLogicViewLike)(updated))
+                return;
+            const logicQName = (0, def_key_helpers_1.getGlobalDefKey)(updatedDefNode);
+            if (!logicQName)
+                return;
+            const oldParams = old.params ?? [];
+            const newParams = updated.params ?? [];
+            const newParamNames = new Set(newParams.map((p) => p?.name));
+            const oldParamNames = new Set(oldParams.map((p) => p?.name));
+            // 只卸载已删除的参数，用 getGlobalDefKey(p) 与注册时 key 一致
+            for (const p of oldParams) {
+                const name = p?.name;
+                if (newParamNames.has(name))
+                    continue;
+                const pq = (0, def_key_helpers_1.getGlobalDefKey)(p);
+                if (!pq)
+                    continue;
+                const def = this.gQNameDefs.get(pq);
+                if (def)
+                    this.deleteSymbolRefs(def);
+                this.gQNameDefs.delete(pq);
+            }
+            // 对新参数：存在的迁移 refs，新增的只注册，用 getGlobalDefKey(p) 与注册时 key 一致
+            for (const p of newParams) {
+                const pq = (0, def_key_helpers_1.getGlobalDefKey)(p);
+                if (!pq)
+                    continue;
+                const name = p?.name;
+                if (oldParamNames.has(name)) {
+                    const oldDef = this.gQNameDefs.get(pq);
+                    const refs = oldDef ? this.globalRefs.get(oldDef) : undefined;
+                    if (oldDef)
+                        this.globalRefs.delete(oldDef);
+                    this.gQNameDefs.set(pq, p);
+                    if (refs?.size)
+                        this.globalRefs.set(p, refs);
+                }
+                else {
+                    this.gQNameDefs.set(pq, p);
+                }
+            }
+            this.recollectParamRefsForCallers(env, logicQName);
+        };
+        /**
+         * 新增参数进入 createNodes 时（Param create 事件）：注册该参数并对调用该 Logic/View 的 CallLogic 重新收集参数引用。
+         * 与 syncParamsOfLogicOrView 互补：后者处理 Logic update；本方法处理 Param create。
          */
-        this.transferQNameDef = (oldQName, newQName, mode) => {
-            if (!oldQName || !newQName)
+        this.registerNewParamAndRecollectRefs = (env, paramNode) => {
+            const nd = paramNode;
+            if (nd.concept !== 'Param' && nd.concept !== 'ParamWithGroup')
+                return;
+            const parent = nd.parentNode;
+            if (!(0, symbol_type_1.isLogicViewLike)(parent))
+                return;
+            const logicQName = (0, def_key_helpers_1.getGlobalDefKey)(parent);
+            if (!logicQName)
                 return;
-            const oldDef = this.gQNameDefs.get(oldQName);
-            if (!oldDef)
+            const pq = (0, def_key_helpers_1.getGlobalDefKey)(nd);
+            if (!pq)
                 return;
-            // 1. 删除 oldQName，建立 newQName，def 地址不变
-            this.gQNameDefs.delete(oldQName);
-            this.gQNameDefs.set(newQName, oldDef);
-            // 2. 处理引用集合
-            if (mode === 'update') {
-                // 获取 oldQName 的既存引用
-                const oldRefs = this.gSymbolRefs.get(oldDef) ?? new Set();
-                // 获取 newQName 在缓存中的引用
-                const newCachedRefs = this.gCachedQNameSymbolRefs.get(newQName) ?? new Set();
-                // 合并引用集合
-                const mergedRefs = mnemonist_1.set.union(oldRefs, newCachedRefs);
-                // 设置新名字的引用集合
-                mergedRefs.size > 0 && this.setSymbolRefs(oldDef, mergedRefs);
-                // 删除 newQName 在缓存中的引用
-                this.gCachedQNameSymbolRefs.delete(newQName);
+            this.gQNameDefs.set(pq, nd);
+            this.recollectParamRefsForCallers(env, logicQName);
+        };
+        /**
+         * 建立「调用处实参」到「Logic/View/BusinessComponent 形参」的引用。
+         * 支持 CallLogic（调用逻辑）、Destination（页面跳转）、ViewElement（业务组件 bindAttrs）等。
+         * 扩充新类型时只需在此处增加分支。
+         */
+        this.handleCallerParamRefs = (env, nd) => {
+            if (!this.modeForCollect)
+                return;
+            let callee;
+            let bindings;
+            if (nd.concept === 'CallLogic' || nd.concept === 'Destination') {
+                const calleeQName = (0, def_key_helpers_1.getGlobalDefKey)(nd);
+                if (!calleeQName)
+                    return;
+                callee = this.gQNameDefs.get(calleeQName);
+                if (!callee?.params?.length)
+                    return;
+                const args = nd.arguments ?? [];
+                bindings = args
+                    .map((arg, i) => {
+                    const param = callee.params.find((p) => p.name === arg.keyword)
+                        ?? callee.params[i];
+                    return param ? { refNode: arg, param } : null;
+                })
+                    .filter((x) => !!x);
+            }
+            else if (nd.concept === 'ViewElement' && nd.tag.startsWith('bs-')) {
+                // 无 bindAttrs 则无需注册实参→形参引用，直接跳过，避免 frontendType/businessComponents 查找
+                if (!nd.bindAttrs?.length)
+                    return;
+                const bsName = nd.tag.split('bs-')[1];
+                const fet = nd.frontendType;
+                const bsDef = fet?.businessComponents?.find((bc) => bc.name === bsName);
+                if (!bsDef?.params?.length)
+                    return;
+                callee = bsDef;
+                bindings = nd.bindAttrs
+                    .map((attr) => {
+                    const param = bsDef.params.find((p) => p.name === attr.name);
+                    return param ? { refNode: attr, param } : null;
+                })
+                    .filter((x) => !!x);
             }
             else {
-                // 不是 update，直接取 newQName 在缓存中的引用
-                const newCachedRefs = this.gCachedQNameSymbolRefs.get(newQName) ?? new Set();
-                this.setSymbolRefs(oldDef, newCachedRefs);
-                // oldQName 的引用集合被放入 cachedQNameSymbolRefs
-                const oldRefs = this.gSymbolRefs.get(oldDef) ?? new Set();
-                oldRefs.size > 0 && this.gCachedQNameSymbolRefs.set(oldQName, oldRefs);
-                // 删除 newQName 在缓存中的引用
-                this.gCachedQNameSymbolRefs.delete(newQName);
+                return;
+            }
+            for (const { refNode, param } of bindings) {
+                const paramQName = (0, def_key_helpers_1.getGlobalDefKey)(param);
+                if (paramQName) {
+                    this.handleRefOp(this.modeForCollect, refNode, paramQName);
+                }
             }
         };
-        this.updateRefsInNaslFragment = update_nasl_fragment_1.updateRefsInNaslFragment;
         /**
-        * @warning Only handle global symbols
-        */
+         * 处理「定义」的增删
+         * @warning Only handle global symbols
+         **/
         this.handleDefOp = (mode, defNode, qName) => {
             switch (mode) {
                 // 目前的策略是 re-link：删除 logic1 后，不会删除引用。新建一个 logic1 后，自动关联到老的引用上
@@ -719,16 +1129,16 @@ class ReferenceManager {
                         this.isLocalCacheValid = false;
                     }
                     else {
-                        // 可以链接回旧的引用，类似于 rename
-                        const oldRefs = this.gCachedQNameSymbolRefs.get(qName);
-                        oldRefs && this.setSymbolRefs(defNode, oldRefs);
                         // qName 链接到新的 defNode 的 mem addr
                         this.gQNameDefs.set(qName, defNode);
+                        // 逻辑/页面参数一并注册，便于建立「调用逻辑的参数」到「逻辑的参数」的引用
+                        this.registerParamsOfLogicOrView(defNode);
                         if ((0, component_def_manager_1.isGeneralViewElementDefinition)(defNode)) {
                             this.compDefMgr.add(defNode, 'handleDefOp');
                         }
-                        // 删除缓存
-                        this.gCachedQNameSymbolRefs.delete(qName);
+                        // 尝试从缓存恢复引用（来自删除操作）
+                        // 如果恢复成功，缓存会被自动清除；如果失败，引用会在类型检查时自动重新建立
+                        this.restoreRefsFromCache(qName, defNode);
                     }
                     break;
                 }
@@ -737,17 +1147,11 @@ class ReferenceManager {
                         this.isLocalCacheValid = false;
                     }
                     else {
-                        const refs = this.getSymbolRefs(defNode);
-                        if (refs) {
-                            if (refs.size > 0) {
-                                // 过滤掉 BindAttribute 的引用，因为 BindAttribute 的引用很容易冗余
-                                // 使用类型断言因为 BindAttribute 是特殊的引用类型，未包含在 RefConcept 中
-                                this.gCachedQNameSymbolRefs.set(qName, new Set(Array.from(refs).filter(ref => ref.concept !== 'BindAttribute')));
-                            }
-                            else {
-                                this.gCachedQNameSymbolRefs.set(qName, refs);
-                            }
-                        }
+                        // 先移除逻辑/页面参数的注册及其引用
+                        this.unregisterParamsOfLogicOrView(defNode);
+                        // 缓存引用以备后续恢复（在删除引用之前调用）
+                        this.cacheRefsForRecreation(qName, defNode);
+                        // 删除 qName 和引用
                         this.gQNameDefs.delete(qName);
                         if ((0, component_def_manager_1.isGeneralViewElementDefinition)(defNode)) {
                             this.compDefMgr.removeComponentGroup(defNode);
@@ -759,16 +1163,17 @@ class ReferenceManager {
             }
         };
         /**
+         * 处理「引用」的增删
          * @warning Only handle global symbols
-         */
+         **/
         this.handleRefOp = (mode, refNd, qName) => {
             const def = this.gQNameDefs.get(qName);
             if (def) {
                 switch (mode) {
                     case "create" /* Operation.Create */: {
                         // Route reference to the appropriate map based on whether it's explicit or implicit
-                        // Explicit references go to symbolRefs
-                        (0, fp_macros_1.createOnAdd)(this.gSymbolRefs, def, refNd);
+                        // Explicit references go to globalRefs
+                        (0, fp_macros_1.createOnAdd)(this.globalRefs, def, refNd);
                         break;
                     }
                     case "delete" /* Operation.Remove */: {
@@ -778,19 +1183,8 @@ class ReferenceManager {
                     }
                 }
             }
-            else {
-                // cache 里的也要处理……
-                switch (mode) {
-                    case "create" /* Operation.Create */: {
-                        (0, fp_macros_1.createOnAdd)(this.gCachedQNameSymbolRefs, qName, refNd);
-                        break;
-                    }
-                    case "delete" /* Operation.Remove */: {
-                        this.gCachedQNameSymbolRefs.get(qName)?.delete(refNd);
-                        break;
-                    }
-                }
-            }
+            // 注意：如果定义不存在，引用会被忽略
+            // 类型检查时会重新建立引用关系
         };
         this.handleSymbolImplicitRefs = (nd) => {
             if (!nd)
@@ -847,7 +1241,7 @@ class ReferenceManager {
             if (!(0, type_predicate_1.isEntityTy)(typeAnnotation) && !(0, type_predicate_1.isStructureTy)(typeAnnotation)) {
                 return;
             }
-            const tyQName = (0, get_q_name_1.getTokenQualifiedName)(typeAnnotation);
+            const tyQName = (0, def_key_helpers_1.getGlobalDefKey)(typeAnnotation);
             if (!tyQName) {
                 return;
             }
@@ -882,7 +1276,7 @@ class ReferenceManager {
             if (!bsDef) {
                 return;
             }
-            this.handleRefOp(this.modeForCollect, nd, (0, get_q_name_1.getTokenQualifiedName)(bsDef));
+            this.handleRefOp(this.modeForCollect, nd, (0, def_key_helpers_1.getGlobalDefKey)(bsDef));
         };
         this.handleBindRoles = (env, nd) => {
             for (const roleName of nd.bindRoles ?? nd.roles) {
@@ -909,11 +1303,11 @@ class ReferenceManager {
             parent?.interfaceDependencies?.forEach(dep => {
                 dep.interfaces.forEach(itfc => {
                     if (itfc.concept === 'AuthInterface' && itfc.name === nd.calleeName) {
-                        // this.handleRefOp(this.modeForCollect!, nd, getTokenQualifiedName(itfc)!);
+                        // this.handleRefOp(this.modeForCollect!, nd, getGlobalDefKey(itfc)!);
                         const authName = itfc.authLogic;
                         parent?.authLogicsForCallInterface?.forEach(l => {
                             if (l.name === authName) {
-                                this.handleRefOp(this.modeForCollect, nd, (0, get_q_name_1.getTokenQualifiedName)(l));
+                                this.handleRefOp(this.modeForCollect, nd, (0, def_key_helpers_1.getGlobalDefKey)(l));
                             }
                         });
                     }
@@ -921,17 +1315,29 @@ class ReferenceManager {
             });
             parent.interfaces?.forEach(itfc => {
                 if (itfc.concept === 'AuthInterface' && itfc.name === nd.calleeName) {
-                    // this.handleRefOp(this.modeForCollect!, nd, getTokenQualifiedName(itfc)!);
-                    // this.handleRefOp(this.modeForCollect!, nd, getTokenQualifiedName(itfc)!);
+                    // this.handleRefOp(this.modeForCollect!, nd, getGlobalDefKey(itfc)!);
+                    // this.handleRefOp(this.modeForCollect!, nd, getGlobalDefKey(itfc)!);
                     const authName = itfc.authLogic;
                     parent?.authLogics?.forEach(l => {
                         if (l.name === authName) {
-                            this.handleRefOp(this.modeForCollect, nd, (0, get_q_name_1.getTokenQualifiedName)(l));
+                            this.handleRefOp(this.modeForCollect, nd, (0, def_key_helpers_1.getGlobalDefKey)(l));
                         }
                     });
                 }
             });
         };
+        /**
+         * 处理 ProcessElementV2 的 CallSubProcess 类型对 ProcessV2 的引用
+         * 当 ProcessElementV2 的 type === 'CallSubProcess' 时，subProcessKey 字段引用另一个 ProcessV2 的 uniqueKey
+         */
+        this.handleProcessSubProcessRef = (env, nd) => {
+            if (nd.type !== 'CallSubProcess' || !nd.subProcessKey) {
+                return;
+            }
+            // subProcessKey 就是 ProcessV2 的 uniqueKey，直接作为 qName 使用
+            const subProcessQName = nd.subProcessKey;
+            this.handleRefOp(this.modeForCollect, nd, subProcessQName);
+        };
         /**
          * 无论根节点是 ref 还是 def，都要递归收集下层所有的引用节点
          * 会打散 a.b.c、A | B、x.a.b 等结构，并记录必要的信息
@@ -959,7 +1365,7 @@ class ReferenceManager {
             !skipSubView && views.push(...(0, misc_1.getSubViews)(nd));
             if (nd.concept === 'View' || nd.concept === 'BusinessComponent') {
                 this.curFileNode = nd;
-                env.viewAssocProcess = env.processV2ViewBindings.get((0, get_q_name_1.getTokenQualifiedName)(nd)) ?? null;
+                env.viewAssocProcess = env.processV2ViewBindings.get((0, def_key_helpers_1.getGlobalDefKey)(nd)) ?? null;
             }
             const res = new Array(); // 使用数组而不是 Map
             // specialization for speeding up
@@ -974,10 +1380,16 @@ class ReferenceManager {
                 n.concept === 'EntityProperty' && this.handleForeignKeyRef(env, n);
                 n.concept === 'AssigneeV2' && this.handleBindRoles(env, n);
                 n.concept === 'CallAuthInterface' && this.handleAuthLogicRef(env, n);
+                // 处理流程子流程引用
+                n.concept === 'ProcessElementV2' && this.handleProcessSubProcessRef(env, n);
+                // 处理 CallLogic、Destination、ViewElement 的调用处实参到形参的引用
+                if (['CallLogic', 'Destination', 'ViewElement'].includes(n.concept)) {
+                    this.handleCallerParamRefs(env, n);
+                }
                 if (!symbol_type_1.refConcept.includes(n.concept)) {
                     return;
                 }
-                const qName = (0, get_q_name_1.getTokenQualifiedName)(n); // 太慢，后续应该需要优化速度
+                const qName = (0, def_key_helpers_1.getGlobalDefKey)(n); // 太慢，后续应该需要优化速度
                 if (!qName) {
                     return;
                 }
@@ -1004,7 +1416,7 @@ class ReferenceManager {
                     case 'TypeAnnotation':
                         const refs = this.splitPolyType(n);
                         for (const ref of refs) {
-                            const qName = (0, get_q_name_1.getTokenQualifiedName)(ref);
+                            const qName = (0, def_key_helpers_1.getGlobalDefKey)(ref);
                             qName && qNameRefs.push([ref, qName]);
                         }
                         break;
@@ -1039,7 +1451,7 @@ class ReferenceManager {
                 for (const v of views) {
                     v.bindRoles.length && this.handleBindRoles(env, v);
                     const lastViewAssocProcess = env.viewAssocProcess;
-                    env.viewAssocProcess = env.processV2ViewBindings.get((0, get_q_name_1.getTokenQualifiedName)(v)) ?? null;
+                    env.viewAssocProcess = env.processV2ViewBindings.get((0, def_key_helpers_1.getGlobalDefKey)(v)) ?? null;
                     const lastCurFileNode = this.curFileNode;
                     this.curFileNode = v;
                     // @ts-expect-error contra-variance errors
@@ -1054,7 +1466,7 @@ class ReferenceManager {
                 (0, traverse_util_1.visitChildrenWith)(nd, normalCb, compositeNodePred, compositeNodeCb);
             }
             if (nd.concept === 'McpInterface') {
-                const qName = nd.originLogic && (0, get_q_name_1.getTokenQualifiedName)(nd.originLogic);
+                const qName = nd.originLogic && (0, def_key_helpers_1.getGlobalDefKey)(nd.originLogic);
                 qName && res.push([nd, qName]);
             }
             else if (nd.concept !== 'QueryFieldExpression') {
@@ -1116,7 +1528,7 @@ class ReferenceManager {
             const visibleLocalSyms = this.getVisibleLocalSyms(nd);
             const localQNameSet = new Set();
             for (const s of visibleLocalSyms) {
-                const q = (0, get_q_name_1.getTokenQualifiedName)(s);
+                const q = (0, def_key_helpers_1.getGlobalDefKey)(s);
                 q && localQNameSet.add(q);
             }
             for (const [ref, qName] of refAndQNames) {
@@ -1187,8 +1599,16 @@ class ReferenceManager {
                     processVar = (0, typer_1.createProcessVariable)(env, proc);
                     (0, helper_1.createOnPush)(env.allocatedVirtualNodes, this.curFileNode, processVar);
                 });
-                if (symbol_type_1.refConcept.includes(id0.concept)) {
-                    const qName = (0, get_q_name_1.getTokenQualifiedName)(id0);
+                // 处理 processVariable.variable1 的情况
+                // processVariable 是虚拟变量，不需要添加引用，只需要设置类型以便后续处理
+                if (processVar && id0.name === 'processVariable') {
+                    const procVarTy = env.getType(processVar);
+                    if (procVarTy) {
+                        env.setType(id0, procVarTy);
+                    }
+                }
+                else if (symbol_type_1.refConcept.includes(id0.concept)) {
+                    const qName = (0, def_key_helpers_1.getGlobalDefKey)(id0);
                     let isProcessRef = false;
                     if (qName) {
                         // Handle process reference in view
@@ -1207,7 +1627,7 @@ class ReferenceManager {
                         }
                         if (isProcessRef) {
                             const processDef = env.viewAssocProcess;
-                            const pId = (0, get_q_name_1.getTokenQualifiedName)(processDef);
+                            const pId = (0, def_key_helpers_1.getGlobalDefKey)(processDef);
                             res.push([ids[0], pId]);
                             const processBindDataTy = (0, type_manager_1.createTypeofBindData)(pId, env);
                             env.setType(ids[0], processBindDataTy);
@@ -1231,7 +1651,17 @@ class ReferenceManager {
                 }
                 // 是这样的，为了兼容 processVariable.variable1，前面的是匿名数据结构，只需要 variable1 的引用就行了
                 let ndDef = this.getNodeDef(ty);
-                if (ndDef && (ndDef.concept === 'Entity' || ndDef.concept === 'Structure' || ndDef.concept === 'Enum')) {
+                // 处理 processVariable.variable1 的情况：匿名结构类型，需要添加 processVariable.variable1 的引用
+                if (ty.typeKind === 'anonymousStructure' && ids[0].name === 'processVariable' && processVar) {
+                    const procDef = processVar.parentNode;
+                    if (procDef && procDef.concept === 'ProcessDefinitionV2') {
+                        const procVar = procDef.variables?.find((v) => v.name === ids[i + 1].name);
+                        if (procVar) {
+                            res.push([ids[i + 1], `processVariable.${ids[i + 1].name}`]);
+                        }
+                    }
+                }
+                else if (ndDef && (ndDef.concept === 'Entity' || ndDef.concept === 'Structure' || ndDef.concept === 'Enum')) {
                     const propQName = (0, string_2.getPropQName)(`${ty.typeNamespace}.${ty.typeName}`, ids[i + 1].name, 'Entity');
                     res.push([ids[i + 1], propQName]); // type reference
                 }
@@ -1344,8 +1774,8 @@ class ReferenceManager {
                 return res;
             }
             const entityQName = nd.propertyName === 'data'
-                ? (0, get_q_name_1.getTokenQualifiedName)(entityRef.typeAnnotation) // data 是 Entity
-                : (0, get_q_name_1.getTokenQualifiedName)(entityRef.typeAnnotation.typeArguments[0]); // relation_data 是 List<Entity>
+                ? (0, def_key_helpers_1.getGlobalDefKey)(entityRef.typeAnnotation) // data 是 Entity
+                : (0, def_key_helpers_1.getGlobalDefKey)(entityRef.typeAnnotation.typeArguments[0]); // relation_data 是 List<Entity>
             for (const sub of nd.subFieldPermissions) {
                 res.push([sub, (0, string_2.getPropQName)(entityQName, sub.propertyName, 'Entity')]);
             }
@@ -1357,9 +1787,9 @@ class ReferenceManager {
         this.getMemoryStats = () => {
             const stats = {
                 gQNameDefs: this.gQNameDefs,
-                symbolRefs: this.gSymbolRefs, // Exporting private map for serialization
-                cachedQNameSymbolRefs: this.gCachedQNameSymbolRefs,
-                localQNameRefs: this.lQNameRefs,
+                globalRefs: this.globalRefs, // Exporting private map for serialization
+                pendingRefsForRecreation: this.pendingRefsForRecreation, // Exporting private map for serialization
+                localRefs: this.localRefs,
                 compDefMgr: this.compDefMgr,
             };
             const result = {
@@ -1411,7 +1841,7 @@ class ReferenceManager {
             if (!(0, helper_2.isEntityLogic)(nd)) {
                 return nd;
             }
-            const qName = (0, get_q_name_1.getTokenQualifiedName)(nd);
+            const qName = (0, def_key_helpers_1.getGlobalDefKey)(nd);
             if (!qName) {
                 throw new Error('The entity logic does not have namespace');
             }
@@ -1422,8 +1852,8 @@ class ReferenceManager {
             // 同步跟新引用管理器，跟上实体逻辑内存地址变化的节奏
             if (nd !== def) {
                 this.gQNameDefs.set(qName, nd);
-                const refs = mnemonist_1.set.union(this.gSymbolRefs.get(def) ?? new Set(), this.gSymbolRefs.get(nd) ?? new Set());
-                refs.size > 0 && this.gSymbolRefs.set(nd, refs);
+                const refs = mnemonist_1.set.union(this.globalRefs.get(def) ?? new Set(), this.globalRefs.get(nd) ?? new Set());
+                refs.size > 0 && this.globalRefs.set(nd, refs);
             }
             return nd;
         };
@@ -1442,7 +1872,7 @@ class ReferenceManager {
         if (!(ctxViewLike && (ctxViewLike.concept === 'View' || ctxViewLike.concept === 'BusinessComponent'))) {
             return;
         }
-        const ctxQName = (0, get_q_name_1.getTokenQualifiedName)(ctxViewLike);
+        const ctxQName = (0, def_key_helpers_1.getGlobalDefKey)(ctxViewLike);
         if (!ctxQName)
             return;
         const assocProc = env.processV2ViewBindings.get(ctxQName);
@@ -1479,9 +1909,9 @@ class ReferenceManager {
         if (!ctxViewElement) {
             return;
         }
-        const macthed = node.concept === 'BindAttribute';
-        const ancestor = !macthed && node.getAncestorRaw('BindAttribute');
-        const boundary = (macthed ? node : ancestor);
+        const matched = node.concept === 'BindAttribute';
+        const ancestor = !matched && node.getAncestorRaw('BindAttribute');
+        const boundary = (matched ? node : ancestor);
         if (boundary?.name !== 'rules') {
             return;
         }
@@ -1521,7 +1951,7 @@ class ReferenceManager {
         }
     }; }
     static getEntityLogicQNames(nd) {
-        const qName = (0, get_q_name_1.getTokenQualifiedName)(nd);
+        const qName = (0, def_key_helpers_1.getGlobalDefKey)(nd);
         const res = new Array();
         for (const l of nd.logics) {
             res.push(`${qName}.logics.${l.name}`);
@@ -1529,13 +1959,11 @@ class ReferenceManager {
         return res;
     }
     clearAll() {
-        this.clearSymbolRefs();
+        this.clearGlobalRefs();
         this.gQNameDefs.clear();
-        this.gCachedQNameSymbolRefs.clear();
-        this.lQNameRefs.clear();
-        this.veQNameDefs.clear();
-        this.veRefs.clear();
+        this.localRefs.clear();
         this.compDefMgr.clearAll();
+        this.clearPendingRefsCache(); // 清除待恢复引用缓存
         this.gSymbolImplicitRefs = new WeakMap();
     }
 }