@lcap/nasl-language-server-core 4.4.0-beta.1 → 4.4.0-beta.10

package/out/checker.d.ts

@@ -1,4 +1,4 @@
-import type { SyntaxNode, App, BaseNode } from '@lcap/nasl-concepts';
+import type { SyntaxNode, Frontend, View, App, BaseNode } from '@lcap/nasl-concepts';
 import { TypeAnnotation } from '@lcap/nasl-concepts';
 import { type SemEnv } from './typer/typer';
 import { Diagnostic as NaslTypeDiagnostic } from '@lcap/nasl-types';
@@ -49,6 +49,8 @@ export declare function createErrorDiagnoser(context: DiagnoseContext): {
         nodeConcept: string;
     }[];
     error: (node: SyntaxNode, message: string, context?: ErrorContext) => void;
+    checkViewIndexPageSetting: (node: View | Frontend) => void;
+    revalidateAncestorNode: (ancestorNode: SyntaxNode, validationFn: (ancestorNode: SyntaxNode, env: SemEnv) => void, errorFilter?: (err: Diagnostic) => boolean) => NodeDiagnosticsMap | null;
 };
 export interface DiagnosticRecord {
     id: string;

package/out/checker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checker.d.ts","sourceRoot":"","sources":["../src/checker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,UAAU,EAU2G,GAAG,EAMxH,QAAQ,EAET,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACgE,cAAc,EAGpF,MAAM,qBAAqB,CAAC;AAS7B,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAK5C,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAOpE,oBAAY,QAAQ;IAClB,IAAI,YAAY;IAChB,KAAK,UAAU;CAChB;AAED,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;AAEnE,KAAK,YAAY,GAAG;IAClB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB,CAAC;AAMF,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;AAEpE,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,CAAC;AAMrE,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAqBF,KAAK,eAAe,GAAG;IACrB,GAAG,EAAE,GAAG,CAAC;IACT,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;IACf,yBAAyB,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/C,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB,CAAC;AA4OF;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,eAAe;oCA01IpB,OAAO;sDAPW,gBAAgB,EAAE;;;;sBAhBjD,UAAU,GAAG,SAAS;;;8BA4Df,UAAU;2BAyBb,UAAU;;;iBAW3B,MAAM;kBACL,MAAM;kBACN,MAAM;qBACH,MAAM;;kBA72IF,UAAU,WAAW,MAAM,YAAY,YAAY;EAg5IzE;AAGD,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IAEX,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IACrC,mBAAmB,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IACvC,qBAAqB,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC1C;AAMD,eAAO,MAAM,6BAA6B,aAC9B,UAAU,+DAGnB,MAAM,gBAAgB,CAyCxB,CAAC;AAMF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"checker.d.ts","sourceRoot":"","sources":["../src/checker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,UAAU,EAC4C,QAAQ,EAC5B,IAAI,EAQ+E,GAAG,EAMxH,QAAQ,EAET,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACgE,cAAc,EAGpF,MAAM,qBAAqB,CAAC;AAS7B,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAK5C,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAWpE,oBAAY,QAAQ;IAClB,IAAI,YAAY;IAChB,KAAK,UAAU;CAChB;AAED,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;AAEnE,KAAK,YAAY,GAAG;IAClB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB,CAAC;AAMF,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;AAEpE,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,CAAC;AAMrE,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAqBF,KAAK,eAAe,GAAG;IACrB,GAAG,EAAE,GAAG,CAAC;IACT,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;IACf,yBAAyB,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/C,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB,CAAC;AA6OF;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,eAAe;oCA4lJpB,OAAO;sDAPW,gBAAgB,EAAE;;;;sBAhBjD,UAAU,GAAG,SAAS;;;8BA4Df,UAAU;2BAyBb,UAAU;;;iBAW3B,MAAM;kBACL,MAAM;kBACN,MAAM;qBACH,MAAM;;kBA9mJF,UAAU,WAAW,MAAM,YAAY,YAAY;sCA+qD/B,IAAI,GAAG,QAAQ;2CAg+FxC,UAAU,gBACV,CAAC,YAAY,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,gBAC/C,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,KACzC,kBAAkB,GAAG,IAAI;EAgD7B;AAGD,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IAEX,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IACrC,mBAAmB,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IACvC,qBAAqB,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC1C;AAMD,eAAO,MAAM,6BAA6B,aAC9B,UAAU,+DAGnB,MAAM,gBAAgB,CAyCxB,CAAC;AAMF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/out/checker.js

@@ -10,10 +10,12 @@ 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 regeExp = new nasl_utils_1.ExpressionLexer();
+regeExp.profile = nasl_utils_1.profiles.js;
 var Severity;
 (function (Severity) {
     Severity["WARN"] = "warning";
@@ -321,7 +323,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 +368,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);
@@ -1912,9 +1937,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 +2017,7 @@ function createErrorDiagnoser(context) {
             yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.children, function* (node) {
                 yield* checkNode(node);
             });
+            checkViewIndexPageSetting(node);
         }
         env.exitScope();
     }
@@ -1971,6 +2027,17 @@ function createErrorDiagnoser(context) {
      */
     function* checkBusinessComponent(node) {
         env.enterScope(node);
+        if (node.params?.length) {
+            yield* checkParams(node.params);
+            yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.params, function* (node) {
+                yield* checkNode(node);
+            });
+        }
+        if (node.variables?.length) {
+            yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.variables, function* (node) {
+                yield* checkNode(node);
+            });
+        }
         // 组件元素
         if (node.elements?.length) {
             yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.elements, function* (node) {
@@ -2930,15 +2997,27 @@ 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;
                 if (expr?.concept === 'AnonymousFunction') {
                     resTy = env.getType(expr.body);
+                    if (!nasl_concepts_1.asserts.isNewComposite(expr.body)) {
+                        error(nd.arguments[i], (0, sem_diag_1.mkIncompatibleTyErr)(env, env.getType(expr) || type_manager_1.naslAnyTy, expectTy));
+                    }
                 }
                 else if (expr?.concept === 'SubLogic') {
                     resTy = env.getType(expr.returns?.[0]);
                 }
+                else {
+                    error(nd.arguments[i], (0, sem_diag_1.mkIncompatibleTyErr)(env, env.getType(expr) || type_manager_1.naslAnyTy, expectTy));
+                }
                 const byTy = resTy?.properties?.find((prop) => prop.name === 'by')?.typeAnnotation;
                 if (byTy?.typeKind === 'union') {
                     // 这里使用 node.arguments[i] 则无红框，猜测是 ListSort 的特殊交互导致的问题
@@ -3020,6 +3099,7 @@ function createErrorDiagnoser(context) {
      */
     function* checkIfStatement(node) {
         if (ensureNodeKeyExists(node, 'test')) {
+            yield* rejectNullLiteral(node.test);
             yield* checkNode(node.test);
         }
         // then
@@ -3035,12 +3115,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) {
@@ -3295,6 +3395,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);
             }
         }
@@ -3339,6 +3440,7 @@ function createErrorDiagnoser(context) {
      */
     function* checkWhileStatement(node) {
         if (ensureNodeKeyExists(node, 'test')) {
+            yield* rejectNullLiteral(node.test);
             yield* checkNode(node.test);
         }
         if (node.body?.length) {
@@ -3458,6 +3560,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);
     }
     /**
@@ -3613,9 +3720,121 @@ 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);
     }
+    /**
+     * 递归检查赋值类型不兼容问题
+     * 检查左侧类型(Decimal/Long)是否与右侧联合类型(Union<Decimal, Long>)不兼容
+     * @param leftType 左侧类型
+     * @param rightType 右侧类型
+     * @param context 上下文信息，用于生成错误消息
+     * @returns 所有类型不兼容的错误信息数组
+     */
+    function checkAssignmentTypeIncompatibility(leftType, rightType, context = {}) {
+        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; // 找到基本类型错误后直接返回，不再检查嵌套
+        }
+        // 2. 检查 List 类型（包括嵌套）：List<T> vs List<Union<...>>
+        if (leftType.typeKind === 'generic' &&
+            leftType.typeName === 'List' &&
+            rightType.typeKind === 'generic' &&
+            rightType.typeName === 'List' &&
+            leftType.typeArguments?.[0] &&
+            rightType.typeArguments?.[0]) {
+            // 递归检查 List 的元素类型
+            return checkAssignmentTypeIncompatibility(leftType.typeArguments[0], rightType.typeArguments[0], { ...context, prefix: context.prefix || '赋值' });
+        }
+        // 3. 检查 Map 类型（包括嵌套）：Map<K, V> vs Map<K, Union<...>>
+        if (leftType.typeKind === 'generic' &&
+            leftType.typeName === 'Map' &&
+            rightType.typeKind === 'generic' &&
+            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 || '赋值' });
+            errors.push(...valueTypeErrors);
+            // 也检查键类型（第一个类型参数）
+            const keyTypeErrors = checkAssignmentTypeIncompatibility(leftType.typeArguments[0], rightType.typeArguments[0], { ...context, prefix: context.prefix || '赋值' });
+            errors.push(...keyTypeErrors);
+            return errors;
+        }
+        // 4. 检查匿名结构体：递归检查每个字段，收集所有字段的错误
+        if ((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 && leftProp.typeAnnotation && rightProp.typeAnnotation) {
+                    const fieldErrors = checkAssignmentTypeIncompatibility(leftProp.typeAnnotation, rightProp.typeAnnotation, { prefix: context.prefix || '赋值', fieldName: leftProp.name });
+                    errors.push(...fieldErrors); // 收集所有字段的错误，不提前返回
+                }
+            }
+        }
+        return errors;
+    }
     /**
      * 检查 赋值语句
      * @param node
@@ -3627,37 +3846,14 @@ 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)} 类型。`);
-                }
-            }
-        }
+        const errorMessages = checkAssignmentTypeIncompatibility(leftType, rightType);
+        // 报告所有错误
+        errorMessages.forEach(errorMessage => {
+            error(node, errorMessage);
+        });
     }
     /**
      * 检查 批量赋值语句
@@ -3992,10 +4188,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);
@@ -4008,6 +4211,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);
@@ -4018,6 +4222,10 @@ function createErrorDiagnoser(context) {
      */
     function* checkUnaryExpression(node) {
         if (ensureNodeKeyExists(node, 'argument')) {
+            const isCandidate = ['!'].includes(node.operator);
+            if (isCandidate) {
+                yield* rejectNullLiteral(node.argument);
+            }
             yield* checkNode(node.argument);
         }
         return env.getType(node);
@@ -4197,6 +4405,15 @@ function createErrorDiagnoser(context) {
             error(node, `无返回值的${node?.constructor?.nodeTitle}${node.calleeName} 不能在${parentNode?.constructor?.nodeTitle}中作为表达式使用。`);
         }
     }
+    /**
+     * 检查 不允许使用 null 字面量
+     * @param node
+     */
+    function* rejectNullLiteral(node) {
+        if (node.concept === 'NullLiteral') {
+            error(node, `此处不允许使用 null`);
+        }
+    }
     function* dispatchNode(node) {
         try {
             // 调用表达式
@@ -4233,6 +4450,8 @@ function createErrorDiagnoser(context) {
                     return yield* checkBackendVariable(node);
                 case 'Param':
                     return yield* checkParam(node);
+                case 'ParamWithGroup':
+                    return yield* checkParam(node);
                 case 'Return':
                     return yield* checkReturn(node);
                 case 'DefaultValue':
@@ -4341,6 +4560,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':
@@ -4580,6 +4801,45 @@ function createErrorDiagnoser(context) {
         });
         return flattenedDiags;
     }
+    /**
+     * 重新验证祖先节点
+     * 用于增量更新时，当子节点变更需要重新验证祖先节点的场景
+     * @param ancestorNode 需要重新验证的祖先节点
+     * @param validationFn 验证函数
+     * @param errorFilter 错误过滤函数（可选），用于保留特定的错误
+     * @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,
+                    });
+                }
+            });
+        }
+        // 设置文件节点上下文并执行验证
+        const cleanup = handleFileNode(ancestorNode);
+        try {
+            validationFn(ancestorNode, env);
+        }
+        finally {
+            cleanup?.();
+        }
+        // 返回新的诊断信息
+        return getDiagnostics(ancestorNode) || null;
+    }
     return {
         setMetadataTypeEnable,
         setLatestVersionsOfSharedApp,
@@ -4590,6 +4850,8 @@ function createErrorDiagnoser(context) {
         getAllDiagnostics,
         getDebugDiagnostics,
         error,
+        checkViewIndexPageSetting,
+        revalidateAncestorNode,
     };
 }
 exports.createErrorDiagnoser = createErrorDiagnoser;