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

package/out/typer/incremental-update.js

@@ -10,7 +10,8 @@ const type_predicate_1 = require("./type-predicate");
 const dispatch_all_1 = require("./dispatch-all");
 const checker_1 = require("../checker");
 const service_2 = require("@lcap/nasl-concepts/service");
-const get_q_name_1 = require("../reference-manager/get-q-name");
+const symbol_type_1 = require("../reference-manager/symbol-type");
+const def_key_helpers_1 = require("../reference-manager/def-key-helpers");
 const reference_manager_1 = require("../reference-manager/reference-manager");
 const collect_q_name_1 = require("../reference-manager/collect-q-name");
 const remove_q_name_1 = require("../reference-manager/remove-q-name");
@@ -18,10 +19,97 @@ const rename_q_name_1 = require("../reference-manager/rename-q-name");
 const dispatch_def_1 = require("./dispatch-def");
 const type_manager_1 = require("./type-manager");
 const helper_1 = require("./helper");
+const topo_sort_1 = require("./topo-sort");
 const helper_2 = require("../reference-manager/helper");
 const misc_1 = require("../utils/misc");
 const get_oql_files_1 = require("./get-oql-files");
 const asserts_1 = require("@lcap/nasl-concepts/asserts");
+/**
+ * 祖先节点重新验证规则配置
+ * 当子节点的特定字段变更时，会触发祖先节点的重新验证
+ * 通过配置驱动的方式，可以轻松添加新的验证规则，避免硬编码
+ *
+ * 默认会向上查找整个祖先链，找到所有匹配类型的祖先节点进行验证
+ * 如果设置了 directParentOnly: true，则只查找直接父节点
+ */
+const ANCESTOR_REVALIDATION_RULES = [
+    {
+        childNodeType: 'View',
+        triggerFields: ['isIndex'],
+        ancestorNodeTypes: ['View', 'Frontend'],
+        directParentOnly: true,
+        validationFn: (ancestorNode, env) => {
+            // 类型检查：确保 ancestorNode 是 View 或 Frontend 类型
+            if ((0, asserts_1.isView)(ancestorNode) || (0, asserts_1.isFrontend)(ancestorNode)) {
+                env.errorDiagnoser.checkViewIndexPageSetting(ancestorNode);
+            }
+        },
+        errorFilter: (err) => !err.isIndex,
+    },
+    {
+        childNodeType: 'ProcessElementV2',
+        triggerFields: ['subProcessKey'],
+        ancestorNodeTypes: ['App'],
+        directParentOnly: false,
+        validationFn: (ancestorNode, env) => {
+            // 类型检查：确保 ancestorNode 是 App 类型
+            if (ancestorNode.concept === 'App') {
+                // 检测所有流程的循环引用（在 App 级别，因为流程的变更会影响兄弟级别的流程）
+                env.errorDiagnoser.checkAllProcessCircularReferences(ancestorNode);
+            }
+        },
+        errorFilter: (err) => {
+            // 过滤掉流程循环引用相关的错误，以便重新检测
+            return !err.message?.includes('流程存在循环引用');
+        },
+        siblingNodeTypes: ['ProcessV2'],
+        getSiblingNodes: (ancestorNode) => {
+            // 从 App 节点获取所有 ProcessV2 兄弟节点
+            if (ancestorNode.concept === 'App') {
+                const appNode = ancestorNode;
+                return appNode.processV2s || [];
+            }
+            return [];
+        },
+    },
+];
+/**
+ * 检查节点类型是否匹配规则
+ */
+function matchesChildNodeType(rule, nodeConcept) {
+    if (Array.isArray(rule.childNodeType)) {
+        return rule.childNodeType.includes(nodeConcept);
+    }
+    return rule.childNodeType === nodeConcept;
+}
+/**
+ * 查找匹配的祖先节点
+ * @param startNode 起始节点
+ * @param ancestorNodeTypes 要查找的祖先节点类型列表
+ * @param directParentOnly 是否只查找直接父节点
+ * @returns 匹配的祖先节点列表（从近到远）
+ */
+function findMatchingAncestors(startNode, ancestorNodeTypes, directParentOnly = false) {
+    const matchingAncestors = [];
+    if (directParentOnly) {
+        // 只查找直接父节点
+        const parentNode = startNode.parentNode;
+        if (parentNode && ancestorNodeTypes.includes(parentNode.concept)) {
+            matchingAncestors.push(parentNode);
+        }
+    }
+    else {
+        // 向上遍历整个祖先链
+        let currentNode = startNode.parentNode;
+        while (currentNode) {
+            if (ancestorNodeTypes.includes(currentNode.concept)) {
+                matchingAncestors.push(currentNode);
+            }
+            currentNode = currentNode.parentNode;
+        }
+    }
+    return matchingAncestors;
+}
 /**
  * @warning 改动这个文件中的逻辑时很容易引发增量检查问题、查找引用问题、内存泄漏，请谨慎；如单元测试 UT 发生错误，更要谨慎
  * 为了增加效率，直接往 params 的 Set 里加东西
@@ -42,14 +130,11 @@ const preProcessOther = (env, nd, typerCheckFiles) => {
 };
 exports.preProcessOther = preProcessOther;
 /**
- * rename xs:
+ * 重命名定义节点：
  *  1 获取要删除的旧的 qNames1
  *  2 获取引用旧的 qNames1 的待检查项 ys
  *  3 获取要增加的新的 qNames2
- *  4 引用转移：gQNameDefs 中增加 qNames2，并且把 qNames1 的 symbolRefs 转移到 qNames2，gQNameDefs 中删除 qNames1
- *  5 尝试 'relink'：改名后，如果新名字已经存在一些存量 refs，也要加进去
- *  6 根据转移的 symbolRefs，获取引用新的 qNames2 的待检查项 zs（比如可能一个以前找不到的名字碰巧连接上了）
- *  7 类型检查 ys 和 zs
+ *  4 删除旧的 qNames1，清空旧引用（根据 mode 决定是否缓存引用）
  */
 /**
  * @warning 改动这个文件中的逻辑时很容易引发增量检查问题、查找引用问题、内存泄漏，请谨慎；如单元测试 UT 发生错误，更要谨慎
@@ -62,8 +147,8 @@ const preProcessDefRename = (env, nd, typerCheckFiles, oldName, mode, oqlRemoveN
         env.refMgr.invalidateLocalSymCache();
         return true;
     }
-    const qName = (0, get_q_name_1.getTokenQualifiedName)(nd);
-    // 2. Get items to check which have references to old qNames1
+    const qName = (0, def_key_helpers_1.getGlobalDefKey)(nd);
+    // 2. 获取引用旧的 qNames1 的待检查项
     const oldQName = easyGetOldQName(qName, oldName);
     try {
         const filePath = nd.getEmbeddedFilePath();
@@ -80,20 +165,27 @@ const preProcessDefRename = (env, nd, typerCheckFiles, oldName, mode, oqlRemoveN
             typerCheckFiles.add(refFileNode);
         });
     }
-    // 3. Get new qNames2 to add
+    // 3. 获取要增加的新的 qNames2
     const nsp = (0, helper_2.getNamespaceWithoutLast)(nd);
-    const qNamesToRename = (0, rename_q_name_1.getQNamesOfRenameAction)(oldName, nsp, nd);
-    // 4. Transfer references: add qNames2 to gQNameDefs, transfer symbolRefs from qNames1 to qNames2, remove qNames1 from gQNameDefs
-    // transferQNameDef already handles gQNameDefs deletion and addition
+    const qNamesToRename = (0, rename_q_name_1.getDefKeysForRename)(oldName, nsp, nd);
+    // 4. 删除旧的 qNames1 并清空旧引用
+    // 注意：新的 qNames2 会在 batchPreProcessAllCreateNodes 阶段统一设置（通过 typerCreateNodes.add 调用）
+    // 这确保了统一性：所有新的 qName 都通过相同的代码路径设置
+    // 所有引用会在类型检查阶段通过 addRefsForGlobalSym 重新建立
     qNamesToRename.forEach(([oldQName, newQName]) => {
-        // 5. Try to 'relink': if the new name already has existing refs, they also need to be added
-        // Transfer or relinquish symbolRefs
-        env.refMgr.transferQNameDef(oldQName, newQName, mode);
+        if (!oldQName || !newQName)
+            return;
+        const oldDef = env.refMgr.gQNameDefs.get(oldQName);
+        if (!oldDef)
+            return;
+        // 缓存引用（用于撤销/重做，重命名回旧名字/创建同名节点建立关联）
+        env.refMgr.cacheRefsForRecreation(oldQName, oldDef);
+        // 从 gQNameDefs 中删除旧的 qName
+        // 注意：新的 qName 会在 batchPreProcessAllCreateNodes 阶段设置
+        env.refMgr.gQNameDefs.delete(oldQName);
+        // 清空旧定义的引用：引用会在类型检查阶段重新建立
+        env.refMgr.deleteSymbolRefs(oldDef);
     });
-    // 6. Based on transferred symbolRefs, get items to check that reference new qNames2
-    // getDirectRefFileNodes(env, nd as DefConcept).forEach((refFileNode) => {
-    //     typerCheckFiles.add(refFileNode);
-    // });
     return true;
 };
 exports.preProcessDefRename = preProcessDefRename;
@@ -123,6 +215,61 @@ const pushRefFilesToChkFiles = (env, chkFiles, qNames) => {
         }
     }
 };
+/**
+ * 清理节点内部引用的所有定义
+ * @param env 语义环境
+ * @param sourceNode 源节点（可以是完整节点或临时节点）
+ * @param targetNode 目标节点（用于判断引用节点是否属于它）
+ * @param errorContext 错误上下文，用于日志
+ */
+const clearRefsFromNode = (env, sourceNode, targetNode, errorContext) => {
+    try {
+        // 遍历源节点，收集所有引用的 qName
+        const refQNames = new Set();
+        if (sourceNode.traverseStrictChildren) {
+            sourceNode.traverseStrictChildren((nd) => {
+                if (reference_manager_1.ReferenceManager.refConcept.includes(nd.concept)) {
+                    const qName = (0, def_key_helpers_1.getGlobalDefKey)(nd);
+                    if (qName) {
+                        refQNames.add(qName);
+                    }
+                }
+            });
+        }
+        // 对于每个被引用的定义，清理属于目标节点的引用
+        for (const qName of refQNames) {
+            const def = env.refMgr.gQNameDefs.get(qName);
+            if (!def) {
+                continue;
+            }
+            const refs = env.refMgr.getSymbolRefs(def);
+            if (!refs) {
+                continue;
+            }
+            // 找出属于目标节点的引用节点并清理
+            // 通过 parentNode 链判断：从引用节点向上遍历，看是否能到达 targetNode
+            const refsToRemove = [];
+            for (const ref of refs) {
+                let currentNode = ref;
+                while (currentNode) {
+                    if (currentNode === targetNode) {
+                        // 找到了，说明 ref 是 targetNode 的子节点，需要清理
+                        refsToRemove.push(ref);
+                        break;
+                    }
+                    currentNode = currentNode.parentNode;
+                }
+            }
+            // 清理这些引用
+            for (const ref of refsToRemove) {
+                env.refMgr.getSymbolRefs(def)?.delete(ref);
+            }
+        }
+    }
+    catch (err) {
+        nasl_utils_1.isDebugMode && console.warn(`Failed to clear refs from ${errorContext}:`, targetNode.nodePath, err);
+    }
+};
 const batchPreProcessAllRemoveNodes = (env, removeNodes, chkFiles, removedFiles) => {
     // 首先需要删除所有引用，后面移除定义后，删除引用时要么符号找不到，要么要去缓存里找，更麻烦，不如多一次遍历
     const allQNameDefs = new Set();
@@ -141,9 +288,12 @@ const batchPreProcessAllRemoveNodes = (env, removeNodes, chkFiles, removedFiles)
         if (!reference_manager_1.ReferenceManager.globalDefConcept.includes(rmNd.concept)) {
             env.removeTypes(rmNd);
         }
+        // 对于被删除的节点，清理它内部引用的所有定义
+        const rawNode = (0, misc_1.toRaw)(rmNd);
+        clearRefsFromNode(env, rawNode, rawNode, 'removed node');
         const nsp = (0, helper_2.getNamespaceWithoutLast)(rmNd) ?? '';
         // Including entity logics if nd.concept === 'Entity'
-        const qNames = (0, remove_q_name_1.getQNamesOfRemoveAction)(nsp, rmNd);
+        const qNames = (0, remove_q_name_1.getDefKeysForRemove)(nsp, rmNd);
         for (const [qName, def] of qNames) {
             allQNameDefs.add([qName, def]);
         }
@@ -199,10 +349,18 @@ const batchPreProcessAllCreateNodes = (env, createNodes, chkFiles) => {
     // TODO：之后再整理代码
     for (const nd of createNodes) {
         if (reference_manager_1.ReferenceManager.localDefConcept.includes(nd.concept)) {
+            // 新增的 Logic/View 参数：注册到 gQNameDefs 并对调用处重新收集参数引用，否则「查找引用」查不到
+            const raw = (0, misc_1.toRaw)(nd);
+            if ((raw.concept === 'Param' || raw.concept === 'ParamWithGroup') && raw.parentNode) {
+                const parent = (0, misc_1.toRaw)(raw.parentNode);
+                if ((0, symbol_type_1.isLogicViewLike)(parent)) {
+                    env.refMgr.registerNewParamAndRecollectRefs(env, raw);
+                }
+            }
             continue;
         }
         const nsp = (0, helper_2.getNamespaceWithoutLast)(nd);
-        const createdQNames = (0, collect_q_name_1.getQNamesOfCreateAction)(nsp, nd);
+        const createdQNames = (0, collect_q_name_1.getDefKeysForCreate)(nsp, nd);
         // Try to 'relink' to old defs，仅 relink refs，和建立 QNames，新的 refs 需要检查后再收集
         for (const [qName, def] of createdQNames) {
             env.refMgr.handleDefOp("create" /* Operation.Create */, def, qName);
@@ -215,6 +373,46 @@ const batchPreProcessAllCreateNodes = (env, createNodes, chkFiles) => {
         pushRefFilesToChkFiles(env, chkFiles, createdQNames.map(([qName]) => qName));
     }
 };
+const batchPreProcessAllUpdatedNodes = (env, updatedNodes, chkFiles) => {
+    const updatedQNames = [];
+    // 基于 oldObject 清理旧的引用关系；所有改动都需将所在文件加入 chkFiles，使关联节点重新计算类型
+    for (const [updatedNode, { oldObject }] of updatedNodes.entries()) {
+        const rawNode = (0, misc_1.toRaw)(updatedNode);
+        // 任一更新节点所在文件都加入 chkFiles，保证该文件被重新类型检查
+        const fileNode = (0, service_1.getFileNode)(rawNode);
+        if (fileNode) {
+            chkFiles.add(fileNode);
+        }
+        try {
+            const restoredJSON = {
+                ...oldObject,
+                concept: oldObject.concept || rawNode.concept
+            };
+            // 基于 oldObject 创建临时节点（只包含 oldObject 中的字段）
+            const tempNode = nasl_concepts_1.BaseNode.from(restoredJSON);
+            clearRefsFromNode(env, tempNode, rawNode, 'oldObject');
+            // 逻辑/页面参数变更时同步 gQNameDefs，新加参数才能被「查找引用」查到
+            if ((0, symbol_type_1.isLogicViewLike)(rawNode)) {
+                env.refMgr.syncParamsOfLogicOrView(env, rawNode, tempNode);
+            }
+        }
+        catch (err) {
+            // 如果处理失败，记录错误但继续处理
+            nasl_utils_1.isDebugMode && console.warn('Failed to clear old refs from oldObject:', rawNode.nodePath, err);
+        }
+        // 收集更新节点对应的 qNames，用于将引用这些定义的文件加入 chkFiles，使关联节点重新计算类型
+        if (!reference_manager_1.ReferenceManager.localDefConcept.includes(rawNode.concept)) {
+            const nsp = (0, helper_2.getNamespaceWithoutLast)(rawNode) ?? '';
+            const qNames = (0, collect_q_name_1.getDefKeysForCreate)(nsp, rawNode);
+            for (const [qName] of qNames) {
+                updatedQNames.push(qName);
+            }
+        }
+    }
+    if (updatedQNames.length > 0) {
+        pushRefFilesToChkFiles(env, chkFiles, updatedQNames);
+    }
+};
 /**
  * 增量更新诊断信息
  * @param params 包含所有参数的对象
@@ -224,7 +422,7 @@ const batchPreProcessAllCreateNodes = (env, createNodes, chkFiles) => {
  * @warning 改动这个文件中的逻辑时很容易引发增量检查问题、查找引用问题、内存泄漏，请谨慎；如单元测试 UT 发生错误，更要谨慎
  */
 async function checkUpdateRefsDiag(params) {
-    const { env, diagMgr: diagnosticManager, removeNodes, createNodes, tsDiagnostics, removedConnectors = new Set(), checkedFiles = new Set() } = params;
+    const { env, diagMgr: diagnosticManager, removeNodes, createNodes, tsDiagnostics, removedConnectors = new Set(), checkedFiles = new Set(), updatedNodes = new Map() } = params;
     // Integration-specific diagnostics accumulator
     let diagRecs = [];
     // 将 removeNodes、createNodes、removeNodes 根据是否在 integration 下分成两类
@@ -233,8 +431,9 @@ async function checkUpdateRefsDiag(params) {
     nasl_utils_1.isDebugMode && console.time('\x1b[44m\x1b[97m 1: 按原有类型删除符号引用和类型 \x1b[0m');
     batchPreProcessAllRemoveNodes(env, removeNodes, chkFiles, removedFiles);
     batchPreProcessAllCreateNodes(env, createNodes, chkFiles);
+    batchPreProcessAllUpdatedNodes(env, updatedNodes, chkFiles);
     for (const file of removedFiles) {
-        clearSemInfoDiags(env, diagnosticManager, file);
+        clearSemInfoDiags(env, diagnosticManager, file, false); // 删除的整棵子树都清（含 localSymBindings）
     }
     nasl_utils_1.isDebugMode && console.timeEnd('\x1b[44m\x1b[97m 1: 按原有类型删除符号引用和类型 \x1b[0m');
     // 合并两段过滤：先排除已删除文件和不合法路径（包含 '[-1]'），
@@ -267,8 +466,58 @@ async function checkUpdateRefsDiag(params) {
         return processRelatedConcepts.includes(v?.concept);
     });
     // 拆分 BusinessComponent 和 View，先处理 BusinessComponent
-    const [bsNodes, otherNodes3] = (0, helper_1.divideBy)(otherNodes2, (v) => v?.concept === 'BusinessComponent');
-    const [viewNodes, defNodes] = (0, helper_1.divideBy)(otherNodes3, (v) => v?.concept === 'View');
+    const [bsNodesRaw, otherNodes3] = (0, helper_1.divideBy)(otherNodes2, (v) => v?.concept === 'BusinessComponent');
+    const [viewNodes, otherNodes4] = (0, helper_1.divideBy)(otherNodes3, (v) => v?.concept === 'View');
+    const [frontendNodes, defNodes] = (0, helper_1.divideBy)(otherNodes4, (v) => ['FrontendType', 'Frontend'].includes(v?.concept));
+    // 对 BusinessComponent 做局部拓扑排序：
+    // 若同一个 FrontendType 下的业务组件 A 模板中引用了业务组件 B（通过 bs-XXX 实例），
+    // 则 B 需要先于 A 处理。
+    //
+    // 环的处理：
+    // topoSortBusinessComponentsByAst 会对环内节点做"展开"处理，
+    // 例如 A↔B 时返回 [A, B, A]，使 A 在 B 定型后获得第二次类型检查。
+    //
+    // 因此这里构造两个列表：
+    // - bsNodesForTyping：保留环展开的重复节点，用于 dispatchAsyncDef 类型检查阶段。
+    //   环内首节点会被多次 dispatchAsyncDef，第二次时其依赖已就绪，可正确解析。
+    // - bsNodesUnique：去重版本，用于 removeRefs / addRefs / 签名比较等，
+    //   这些操作具有幂等性或不应重复执行，每个组件只需跑一遍。
+    const bsNodesForTyping = (() => {
+        if (!bsNodesRaw.length)
+            return bsNodesRaw;
+        // 分组：按 FrontendType 归类业务组件，仅在同一 FrontendType 内部建图并排序
+        const groupByFrontend = new Map();
+        for (const nd of bsNodesRaw) {
+            const bc = nd;
+            const fe = bc.frontendType;
+            if (!groupByFrontend.has(fe)) {
+                groupByFrontend.set(fe, []);
+            }
+            groupByFrontend.get(fe).push(bc);
+        }
+        const result = [];
+        for (const [, list] of groupByFrontend) {
+            const ordered = (0, topo_sort_1.topoSortBusinessComponentsByAst)(list);
+            // 不去重，保留环展开产生的重复节点（例如 [A, B, A]）
+            ordered.forEach(bc => {
+                result.push(bc);
+            });
+        }
+        return result;
+    })();
+    // 去重版本：用于 removeRefs / addRefs / 参数签名比较等，只需要每个 BusinessComponent 跑一遍完整管线
+    const bsNodesUnique = (() => {
+        const seen = new Set();
+        const res = [];
+        for (const nd of bsNodesForTyping) {
+            const bc = nd;
+            if (seen.has(bc))
+                continue;
+            seen.add(bc);
+            res.push(nd);
+        }
+        return res;
+    })();
     /**
      * @warning 这个需要先做，因为下面的 topoSortLogicAndSetTypes 会根据逻辑的最新 NASL 更新逻辑的类型
      * 找到页面变量，集合，判断类型有无变化
@@ -276,26 +525,45 @@ async function checkUpdateRefsDiag(params) {
      */
     const [oldLogicRetTys, oldLogicParamTys] = getLogicSigs(env, logicNodes);
     // 收集页面和业务组件的参数类型（它们没有返回值）
-    const oldViewParamTys = getViewComponentSigs(env, [...viewNodes, ...bsNodes]);
+    const oldViewParamTys = getViewComponentSigs(env, [...viewNodes, ...bsNodesUnique]);
     (0, dispatch_def_1.setParamOptionalFlags)([...itfcNodes, ...logicNodes]);
     const logicTasks = (0, dispatch_all_1.topoSortLogicAndSetTypes)(env, logicNodes);
     // 处理类型检查 - 改为顺序处理，确保正确的等待异步操作
     nasl_utils_1.isDebugMode && console.time('\x1b[44m\x1b[97m 2: 类型检查 \x1b[0m');
     // 先处理 BusinessComponent，再处理 View
-    const sortedFiles = [...defNodes, ...itfcNodes, ...logicTasks, ...processNodes, ...bsNodes, ...viewNodes];
-    for (const file of sortedFiles) {
+    const filesForRefs = [...defNodes, ...itfcNodes, ...logicTasks, ...processNodes, ...bsNodesUnique, ...viewNodes, ...frontendNodes];
+    const filesForTyping = [...defNodes, ...itfcNodes, ...logicTasks, ...processNodes, ...bsNodesForTyping, ...viewNodes, ...frontendNodes];
+    // 1) 先按「唯一集合」移除引用 & 旧诊断
+    for (const file of filesForRefs) {
         env.refMgr.removeRefsForGlobalSym(env, file);
         clearSemInfoDiags(env, diagnosticManager, file);
-        await (0, dispatch_all_1.dispatchAsyncDef)(env, file, true);
+    }
+    // 2) 再按「拓扑 + 环展开」的顺序跑类型检查（每个 BusinessComponent 可能多次出现，如 A,B,A）
+    // 重复出现的节点（环展开重启节点）非最后一次时抑制报错，避免依赖未就绪时产生不准确的诊断
+    const errorGuard = env.createDuplicateErrorGuard(filesForTyping);
+    for (const file of filesForTyping) {
+        errorGuard.before(file);
+        try {
+            await (0, dispatch_all_1.dispatchAsyncDef)(env, file, true);
+        }
+        finally {
+            errorGuard.after(file);
+        }
     }
     nasl_utils_1.isDebugMode && console.timeEnd('\x1b[44m\x1b[97m 2: 类型检查 \x1b[0m');
     // 按新类型添加符号
     nasl_utils_1.isDebugMode && console.time('\x1b[44m\x1b[97m 3: 按新类型添加符号 \x1b[0m');
-    for (const file of sortedFiles) {
+    for (const file of filesForRefs) {
         if (reference_manager_1.ReferenceManager.defConcept.includes(file.concept)) {
             env.refMgr.addRefsForGlobalSym(env, file);
         }
     }
+    // View/Logic 的 callers（Destination/CallLogic）已就绪，再对每个 View/Logic 重收参数引用，页面参数才能对应到页面跳转
+    for (const file of filesForRefs) {
+        if ((0, symbol_type_1.isLogicViewLike)(file)) {
+            env.refMgr.recollectParamRefsForDef(env, file);
+        }
+    }
     nasl_utils_1.isDebugMode && console.timeEnd('\x1b[44m\x1b[97m 3: 按新类型添加符号 \x1b[0m');
     nasl_utils_1.isDebugMode && console.time('\x1b[44m\x1b[97m 4: 错误诊断 \x1b[0m');
     // 对OQL节点加载来自TS的错误
@@ -307,8 +575,80 @@ async function checkUpdateRefsDiag(params) {
             node.errorsFromTSServer = [{ message }];
         }
     });
-    // 处理错误诊断
-    for (const file of sortedFiles) {
+    // 配置驱动的祖先节点重新验证机制
+    // 当子节点的特定字段变更时，根据配置的规则向上查找祖先节点并触发重新验证
+    for (const [updatedNode, { object }] of updatedNodes.entries()) {
+        const nodeConcept = updatedNode.concept;
+        // 查找匹配的验证规则
+        const matchingRules = ANCESTOR_REVALIDATION_RULES.filter(rule => matchesChildNodeType(rule, nodeConcept) &&
+            rule.triggerFields.some(field => object.hasOwnProperty(field)));
+        // 对每个匹配的规则执行祖先节点重新验证
+        for (const rule of matchingRules) {
+            // 查找所有匹配的祖先节点（从近到远）
+            const matchingAncestors = findMatchingAncestors(updatedNode, rule.ancestorNodeTypes, rule.directParentOnly ?? false);
+            // 对每个匹配的祖先节点执行重新验证
+            for (const ancestorNode of matchingAncestors) {
+                // 如果祖先节点已经在已排序的文件列表中，则跳过（会在后续统一处理）
+                if (filesForRefs.includes(ancestorNode)) {
+                    continue;
+                }
+                // 调用 checker 的重新验证方法
+                const nodeDiagnosticsMap = env.errorDiagnoser.revalidateAncestorNode(ancestorNode, rule.validationFn, rule.errorFilter, rule.siblingNodeTypes, rule.getSiblingNodes);
+                // 收集新的诊断信息
+                // 注意：nodeDiagnosticsMap 可能包含多个文件节点的诊断信息（如 App 和 ProcessV2）
+                // 需要按文件节点分组处理
+                // 同时，即使兄弟节点没有诊断信息，也需要为它们生成空的 DiagnosticRecord，以便 pushAll 能清除它们的错误
+                const processedFileNodes = new Set();
+                if (nodeDiagnosticsMap) {
+                    // 按文件节点分组诊断信息
+                    const diagnosticsByFileNode = new Map();
+                    nodeDiagnosticsMap.forEach((errs, node) => {
+                        const fileNode = (0, service_1.getFileNode)(node);
+                        if (fileNode) {
+                            processedFileNodes.add(fileNode);
+                            let fileDiagnostics = diagnosticsByFileNode.get(fileNode);
+                            if (!fileDiagnostics) {
+                                fileDiagnostics = new Map();
+                                diagnosticsByFileNode.set(fileNode, fileDiagnostics);
+                            }
+                            fileDiagnostics.set(node, errs);
+                        }
+                    });
+                    // 为每个文件节点生成 DiagnosticRecord
+                    diagnosticsByFileNode.forEach((fileDiagnostics, fileNode) => {
+                        diagRecs.push(...(0, checker_1.transformDiagnosticsToRecords)(fileNode, fileDiagnostics));
+                    });
+                }
+                // 为兄弟节点生成 DiagnosticRecord（即使它们没有诊断信息，也要生成空的，以便 pushAll 能清除它们的错误）
+                if (rule.getSiblingNodes) {
+                    const siblings = rule.getSiblingNodes(ancestorNode);
+                    for (const siblingNode of siblings) {
+                        // 如果指定了 siblingNodeTypes，则只处理匹配类型的兄弟节点
+                        if (rule.siblingNodeTypes && rule.siblingNodeTypes.length > 0) {
+                            if (!rule.siblingNodeTypes.includes(siblingNode.concept)) {
+                                continue;
+                            }
+                        }
+                        // 如果已经处理过这个文件节点，跳过
+                        if (processedFileNodes.has(siblingNode)) {
+                            continue;
+                        }
+                        // 为兄弟节点生成空的 DiagnosticRecord
+                        const siblingDiagnostics = env.errorDiagnoser.getDiagnostics(siblingNode);
+                        if (siblingDiagnostics) {
+                            diagRecs.push(...(0, checker_1.transformDiagnosticsToRecords)(siblingNode, siblingDiagnostics));
+                        }
+                        else {
+                            // 即使没有诊断信息，也要生成一个空的 DiagnosticRecord，以便 pushAll 能清除错误
+                            diagRecs.push(...(0, checker_1.transformDiagnosticsToRecords)(siblingNode, new Map()));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // 处理错误诊断：仅对每个文件节点执行一次
+    for (const file of filesForRefs) {
         await (0, nasl_utils_1.timeSlicingWithGenerator)(env.errorDiagnoser.checkNode(file));
         const nodeDiagnosticsMap = env.errorDiagnoser.getDiagnostics(file);
         nodeDiagnosticsMap && diagRecs.push(...(0, checker_1.transformDiagnosticsToRecords)(file, nodeDiagnosticsMap));
@@ -342,7 +682,7 @@ async function checkUpdateRefsDiag(params) {
         oldLogicRetTys,
         oldLogicParamTys,
         viewNodes: [...viewNodes],
-        bsNodes: [...bsNodes],
+        bsNodes: [...bsNodesUnique],
         oldViewParamTys,
     });
     if (nextChkFiles.size) {
@@ -355,7 +695,8 @@ async function checkUpdateRefsDiag(params) {
             createNodes: new Set(),
             tsDiagnostics: [],
             removedConnectors,
-            checkedFiles
+            checkedFiles,
+            updatedNodes: new Map() // 递归调用时不需要处理更新的节点
         }));
     }
     return diagRecs;
@@ -467,17 +808,22 @@ const removeNodeDiagnostics = (errorDiagnoser, diagnosticManager, file) => {
     diagnosticManager && diagnosticManager.deleteOwn(file.id);
 };
 /**
- * @warning 增量处理都默认不处理子页面
+ * 清除节点的语义信息和诊断，为重新类型检查做准备
+ * @param skipSubView true 时遇到子 View 剪枝，并顺带清除 start 的 localSymBindings（不深入子文件，子 View 等保留供 checker 使用）；false 时整棵子树都清（含 localSymBindings）
  */
 const clearSemInfoDiags = (env, diagnosticManager, start, skipSubView = true) => {
     const fileNodes = new Array;
-    // 遍历包含自身
+    // 遍历包含自身；skipSubView 时遇到子 View 剪枝且不收集、不删该节点，避免误清子 View 的 typeBindings/allocatedVirtualNodes 等
     start.traverseStrictChildrenWithPruning((nd) => {
-        (0, file_node_cache_1.checkNodeIsFileModuleInIdeWithCache)(nd) && fileNodes.push(nd);
-        env.typeBindings.delete(nd);
-        (0, service_2.isNaslCallExpr)(nd) && env.resolvedCallInfo.delete(nd);
-        return skipSubView && nd !== start && nd.concept === 'View'; // 不能排除自身
+        const prune = skipSubView && nd !== start && nd.concept === 'View';
+        if (!prune) {
+            (0, file_node_cache_1.checkNodeIsFileModuleInIdeWithCache)(nd) && fileNodes.push(nd);
+            env.typeBindings.delete(nd);
+            (0, service_2.isNaslCallExpr)(nd) && env.resolvedCallInfo.delete(nd);
+        }
+        return prune;
     });
+    // fileNodes 在 skipSubView 时已排除子 View，故以下均不会碰到子 View
     for (const fileNode of fileNodes) {
         removeNodeDiagnostics(env.errorDiagnoser, diagnosticManager, fileNode);
         env.allocatedVirtualNodes.get(fileNode)?.forEach(virtualNd => {
@@ -486,13 +832,20 @@ const clearSemInfoDiags = (env, diagnosticManager, start, skipSubView = true) =>
         });
         env.allocatedVirtualNodes.delete(fileNode);
         if (fileNode.concept === 'MetadataType') {
-            env.typeAlias.delete((0, get_q_name_1.getTokenQualifiedName)(fileNode));
+            env.typeAlias.delete((0, def_key_helpers_1.getGlobalDefKey)(fileNode));
         }
         else if (fileNode.concept === 'BusinessComponent') {
             env.refMgr.compDefMgr.removeBusinessComponentDef(fileNode);
         }
-        // Clear recorded local scope bindings for this file; localVars removed
-        env.refMgr.clearLocalSymBindingsForFile(fileNode);
+    }
+    if (skipSubView) {
+        env.refMgr.clearLocalSymBindingsForFile(start, {
+            skipDescendantFileNodes: true,
+            isFileNode: file_node_cache_1.checkNodeIsFileModuleInIdeWithCache,
+        });
+    }
+    else {
+        env.refMgr.clearLocalSymBindingsForFile(start);
     }
 };
 /**