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

package/out/checker.js

@@ -10,10 +10,13 @@ const sem_diag_1 = require("./typer/sem-diag");
 const type_predicate_1 = require("./typer/type-predicate");
 const type_manager_1 = require("./typer/type-manager");
 const service_2 = require("@lcap/nasl-concepts/service");
-const asserts_1 = require("@lcap/nasl-concepts/asserts");
 const lodash_1 = require("lodash");
+const asserts_1 = require("@lcap/nasl-concepts/asserts");
 const helper_1 = require("./typer/helper");
 const semantic_rules_1 = require("./semantic-rules");
+const view_element_field_attrs_1 = require("@lcap/nasl-concepts/view-element-field-attrs");
+const regeExp = new nasl_utils_1.ExpressionLexer();
+regeExp.profile = nasl_utils_1.profiles.js;
 var Severity;
 (function (Severity) {
     Severity["WARN"] = "warning";
@@ -71,6 +74,7 @@ function getExpressionNodeName(concept) {
         CallMicroserviceInterface: '微服务接口',
         CallGatewayInterface: '网关接口',
         CallEvent: '事件',
+        Destination: '页面',
     };
     return expressionNodeName[concept];
 }
@@ -238,6 +242,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
@@ -246,6 +256,8 @@ function createErrorDiagnoser(context) {
     let app = context.app;
     let env = context.env;
     let isDebug = context.debug;
+    // 严格模式
+    let isAIStrictMode = context.isAIStrictMode;
     // 引用管理器
     let referenceManager = env.refMgr;
     // 检查共享数据是否有更新
@@ -258,8 +270,11 @@ function createErrorDiagnoser(context) {
     let inModule = false;
     let inPlayground = 0;
     let inAuthLogic = false;
+    let inFrontendType = false;
+    let currentFrontendKind = '';
     let dbType = '';
     let curVarCounter = 0;
+    const listComponentStack = [];
     const nodeNameCache = new Map();
     const nodeNameGetterMap = {
         View: 'getViewExistingNames',
@@ -304,6 +319,16 @@ function createErrorDiagnoser(context) {
             diagnosticMap.set(curFileNode, diagnostics);
         }
         if (diagnostics) {
+            const parentKey = node?.parentKey;
+            const parentConcept = node.parentNode?.concept;
+            if (message.startsWith('类型不匹配：') &&
+                ((parentKey === 'test' && parentConcept === 'IfStatement') || (parentKey === 'condition' && parentConcept === 'IfExpression'))) {
+                const map = {
+                    'IfExpression': 'If表达式',
+                    'IfStatement': 'If语句',
+                };
+                message = `${map[parentConcept]}条件槽位${message}`;
+            }
             const diagnostic = {
                 message,
                 severity: inPlayground > 0 ? Severity.WARN : (severity ?? Severity.ERROR),
@@ -321,7 +346,30 @@ function createErrorDiagnoser(context) {
             }
             const finalNode = memberExpression ?? node;
             (0, helper_1.createOnPush)(diagnostics, finalNode, diagnostic);
-            finalNode.tsErrorDetail = diagnostic;
+            const aggregationFields = {
+                assignmentLine: 'assignmentLines',
+            };
+            const nodeDiagnostics = diagnostics.get(finalNode);
+            if (nodeDiagnostics && nodeDiagnostics.length > 0) {
+                // 构建最终的 tsErrorDetail，合并所有上下文信息
+                const aggregatedContext = {};
+                // 对每个需要聚合的字段进行收集
+                for (const [singleField, arrayField] of Object.entries(aggregationFields)) {
+                    const values = nodeDiagnostics
+                        .map(d => d[singleField])
+                        .filter((val) => val !== undefined);
+                    if (values.length > 0) {
+                        aggregatedContext[arrayField] = values;
+                    }
+                }
+                finalNode.tsErrorDetail = {
+                    ...diagnostic,
+                    ...aggregatedContext,
+                };
+            }
+            else {
+                finalNode.tsErrorDetail = diagnostic;
+            }
         }
         else { }
     }
@@ -343,7 +391,7 @@ function createErrorDiagnoser(context) {
      * @returns
      */
     function getError(node) {
-        const curFileNode = getCurFileNode();
+        const curFileNode = getCurFileNode() ?? node;
         const diagnostics = diagnosticMap.get(curFileNode);
         if (diagnostics) {
             return diagnostics.get(node);
@@ -572,6 +620,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);
         }
@@ -623,6 +674,148 @@ 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;
+    }
+    /**
+     * 获取 ViewElement 的数据源类型（T 或 T1）
+     * 参考 util.js 中的 getDataTypeOfViewElement 实现
+     */
+    function getDataSourceTypeAnnotation(viewElement) {
+        // 向上查找定义了数据源类型的祖先组件
+        let currentNode = viewElement;
+        let depth = 0;
+        const maxSearchDepth = 5;
+        while (currentNode?.concept === 'ViewElement' && depth <= maxSearchDepth) {
+            // 使用 __ViewElementTV 获取类型，与 IDE 前端 getDataTypeOfViewElement 保持一致
+            if (currentNode.__TypeAnnotation && currentNode.__ViewElementTV?.length) {
+                // 先查找 T1（动态列），若无再查找 T（普通数据源组件）
+                const t1 = currentNode.__ViewElementTV.find((x) => x.rawName === 'T1');
+                if (t1?.renamed)
+                    return t1.renamed;
+                const t = currentNode.__ViewElementTV.find((x) => x.rawName === 'T');
+                if (t?.renamed)
+                    return t.renamed;
+            }
+            currentNode = currentNode.parentNode;
+            depth++;
+        }
+        return undefined;
+    }
     /**
      * 是否在赋值左侧
      * @param node
@@ -705,7 +898,8 @@ function createErrorDiagnoser(context) {
             if (param?.spread) {
                 continue;
             }
-            if (!isNonRequiredParam(param)) {
+            // 严格模式非必填也需要有Argument占位
+            if (isAIStrictMode || !isNonRequiredParam(param)) {
                 minArgsCount++; // 如果参数有默认值，则跳过
             }
         }
@@ -823,7 +1017,11 @@ function createErrorDiagnoser(context) {
             error(node, `预期 ${paramsLen} 个参数，但传入了 ${argsLen} 个。`);
         }
         else if (argsLen < minArgsCount) {
-            error(node, `预期 ${minArgsCount} 个参数，但传入了 ${argsLen} 个。`);
+            let msg = `传入参数的个数 ${argsLen} 与 ${getExpressionNodeName(node.concept)} 定义的参数个数 ${paramsLen} 不符。`;
+            if (isAIStrictMode) {
+                msg += `可选参数和默认值参数必须用 undefined 占位`;
+            }
+            error(node, msg);
         }
         yield* (0, nasl_utils_1.wrapForEachToGenerator)(args, function* (arg, index) {
             const param = params?.[index];
@@ -1062,6 +1260,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) {
@@ -1098,6 +1298,11 @@ function createErrorDiagnoser(context) {
                 });
             }
         }
+        if (node.interfaces?.length) {
+            yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.interfaces, function* (node) {
+                yield* checkNode(node);
+            });
+        }
         yield* checkNode(node.configuration);
         if (node.type === 'sharedApp') {
             const status = getStatusOfSharedApp(node);
@@ -1111,6 +1316,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;
     }
     /**
@@ -1287,7 +1505,7 @@ function createErrorDiagnoser(context) {
                 yield* checkNode(node);
             });
         }
-        const dataSourceGroup = app.configuration?.getGroup('dataSource');
+        const dataSourceGroup = app.configuration?.getGroup?.('dataSource');
         if (dataSourceGroup) {
             const property = dataSourceGroup.getProperty(node.name);
             if (property.values?.length) {
@@ -1317,6 +1535,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;
@@ -1554,7 +1777,7 @@ function createErrorDiagnoser(context) {
                                 const decimalPlaces = value?.split('.')[1]?.length || 0;
                                 if (decimalPlaces > +scale) {
                                     error(node, `实体字段${node.name}默认值的小数位数不能大于设置的小数位数${scale}，否则将会按照小数位数自动截断`, {
-                                        severity: Severity.WARN,
+                                        severity: isAIStrictMode ? Severity.ERROR : Severity.WARN,
                                     });
                                 }
                             }
@@ -1644,11 +1867,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);
@@ -1784,6 +2027,17 @@ function createErrorDiagnoser(context) {
                 yield* checkNode(node);
             });
         }
+        // 仅对内部接口（app.interfaces，由 Logic 导出）校验 originLogicName；外部接口（interfaceDependencies 等）无此字段
+        const isInternalInterface = nasl_concepts_1.asserts.isApp(node.parentNode);
+        if (isInternalInterface) {
+            if (ensureNodeKeyExists(node, 'originLogicName')) {
+                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();
@@ -1912,9 +2166,39 @@ function createErrorDiagnoser(context) {
             yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.views, function* (node) {
                 yield* checkNode(node);
             });
+            checkViewIndexPageSetting(node);
         }
         env.exitScope();
     }
+    /**
+     * 检查页面的首页/默认跳转页设置
+     * 根据父级类型（Frontend 或 View）自动判断检查场景
+     * @param node 当前页面节点
+     */
+    function checkViewIndexPageSetting(node) {
+        const isNodeFrontend = (0, asserts_1.isFrontend)(node);
+        const children = isNodeFrontend ? node.views : node.children;
+        // 防御性检查：确保 children 存在且是数组
+        if (!children || !Array.isArray(children)) {
+            return;
+        }
+        // 检查默认跳转页数量，只允许有一个默认跳转页
+        const defaultViews = children.filter((view) => view.isIndex);
+        if (defaultViews.length > 1) {
+            // 收集所有默认跳转页的名称
+            const defaultViewNames = defaultViews.map((view) => view.name).join('、');
+            const typeMap = {
+                Frontend: '首页',
+                View: '默认跳转页',
+            };
+            const pageType = typeMap[node.concept] || '默认跳转页';
+            const errorMessage = `页面 ${node.name} 只能有一个 ${pageType}，目前存在 ${defaultViewNames}`;
+            error(node, errorMessage, {
+                fileNode: node,
+                isIndex: true,
+            });
+        }
+    }
     /**
      * 检查 页面
      * @param node
@@ -1962,6 +2246,7 @@ function createErrorDiagnoser(context) {
             yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.children, function* (node) {
                 yield* checkNode(node);
             });
+            checkViewIndexPageSetting(node);
         }
         env.exitScope();
     }
@@ -2019,57 +2304,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--;
+            }
         }
     }
     /**
@@ -2090,6 +2402,31 @@ function createErrorDiagnoser(context) {
         }
         yield* checkPlayground(node.playground);
         yield* checkBindExpressions(node);
+        // 检查数据源上的字段属性是否在类型上存在
+        // 判断条件：
+        // 1. 属性的 setter 是 PropertySelectSetter（从组件定义的 ViewComponentDeclaration 中获取）
+        // 2. 或者属性在 FIELD_ATTRS_BY_COMPONENT 配置中（兼容老版本组件配置）
+        if (node.type === 'string' && typeof node.value === 'string' && node.value) {
+            const viewElement = node.parentNode;
+            if (viewElement?.concept === 'ViewElement') {
+                // 优先检查组件定义中的 PropertySelectSetter
+                const isPropertySelect = env.refMgr.compDefMgr.isPropertySelectSetter(viewElement.tag, node.name);
+                // 同时兼容 FIELD_ATTRS_BY_COMPONENT 配置
+                const needsFieldCheck = isPropertySelect || (0, view_element_field_attrs_1.shouldCheckFieldExists)(viewElement.tag, node.name);
+                if (needsFieldCheck) {
+                    const dataSourceType = getDataSourceTypeAnnotation(viewElement);
+                    if (dataSourceType) {
+                        const { exists, missingField } = checkFieldExistsInType(env, dataSourceType, node.value);
+                        if (!exists && missingField) {
+                            // 优先从组件定义中获取属性标题，兜底使用硬编码配置
+                            const attrTitle = env.refMgr.compDefMgr.getPropTitle(viewElement.tag, node.name)
+                                || (0, view_element_field_attrs_1.getFieldAttrTitle)(node.name);
+                            error(node, `${attrTitle} "${missingField}" 在数据类型上不存在`);
+                        }
+                    }
+                }
+            }
+        }
         // 检查不可复制属性开启双向绑定
         if ((node.model || node.sync) && node.expression) {
             const bindExpression = node.expression;
@@ -2116,6 +2453,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 || [];
@@ -2177,8 +2517,15 @@ function createErrorDiagnoser(context) {
             ...(node.fromLogics || []),
             ...(node.roles || []),
         ].length) {
+            const processElementV2 = node.getAncestor('ProcessElementV2');
+            const title = processElementV2 && processElementV2.type === 'CallSubProcess' ? '子流程发起人' : '任务完成人';
             // 任务完成人为空会有一个提示信息
-            error(node, '任务完成人为空');
+            error(node, `${title}为空`);
+        }
+        if (Array.isArray(node.fromLogics)) {
+            yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.fromLogics, function* (node) {
+                yield* checkNode(node);
+            });
         }
     }
     /**
@@ -2340,6 +2687,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
@@ -2430,6 +2919,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();
     }
     /**
@@ -2588,8 +3100,8 @@ function createErrorDiagnoser(context) {
                         }
                     }
                     if (!isSame) {
-                        const macthed = exportInterface.concept === 'McpInterface';
-                        const key = macthed ? 'exportMcpInterface' : 'exportInterface';
+                        const matched = exportInterface.concept === 'McpInterface';
+                        const key = matched ? 'exportMcpInterface' : 'exportInterface';
                         error(node, `逻辑已变更，请确认请求类型无误后重新导出${'${event}'}`, {
                             severity: Severity.ERROR,
                             events: [
@@ -2849,7 +3361,7 @@ function createErrorDiagnoser(context) {
             return;
         }
         yield* checkVoidCallUsedAsStatement(node);
-        const ref = env.resolveRef(node); // 前端
+        const ref = env.resolveRef(node) ?? env.quickGetLibDef(node, node.calleeName, undefined); // 前端
         // TODO: sql 函数的 namespace 带有数据库名 nasl.sqlFunction.mysql nasl.sqlFunction.oracle ...
         // 暂时不在 gQNameDefs 里，用 isBuiltInCall 简单判断了
         if (!ref && !isBuiltInCall(node)) {
@@ -2941,15 +3453,40 @@ function createErrorDiagnoser(context) {
         }
         return type;
         function checkListSort(nd) {
+            const parTy = env.getType(nd.arguments?.[0]);
+            let paramType = '未知类型';
+            if (parTy?.typeName === 'List') {
+                paramType = (0, type_manager_1.showUserLevelType)(parTy.typeArguments?.[0] || type_manager_1.naslAnyTy);
+            }
+            const expectTy = `{ by: (item: ${paramType}) => 未知类型, asc: 布尔值 }`;
             for (let i = 1; i < nd.arguments.length; i++) {
                 const expr = nd.arguments[i].expression;
                 let resTy;
+                const reportArgError = (targetExpr) => {
+                    const actualTy = targetExpr ? env.getType(targetExpr) || type_manager_1.naslAnyTy : type_manager_1.naslAnyTy;
+                    error(nd.arguments[i], (0, sem_diag_1.mkIncompatibleTyErr)(env, actualTy, expectTy));
+                };
                 if (expr?.concept === 'AnonymousFunction') {
                     resTy = env.getType(expr.body);
+                    if (!nasl_concepts_1.asserts.isNewComposite(expr.body)) {
+                        reportArgError(expr);
+                    }
                 }
                 else if (expr?.concept === 'SubLogic') {
                     resTy = env.getType(expr.returns?.[0]);
                 }
+                else if (expr?.concept === 'Identifier') {
+                    const ty = env.getType(expr);
+                    if ((0, type_predicate_1.isFuncTy)(ty)) {
+                        resTy = ty;
+                    }
+                    else {
+                        reportArgError(expr);
+                    }
+                }
+                else {
+                    reportArgError(expr);
+                }
                 const byTy = resTy?.properties?.find((prop) => prop.name === 'by')?.typeAnnotation;
                 if (byTy?.typeKind === 'union') {
                     // 这里使用 node.arguments[i] 则无红框，猜测是 ListSort 的特殊交互导致的问题
@@ -2985,6 +3522,29 @@ function createErrorDiagnoser(context) {
                 error(node, '下载组件必须为page和size指定入参,且不能重复');
             }
         }
+        const map = {
+            frontend: {
+                scope: '前端',
+                forbiddenScope: '服务端',
+                forbiddenCalleeNamesMap: {
+                    'nasl.auth': ['getCurrentUser', 'generateUserId', 'validatePassword', 'encryptPassword'],
+                },
+            },
+            backend: {
+                scope: '服务端',
+                forbiddenScope: '前端',
+                forbiddenCalleeNamespaces: ['nasl.browser', 'nasl.io'],
+                forbiddenCalleeNamesMap: {
+                    'nasl.auth': ['decryptByAES', 'encryptByAES', 'logout', 'hasAuth'],
+                    'nasl.configuration': ['getCurrentIp', 'getUserLanguage', 'getI18nList', 'setI18nLocale'],
+                },
+            },
+        };
+        const config = inFrontendType ? map.frontend : map.backend;
+        const { scope, forbiddenScope, forbiddenCalleeNamespaces, forbiddenCalleeNamesMap } = config;
+        if (forbiddenCalleeNamespaces?.includes(node.calleeNamespace) || forbiddenCalleeNamesMap?.[node.calleeNamespace]?.includes(node.calleeName)) {
+            error(node, `不能在${scope}作用域下使用${forbiddenScope}系统逻辑`);
+        }
         return env.getType(node);
     }
     /**
@@ -3031,6 +3591,7 @@ function createErrorDiagnoser(context) {
      */
     function* checkIfStatement(node) {
         if (ensureNodeKeyExists(node, 'test')) {
+            yield* rejectNullLiteral(node.test);
             yield* checkNode(node.test);
         }
         // then
@@ -3046,12 +3607,32 @@ function createErrorDiagnoser(context) {
             });
         }
     }
+    /**
+     * 检查 条件表达式
+     * @param node
+     */
+    function* checkIfExpression(node) {
+        if (ensureNodeKeyExists(node, 'condition')) {
+            yield* rejectNullLiteral(node.condition);
+            yield* checkNode(node.condition);
+        }
+        // then
+        if (ensureNodeKeyExists(node, 'consequent')) {
+            yield* checkNode(node.consequent);
+        }
+        // else
+        if (ensureNodeKeyExists(node, 'alternate')) {
+            yield* checkNode(node.alternate);
+        }
+        return env.getType(node);
+    }
     /**
      * 检查 匹配
      * @param node
      */
     function* checkMatch(node) {
         if (ensureNodeKeyExists(node, 'expression')) {
+            yield* rejectNullLiteral(node.expression);
             yield* checkNode(node.expression);
         }
         if (node.cases?.length) {
@@ -3306,6 +3887,7 @@ function createErrorDiagnoser(context) {
     function* checkSwitchCase(node) {
         if (!(0, nasl_concepts_1.isLastNode)(node)) {
             if (ensureNodeKeyExists(node, 'test')) {
+                yield* rejectNullLiteral(node.test);
                 yield* checkNode(node.test);
             }
         }
@@ -3321,12 +3903,18 @@ function createErrorDiagnoser(context) {
      */
     function* checkForEachStatement(node) {
         env.enterScope(node);
+        if (ensureNodeKeyExists(node, 'item')) {
+            yield* checkNode(node.item);
+        }
         if (ensureNodeKeyExists(node, 'each')) {
             yield* checkNode(node.each);
         }
         if (ensureNodeKeyExists(node, 'start')) {
             yield* checkNode(node.start);
         }
+        if (node.end) {
+            yield* checkNode(node.end);
+        }
         if (node.body?.length) {
             yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.body, function* (node) {
                 yield* checkNode(node);
@@ -3350,6 +3938,7 @@ function createErrorDiagnoser(context) {
      */
     function* checkWhileStatement(node) {
         if (ensureNodeKeyExists(node, 'test')) {
+            yield* rejectNullLiteral(node.test);
             yield* checkNode(node.test);
         }
         if (node.body?.length) {
@@ -3379,11 +3968,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;
@@ -3403,6 +4004,36 @@ function createErrorDiagnoser(context) {
                 scopedError(node, `${node.toNaturalTS()} 枚举类不能直接使用，请取它的枚举项`);
                 return errorType;
             }
+            const map = {
+                frontend: {
+                    scope: '前端',
+                    forbiddenScope: '服务端',
+                    prefix: 'app.frontendTypes',
+                    forbiddenPrefix: 'app.backend',
+                },
+                backend: {
+                    scope: '服务端',
+                    forbiddenScope: '前端',
+                    prefix: 'app.backend',
+                    forbiddenPrefix: 'app.frontendTypes',
+                    forbiddenCalleeNamesMap: {
+                        'nasl.auth': ['userInfo']
+                    }
+                },
+            };
+            const config = inFrontendType ? map.frontend : map.backend;
+            const { scope, forbiddenScope, prefix, forbiddenPrefix, forbiddenCalleeNamesMap } = config;
+            // 互斥的端类型 (pc <-> h5)
+            const forbiddenKind = currentFrontendKind === 'pc' ? 'h5' : 'pc';
+            if (node.namespace?.startsWith(forbiddenPrefix)) {
+                error(node, `不能在${scope}作用域下使用${forbiddenScope}全局变量`);
+            }
+            else if (inFrontendType && node.namespace?.startsWith(`${prefix}.${forbiddenKind}`)) {
+                error(node, `不能在${currentFrontendKind}作用域下使用${forbiddenKind}作用域下的前端变量`);
+            }
+            if (forbiddenCalleeNamesMap?.[node.namespace]?.includes(node.name)) {
+                error(node, '不能在服务端作用域下使用前端公共变量');
+            }
             // 检查使用范围
             yield* checkScopeOfUse(node, ref);
             return env.getType(node);
@@ -3469,6 +4100,11 @@ function createErrorDiagnoser(context) {
         if (typeof node.value !== 'string') {
             error(node, '字符串');
         }
+        const MAX_LENGTH = 2 ** 16;
+        if (node.value.length > MAX_LENGTH) {
+            // 插值内部的字符串过长时要报错在插值节点上有红框
+            error(node.parentNode?.concept === 'StringInterpolation' ? node.parentNode : node, `存在过长文本，当前长度：${node.value.length}，最大长度：${MAX_LENGTH}。建议使用变量拆分文本后再拼接。`);
+        }
         return env.getType(node);
     }
     /**
@@ -3531,15 +4167,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)) {
@@ -3581,7 +4208,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;
     }
     /**
      * 检查 实体/（匿名）数据结构构造器
@@ -3589,6 +4222,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) {
@@ -3624,7 +4258,59 @@ function createErrorDiagnoser(context) {
         }
         return type;
     }
+    /**
+     * 获取正则表达式错误的中文消息
+     */
+    function getRegexErrorMessage(errorId) {
+        const errors = nasl_utils_1.referenceContent?.errors;
+        return errors?.[errorId] || `正则表达式错误: ${errorId}`;
+    }
+    /**
+     * 检查正则表达式标志符
+     */
+    function checkRegexFlags(flags, targetNode) {
+        const VALID_FLAGS = new Set(['g', 'i', 'm', 's', 'u', 'y']);
+        const flagCounts = new Map();
+        for (const flag of flags) {
+            if (!VALID_FLAGS.has(flag)) {
+                error(targetNode, `正则表达式标志符 "${flag}" 无效`);
+                continue;
+            }
+            const count = (flagCounts.get(flag) || 0) + 1;
+            flagCounts.set(flag, count);
+            if (count > 1) {
+                error(targetNode, `正则表达式标志符 "${flag}" 重复`);
+            }
+        }
+    }
+    /**
+     * 检查正则表达式语法和标志符
+     */
     function checkNewRegex(node) {
+        // 检查正则表达式模式语法
+        if (nasl_concepts_1.asserts.isStringLiteral(node.pattern)) {
+            const targetNode = node.kind === 'static' ? node : node.pattern;
+            try {
+                regeExp.parse(`/${node.pattern.value}/`);
+                const parseErrors = regeExp.errors;
+                if (Array.isArray(parseErrors) && parseErrors.length > 0) {
+                    parseErrors.forEach((errToken) => {
+                        const errorId = errToken?.error?.id;
+                        if (errorId) {
+                            error(targetNode, getRegexErrorMessage(errorId));
+                        }
+                    });
+                }
+            }
+            catch (e) {
+                error(targetNode, '正则表达式解析失败');
+            }
+        }
+        // 检查正则表达式标志符
+        if (nasl_concepts_1.asserts.isStringLiteral(node.flags)) {
+            const targetNode = node.kind === 'static' ? node : node.flags;
+            checkRegexFlags(node.flags.value, targetNode);
+        }
         return env.getType(node);
     }
     /**
@@ -3638,36 +4324,8 @@ function createErrorDiagnoser(context) {
         if (ensureNodeKeyExists(node, 'right')) {
             yield* checkNode(node.right);
         }
-        // 检查左侧为 Decimal，右侧为 Union<Decimal, Integer> 的情况
-        const leftType = env.getType(node.left);
-        const rightType = env.getType(node.right);
-        // 检查左右两侧同为匿名结构体时，对每个字段，都增加 Decimal 和 Union<Decimal, Long> 的检查
-        if (leftType && rightType && (0, type_predicate_1.isAnonymousTy)(leftType) && (0, type_predicate_1.isAnonymousTy)(rightType)) {
-            const leftProps = leftType.properties ?? [];
-            const rightProps = rightType.properties ?? [];
-            for (const leftProp of leftProps) {
-                const rightProp = rightProps.find(p => p.name === leftProp.name);
-                if (rightProp) {
-                    if (leftProp.typeAnnotation && rightProp.typeAnnotation) {
-                        if ((0, type_predicate_1.isDecimalTy)(leftProp.typeAnnotation) && (0, type_predicate_1.isDecimalUnionLongTy)(rightProp.typeAnnotation)) {
-                            error(node, `赋值：字段 ${leftProp.name} 类型不匹配，不能将 ${(0, type_manager_1.showUserLevelType)(rightProp.typeAnnotation)} 赋值给 ${(0, type_manager_1.showUserLevelType)(leftProp.typeAnnotation)} 类型。`);
-                        }
-                    }
-                }
-            }
-        }
-        if (leftType && rightType) {
-            // 检查左侧是否为 Decimal
-            const isLeftDecimal = leftType.typeKind === 'primitive' && leftType.typeName === 'Decimal';
-            // 检查右侧是否为 Union<Decimal, Long> 或 Union<Long, Decimal>
-            if (isLeftDecimal && rightType.typeKind === 'union' && rightType.typeArguments) {
-                const typeArgs = rightType.typeArguments;
-                const hasDecimal = typeArgs.some((arg) => arg.typeKind === 'primitive' && arg.typeName === 'Decimal');
-                const hasLong = typeArgs.some((arg) => arg.typeKind === 'primitive' && arg.typeName === 'Long');
-                if (hasDecimal && hasLong && typeArgs.length === 2) {
-                    error(node, `赋值：类型不匹配，不能将联合类型 ${(0, type_manager_1.showUserLevelType)(rightType)} 赋值给 ${(0, type_manager_1.showUserLevelType)(leftType)} 类型。`);
-                }
-            }
+        if (nasl_concepts_1.asserts.isMemberExpression(node.left)) {
+            reportCurrentItemModification(node.left, node);
         }
     }
     /**
@@ -3731,6 +4389,9 @@ function createErrorDiagnoser(context) {
                         error(args[i], '当前参数无效，不可用。');
                     }
                 }
+                if (isAIStrictMode) {
+                    yield* checkCallExpressionParameters(node, ref);
+                }
             }
             else {
                 error(node, `找不到页面${node.viewName}`);
@@ -3777,6 +4438,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
@@ -3788,6 +4477,8 @@ function createErrorDiagnoser(context) {
         else {
             error(node, '预期 1 个参数，但传入了 0 个。');
         }
+        // 检查数据查询的使用上下文
+        yield* checkQueryContextValidity(node);
         // where 子句
         yield* checkNode(node.where);
         // wherePlayground
@@ -3859,7 +4550,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) {
@@ -3902,6 +4599,9 @@ function createErrorDiagnoser(context) {
                 yield* checkNode(node);
             });
         }
+        else {
+            error(node, 'Join 子句的关联关系不能为空');
+        }
         if (node.joinParts?.length) {
             yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.joinParts, function* (node) {
                 yield* checkNode(node);
@@ -3936,6 +4636,9 @@ function createErrorDiagnoser(context) {
         else if (!node.asName) {
             error(node, '数据查询：聚合函数别名不能为空。');
         }
+        if (node.aggregateParam) {
+            yield* checkNode(node.aggregateParam);
+        }
     }
     /**
      * 检查 SQL 查询
@@ -4003,10 +4706,17 @@ function createErrorDiagnoser(context) {
      */
     function* checkBinaryExpression(node) {
         yield* semantic_rules_1.ExtraSemanticRules.rejectFileTypes(node, env, error);
+        const isCandidate = ['+', '-', '*', '/', '%', '>', '<', '>=', '<='].includes(node.operator);
         if (ensureNodeKeyExists(node, 'left')) {
+            if (isCandidate) {
+                yield* rejectNullLiteral(node.left);
+            }
             yield* checkNode(node.left);
         }
         if (ensureNodeKeyExists(node, 'right')) {
+            if (isCandidate) {
+                yield* rejectNullLiteral(node.right);
+            }
             yield* checkNode(node.right);
         }
         return env.getType(node);
@@ -4019,6 +4729,7 @@ function createErrorDiagnoser(context) {
             error(node, '表达式不能为空！');
         }
         yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.expressions, function* (node) {
+            yield* rejectNullLiteral(node);
             yield* checkNode(node);
         });
         return env.getType(node);
@@ -4029,6 +4740,13 @@ function createErrorDiagnoser(context) {
      */
     function* checkUnaryExpression(node) {
         if (ensureNodeKeyExists(node, 'argument')) {
+            const isCandidate = ['!'].includes(node.operator);
+            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);
@@ -4051,6 +4769,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;
     }
     /**
@@ -4208,6 +4946,18 @@ function createErrorDiagnoser(context) {
             error(node, `无返回值的${node?.constructor?.nodeTitle}${node.calleeName} 不能在${parentNode?.constructor?.nodeTitle}中作为表达式使用。`);
         }
     }
+    /**
+     * 检查 不允许使用 null 字面量
+     * @param node
+     */
+    function* rejectNullLiteral(node) {
+        if (!node) {
+            return; // 如果 node 为 null 或 undefined，直接返回
+        }
+        if (node.concept === 'NullLiteral') {
+            error(node, `此处不允许使用 null`);
+        }
+    }
     function* dispatchNode(node) {
         try {
             // 调用表达式
@@ -4260,6 +5010,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':
@@ -4354,6 +5106,8 @@ function createErrorDiagnoser(context) {
                     return yield* checkBlock(node);
                 case 'IfStatement':
                     return yield* checkIfStatement(node);
+                case 'IfExpression':
+                    return yield* checkIfExpression(node);
                 case 'Match':
                     return yield* checkMatch(node);
                 case 'MatchCase':
@@ -4471,6 +5225,13 @@ function createErrorDiagnoser(context) {
         // TODO: checkNodeIsFileModuleInIdeWithCache 也慢，后续可以优化
         const isFileModule = fileNodes.length ? (0, file_node_cache_1.checkNodeIsFileModuleInIdeWithCache)(node) : true;
         if (isFileModule) {
+            // 增量更新时按文件逐个 checkNode，需重置闭包状态；若本文件在 Module 内，inModule 需为 true（否则不会经过 checkModule，inModule 会失效）
+            inModule = !!node.getAncestor?.('Module');
+            inPlayground = 0;
+            inAuthLogic = false;
+            const frontendType = node.getAncestor?.('FrontendType');
+            inFrontendType = !!frontendType;
+            currentFrontendKind = frontendType?.kind || '';
             fileNodes.push(node);
             let diagnostics = diagnosticMap.get(node);
             if (!diagnostics) {
@@ -4593,6 +5354,84 @@ function createErrorDiagnoser(context) {
         });
         return flattenedDiags;
     }
+    /**
+     * 重新验证祖先节点
+     * 用于增量更新时，当子节点变更需要重新验证祖先节点的场景
+     * @param ancestorNode 需要重新验证的祖先节点
+     * @param validationFn 验证函数
+     * @param errorFilter 错误过滤函数（可选），用于保留特定的错误（返回 true 表示保留）
+     * @param siblingNodeTypes 需要过滤错误的兄弟节点类型（可选）
+     * @param getSiblingNodes 获取兄弟节点的函数（可选），用于从祖先节点中获取需要过滤错误的兄弟节点
+     * @returns 新的诊断信息 Map，如果没有则返回 null
+     */
+    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 {
+            validationFn(ancestorNode, env);
+        }
+        finally {
+            cleanup?.();
+        }
+        // 收集并返回所有文件节点的诊断信息
+        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,
         setLatestVersionsOfSharedApp,
@@ -4601,11 +5440,72 @@ function createErrorDiagnoser(context) {
         clearDiagnostics,
         getDiagnostics,
         getAllDiagnostics,
+        checkAllProcessCircularReferences,
         getDebugDiagnostics,
         error,
+        checkViewIndexPageSetting,
+        revalidateAncestorNode,
     };
 }
 exports.createErrorDiagnoser = createErrorDiagnoser;
+/**
+ * 检查字段路径是否在类型上存在
+ * 类似于 s-component-attr-form.vue 中的 findPropertyNode 功能
+ * @param env 语义环境
+ * @param dataType 数据源类型
+ * @param fieldPath 字段路径，如 "name" 或 "user.name"
+ * @returns { exists: boolean, missingField?: string } 如果字段不存在，返回第一个不存在的字段名
+ */
+function checkFieldExistsInType(env, dataType, fieldPath) {
+    if (!dataType || !fieldPath) {
+        return { exists: true }; // 没有类型信息或字段路径时，跳过检查
+    }
+    const fieldParts = fieldPath.split('.');
+    let currentType = dataType;
+    for (const fieldName of fieldParts) {
+        if (!currentType) {
+            return { exists: false, missingField: fieldName };
+        }
+        // 获取类型的 properties
+        let properties;
+        if (currentType.typeKind === 'anonymousStructure') {
+            properties = currentType.properties;
+        }
+        else if (currentType.typeKind === 'reference') {
+            // 对于引用类型，需要解析引用
+            const resolved = env.resolveRef(currentType);
+            // @ts-expect-error
+            properties = resolved?.properties;
+        }
+        else if (currentType.typeKind === 'generic' && currentType.typeName === 'List') {
+            // 对于 List<T>，检查 T 的属性
+            currentType = currentType.typeArguments?.[0];
+            if (currentType?.typeKind === 'anonymousStructure') {
+                properties = currentType.properties;
+            }
+            else if (currentType?.typeKind === 'reference') {
+                const resolved = env.resolveRef(currentType);
+                // @ts-expect-error
+                properties = resolved?.properties;
+            }
+        }
+        if (!properties) {
+            // 类型没有 properties，可能是基本类型或未解析的类型
+            // 对于未解析的类型，跳过检查
+            if ((0, type_predicate_1.isTyAnnTyParam)(currentType) || (0, type_predicate_1.isAnyTy)(currentType)) {
+                return { exists: true };
+            }
+            return { exists: false, missingField: fieldName };
+        }
+        const prop = properties.find((p) => p.name === fieldName);
+        if (!prop) {
+            return { exists: false, missingField: fieldName };
+        }
+        // 继续检查下一级
+        currentType = prop.typeAnnotation;
+    }
+    return { exists: true };
+}
 function deduplicateDiagnostics(diagnostics) {
     return (0, lodash_1.uniqWith)(diagnostics, (a, b) => a.node === b.node && a.message === b.message);
 }
@@ -4655,7 +5555,7 @@ exports.transformDiagnosticsToRecords = transformDiagnosticsToRecords;
 // @ts-expect-error
 const toRaw = (nd) => nd.__v_raw ?? nd;
 // 是否来自系统内置
-const isBuiltInCall = (nd) => !!nd.calleeNamespace?.startsWith('nasl.');
+const isBuiltInCall = (nd) => !!nd.calleeNamespace?.startsWith('nasl.') && !['nasl.auth'].includes(nd.calleeNamespace);
 // 获取依赖库名
 const getExtensionLibName = (nd) => nd.calleeNamespace?.startsWith('extensions.') ? nd.calleeNamespace.split('.')[1] : undefined;
 //# sourceMappingURL=checker.js.map