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

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,EAC4C,QAAQ,EAC5B,IAAI,EAQ+E,GAAG,EAMxH,QAAQ,EAGT,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;AAkPF;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,eAAe;oCA6kKpB,OAAO;sDAPW,gBAAgB,EAAE;;;;sBAhBjD,UAAU,GAAG,SAAS;;;8BA4Df,UAAU;2BAyBb,UAAU;;iDAlwFY,GAAG,KAAG,IAAI;;iBA6wFjD,MAAM;kBACL,MAAM;kBACN,MAAM;qBACH,MAAM;;kBA9lKF,UAAU,WAAW,MAAM,YAAY,YAAY;sCAs1D/B,IAAI,GAAG,QAAQ;2CA2yGxC,UAAU,gBACV,CAAC,YAAY,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,gBAC/C,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,qBACvB,MAAM,EAAE,oBACT,CAAC,YAAY,EAAE,UAAU,KAAK,UAAU,EAAE,KAC3D,kBAAkB,GAAG,IAAI;EAwF7B;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,EAGT,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;AAYpE,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;AAOF,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;AAmPF;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,eAAe;oCA2nKpB,OAAO;sDAPW,gBAAgB,EAAE;;;;sBAhBjD,UAAU,GAAG,SAAS;;;8BA4Df,UAAU;2BAyBb,UAAU;;iDAztFY,GAAG,KAAG,IAAI;;iBAouFjD,MAAM;kBACL,MAAM;kBACN,MAAM;qBACH,MAAM;;kBAxoKF,UAAU,WAAW,MAAM,YAAY,YAAY;sCA04D/B,IAAI,GAAG,QAAQ;2CAiyGxC,UAAU,gBACV,CAAC,YAAY,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,gBAC/C,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,qBACvB,MAAM,EAAE,oBACT,CAAC,YAAY,EAAE,UAAU,KAAK,UAAU,EAAE,KAC3D,kBAAkB,GAAG,IAAI;EAwF7B;AAqED,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

@@ -14,6 +14,7 @@ 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;
@@ -73,6 +74,7 @@ function getExpressionNodeName(concept) {
         CallMicroserviceInterface: '微服务接口',
         CallGatewayInterface: '网关接口',
         CallEvent: '事件',
+        Destination: '页面',
     };
     return expressionNodeName[concept];
 }
@@ -254,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;
     // 检查共享数据是否有更新
@@ -266,6 +270,8 @@ function createErrorDiagnoser(context) {
     let inModule = false;
     let inPlayground = 0;
     let inAuthLogic = false;
+    let inFrontendType = false;
+    let currentFrontendKind = '';
     let dbType = '';
     let curVarCounter = 0;
     const listComponentStack = [];
@@ -313,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),
@@ -775,6 +791,31 @@ function createErrorDiagnoser(context) {
         }
         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
@@ -857,7 +898,8 @@ function createErrorDiagnoser(context) {
             if (param?.spread) {
                 continue;
             }
-            if (!isNonRequiredParam(param)) {
+            // 严格模式非必填也需要有Argument占位
+            if (isAIStrictMode || !isNonRequiredParam(param)) {
                 minArgsCount++; // 如果参数有默认值，则跳过
             }
         }
@@ -975,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];
@@ -1252,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);
@@ -1454,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) {
@@ -1726,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,
                                     });
                                 }
                             }
@@ -1976,8 +2027,10 @@ function createErrorDiagnoser(context) {
                 yield* checkNode(node);
             });
         }
-        if (ensureNodeKeyExists(node, 'originLogicName')) {
-            if (nasl_concepts_1.asserts.isApp(node.parentNode)) {
+        // 仅对内部接口（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) {
@@ -2349,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;
@@ -2444,6 +2522,11 @@ function createErrorDiagnoser(context) {
             // 任务完成人为空会有一个提示信息
             error(node, `${title}为空`);
         }
+        if (Array.isArray(node.fromLogics)) {
+            yield* (0, nasl_utils_1.wrapForEachToGenerator)(node.fromLogics, function* (node) {
+                yield* checkNode(node);
+            });
+        }
     }
     /**
      * 检查 元素指令
@@ -3017,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: [
@@ -3278,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)) {
@@ -3379,17 +3462,30 @@ function createErrorDiagnoser(context) {
             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)) {
-                        error(nd.arguments[i], (0, sem_diag_1.mkIncompatibleTyErr)(env, env.getType(expr) || type_manager_1.naslAnyTy, expectTy));
+                        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 {
-                    error(nd.arguments[i], (0, sem_diag_1.mkIncompatibleTyErr)(env, env.getType(expr) || type_manager_1.naslAnyTy, expectTy));
+                    reportArgError(expr);
                 }
                 const byTy = resTy?.properties?.find((prop) => prop.name === 'by')?.typeAnnotation;
                 if (byTy?.typeKind === 'union') {
@@ -3426,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);
     }
     /**
@@ -3784,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);
@@ -3879,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);
@@ -4158,97 +4313,6 @@ function createErrorDiagnoser(context) {
         }
         return env.getType(node);
     }
-    /**
-     * 递归检查赋值类型不兼容问题
-     * 检查左侧类型(Decimal/Long)是否与右侧联合类型(Union<Decimal, Long>)不兼容
-     * @param leftType 左侧类型
-     * @param rightType 右侧类型
-     * @param context 上下文信息，用于生成错误消息
-     * @param allowImplicitConversion 是否允许隐式类型转换（仅对直接的基础类型赋值允许，复杂类型内部不允许）
-     * @returns 所有类型不兼容的错误信息数组
-     */
-    function checkAssignmentTypeIncompatibility(leftType, rightType, context = {}, allowImplicitConversion = true) {
-        if (!leftType || !rightType)
-            return [];
-        const errors = [];
-        // 先检查 Decimal/Long vs Union<Decimal, Long> 的情况（需要先于其他检查）
-        // 这种情况应该报错，即使允许隐式转换
-        if (allowImplicitConversion) {
-            const isLeftPrimitive = leftType.typeKind === 'primitive';
-            const isLeftDecimalOrLong = isLeftPrimitive && (leftType.typeName === 'Decimal' || leftType.typeName === 'Long');
-            if (isLeftDecimalOrLong && (0, type_predicate_1.isDecimalUnionLongTy)(rightType)) {
-                const prefix = context.prefix || '赋值';
-                const fieldInfo = context.fieldName ? `字段 ${context.fieldName} ` : '';
-                errors.push(`${prefix}：${fieldInfo}类型不匹配，不能将 ${(0, type_manager_1.showUserLevelType)(rightType)} 赋值给 ${(0, type_manager_1.showUserLevelType)(leftType)} 类型。`);
-                return errors; // 找到基本类型错误后直接返回，不再检查嵌套
-            }
-        }
-        // 检查基础类型是否严格相等（不允许隐式转换）
-        const isLeftPrimitive = leftType.typeKind === 'primitive';
-        const isRightPrimitive = rightType.typeKind === 'primitive';
-        if (isLeftPrimitive && isRightPrimitive) {
-            // 如果不允许隐式转换，则要求类型完全相等
-            if (!allowImplicitConversion) {
-                if (leftType.typeName !== rightType.typeName || leftType.typeNamespace !== rightType.typeNamespace) {
-                    const prefix = context.prefix || '赋值';
-                    const fieldInfo = context.fieldName ? `字段 ${context.fieldName} ` : '';
-                    errors.push(`${prefix}：${fieldInfo}类型不匹配，不能将 ${(0, type_manager_1.showUserLevelType)(rightType)} 赋值给 ${(0, type_manager_1.showUserLevelType)(leftType)} 类型。`);
-                    return errors;
-                }
-                // 类型完全相等，没有错误，继续检查其他情况
-            }
-            else {
-                // 允许隐式转换的情况下，检查是否通过 isSubTy 检查（允许隐式转换）
-                if ((0, type_predicate_1.isSubTy)(env, rightType, leftType)) {
-                    // 类型兼容（允许隐式转换），没有错误，继续检查其他情况
-                }
-                // 如果 isSubTy 返回 false，继续检查其他不兼容的情况
-            }
-        }
-        // 2. 检查 List 类型（包括嵌套）：List<T> vs List<Union<...>>
-        if (leftType.typeKind === 'generic' &&
-            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 || '赋值' }, false // 嵌套类型内部不允许隐式转换
-            );
-        }
-        // 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 || '赋值' }, false // 嵌套类型内部不允许隐式转换
-            );
-            errors.push(...valueTypeErrors);
-            // 也检查键类型（第一个类型参数），嵌套类型内部不允许隐式转换
-            const keyTypeErrors = checkAssignmentTypeIncompatibility(leftType.typeArguments[0], rightType.typeArguments[0], { ...context, prefix: context.prefix || '赋值' }, false // 嵌套类型内部不允许隐式转换
-            );
-            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 }, false // 复杂类型内部不允许隐式转换
-                    );
-                    errors.push(...fieldErrors); // 收集所有字段的错误，不提前返回
-                }
-            }
-        }
-        return errors;
-    }
     /**
      * 检查 赋值语句
      * @param node
@@ -4260,14 +4324,6 @@ function createErrorDiagnoser(context) {
         if (ensureNodeKeyExists(node, 'right')) {
             yield* checkNode(node.right);
         }
-        // 使用统一的类型兼容性检查
-        const leftType = env.getType(node.left);
-        const rightType = env.getType(node.right);
-        const errorMessages = checkAssignmentTypeIncompatibility(leftType, rightType);
-        // 报告所有错误
-        errorMessages.forEach(errorMessage => {
-            error(node, errorMessage);
-        });
         if (nasl_concepts_1.asserts.isMemberExpression(node.left)) {
             reportCurrentItemModification(node.left, node);
         }
@@ -4333,6 +4389,9 @@ function createErrorDiagnoser(context) {
                         error(args[i], '当前参数无效，不可用。');
                     }
                 }
+                if (isAIStrictMode) {
+                    yield* checkCallExpressionParameters(node, ref);
+                }
             }
             else {
                 error(node, `找不到页面${node.viewName}`);
@@ -4540,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);
@@ -4574,6 +4636,9 @@ function createErrorDiagnoser(context) {
         else if (!node.asName) {
             error(node, '数据查询：聚合函数别名不能为空。');
         }
+        if (node.aggregateParam) {
+            yield* checkNode(node.aggregateParam);
+        }
     }
     /**
      * 检查 SQL 查询
@@ -5160,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) {
@@ -5376,6 +5448,64 @@ function createErrorDiagnoser(context) {
     };
 }
 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);
 }
@@ -5425,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