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

package/out/checker.js

@@ -240,6 +240,12 @@ function resolveMetadataType(typeArg, app) {
         return metadataTypes?.find(metadataType => metadataType.name === typeArg.typeName)?.typeAnnotation;
     }
 }
+function isConcreteTy(ty) {
+    if (ty.typeKind === 'generic') {
+        return !!ty.typeArguments?.every(x => isConcreteTy(x));
+    }
+    return !(0, type_predicate_1.isAnyTy)(ty) && !(0, type_predicate_1.isTyAnnTyParam)(ty);
+}
 /**
  * 创建错误诊断器
  * @returns
@@ -262,6 +268,7 @@ function createErrorDiagnoser(context) {
     let inAuthLogic = false;
     let dbType = '';
     let curVarCounter = 0;
+    const listComponentStack = [];
     const nodeNameCache = new Map();
     const nodeNameGetterMap = {
         View: 'getViewExistingNames',
@@ -597,6 +604,9 @@ function createErrorDiagnoser(context) {
         else if (nasl_concepts_1.asserts.isValidationLogic(node)) {
             message = '验证函数：参数不能为空！';
         }
+        else if (nasl_concepts_1.asserts.isNewComposite(node)) {
+            message = '新建实体/数据结构：参数不能为空！';
+        }
         if (message) {
             error(node, message);
         }
@@ -648,6 +658,123 @@ function createErrorDiagnoser(context) {
         const ref = type?.typeKind === 'anonymousStructure' ? type : env.resolveRef(type);
         return findPropertyByName(ref, name);
     }
+    // 判断节点是否在指定祖先之内，用于给列表上下文回填 slot 变量
+    function isDescendantOf(node, ancestor) {
+        let cur = node?.parentNode;
+        while (cur) {
+            if (cur === ancestor)
+                return true;
+            cur = cur.parentNode;
+        }
+        return false;
+    }
+    function getMemberPropertyName(member) {
+        const { property } = member || {};
+        if (!property)
+            return '';
+        if (nasl_concepts_1.asserts.isIdentifier(property))
+            return property.name;
+        return property?.value ?? property?.name ?? '';
+    }
+    function getMemberPath(member) {
+        const path = [];
+        let cur = member;
+        while (nasl_concepts_1.asserts.isMemberExpression(cur)) {
+            const propName = getMemberPropertyName(cur);
+            if (propName) {
+                path.unshift(propName);
+            }
+            const obj = cur.object;
+            if (nasl_concepts_1.asserts.isIdentifier(obj)) {
+                path.unshift(obj.name);
+                break;
+            }
+            cur = obj;
+        }
+        return path;
+    }
+    function isCurrentItemMember(member, slotVarName) {
+        if (!slotVarName)
+            return false;
+        const completeName = member?.completeName;
+        if (typeof completeName === 'string' && completeName.startsWith(`${slotVarName}.item`)) {
+            return true;
+        }
+        const path = getMemberPath(member);
+        return path[0] === slotVarName && path[1] === 'item';
+    }
+    // 找到命中的 currentX.item.* 成员表达式，优先返回首个匹配
+    function findCurrentItemMember(node, slotVarName) {
+        if (!slotVarName || !node)
+            return;
+        if (nasl_concepts_1.asserts.isMemberExpression(node) && isCurrentItemMember(node, slotVarName)) {
+            return node;
+        }
+        let matched;
+        node.traverseStrictChildren?.((child) => {
+            if (matched)
+                return;
+            if (nasl_concepts_1.asserts.isMemberExpression(child) && isCurrentItemMember(child, slotVarName)) {
+                matched = child;
+            }
+        });
+        return matched;
+    }
+    // 自内向外查找最近的未开启 formMode 的列表上下文，并携带命中的 MemberExpression
+    function getListContextByNode(node) {
+        if (!node)
+            return;
+        for (let i = listComponentStack.length - 1; i >= 0; i--) {
+            const ctx = listComponentStack[i];
+            if (ctx.formModeEnabled)
+                continue;
+            const member = findCurrentItemMember(node, ctx.slotVarName);
+            if (member) {
+                return { ...ctx, member };
+            }
+        }
+    }
+    // 解析 currentX.item.* 访问的上下文与字段路径
+    function getCurrentItemAccessInfo(target) {
+        const ctxWithMember = getListContextByNode(target);
+        if (!ctxWithMember)
+            return;
+        const member = ctxWithMember.member;
+        if (!member)
+            return;
+        const path = getMemberPath(member);
+        const itemIndex = path.indexOf('item');
+        if (itemIndex < 0)
+            return;
+        const afterItemPath = path.slice(itemIndex + 1).join('.');
+        const currentName = ctxWithMember.slotVarName || path[0] || 'current';
+        return {
+            ctx: ctxWithMember,
+            afterItemPath,
+            currentName,
+        };
+    }
+    // 统一报错出口：仅在 item 之后存在字段时提示切换表单模式
+    function reportCurrentItemModification(target, errorNode) {
+        const info = getCurrentItemAccessInfo(target);
+        if (!info)
+            return;
+        const { ctx, afterItemPath, currentName } = info;
+        if (!afterItemPath)
+            return;
+        error(errorNode, `组件列表 ${ctx.node.name || ctx.node.tag} 内部存在对数据源数据 ${currentName}.item.${afterItemPath} 的修改，请切换成表单模式，并且需要将“数据源”属性切换为使用“表单数据”属性`);
+    }
+    function isFormModeEnabled(attr) {
+        if (!attr)
+            return false;
+        if (attr.type === 'static') {
+            return attr.value === true || attr.value === 'true';
+        }
+        if (nasl_concepts_1.asserts.isBooleanLiteral(attr.expression)) {
+            return attr.expression.value === 'true';
+        }
+        return false;
+    }
     /**
      * 是否在赋值左侧
      * @param node
@@ -1087,6 +1214,8 @@ function createErrorDiagnoser(context) {
             yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.processV2s, function* (node) {
                 yield* checkNode(node);
             });
+            // 检测所有流程的循环引用（在 App 级别，因为流程的变更会影响兄弟级别的流程）
+            checkAllProcessCircularReferences(node);
         }
         if (node.roles?.length) {
             yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.roles, function* (node) {
@@ -1136,6 +1265,19 @@ function createErrorDiagnoser(context) {
                 });
             }
         }
+        // 检查 JDK 版本兼容性
+        function jdkDisabled(item) {
+            const isBackendComp = !!item?.externalDependencyMap?.maven;
+            if (isBackendComp) {
+                const jdk = app?.jdkVersion || 'JDK8';
+                const dependencyJdk = item?.externalDependencyMap?.jdk?.version || 'JDK8';
+                return jdk.toLowerCase() !== dependencyJdk.toLowerCase();
+            }
+            return false;
+        }
+        if (jdkDisabled(node)) {
+            error(node, `与当前应用的JDK版本不匹配`);
+        }
         inModule = false;
     }
     /**
@@ -1342,6 +1484,11 @@ function createErrorDiagnoser(context) {
                 yield* checkNode(node);
             });
         }
+        if (node.indexes?.length) {
+            yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.indexes, function* (node) {
+                yield* checkNode(node);
+            });
+        }
         // 在多模式切换为单模式的时候，数据库表名是否符合规范
         // /^[a-zA-Z0-9_]+$/ 由字母、数字、下划线组成
         const dataSource = node.dataSource;
@@ -1669,11 +1816,31 @@ function createErrorDiagnoser(context) {
             }
         }
     }
+    /**
+     * 检查 实体索引
+     * @param node
+     */
+    function* checkEntityIndex(node) {
+        if (node.propertyNames?.length) {
+            const entity = node.parentNode;
+            node.propertyNames.forEach((propertyName) => {
+                const prop = findPropertyByName(entity, propertyName);
+                if (!prop) {
+                    const scope = node?.constructor?.nodeTitle;
+                    error(node, `${scope}：索引${node.name}找不到 实体上的 ${propertyName}属性。`);
+                    return errorType;
+                }
+            });
+        }
+    }
     /**
      * 检查 枚举
      * @param node
      */
     function* checkEnum(node) {
+        if (!node.valueType) {
+            error(node, `枚举 ${node.name} 缺少值类型定义`);
+        }
         if (node.enumItems?.length) {
             yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.enumItems, function* (node) {
                 yield* checkNode(node);
@@ -1809,6 +1976,15 @@ function createErrorDiagnoser(context) {
                 yield* checkNode(node);
             });
         }
+        if (ensureNodeKeyExists(node, 'originLogicName')) {
+            if (nasl_concepts_1.asserts.isApp(node.parentNode)) {
+                const originLogicName = node.originLogicName;
+                const ref = app.logics.find((item) => item.name === originLogicName);
+                if (!ref) {
+                    error(node, `接口 ${node.title || node.name} 引用了不存在的逻辑 ${originLogicName}`);
+                }
+            }
+        }
         yield* checkNode(node.validation);
         yield* checkTimeout(node);
         env.exitScope();
@@ -2075,57 +2251,84 @@ function createErrorDiagnoser(context) {
         }
         const shouldProvideCurrentCtx = !!(node.slotScope);
         let scopeEntered = false;
+        const isListComponents = node.tag === 'el-list-components';
+        const formModeAttr = isListComponents ? node.bindAttrs?.find(attr => attr.name === 'formMode') : undefined;
+        const formModeEnabled = isFormModeEnabled(formModeAttr);
+        let currentSlotVarName;
         if (shouldProvideCurrentCtx) {
             const name = curVarCounter > 0 ? node.slotScope + curVarCounter : node.slotScope;
+            currentSlotVarName = name;
             const variable = new nasl_concepts_1.Variable({ name });
             curVarCounter++;
             // @ts-expect-error ViewElement 引入的 current 目前没有加入 refMgr，VE 也没当做 ScopeNode
             env.enterScope(node, [variable]);
             scopeEntered = true;
         }
-        if (node.bindAttrs?.length) {
-            yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.bindAttrs, function* (node) {
-                yield* checkNode(node);
-            });
-        }
-        if (node.bindDirectives?.length) {
-            yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.bindDirectives, function* (node) {
-                yield* checkNode(node);
-            });
-        }
-        if (node.bindStyles?.length) {
-            yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.bindStyles, function* (node) {
-                yield* checkNode(node);
-            });
-        }
-        if (node.bindEvents?.length) {
-            yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.bindEvents, function* (node) {
-                yield* checkNode(node);
-            });
-        }
-        if (node.children?.length) {
-            yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.children, function* (node) {
-                yield* checkNode(node);
-            });
-        }
-        // 已知：选择器会漏报，因为 children 里是两个空 template。暂时先这样吧。
-        let dsFilled = true;
-        let errNode = node;
-        const ds = node.bindAttrs.find(nd => nd.name === 'dataSource');
-        if (ds) {
-            if (ds.type === 'dynamic' && !ds.expression) {
-                dsFilled = false;
-                errNode = ds;
+        let listCtxPushed = false;
+        try {
+            if (currentSlotVarName && listComponentStack.length) {
+                const top = listComponentStack[listComponentStack.length - 1];
+                if (!top.slotVarName && isDescendantOf(node, top.node)) {
+                    top.slotVarName = currentSlotVarName;
+                }
+            }
+            if (isListComponents && !formModeEnabled) {
+                listComponentStack.push({
+                    node,
+                    slotVarName: currentSlotVarName,
+                    formModeEnabled,
+                });
+                listCtxPushed = true;
+            }
+            if (node.bindAttrs?.length) {
+                yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.bindAttrs, function* (node) {
+                    yield* checkNode(node);
+                });
+            }
+            if (node.bindDirectives?.length) {
+                yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.bindDirectives, function* (node) {
+                    yield* checkNode(node);
+                });
+            }
+            if (node.bindStyles?.length) {
+                yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.bindStyles, function* (node) {
+                    yield* checkNode(node);
+                });
+            }
+            if (node.bindEvents?.length) {
+                yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.bindEvents, function* (node) {
+                    yield* checkNode(node);
+                });
+            }
+            if (node.children?.length) {
+                yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.children, function* (node) {
+                    yield* checkNode(node);
+                });
+            }
+            // 已知：选择器会漏报，因为 children 里是两个空 template。暂时先这样吧。
+            let dsFilled = true;
+            let errNode = node;
+            const ds = node.bindAttrs.find(nd => nd.name === 'dataSource');
+            if (ds) {
+                if (ds.type === 'dynamic' && !ds.expression) {
+                    dsFilled = false;
+                    errNode = ds;
+                }
+            }
+            const hasSubComponents = node.children.filter(c => c.tag !== 'template').length > 0 ||
+                node.children.filter(c => c.tag === 'template').some(cc => cc.children.length > 0);
+            if (!dsFilled && !hasSubComponents) {
+                error(errNode, '数据源不能为空');
             }
         }
-        const hasSubComponents = node.children.filter(c => c.tag !== 'template').length > 0 ||
-            node.children.filter(c => c.tag === 'template').some(cc => cc.children.length > 0);
-        if (!dsFilled && !hasSubComponents) {
-            error(errNode, '数据源不能为空');
-        }
-        if (scopeEntered) {
-            env.exitScope();
-            curVarCounter--;
+        finally {
+            if (listCtxPushed) {
+                listComponentStack.pop();
+            }
+            if (scopeEntered) {
+                env.exitScope();
+                curVarCounter--;
+            }
         }
     }
     /**
@@ -2172,6 +2375,9 @@ function createErrorDiagnoser(context) {
                 error(bindExpression, '页面组件属性表达式：该表达式不支持获取组件输入内容，请改为可赋值的变量或属性。');
             }
         }
+        if (node.model || node.sync) {
+            reportCurrentItemModification(node.expression, node);
+        }
         // 检查组件数据源依赖监听变量重复
         if (node?.name === 'dataSourceWatch' && nasl_concepts_1.asserts.isNewList(node?.expression)) {
             const items = node?.expression?.items || [];
@@ -2233,8 +2439,10 @@ function createErrorDiagnoser(context) {
             ...(node.fromLogics || []),
             ...(node.roles || []),
         ].length) {
+            const processElementV2 = node.getAncestor('ProcessElementV2');
+            const title = processElementV2 && processElementV2.type === 'CallSubProcess' ? '子流程发起人' : '任务完成人';
             // 任务完成人为空会有一个提示信息
-            error(node, '任务完成人为空');
+            error(node, `${title}为空`);
         }
     }
     /**
@@ -2396,6 +2604,148 @@ function createErrorDiagnoser(context) {
         }
         env.exitScope();
     }
+    /**
+     * 检测所有流程的循环引用（在 App 级别）
+     * 使用 DFS 算法检测 ProcessV2 之间的循环引用关系
+     * 因为流程的变更会影响兄弟级别的流程，所以需要在 App 级别进行检测
+     */
+    function checkAllProcessCircularReferences(appNode) {
+        if (!appNode?.processV2s || appNode.processV2s.length === 0) {
+            return;
+        }
+        const visiting = new Set();
+        const processMap = new Map();
+        const depthReported = new Set();
+        // 构建流程映射表
+        for (const p of appNode.processV2s) {
+            if (p.uniqueKey) {
+                processMap.set(p.uniqueKey, p);
+            }
+        }
+        // 查找 CallSubProcess 元素
+        const findCallSubProcessElement = (fromKey, toKey) => {
+            const fromProcess = processMap.get(fromKey);
+            if (!fromProcess)
+                return undefined;
+            for (const procDef of fromProcess.processDefinitions || []) {
+                for (const ele of procDef.elements || []) {
+                    if (ele.type === 'CallSubProcess' && ele.subProcessKey === toKey) {
+                        return ele;
+                    }
+                }
+            }
+            return undefined;
+        };
+        // 将路径转换为流程名称字符串
+        const pathToNames = (path) => {
+            return path.map(key => processMap.get(key)?.name || key).join(' -> ');
+        };
+        // 记录循环并返回完整路径
+        const recordCycle = (path, currentKey, cycles) => {
+            const fullPath = [...path, currentKey];
+            const cycleStart = path.indexOf(currentKey);
+            if (cycleStart >= 0) {
+                cycles.push(fullPath.slice(cycleStart));
+            }
+            return fullPath;
+        };
+        // DFS 遍历检测循环和深度
+        function dfs(currentProcessKey, path, cycles) {
+            const fullPath = [...path, currentProcessKey];
+            // 检测循环：当前节点已在访问路径中
+            if (visiting.has(currentProcessKey)) {
+                return { path: recordCycle(path, currentProcessKey, cycles) };
+            }
+            visiting.add(currentProcessKey);
+            const currentProcess = processMap.get(currentProcessKey);
+            let maxPath = fullPath; // 记录最长路径
+            if (currentProcess) {
+                for (const procDef of currentProcess.processDefinitions || []) {
+                    for (const element of procDef.elements || []) {
+                        if (element.type === 'CallSubProcess' && element.subProcessKey) {
+                            const subProcessKey = element.subProcessKey;
+                            // 检测循环：子流程已在访问路径中
+                            if (visiting.has(subProcessKey)) {
+                                const cycleStart = fullPath.indexOf(subProcessKey);
+                                if (cycleStart >= 0) {
+                                    cycles.push(fullPath.slice(cycleStart).concat(subProcessKey));
+                                }
+                                visiting.delete(currentProcessKey);
+                                // 发现循环，立即返回
+                                return { path: [...fullPath, subProcessKey] };
+                            }
+                            // 递归检查子流程
+                            const result = dfs(subProcessKey, fullPath, cycles);
+                            if (result) {
+                                // 如果发现循环，立即返回
+                                if (cycles.length > 0) {
+                                    visiting.delete(currentProcessKey);
+                                    return result;
+                                }
+                                // 否则记录最长路径，继续检查其他子流程
+                                if (result.path.length > maxPath.length) {
+                                    maxPath = result.path;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            visiting.delete(currentProcessKey);
+            return { path: maxPath };
+        }
+        // 报告循环引用错误
+        const reportCycleError = (process, path) => {
+            const nextKey = path[1];
+            if (!nextKey)
+                return;
+            const callSubProcess = findCallSubProcessElement(process.uniqueKey, nextKey);
+            if (callSubProcess) {
+                error(callSubProcess, `流程存在循环引用: ${pathToNames(path)}`, {
+                    fileNode: process,
+                });
+            }
+        };
+        // 报告深度超限错误
+        const reportDepthError = (path) => {
+            const MIN_LEN = 4;
+            for (let i = 0; i <= path.length - MIN_LEN; i++) {
+                const subChain = path.slice(i);
+                if (subChain.length < MIN_LEN)
+                    break;
+                const reportKey = subChain.join('>');
+                if (depthReported.has(reportKey))
+                    continue;
+                depthReported.add(reportKey);
+                const topFrom = subChain[0];
+                const topTo = subChain[1];
+                const topElement = findCallSubProcessElement(topFrom, topTo);
+                const topProcess = processMap.get(topFrom);
+                if (topElement && topProcess) {
+                    error(topElement, `流程引用层级不可超过3层，当前为: ${pathToNames(subChain)}`, {
+                        fileNode: topProcess,
+                    });
+                }
+            }
+        };
+        // 对每个流程独立检测
+        for (const process of appNode.processV2s) {
+            if (!process.uniqueKey)
+                continue;
+            visiting.clear();
+            depthReported.clear();
+            const cycles = [];
+            const result = dfs(process.uniqueKey, [], cycles);
+            if (cycles.length > 0 && result) {
+                // 有循环：使用完整路径报错
+                reportCycleError(process, result.path);
+            }
+            else if (result && result.path.length > 3) {
+                // 无循环但深度超限：报告所有超长链路
+                reportDepthError(result.path);
+            }
+        }
+    }
     /**
      * 检查 绑定实体或数据结构
      * @param node
@@ -2486,6 +2836,29 @@ function createErrorDiagnoser(context) {
         else if (!service_1.ProcessesV2.isFromStartNode(node)) {
             error(node, '节点未关联到流程图');
         }
+        // 子流程
+        if (node.type === 'CallSubProcess') {
+            // 数据映射规则子逻辑
+            if (node.dataMappingRule) {
+                if (node.dataMappingRule.mainToSub) {
+                    yield* checkNode(node.dataMappingRule.mainToSub);
+                }
+                if (node.dataMappingRule.subToMain) {
+                    yield* checkNode(node.dataMappingRule.subToMain);
+                }
+            }
+            if (!node.subProcessKey) {
+                error(node, '关联子流程为空');
+            }
+            else {
+                // 检查引用的子流程是否存在（类似调用逻辑的检查）
+                // subProcessKey 就是 ProcessV2 的 uniqueKey，直接作为 qName 使用
+                const subProcessDef = env.refMgr.gQNameDefs.get(node.subProcessKey);
+                if (!subProcessDef || subProcessDef.concept !== 'ProcessV2') {
+                    error(node, `找不到子流程 ${node.subProcessKey}`);
+                }
+            }
+        }
         env.exitScope();
     }
     /**
@@ -3470,11 +3843,23 @@ function createErrorDiagnoser(context) {
                 }
                 else {
                     const { name } = node;
+                    // 检查是否在 NewComposite 的 properties（左边）中
+                    // 如果在 properties 中，可以跳过未定义检查（因为 properties 是属性名，不是变量）
+                    // 但如果是在 rights（右边）中，即使有类型也应该检查变量是否定义
+                    const newComposite = node.getAncestor('NewComposite');
+                    if (newComposite) {
+                        const { properties = [] } = newComposite;
+                        // 只对 properties 中的 node 允许跳过未定义检查
+                        // 无论是否有类型都应该返回，因为 properties 是属性名，不是变量，不应该报"未定义"错误
+                        if (properties.some((item) => item === node)) {
+                            const type = env.getType(node);
+                            return type || errorType;
+                        }
+                    }
                     if (
                     // name 是 A.B.C
                     name?.split('.')?.length > 1
-                        || node.getAncestor('CallQueryComponent')
-                        || node.getAncestor('NewComposite')) {
+                        || node.getAncestor('CallQueryComponent')) {
                         const type = env.getType(node);
                         if (type) {
                             return type;
@@ -3627,15 +4012,6 @@ function createErrorDiagnoser(context) {
             }
         }
         const ty = env.getType(node);
-        function isConcreteTy(ty) {
-            if (ty.typeKind === 'generic') {
-                return !!ty.typeArguments?.every(x => isConcreteTy(x));
-            }
-            else if (ty.typeKind === 'primitive') {
-                return ty !== type_manager_1.naslAnyTy;
-            }
-            return true;
-        }
         if (!ty || !isConcreteTy(ty)) {
             const p = node.parentNode;
             if (p && p.name === 'dataSourceWatch' && (0, asserts_1.isBindAttribute)(p)) {
@@ -3677,7 +4053,13 @@ function createErrorDiagnoser(context) {
                 });
             }
         }
-        return env.getType(node);
+        const type = env.getType(node);
+        if (!node.keys?.length && !node.values?.length) {
+            if (!type || !isConcreteTy(type)) {
+                error(node, `NewMap 无法推导类型，请添加元素`);
+            }
+        }
+        return type;
     }
     /**
      * 检查 实体/（匿名）数据结构构造器
@@ -3685,6 +4067,7 @@ function createErrorDiagnoser(context) {
      */
     function* checkNewComposite(node) {
         yield* semantic_rules_1.ExtraSemanticRules.rejectFileTypes(node, env, error);
+        ensureNodeKeyExists(node, 'typeAnnotation');
         const type = env.getType(node);
         if (node.properties?.length) {
             yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.properties, function* (property, index) {
@@ -3781,20 +4164,46 @@ function createErrorDiagnoser(context) {
      * @param leftType 左侧类型
      * @param rightType 右侧类型
      * @param context 上下文信息，用于生成错误消息
+     * @param allowImplicitConversion 是否允许隐式类型转换（仅对直接的基础类型赋值允许，复杂类型内部不允许）
      * @returns 所有类型不兼容的错误信息数组
      */
-    function checkAssignmentTypeIncompatibility(leftType, rightType, context = {}) {
+    function checkAssignmentTypeIncompatibility(leftType, rightType, context = {}, allowImplicitConversion = true) {
         if (!leftType || !rightType)
             return [];
         const errors = [];
-        // 1. 检查普通类型：Decimal/Long vs Union<Decimal, Long>
-        const isLeftDecimalOrLong = (leftType.typeKind === 'primitive' && leftType.typeName === 'Decimal') ||
-            (leftType.typeKind === 'primitive' && leftType.typeName === 'Long');
-        if (isLeftDecimalOrLong && (0, type_predicate_1.isDecimalUnionLongTy)(rightType)) {
-            const prefix = context.prefix || '赋值';
-            const fieldInfo = context.fieldName ? `字段 ${context.fieldName} ` : '';
-            errors.push(`${prefix}：${fieldInfo}类型不匹配，不能将 ${(0, type_manager_1.showUserLevelType)(rightType)} 赋值给 ${(0, type_manager_1.showUserLevelType)(leftType)} 类型。`);
-            return errors; // 找到基本类型错误后直接返回，不再检查嵌套
+        // 先检查 Decimal/Long vs Union<Decimal, Long> 的情况（需要先于其他检查）
+        // 这种情况应该报错，即使允许隐式转换
+        if (allowImplicitConversion) {
+            const isLeftPrimitive = leftType.typeKind === 'primitive';
+            const isLeftDecimalOrLong = isLeftPrimitive && (leftType.typeName === 'Decimal' || leftType.typeName === 'Long');
+            if (isLeftDecimalOrLong && (0, type_predicate_1.isDecimalUnionLongTy)(rightType)) {
+                const prefix = context.prefix || '赋值';
+                const fieldInfo = context.fieldName ? `字段 ${context.fieldName} ` : '';
+                errors.push(`${prefix}：${fieldInfo}类型不匹配，不能将 ${(0, type_manager_1.showUserLevelType)(rightType)} 赋值给 ${(0, type_manager_1.showUserLevelType)(leftType)} 类型。`);
+                return errors; // 找到基本类型错误后直接返回，不再检查嵌套
+            }
+        }
+        // 检查基础类型是否严格相等（不允许隐式转换）
+        const isLeftPrimitive = leftType.typeKind === 'primitive';
+        const isRightPrimitive = rightType.typeKind === 'primitive';
+        if (isLeftPrimitive && isRightPrimitive) {
+            // 如果不允许隐式转换，则要求类型完全相等
+            if (!allowImplicitConversion) {
+                if (leftType.typeName !== rightType.typeName || leftType.typeNamespace !== rightType.typeNamespace) {
+                    const prefix = context.prefix || '赋值';
+                    const fieldInfo = context.fieldName ? `字段 ${context.fieldName} ` : '';
+                    errors.push(`${prefix}：${fieldInfo}类型不匹配，不能将 ${(0, type_manager_1.showUserLevelType)(rightType)} 赋值给 ${(0, type_manager_1.showUserLevelType)(leftType)} 类型。`);
+                    return errors;
+                }
+                // 类型完全相等，没有错误，继续检查其他情况
+            }
+            else {
+                // 允许隐式转换的情况下，检查是否通过 isSubTy 检查（允许隐式转换）
+                if ((0, type_predicate_1.isSubTy)(env, rightType, leftType)) {
+                    // 类型兼容（允许隐式转换），没有错误，继续检查其他情况
+                }
+                // 如果 isSubTy 返回 false，继续检查其他不兼容的情况
+            }
         }
         // 2. 检查 List 类型（包括嵌套）：List<T> vs List<Union<...>>
         if (leftType.typeKind === 'generic' &&
@@ -3803,8 +4212,9 @@ function createErrorDiagnoser(context) {
             rightType.typeName === 'List' &&
             leftType.typeArguments?.[0] &&
             rightType.typeArguments?.[0]) {
-            // 递归检查 List 的元素类型
-            return checkAssignmentTypeIncompatibility(leftType.typeArguments[0], rightType.typeArguments[0], { ...context, prefix: context.prefix || '赋值' });
+            // 递归检查 List 的元素类型，嵌套类型内部不允许隐式转换
+            return checkAssignmentTypeIncompatibility(leftType.typeArguments[0], rightType.typeArguments[0], { ...context, prefix: context.prefix || '赋值' }, false // 嵌套类型内部不允许隐式转换
+            );
         }
         // 3. 检查 Map 类型（包括嵌套）：Map<K, V> vs Map<K, Union<...>>
         if (leftType.typeKind === 'generic' &&
@@ -3813,11 +4223,13 @@ function createErrorDiagnoser(context) {
             rightType.typeName === 'Map' &&
             leftType.typeArguments?.length === 2 &&
             rightType.typeArguments?.length === 2) {
-            // 递归检查 Map 的值类型（第二个类型参数）
-            const valueTypeErrors = checkAssignmentTypeIncompatibility(leftType.typeArguments[1], rightType.typeArguments[1], { ...context, prefix: context.prefix || '赋值' });
+            // 递归检查 Map 的值类型（第二个类型参数），嵌套类型内部不允许隐式转换
+            const valueTypeErrors = checkAssignmentTypeIncompatibility(leftType.typeArguments[1], rightType.typeArguments[1], { ...context, prefix: context.prefix || '赋值' }, false // 嵌套类型内部不允许隐式转换
+            );
             errors.push(...valueTypeErrors);
-            // 也检查键类型（第一个类型参数）
-            const keyTypeErrors = checkAssignmentTypeIncompatibility(leftType.typeArguments[0], rightType.typeArguments[0], { ...context, prefix: context.prefix || '赋值' });
+            // 也检查键类型（第一个类型参数），嵌套类型内部不允许隐式转换
+            const keyTypeErrors = checkAssignmentTypeIncompatibility(leftType.typeArguments[0], rightType.typeArguments[0], { ...context, prefix: context.prefix || '赋值' }, false // 嵌套类型内部不允许隐式转换
+            );
             errors.push(...keyTypeErrors);
             return errors;
         }
@@ -3828,7 +4240,9 @@ function createErrorDiagnoser(context) {
             for (const leftProp of leftProps) {
                 const rightProp = rightProps.find(p => p.name === leftProp.name);
                 if (rightProp && leftProp.typeAnnotation && rightProp.typeAnnotation) {
-                    const fieldErrors = checkAssignmentTypeIncompatibility(leftProp.typeAnnotation, rightProp.typeAnnotation, { prefix: context.prefix || '赋值', fieldName: leftProp.name });
+                    // 匿名结构体的字段类型检查不允许隐式转换
+                    const fieldErrors = checkAssignmentTypeIncompatibility(leftProp.typeAnnotation, rightProp.typeAnnotation, { prefix: context.prefix || '赋值', fieldName: leftProp.name }, false // 复杂类型内部不允许隐式转换
+                    );
                     errors.push(...fieldErrors); // 收集所有字段的错误，不提前返回
                 }
             }
@@ -3854,6 +4268,9 @@ function createErrorDiagnoser(context) {
         errorMessages.forEach(errorMessage => {
             error(node, errorMessage);
         });
+        if (nasl_concepts_1.asserts.isMemberExpression(node.left)) {
+            reportCurrentItemModification(node.left, node);
+        }
     }
     /**
      * 检查 批量赋值语句
@@ -3962,6 +4379,34 @@ function createErrorDiagnoser(context) {
             severity: Severity.WARN,
         });
     }
+    /**
+     * 检查数据查询是否在有效的上下文中使用
+     * 数据查询不能直接放在语句中，只能作为表达式使用
+     */
+    function* checkQueryContextValidity(node) {
+        const parent = node.parentNode;
+        const parentConcept = parent.concept;
+        // 允许的父节点类型直接返回
+        const invalidParentConcepts = ['Logic', 'IfStatement', 'ForEachStatement', 'SwitchCase', 'MatchCase', 'WhileStatement'];
+        if (!invalidParentConcepts.includes(parentConcept)) {
+            return;
+        }
+        // MatchCase 在表达式场景下是例外：Match 表达式中的 MatchCase 允许数据查询
+        if (parentConcept === 'MatchCase') {
+            const matchNode = parent.parentNode;
+            if (matchNode?.concept === 'Match' && matchNode.isExpression) {
+                return;
+            }
+        }
+        // 获取当前节点在父节点中的属性名
+        const parentKey = node.parentKey;
+        // 只在 parentKey 为 body、consequent、alternate 时才报错
+        const errorParentKeys = ['body', 'consequent', 'alternate'];
+        if (!errorParentKeys.includes(parentKey)) {
+            return;
+        }
+        error(node, '数据查询不能直接放在语句中，只能作为表达式使用。');
+    }
     /**
      * 检查 数据查询
      * @param node
@@ -3973,6 +4418,8 @@ function createErrorDiagnoser(context) {
         else {
             error(node, '预期 1 个参数，但传入了 0 个。');
         }
+        // 检查数据查询的使用上下文
+        yield* checkQueryContextValidity(node);
         // where 子句
         yield* checkNode(node.where);
         // wherePlayground
@@ -4044,7 +4491,13 @@ function createErrorDiagnoser(context) {
             return;
         }
         const { entityAsName } = node;
-        const entityNamespace = node.entityNamespace ?? node.getAncestor('CallQueryComponent')?.from?.entityNamespace;
+        const callQueryComponent = node.getAncestor('CallQueryComponent');
+        if (!callQueryComponent.inFromJoinPart(entityAsName)) {
+            // 实体不存在from中
+            error(node, '数据查询：所查询的实体不存在数据源中。');
+            return;
+        }
+        const entityNamespace = node.entityNamespace ?? callQueryComponent?.from?.entityNamespace;
         const entityQName = `${entityNamespace}.${entityAsName}`;
         const ref = referenceManager.gQNameDefs.get(entityQName);
         if (!ref) {
@@ -4226,6 +4679,9 @@ function createErrorDiagnoser(context) {
             if (isCandidate) {
                 yield* rejectNullLiteral(node.argument);
             }
+            if (node.operator === 'isNull' && node.getAncestor('CallQueryComponent') && !nasl_concepts_1.asserts.isQueryFieldExpression(node.argument)) {
+                error(node, '数据查询：数据查询中的 isNull 只面向实体属性使用。针对变量和表达式为空值的情况，已自动进行剪枝处理，请移除条件中的 isNull 即可。');
+            }
             yield* checkNode(node.argument);
         }
         return env.getType(node);
@@ -4248,6 +4704,26 @@ function createErrorDiagnoser(context) {
         if (typeAnnotation?.typeKind === 'generic') {
             yield* checkGenericTypeHasExpectedTyArgs(typeAnnotation);
         }
+        // 在特定流程逻辑中，data 形参必须传入且内部 new 对象的 data 字段需要显式初始化且不可为 null
+        if (node.keyword === 'data' && node.getAncestor('CallLogic')?.isSpecificProcessLogic && ensureNodeKeyExists(node, 'expression')) {
+            if (nasl_concepts_1.asserts.isNewComposite(node.expression)) {
+                const dataIndex = (node.expression.properties || [])?.findIndex((propery) => {
+                    return nasl_concepts_1.asserts.isIdentifier(propery) && propery.name === 'data';
+                });
+                if (dataIndex === -1) {
+                    error(node, 'data未初始化！');
+                }
+                else {
+                    const rightSelectMember = (0, nasl_concepts_1.getRightFromNewCompositeByLeftIndex)({
+                        newComposite: node.expression,
+                        propertyIndex: dataIndex,
+                    });
+                    if (nasl_concepts_1.asserts.isNullLiteral(rightSelectMember?.expression)) {
+                        error(rightSelectMember?.expression, 'data不能为null');
+                    }
+                }
+            }
+        }
         return typeAnnotation;
     }
     /**
@@ -4410,6 +4886,9 @@ function createErrorDiagnoser(context) {
      * @param node
      */
     function* rejectNullLiteral(node) {
+        if (!node) {
+            return; // 如果 node 为 null 或 undefined，直接返回
+        }
         if (node.concept === 'NullLiteral') {
             error(node, `此处不允许使用 null`);
         }
@@ -4466,6 +4945,8 @@ function createErrorDiagnoser(context) {
                     return yield* checkEntity(node);
                 case 'EntityProperty':
                     return yield* checkEntityProperty(node);
+                case 'EntityIndex':
+                    return yield* checkEntityIndex(node);
                 case 'Enum':
                     return yield* checkEnum(node);
                 case 'EnumItem':
@@ -4806,29 +5287,59 @@ function createErrorDiagnoser(context) {
      * 用于增量更新时，当子节点变更需要重新验证祖先节点的场景
      * @param ancestorNode 需要重新验证的祖先节点
      * @param validationFn 验证函数
-     * @param errorFilter 错误过滤函数（可选），用于保留特定的错误
+     * @param errorFilter 错误过滤函数（可选），用于保留特定的错误（返回 true 表示保留）
+     * @param siblingNodeTypes 需要过滤错误的兄弟节点类型（可选）
+     * @param getSiblingNodes 获取兄弟节点的函数（可选），用于从祖先节点中获取需要过滤错误的兄弟节点
      * @returns 新的诊断信息 Map，如果没有则返回 null
      */
-    function revalidateAncestorNode(ancestorNode, validationFn, errorFilter) {
-        // 保存并过滤相关的错误诊断
-        const errs = getError(ancestorNode) || [];
-        const filteredErrs = errorFilter
-            ? errs.filter(errorFilter)
-            : [];
-        // 清除祖先节点的诊断信息
-        clearDiagnostics(ancestorNode);
-        // 恢复过滤后的错误诊断
-        if (filteredErrs.length > 0) {
-            filteredErrs.forEach((err) => {
-                const { message, severity, ...context } = err;
-                if (message) {
-                    error(ancestorNode, message, {
-                        severity: severity,
-                        ...context,
+    function revalidateAncestorNode(ancestorNode, validationFn, errorFilter, siblingNodeTypes, getSiblingNodes) {
+        // 收集所有需要处理的文件节点（祖先节点 + 兄弟节点）
+        const fileNodesToProcess = [ancestorNode];
+        // 获取需要过滤错误的兄弟节点（通过配置的 getSiblingNodes 函数）
+        if (errorFilter && getSiblingNodes) {
+            const siblings = getSiblingNodes(ancestorNode);
+            if (siblingNodeTypes && siblingNodeTypes.length > 0) {
+                fileNodesToProcess.push(...siblings.filter(s => siblingNodeTypes.includes(s.concept)));
+            }
+            else {
+                fileNodesToProcess.push(...siblings);
+            }
+        }
+        // 收集所有文件节点需要保留的错误
+        const errorsToRestore = [];
+        for (const fileNode of fileNodesToProcess) {
+            const diagnostics = getDiagnostics(fileNode);
+            if (diagnostics) {
+                diagnostics.forEach((errs, node) => {
+                    // 如果有 errorFilter，只保留满足条件的错误；否则保留所有错误
+                    const filtered = errorFilter ? errs.filter(errorFilter) : errs;
+                    filtered.forEach(err => {
+                        errorsToRestore.push({ fileNode, node, err });
                     });
-                }
-            });
+                });
+            }
+        }
+        // 清除所有文件节点的诊断信息
+        for (const fileNode of fileNodesToProcess) {
+            clearDiagnostics(fileNode);
+            let diagnostics = diagnosticMap.get(fileNode);
+            if (!diagnostics && fileNode) {
+                diagnostics = new Map();
+                diagnosticMap.set(fileNode, diagnostics);
+            }
+            diagnostics.set(fileNode, []);
         }
+        // 恢复所有需要保留的错误
+        errorsToRestore.forEach(({ fileNode, node, err }) => {
+            const { message, severity, ...context } = err;
+            if (message) {
+                error(node, message, {
+                    severity: severity,
+                    fileNode,
+                    ...context,
+                });
+            }
+        });
         // 设置文件节点上下文并执行验证
         const cleanup = handleFileNode(ancestorNode);
         try {
@@ -4837,8 +5348,17 @@ function createErrorDiagnoser(context) {
         finally {
             cleanup?.();
         }
-        // 返回新的诊断信息
-        return getDiagnostics(ancestorNode) || null;
+        // 收集并返回所有文件节点的诊断信息
+        const allDiagnostics = new Map();
+        for (const fileNode of fileNodesToProcess) {
+            const diagnostics = getDiagnostics(fileNode);
+            if (diagnostics) {
+                diagnostics.forEach((errs, node) => {
+                    allDiagnostics.set(node, errs);
+                });
+            }
+        }
+        return allDiagnostics.size > 0 ? allDiagnostics : null;
     }
     return {
         setMetadataTypeEnable,
@@ -4848,6 +5368,7 @@ function createErrorDiagnoser(context) {
         clearDiagnostics,
         getDiagnostics,
         getAllDiagnostics,
+        checkAllProcessCircularReferences,
         getDebugDiagnostics,
         error,
         checkViewIndexPageSetting,