@lcap/nasl 2.20.0-beta.3 → 2.20.0-beta.5

package/out/server/naslServer.js

@@ -44,14 +44,17 @@ const diagnostic_1 = require("../manager/diagnostic");
 const createUiTs_1 = __importDefault(require("./createUiTs"));
 const coreTypeList_1 = require("../concepts/basics/types/coreTypeList");
 const formatTsUtils_1 = require("./formatTsUtils");
+const utils = __importStar(require("../utils"));
 const naslStdlibMap_1 = __importDefault(require("./naslStdlibMap"));
 const jsoner = __importStar(require("../service/storage/jsoner"));
 const EventEmitter_1 = require("../common/EventEmitter");
+const utils_1 = require("../utils");
 const EmbeddedTSFileLineMap = {
     Entity: 3,
 };
 const EmbeddedTSFileOffsetMap = {
     Variable: 12,
+    ConfigProperty: 12,
 };
 let isChangeInterface = false; //判断是否导入接口
 let actionArr = []; //用于导入接口收集更改的节点
@@ -102,6 +105,8 @@ class NaslServer {
     changeStackList = [];
     filesToCheck;
     singleFileChangeIng;
+    // 包含组件逻辑调用的逻辑map
+    logicSetWithComponentLogic = new Set();
     constructor() {
         /// #if process.env.BUILD_TARGET === 'node'
         if (globalThis.process) // For TS build
@@ -110,6 +115,7 @@ class NaslServer {
         /// #endif
         /// #if process.env.BUILD_TARGET !== 'node'
         if (globalThis.window) // For TS build
+            /* !!!如果改动这里需要看下关联的对应文件：webpack/ts-worker/loader.js */
             this.worker = new worker_threads_1.Worker('/ts-worker.js');
         /// #endif
         // 要Check的文件
@@ -316,6 +322,21 @@ class NaslServer {
                 }
             });
         }
+        module.configuration?.groups?.forEach((_group) => {
+            if (_group.name === 'custom') {
+                _group.properties.forEach((_property) => {
+                    try {
+                        const result = _property.toEmbeddedTSFile();
+                        results.push(result);
+                        // sourceMap都存在目录级别内容下，在页面层级下去找
+                        _property.sourceMap = result.sourceMap;
+                        this.file2NodeMap.set(result.filePath, _property);
+                    }
+                    catch (err) {
+                    }
+                });
+            }
+        });
     }
     view2TSFile(viewsChildren, results) {
         // 如果有子页面
@@ -698,6 +719,14 @@ class NaslServer {
         const records = await this.getDiagnosticRecords(fileNames);
         // diagnosticManager.pushAll(records);
     }
+    /**
+     * 节点异常是只能挂载单个，如果已经了就不赋值了
+     */
+    baseNodeAssignmentTsError(node, tsErrorDetail) {
+        if (node.tsErrorDetail)
+            return;
+        node.tsErrorDetail = tsErrorDetail;
+    }
     /**
      * 处理诊断结果
      * @param records 结果
@@ -751,6 +780,42 @@ class NaslServer {
                 .map((diag) => this._resolveDiagnostic(diag, node, record))
                 .filter((diag) => !!diag);
             record.semanticDiagnostics.push(...this._attachDiagnostics(node));
+            // 报错降级逻辑
+            record.semanticDiagnostics = record.semanticDiagnostics
+                .map((diagnostic) => {
+                // 错误降级如果属于草稿态的就降级
+                if (diagnostic?.node) {
+                    let currentNode = diagnostic.node;
+                    while (currentNode?.parentNode?.concept !== 'App') {
+                        if (currentNode.parentKey?.toLowerCase()?.includes('playground')) {
+                            // 草稿区降级
+                            // 重置 图标和错误等级
+                            diagnostic.severity = 'warning';
+                            if (diagnostic.node?.tsErrorDetail) {
+                                // 重置组件节点上的错误信息
+                                diagnostic.node.tsErrorDetail.severity = 'warning';
+                            }
+                            record.suggestionDiagnostics.push(diagnostic);
+                            return null;
+                        }
+                        else if (currentNode.concept === 'OqlQueryComponent') {
+                            // OQL别名错误降级为警告
+                            if (diagnostic.originalDiagnostic && diagnostic.originalDiagnostic?.text.includes('__OQL_ALIAS_WARNING__')) {
+                                // 重置 图标和错误等级
+                                diagnostic.severity = 'warning';
+                                if (diagnostic.node?.tsErrorDetail) {
+                                    // 重置组件节点上的错误信息
+                                    diagnostic.node.tsErrorDetail.severity = 'warning';
+                                }
+                                record.suggestionDiagnostics.push(diagnostic);
+                                return null;
+                            }
+                        }
+                        currentNode = currentNode.parentNode;
+                    }
+                }
+                return diagnostic;
+            }).filter((diag) => !!diag);
             // 建议诊断
             // 实体下的建议不用展示，因为都是平台自己写的逻辑
             // if (node instanceof Entity) {
@@ -764,11 +829,51 @@ class NaslServer {
             //     // logic在for循环中，不展示any提示
             //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`implicitly has an 'any' type, but a better type may be inferred from usage.`));
             // }
-            record.suggestionDiagnostics = record.suggestionDiagnostics
-                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`,
-                `'__UpdateNoProperty__' is declared but its value is never read.`].includes(item.text))
-                .map((diag) => this._resolveDiagnostic(diag, node, record))
-                .filter((diag) => !!diag);
+            // 处理后的警告异常提示信息
+            record.suggestionDiagnostics = record.suggestionDiagnostics.map((diag) => {
+                // 上面错误降级下来的
+                if (diag?.node) {
+                    return diag;
+                    // 一些已知警告的单独处理
+                }
+                else if ([`'__LogicEmpty' is declared but its value is never read.`,
+                    `'__destinationEmpty__' is declared but its value is never read.`,
+                    `'__devConfigValueEmpty' is declared but its value is never read.`,
+                    `'__onlineConfigValueEmpty' is declared but its value is never read.`,
+                    `'__UpdateNoProperty__' is declared but its value is never read.`].includes(diag.text)) {
+                    return this._resolveDiagnostic(diag, node, record);
+                }
+                else if ((diag.text).includes(` is declared but its value is never read.`)) {
+                    // 局部变量和输入变量未使用的警告
+                    if ((node.concept === 'View' || node.concept === 'Logic') && node.parentNode.concept !== 'Module') {
+                        const minRange = this._findMinRange(diag, node);
+                        if (minRange) {
+                            /**
+                             * 如果节点是入参类型
+                             * 而且不是foreach中
+                             * 而且不是事件逻辑的入参
+                             */
+                            if (minRange.node instanceof concepts_1.Param && minRange.node.parentNode.concept !== 'ForEachStatement' && !minRange.node.getAncestor('BindEvent')) {
+                                const diagnostic = {
+                                    node: minRange.node,
+                                    severity: 'warning',
+                                    message: `未使用的输入参数${minRange.node.name}`,
+                                };
+                                return diagnostic;
+                            }
+                            else if (minRange.node instanceof concepts_1.Variable) {
+                                const diagnostic = {
+                                    node: minRange.node,
+                                    severity: 'warning',
+                                    message: `未使用的变量${minRange.node.name}`,
+                                };
+                                return diagnostic;
+                            }
+                        }
+                    }
+                }
+                return null;
+            }).filter((diag) => !!diag);
             record.suggestionDiagnostics.push(...this._attachSuggestionDiagnostics(node));
         });
         return records;
@@ -781,22 +886,6 @@ class NaslServer {
     _attachSuggestionDiagnostics(fileNode) {
         const diagnostics = [];
         if (fileNode instanceof concepts_1.Logic || fileNode instanceof concepts_1.View) {
-            // 判断逻辑是否已经删除
-            if (fileNode instanceof concepts_1.Logic && fileNode.parentNode instanceof concepts_1.App && !fileNode.parentNode.logics.includes(fileNode))
-                return diagnostics;
-            // 判断页面是否已经删除
-            let removed = false;
-            let curNode = fileNode;
-            // 递归检查，防止从顶层页面开始删除影响子页面内容检查
-            while (curNode instanceof concepts_1.View && !removed) {
-                if (curNode.parentNode instanceof concepts_1.View && !curNode.parentNode.children.includes(curNode)
-                    || curNode.parentNode instanceof concepts_1.Frontend && !curNode.parentNode.views.includes(curNode)) {
-                    removed = true;
-                }
-                curNode = curNode.parentNode;
-            }
-            if (removed)
-                return diagnostics;
             fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof concepts_1.Match) {
                     const { cases, expression } = node || {};
@@ -912,8 +1001,8 @@ class NaslServer {
                                     if (Array.isArray(body) && body.length) {
                                         const lastExpression = body[body.length - 1];
                                         diagnostic.node = lastExpression;
-                                        diagnostic.message = `${lastExpression?.toUI()}期望的类型是${maxTypeAnnotation?.headTitle}`;
-                                        lastExpression.tsErrorDetail = diagnostic;
+                                        diagnostic.message = `匹配：该分支类型与多数类型不一致，将产生Union类型。当前类型：${typeAnnotation?.headTitle}，多数类型：${maxTypeAnnotation?.headTitle}`;
+                                        this.baseNodeAssignmentTsError(lastExpression, diagnostic);
                                         diagnostics.push(diagnostic);
                                     }
                                 });
@@ -921,31 +1010,232 @@ class NaslServer {
                         }
                     }
                 }
+                else if (node instanceof concepts_1.NewList && !node.typeAnnotation) {
+                    // 匿名函数返回值有可能是newList，需要过滤。代码来源：AnonymousFunction.__ts
+                    const grandParent = node.parentNode?.parentNode?.parentNode;
+                    if (grandParent instanceof concepts_1.CallLogic
+                        && /dataSources\.[^.]+\.entities\.[^.]+\.logics/.test(grandParent.calleeNamespace)
+                        && ['update', 'updateBy', 'createOrUpdate', 'batchUpdate'].includes(grandParent.calleeName)) {
+                        return;
+                    }
+                    const { items } = node || {};
+                    const typeAnnotationMap = {};
+                    // 最多数的类型
+                    let maxTypeAnnotationInfo = {
+                        typeAnnotation: null,
+                        count: 0,
+                    };
+                    if (Array.isArray(items)) {
+                        items.forEach((item) => {
+                            const typeAnnotation = item.__TypeAnnotation;
+                            // 仅处理有类型的情况，返回类型为void的情况由其他地方处理成报错
+                            if (typeAnnotation) {
+                                const sortedTypeKey = typeAnnotation.sortedTypeKey;
+                                if (!typeAnnotationMap[sortedTypeKey]) {
+                                    typeAnnotationMap[sortedTypeKey] = {
+                                        typeAnnotation,
+                                        items: [],
+                                        count: 0,
+                                    };
+                                }
+                                const typeAnnotationInfo = typeAnnotationMap[sortedTypeKey];
+                                typeAnnotationInfo.items.push(item);
+                                typeAnnotationInfo.count++;
+                                const { count } = typeAnnotationInfo;
+                                if (maxTypeAnnotationInfo.count < count) {
+                                    maxTypeAnnotationInfo = {
+                                        typeAnnotation,
+                                        count,
+                                    };
+                                }
+                            }
+                        });
+                    }
+                    const { typeAnnotation: maxTypeAnnotation, } = maxTypeAnnotationInfo;
+                    for (const sortedTypeKey in typeAnnotationMap) {
+                        const { typeAnnotation, items } = typeAnnotationMap[sortedTypeKey];
+                        if (maxTypeAnnotation?.sortedTypeKey !== typeAnnotation?.sortedTypeKey) {
+                            if (Array.isArray(items)) {
+                                items.forEach((item) => {
+                                    const diagnostic = {
+                                        node: item,
+                                        severity: 'warning',
+                                        message: `NewList期望的类型是${maxTypeAnnotation?.headTitle}`,
+                                    };
+                                    this.baseNodeAssignmentTsError(item, diagnostic);
+                                    diagnostics.push(diagnostic);
+                                });
+                            }
+                        }
+                    }
+                }
+                else if (node instanceof concepts_1.NewMap && !node.typeAnnotation) {
+                    const { values } = node || {};
+                    const typeAnnotationMap = {};
+                    // 最多数的类型
+                    let maxTypeAnnotationInfo = {
+                        typeAnnotation: null,
+                        count: 0,
+                    };
+                    if (Array.isArray(values)) {
+                        values.forEach((value) => {
+                            if (!value)
+                                return;
+                            const typeAnnotation = value.__TypeAnnotation;
+                            // 仅处理有类型的情况，返回类型为void的情况由其他地方处理成报错
+                            if (typeAnnotation) {
+                                const sortedTypeKey = typeAnnotation.sortedTypeKey;
+                                if (!typeAnnotationMap[sortedTypeKey]) {
+                                    typeAnnotationMap[sortedTypeKey] = {
+                                        typeAnnotation,
+                                        values: [],
+                                        count: 0,
+                                    };
+                                }
+                                const typeAnnotationInfo = typeAnnotationMap[sortedTypeKey];
+                                typeAnnotationInfo.values.push(value);
+                                typeAnnotationInfo.count++;
+                                const { count } = typeAnnotationInfo;
+                                if (maxTypeAnnotationInfo.count < count) {
+                                    maxTypeAnnotationInfo = {
+                                        typeAnnotation,
+                                        count,
+                                    };
+                                }
+                            }
+                        });
+                    }
+                    const { typeAnnotation: maxTypeAnnotation, } = maxTypeAnnotationInfo;
+                    for (const sortedTypeKey in typeAnnotationMap) {
+                        const { typeAnnotation, values } = typeAnnotationMap[sortedTypeKey];
+                        if (maxTypeAnnotation?.sortedTypeKey !== typeAnnotation?.sortedTypeKey) {
+                            if (Array.isArray(values)) {
+                                values.forEach((value) => {
+                                    const diagnostic = {
+                                        node: value,
+                                        severity: 'warning',
+                                        message: `NewMap中values值所期望的类型是${maxTypeAnnotation?.headTitle}`,
+                                    };
+                                    this.baseNodeAssignmentTsError(value, diagnostic);
+                                    diagnostics.push(diagnostic);
+                                });
+                            }
+                        }
+                    }
+                }
+                else if (node.concept === 'JSBlock') {
+                    // 初始js代码块先屏蔽掉
+                    if (node.code === `location.href = '/';`) {
+                        return null;
+                    }
+                    const diagnostic = {
+                        node,
+                        severity: 'warning',
+                        message: '不建议使用js代码块',
+                    };
+                    diagnostics.push(diagnostic);
+                }
+                else if (node.concept === 'Unparsed') {
+                    const diagnostic = {
+                        node,
+                        severity: 'warning',
+                        message: '不建议使用自定义表达式',
+                    };
+                    diagnostics.push(diagnostic);
+                }
+                else if (node instanceof concepts_1.CallQueryComponent) {
+                    // 可视化查询中不允许有复杂的数据结构
+                    const contentVariables = [];
+                    utils.traverse(({ node }) => {
+                        if (node?.parentNode?.concept !== 'MemberExpression') {
+                            if (node?.concept === 'MemberExpression') {
+                                contentVariables.push(node);
+                            }
+                            else if (node?.concept === 'Identifier') {
+                                // 因为要是父级是MemberExpression， 就放入了父级，子级就不需要了
+                                contentVariables.push(node);
+                                // QueryFromExpression QueryJoinExpression
+                            }
+                            else if (node?.concept === 'QueryFieldExpression' || node?.concept === 'QueryGroupByExpression') {
+                                contentVariables.push(node);
+                            }
+                        }
+                    }, { node }, {
+                        mode: 'anyObject',
+                        excludedKeySet: new Set(['parentNode', '_events', 'globalDataMap', 'havingPlayground', 'wherePlayground']),
+                    });
+                    contentVariables?.forEach((variable) => {
+                        // 如果是复杂数据结构
+                        if (variable.__TypeAnnotation?.isComplexType()) {
+                            const diagnostic = {
+                                node,
+                                severity: 'warning',
+                                message: `数据查询中不可以使用复杂类型！当前类型：${variable.__TypeAnnotation?.typeChineseTitle}。`,
+                            };
+                            this.baseNodeAssignmentTsError(variable, diagnostic);
+                            diagnostics.push(diagnostic);
+                        }
+                    });
+                }
             });
         }
         return diagnostics;
     }
+    // 是否包含组件逻辑
+    hasComponentLogics(expression) {
+        let flag = false;
+        (0, utils_1.traverse)((current) => {
+            const { node } = current || {};
+            const { concept } = node || {};
+            if (concept === 'CallLogic') {
+                // 调用组件逻辑
+                if (node.isComponentLogic) {
+                    flag = true;
+                }
+                else if (node.isViewLogic) { // 调用页面逻辑
+                    const logicNode = node.view?.logics?.find?.((viewLogic) => viewLogic.name === node.calleeName);
+                    if (logicNode) {
+                        if (this.logicSetWithComponentLogic.has(logicNode.nodePath)) {
+                            flag = true;
+                        }
+                        else {
+                            const logicItem = logicNode.body?.find?.((logicItem) => this.hasComponentLogics(logicItem));
+                            if (logicItem) {
+                                flag = true;
+                                this.logicSetWithComponentLogic.add(logicNode.nodePath);
+                            }
+                        }
+                    }
+                }
+            }
+        }, {
+            node: expression,
+        }, {
+            mode: 'anyObject',
+            excludedKeySet: new Set([
+                'parentNode',
+                'sourceMap',
+                'storageJSON',
+                'tsErrorDetail',
+                'NaslAnnotatedJSON',
+                'calledFrom',
+                '_events',
+                '_collectingList',
+                '_historyList',
+            ]),
+        });
+        return flag;
+    }
     /**
      * 额外的诊断
      * @param fileNode 文件级别的节点
      * @returns 诊断结果
      */
     _attachDiagnostics(fileNode) {
+        // 每次诊断前先清空这个Set
+        this.logicSetWithComponentLogic = new Set();
         const diagnostics = [];
         if (fileNode instanceof concepts_1.View) {
-            // 判断页面是否已经删除
-            let removed = false;
-            let curNode = fileNode;
-            // 递归检查，防止从顶层页面开始删除影响子页面内容检查
-            while (curNode instanceof concepts_1.View && !removed) {
-                if (curNode.parentNode instanceof concepts_1.View && !curNode.parentNode.children.includes(curNode)
-                    || curNode.parentNode instanceof concepts_1.Frontend && !curNode.parentNode.views.includes(curNode)) {
-                    removed = true;
-                }
-                curNode = curNode.parentNode;
-            }
-            if (removed)
-                return diagnostics;
             fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof concepts_1.ViewElement && node.view === fileNode) {
                     if (node.tag) {
@@ -990,7 +1280,13 @@ class NaslServer {
                                 if (node.logic && node.logic !== nodeIn.logic)
                                     return;
                                 // 跟变量无关的赋值过滤
-                                const jsCode = nodeIn.toJS();
+                                let jsCode = '';
+                                try {
+                                    jsCode = nodeIn.toJS();
+                                }
+                                catch (err) {
+                                    console.log(err);
+                                }
                                 if (!jsCode.includes(`${node.name} = `))
                                     return;
                                 // 页面局部变量
@@ -1027,7 +1323,7 @@ class NaslServer {
                             }
                         });
                         if (!msg)
-                            msg = '未设置类型或未赋值，直接赋值系统会自动推断类型。';
+                            msg = '未设置类型或未赋值。直接赋值系统可以自动推断类型。';
                         const diagnostic = {
                             node,
                             severity: 'error',
@@ -1037,6 +1333,31 @@ class NaslServer {
                         diagnostics.push(diagnostic);
                     }
                 }
+                else if (node instanceof concepts_1.BindAttribute || node instanceof concepts_1.BindDirective || node instanceof concepts_1.BindStyle) {
+                    if (Array.isArray(node.bindExpressions)) {
+                        const exp = node.bindExpressions.find((bindExpression) => this.hasComponentLogics(bindExpression));
+                        if (exp) {
+                            //const element: any = node.getAncestor('ViewElement');
+                            //const api = config.allNodesAPI[element?.tag];
+                            //const attr = api?.attrs?.find?.((attr) => {
+                            //    return attr.name === node.name;
+                            //});
+                            const map = {
+                                BindAttribute: '属性',
+                                BindDirective: '指令',
+                                BindStyle: '样式属性',
+                            };
+                            //“${attr?.title || node.title || node.name}”
+                            const diagnostic = {
+                                node,
+                                severity: 'error',
+                                message: `${map[node.concept]}表达式不能绑定组件逻辑`,
+                            };
+                            node.tsErrorDetail = diagnostic;
+                            diagnostics.push(diagnostic);
+                        }
+                    }
+                }
                 else {
                     this.checkNodeError(node, diagnostics);
                 }
@@ -1107,9 +1428,6 @@ class NaslServer {
             }
         }
         if (fileNode instanceof concepts_1.Logic) {
-            // 判断逻辑是否已经删除
-            if (fileNode.parentNode instanceof concepts_1.App && !fileNode.parentNode.logics.includes(fileNode))
-                return diagnostics;
             fileNode?.sourceMap.forEach((value, node) => {
                 //OQL支持返回复合类型数据了
                 // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
@@ -1122,23 +1440,49 @@ class NaslServer {
                 //     node.tsErrorDetail = diagnostic;
                 //     diagnostics.push(diagnostic);
                 // }
+                if (node instanceof concepts_1.OqlQueryComponent) {
+                    // 自动推导情况
+                    const typeAnnotation = (0, formatTsUtils_1.type2TypeAnnotation)(node.__nodeType);
+                    if (!node.typeAnnotation && typeAnnotation) {
+                        if (typeAnnotation.typeName === 'List' && typeAnnotation.typeKind === 'generic') {
+                            const typeArguments = typeAnnotation.typeArguments;
+                            if (typeArguments.length && typeArguments[0].isComplexType()) {
+                                const diagnostic = {
+                                    node,
+                                    severity: 'error',
+                                    message: `SQL查询：返回类型不支持单个复杂类型 ${typeArguments[0].headTitle}。`,
+                                };
+                                node.tsErrorDetail = diagnostic;
+                                diagnostics.push(diagnostic);
+                            }
+                        }
+                    }
+                }
                 if (node instanceof concepts_1.Return || node instanceof concepts_1.Variable) {
                     if (!node.typeAnnotation && !node.__TypeAnnotation) {
                         const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
                         let used = false;
                         fileNode?.sourceMap.forEach((valueIn, nodeIn) => {
                             if (!used && nodeIn
-                                && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.Assignment && nodeIn.left?.name))
-                                && nodeIn.toJS().includes(`${node.name} = `)) {
-                                used = true;
-                                if (!nodeIn.tsErrorDetail) {
-                                    const diagnostic = {
-                                        node: nodeIn,
-                                        severity: 'error',
-                                        message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
-                                    };
-                                    nodeIn.tsErrorDetail = diagnostic;
-                                    diagnostics.push(diagnostic);
+                                && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.Assignment && nodeIn.left?.name))) {
+                                let jsCode = '';
+                                try {
+                                    jsCode = nodeIn.toJS();
+                                }
+                                catch (err) {
+                                    console.log(err);
+                                }
+                                if (jsCode.includes(`${node.name} = `)) {
+                                    used = true;
+                                    if (!nodeIn.tsErrorDetail) {
+                                        const diagnostic = {
+                                            node: nodeIn,
+                                            severity: 'error',
+                                            message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                                        };
+                                        nodeIn.tsErrorDetail = diagnostic;
+                                        diagnostics.push(diagnostic);
+                                    }
                                 }
                             }
                         });
@@ -1225,6 +1569,19 @@ class NaslServer {
                 }
             });
         }
+        if (node instanceof concepts_1.MatchCase && node.getAncestor('Match')?.isExpression && node.body.length === 0) {
+            // 如果不是其他就标红
+            if ((node?.getIndexOfParent() !== (node.getAncestor('Match')?.cases?.length || 0) - 1)) {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配分支：返回内容不能为空',
+                    titleTip: '返回内容不能为空',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
+        }
         // 如果节点是match的patterns 里的
         if (node?.parentKey === 'patterns' && node.parentNode instanceof concepts_1.MatchCase) {
             const matchNode = node.getAncestor('Match');
@@ -1300,11 +1657,58 @@ class NaslServer {
             const diagnostic = {
                 node,
                 severity: 'error',
-                message: `类型不一致，当前内置函数${node.calleeName || ''}无返回值。`,
+                message: `类型不匹配，传入类型：void`,
             };
             node.tsErrorDetail = diagnostic;
             diagnostics.push(diagnostic);
         }
+        // newMap key或者value没填都要有报错
+        if (node instanceof concepts_1.NewMap) {
+            // 如果一项没有key 或者没有 value 就报错
+            const findFlag = node.keys?.some((key, index) => !key || !node.values?.[index]);
+            if (findFlag) {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: `新建Map的key和value应该都必填`,
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
+        }
+        // 赋值语句左右list 和 map等可以 必须都一样
+        if (node instanceof concepts_1.Assignment && !node.tsErrorDetail) {
+            const leftType = node.left?.__TypeAnnotation || {};
+            const rightType = node.right?.__TypeAnnotation || {};
+            // 如果左边节点是 泛型，而且 左边泛型的名字 和 右边一样， 而且是list 或者map 就强制报错
+            // 而且右边原来没有报错
+            if (leftType.typeKind === 'generic' && leftType.typeKind === rightType.typeKind && leftType.typeName === rightType.typeName && ['Map', 'List'].includes(leftType.typeName)) {
+                if (!(node.right.tsErrorDetail) && leftType.sortedTypeKey !== rightType.sortedTypeKey) {
+                    const excludeList = [
+                        'nasl.collection.List<nasl.core.String>',
+                        'nasl.collection.List<nasl.core.Text>',
+                        'nasl.collection.List<nasl.core.Email>',
+                        'nasl.collection.Map<nasl.core.String, nasl.core.String>',
+                        'nasl.collection.Map<nasl.core.String, nasl.core.Text>',
+                        'nasl.collection.Map<nasl.core.String, nasl.core.Email>',
+                    ];
+                    // 先特殊处理等 类型合并后就可以去掉了
+                    if (excludeList.includes(leftType.sortedTypeKey) && excludeList.includes(rightType.sortedTypeKey)) {
+                        return null;
+                    }
+                    else if (['nasl.collection.List<>'].includes(leftType.sortedTypeKey) || ['nasl.collection.List<>'].includes(rightType.sortedTypeKey)) {
+                        return null;
+                    }
+                    const diagnostic = {
+                        node: node.right,
+                        severity: 'error',
+                        message: `左右参数类型不一致！左边类型：${leftType.typeChineseTitle}，右边类型：${rightType.typeChineseTitle}。`,
+                    };
+                    node.right.tsErrorDetail = diagnostic;
+                    diagnostics.push(diagnostic);
+                }
+            }
+        }
     }
     /* 接口导入查找 */
     existStructureFix(semanticDiagnostics, node, that) {
@@ -1371,7 +1775,7 @@ class NaslServer {
      */
     _resolveDiagnostic(diagnostic, fileNode, record) {
         // 拓展模块中的翻译先过滤掉，因为有错用户也不能修改
-        if (fileNode.module)
+        if (fileNode.module && !(fileNode instanceof concepts_1.ConfigProperty))
             return;
         const minRange = this._findMinRange(diagnostic, fileNode);
         const tsErrorDetail = {
@@ -1592,6 +1996,53 @@ class NaslServer {
                 refsList = [...methodRefs];
             }
         }
+        if (node instanceof concepts_1.Process) {
+            if (currentSource) {
+                const code = currentSource.code;
+                const prefix = '__ProcessIdentification__';
+                let positions = [];
+                let pos = code.indexOf(prefix);
+                while (pos !== -1) {
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                }
+                positions.shift();
+                // 拿到标识下定义的const process = {...}
+                positions = positions.map((position) => code.indexOf('const', position + prefix.length));
+                const promises = positions.map((item) => this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
+        if (node instanceof concepts_1.ProcessElement) {
+            if (currentSource) {
+                const code = currentSource.code;
+                const prefix = '__ProcessIdentification__';
+                let positions = [];
+                let pos = code.indexOf(prefix);
+                while (pos !== -1) {
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                }
+                // 拿到标识下定义的const process = {...}
+                positions = positions.map((position) => code.indexOf(`${node.name}:`, position + prefix.length));
+                const promises = positions.map((item) => this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
         // console.log(refsList, 'refsList');
         return refsList;
     }
@@ -2241,12 +2692,15 @@ class NaslServer {
         // 如果没有sourceMap,就继续向上找 ,或者到module结束
         // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
         // 如果当前节点是view就不要向上查找了
+        // 配置参数的ConfigProperty也不需要向上找
         while (!sourceMap
             && fileNode
             && !(fileNode.parentNode instanceof concepts_1.App)
             && !(fileNode.parentNode instanceof concepts_1.Module)
             && !(fileNode.parentNode instanceof concepts_1.DataSource)
-            && !(fileNode instanceof concepts_1.View)) {
+            && !(fileNode.parentNode instanceof concepts_1.Frontend)
+            && !(fileNode instanceof concepts_1.View)
+            && !(fileNode instanceof concepts_1.ConfigProperty)) {
             fileNode = fileNode.parentNode;
             sourceMap = fileNode?.sourceMap;
         }
@@ -2334,7 +2788,7 @@ class NaslServer {
      * @returns 不需要去查就可以返回类型的节点
      */
     getCurrentNodeKnownTypeAnnotation(node) {
-        if (node.concept === 'StringLiteral' || node.concept === 'BooleanLiteral' || node.concept === 'NullLiteral') {
+        if (node.concept === 'StringLiteral' || node.concept === 'StringInterpolation' || node.concept === 'BooleanLiteral' || node.concept === 'NullLiteral') {
             let type = 'String';
             switch (node.concept) {
                 case 'NullLiteral':
@@ -2434,6 +2888,9 @@ class NaslServer {
                 'NewComposite',
                 'NewList',
                 'NewMap',
+                'OqlQueryComponent',
+                'QueryFieldExpression',
+                'QueryGroupByExpression',
             ].includes(node.concept))
                 return;
             // 要去ls那边获取的
@@ -2468,7 +2925,7 @@ class NaslServer {
                 }
                 fileDetail.offset = fileDetail.offset + indexOf;
             }
-            else if (node.concept === 'MemberExpression' || node.concept === 'Identifier') {
+            else if (node.concept === 'MemberExpression' || node.concept === 'Identifier' || node.concept === 'QueryFieldExpression' || node.concept === 'QueryGroupByExpression') {
                 if (item.code.includes('.')) {
                     const codeArr = item.code?.split('.');
                     const lastLen = codeArr?.[codeArr.length - 1]?.length;
@@ -2479,7 +2936,12 @@ class NaslServer {
             }
             else if (node.concept === 'Match') {
                 // 去查return 后面的返回值，变成函数调用
-                fileDetail.line = item.range.end.line - 1;
+                if (item.code?.endsWith(';\n')) {
+                    fileDetail.line = item.range.end.line - 1;
+                }
+                else {
+                    fileDetail.line = item.range.end.line;
+                }
                 const indexOf = item.code.indexOf('return __MatchExpressionFuntion');
                 let newCode = item.code.substring(0, indexOf);
                 newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
@@ -2492,6 +2954,9 @@ class NaslServer {
                 newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
                 fileDetail.offset = newCode.length + 'return '.length;
             }
+            else if (['OqlQueryComponent'].includes(node.concept)) {
+                fileDetail.offset += 10;
+            }
             args.push(fileDetail);
         });
         console.time('请求');
@@ -2529,8 +2994,8 @@ class NaslServer {
                 // 直接从最后一项的返回值取，有就有没有就没有
                 if (node.body?.length) {
                     const last = node.body[node.body.length - 1];
-                    if (last.__TypeAnnotation) {
-                        types.set(node, last.__TypeAnnotation);
+                    if (types.get(last)) {
+                        types.set(node, types.get(last));
                     }
                 }
             }
@@ -2541,6 +3006,19 @@ class NaslServer {
                 // 因为node可能是经过处理的TypeAnnotation
                 node.__isCorrectTypeAnnotation = true;
                 if (value) {
+                    if (node instanceof concepts_1.OqlQueryComponent) {
+                        // 自动推导情况
+                        const typeAnnotation = value;
+                        if (!node.typeAnnotation && typeAnnotation) {
+                            if (typeAnnotation.typeName === 'List' && typeAnnotation.typeKind === 'generic') {
+                                const typeArguments = typeAnnotation.typeArguments;
+                                if (typeArguments.length && typeArguments[0].isComplexType()) {
+                                    node.__TypeAnnotation = null;
+                                    return;
+                                }
+                            }
+                        }
+                    }
                     if (value instanceof concepts_1.TypeAnnotation) {
                         node.__TypeAnnotation = Object.freeze(value);
                     }
@@ -2548,6 +3026,10 @@ class NaslServer {
                         node.__TypeAnnotation = Object.freeze(value.typeAnnotation);
                     }
                 }
+                else {
+                    // 清空原来已经赋值上去的类型，可能原来有现在没有了
+                    node.__TypeAnnotation = null;
+                }
             }
             catch (err) {
                 if (globalThis.window) {
@@ -2761,6 +3243,10 @@ class NaslServer {
                     jsonNode.typeAnnotation = value.toJSON();
                 }
             }
+            if (node instanceof concepts_1.NewComposite && node.typeAnnotation.typeKind === 'anonymousStructure') {
+                const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                jsonNode.typeAnnotation = value.toJSON();
+            }
         });
     }
     /**
@@ -2901,6 +3387,12 @@ class NaslServer {
         // 如果是要删除的内容，就是当前的file节点，要关闭当前文件，就把内容置为空
         if (fileNode === targetNode) {
             outputFiles = [{ file: filePath, fileContent: '' }];
+            // 去掉原来存储的当前节点的nasl内存的存储,和错误的存储
+            // 已经删除的就不用在去check错误了
+            // check就会去取类型啥的，没有必要
+            this.diagnosticManager.deleteOwn(fileNode.id);
+            // 删除文件同时删除ls存储nasl 的引用
+            this.file2NodeMap.delete(filePath);
         }
         else {
             // 如果是要删除logic一个小内容，要覆盖全部内容
@@ -2928,13 +3420,17 @@ class NaslServer {
             line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
             offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
         });
-        newRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+        const files = new Set();
+        newRefs.refs.forEach((ref) => {
+            this.filesToCheck.add(ref.file);
+            files.add(ref.file);
+        });
         // 唤起建立连接弹框
         // 文件级别的建立连接采取提醒
         if (action === 'create' && targetNode.__init) {
             // 清除临时状态, 完成本次创建
             delete targetNode.__init;
-            if (fileNode === targetNode && this.filesToCheck.size > 1) {
+            if (fileNode === targetNode && files.size > 1) {
                 const confirmParms = {
                     actionType: 'createEstablishConnection',
                     node: fileNode,