@lcap/nasl-language-server-core 4.4.0-beta.9 → 4.4.0-rc.2

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

@@ -115,8 +115,20 @@ 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;
@@ -332,8 +344,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));
@@ -353,7 +367,7 @@ class ReferenceManager {
                     // Cache reference for future relinking
                     // FIXME:这里有问题，脏脏的，比如局部变量、入参等都扔到这里面了，虽然暂时可能没有太大的正确性问题，但有内存泄漏
                     if (!(0, helper_2.cheapTestLocalSymbol)(qName)) {
-                        (0, helper_1.createSetOnPush)(this.gCachedQNameSymbolRefs, qName, ref);
+                        this.addRefToPendingCache(qName, ref);
                     }
                 }
             });
@@ -456,6 +470,23 @@ class ReferenceManager {
             const qName = (0, get_q_name_1.getTokenQualifiedName)(ref);
             return qName ? this.gQNameDefs.get(qName) : undefined;
         };
+        /**
+         * 查找符号的定义，同时查找全局定义和 View 级别的定义
+         * 用于构建调用图时查找 View 级别的 logics
+         * @param ref
+         * @returns
+         */
+        this.getNodeDefIncludingView = (ref) => {
+            const qName = (0, get_q_name_1.getTokenQualifiedName)(ref);
+            if (!qName)
+                return undefined;
+            // 先查找全局定义
+            const globalDef = this.gQNameDefs.get(qName);
+            if (globalDef)
+                return globalDef;
+            // 再查找 View 级别的定义
+            return this.veQNameDefs.get(qName);
+        };
         /**
          * @warning 对外接口，指用户点击 "查找引用"，只返回用户手动指定的引用
          * @param __nd 要查找引用的定义
@@ -662,52 +693,203 @@ 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.transferQNameDef = (oldQName, newQName, mode) => {
-            if (!oldQName || !newQName)
-                return;
-            const oldDef = this.gQNameDefs.get(oldQName);
-            if (!oldDef)
+        this.cacheRefsForRecreation = (qName, defNode) => {
+            if (!(0, symbol_type_1.isGlobalDef)(defNode)) {
                 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);
             }
-            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);
+            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);
             }
         };
-        this.updateRefsInNaslFragment = update_nasl_fragment_1.updateRefsInNaslFragment;
+        /**
+         * 检查引用是否仍在 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 {
+                // 通过 getTokenQualifiedName 获取引用节点当前引用的 qName
+                const currentQName = (0, get_q_name_1.getTokenQualifiedName)(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();
+        };
         /**
         * @warning Only handle global symbols
         */
@@ -719,16 +901,14 @@ 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);
                         if ((0, component_def_manager_1.isGeneralViewElementDefinition)(defNode)) {
                             this.compDefMgr.add(defNode, 'handleDefOp');
                         }
-                        // 删除缓存
-                        this.gCachedQNameSymbolRefs.delete(qName);
+                        // 尝试从缓存恢复引用（来自删除操作）
+                        // 如果恢复成功，缓存会被自动清除；如果失败，引用会在类型检查时自动重新建立
+                        this.restoreRefsFromCache(qName, defNode);
                     }
                     break;
                 }
@@ -737,17 +917,9 @@ 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.cacheRefsForRecreation(qName, defNode);
+                        // 删除 qName 和引用
                         this.gQNameDefs.delete(qName);
                         if ((0, component_def_manager_1.isGeneralViewElementDefinition)(defNode)) {
                             this.compDefMgr.removeComponentGroup(defNode);
@@ -778,19 +950,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)
@@ -932,6 +1093,18 @@ class ReferenceManager {
                 }
             });
         };
+        /**
+         * 处理 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 等结构，并记录必要的信息
@@ -974,6 +1147,8 @@ 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);
                 if (!symbol_type_1.refConcept.includes(n.concept)) {
                     return;
                 }
@@ -1187,7 +1362,15 @@ 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)) {
+                // 处理 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, get_q_name_1.getTokenQualifiedName)(id0);
                     let isProcessRef = false;
                     if (qName) {
@@ -1231,7 +1414,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
                 }
@@ -1358,7 +1551,7 @@ class ReferenceManager {
             const stats = {
                 gQNameDefs: this.gQNameDefs,
                 symbolRefs: this.gSymbolRefs, // Exporting private map for serialization
-                cachedQNameSymbolRefs: this.gCachedQNameSymbolRefs,
+                pendingRefsForRecreation: this.pendingRefsForRecreation, // Exporting private map for serialization
                 localQNameRefs: this.lQNameRefs,
                 compDefMgr: this.compDefMgr,
             };
@@ -1531,11 +1724,11 @@ class ReferenceManager {
     clearAll() {
         this.clearSymbolRefs();
         this.gQNameDefs.clear();
-        this.gCachedQNameSymbolRefs.clear();
         this.lQNameRefs.clear();
         this.veQNameDefs.clear();
         this.veRefs.clear();
         this.compDefMgr.clearAll();
+        this.clearPendingRefsCache(); // 清除待恢复引用缓存
         this.gSymbolImplicitRefs = new WeakMap();
     }
 }