@lcap/nasl 2.20.0-beta.2 → 2.20.0-beta.4

package/src/server/naslServer.ts

@@ -62,6 +62,14 @@ import {
     BatchAssignment,
     ForEachStatement,
     Frontend,
+    NewList,
+    NewMap,
+    ConfigProperty,
+    BindStyle,
+    BindDirective,
+    LogicItem,
+    JSBlock,
+    NewComposite,
 } from '../concepts';
 import { lsp2tspNumber, SourceMap, SourceMapItem } from '../translator';
 import axios from '../service/storage';
@@ -71,16 +79,20 @@ import { DiagnosticRecord, Diagnostic, DiagnosticManager } from '../manager/diag
 import formatUiTs from './createUiTs';
 import { primitiveTypeList } from '../concepts/basics/types/coreTypeList';
 import { getPlatformType, type2TypeAnnotation } from './formatTsUtils';
+import * as utils from '../utils';
 import naslStdlibMap from './naslStdlibMap';
 import * as jsoner from '../service/storage/jsoner';
 import { EventEmitter } from '../common/EventEmitter';
 
+import { traverse } from '../utils';
+
 const EmbeddedTSFileLineMap: { [name: string]: number } = {
     Entity: 3,
 };
 
 const EmbeddedTSFileOffsetMap: { [name: string]: number } = {
     Variable: 12,
+    ConfigProperty: 12,
 };
 
 export interface FileNode extends BaseNode {
@@ -169,6 +181,9 @@ export class NaslServer {
 
     singleFileChangeIng: Boolean;
 
+    // 包含组件逻辑调用的逻辑map
+    logicSetWithComponentLogic: Set<string> = new Set<string>();
+
     constructor() {
         /// #if process.env.BUILD_TARGET === 'node'
         if (globalThis.process) // For TS build
@@ -177,6 +192,7 @@ export class NaslServer {
         /// #endif
         /// #if process.env.BUILD_TARGET !== 'node'
         if (globalThis.window) // For TS build
+            /* !!!如果改动这里需要看下关联的对应文件：webpack/ts-worker/loader.js */
             this.worker = new Worker('/ts-worker.js');
         /// #endif
 
@@ -386,6 +402,21 @@ export 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: View[], results: Array<ReturnType<Structure['toEmbeddedTSFile']>>) {
@@ -788,6 +819,14 @@ export class NaslServer {
         // diagnosticManager.pushAll(records);
     }
 
+    /**
+     * 节点异常是只能挂载单个，如果已经了就不赋值了
+     */
+    baseNodeAssignmentTsError(node: BaseNode, tsErrorDetail: Diagnostic) {
+        if (node.tsErrorDetail)
+            return;
+        node.tsErrorDetail = tsErrorDetail;
+    }
     /**
      * 处理诊断结果
      * @param records 结果
@@ -846,6 +885,41 @@ export class NaslServer {
                 .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) {
@@ -859,11 +933,49 @@ export 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 as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode, 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 as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode, 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 as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode);
+                        if (minRange) {
+                            /**
+                             * 如果节点是入参类型
+                             * 而且不是foreach中
+                             * 而且不是事件逻辑的入参
+                             */
+                            if (minRange.node instanceof 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 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));
         });
@@ -878,22 +990,6 @@ export class NaslServer {
     _attachSuggestionDiagnostics(fileNode: BaseNode): Diagnostic[] {
         const diagnostics: Diagnostic[] = [];
         if (fileNode instanceof Logic || fileNode instanceof View) {
-            // 判断逻辑是否已经删除
-            if (fileNode instanceof Logic && fileNode.parentNode instanceof App && !fileNode.parentNode.logics.includes(fileNode))
-                return diagnostics;
-            // 判断页面是否已经删除
-            let removed = false;
-            let curNode: Logic | View | App | Frontend = fileNode;
-            // 递归检查，防止从顶层页面开始删除影响子页面内容检查
-            while (curNode instanceof View && !removed) {
-                if (curNode.parentNode instanceof View && !curNode.parentNode.children.includes(curNode)
-                    || curNode.parentNode instanceof Frontend && !curNode.parentNode.views.includes(curNode)) {
-                    removed = true;
-                }
-                curNode = curNode.parentNode as View | Frontend;
-            }
-            if (removed)
-                return diagnostics;
             fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof Match) {
                     const { cases, expression } = node || {};
@@ -1009,41 +1105,237 @@ export class NaslServer {
                                         const lastExpression = body[body.length - 1];
                                         diagnostic.node = lastExpression;
                                         diagnostic.message = `${lastExpression?.toUI()}期望的类型是${maxTypeAnnotation?.headTitle}`;
-                                        lastExpression.tsErrorDetail = diagnostic;
+                                        this.baseNodeAssignmentTsError(lastExpression, diagnostic);
                                         diagnostics.push(diagnostic);
                                     }
                                 });
                             }
                         }
                     }
+                } else if (node instanceof NewList && !node.typeAnnotation) {
+                    // 匿名函数返回值有可能是newList，需要过滤。代码来源：AnonymousFunction.__ts
+                    const grandParent = node.parentNode?.parentNode?.parentNode;
+                    if (grandParent instanceof CallLogic
+                        && /dataSources\.[^.]+\.entities\.[^.]+\.logics/.test(grandParent.calleeNamespace)
+                        && ['update', 'updateBy', 'createOrUpdate', 'batchUpdate'].includes(grandParent.calleeName)) {
+                        return;
+                    }
+                    const { items } = node || {};
+                    const typeAnnotationMap: any = {};
+                    // 最多数的类型
+                    let maxTypeAnnotationInfo: any = {
+                        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 NewMap && !node.typeAnnotation) {
+                    const { values } = node || {};
+                    const typeAnnotationMap: any = {};
+                    // 最多数的类型
+                    let maxTypeAnnotationInfo: any = {
+                        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 as JSBlock).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 CallQueryComponent) {
+                    // 可视化查询中不允许有复杂的数据结构
+                    const contentVariables: Array<Identifier | MemberExpression> = [];
+                    utils.traverse(({ node }) => {
+                        if ((node as any)?.parentNode?.concept !== 'MemberExpression') {
+                            if ((node as any)?.concept === 'MemberExpression') {
+                                contentVariables.push(node as any);
+                            } else if ((node as any)?.concept === 'Identifier') {
+                                // 因为要是父级是MemberExpression， 就放入了父级，子级就不需要了
+                                contentVariables.push(node as any);
+                                // QueryFromExpression QueryJoinExpression
+                            } else if ((node as any)?.concept === 'QueryFieldExpression' || (node as any)?.concept === 'QueryGroupByExpression') {
+                                contentVariables.push(node as any);
+                            }
+                        }
+                    }, { 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: BaseNode) {
+        let flag = false;
+        traverse((current: any) => {
+            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: Logic) => viewLogic.name === node.calleeName);
+                    if (logicNode) {
+                        if (this.logicSetWithComponentLogic.has(logicNode.nodePath)) {
+                            flag = true;
+                        } else {
+                            const logicItem = logicNode.body?.find?.((logicItem: 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: BaseNode): Diagnostic[] {
+        // 每次诊断前先清空这个Set
+        this.logicSetWithComponentLogic = new Set<string>();
         const diagnostics: Diagnostic[] = [];
         if (fileNode instanceof View) {
-            // 判断页面是否已经删除
-            let removed = false;
-            let curNode: View | App | Frontend = fileNode;
-            // 递归检查，防止从顶层页面开始删除影响子页面内容检查
-            while (curNode instanceof View && !removed) {
-                if (curNode.parentNode instanceof View && !curNode.parentNode.children.includes(curNode)
-                    || curNode.parentNode instanceof Frontend && !curNode.parentNode.views.includes(curNode)) {
-                    removed = true;
-                }
-                curNode = curNode.parentNode as View | Frontend;
-            }
-            if (removed)
-                return diagnostics;
-
             fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof ViewElement && node.view === fileNode) {
                     if (node.tag) {
@@ -1123,7 +1415,7 @@ export class NaslServer {
                             }
                         });
                         if (!msg)
-                            msg = '未设置类型或未赋值，直接赋值系统会自动推断类型。';
+                            msg = '未设置类型或未赋值。直接赋值系统可以自动推断类型。';
                         const diagnostic = {
                             node,
                             severity: 'error',
@@ -1132,6 +1424,30 @@ export class NaslServer {
                         node.tsErrorDetail = diagnostic;
                         diagnostics.push(diagnostic);
                     }
+                } else if (node instanceof BindAttribute || node instanceof BindDirective || node instanceof 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);
                 }
@@ -1198,10 +1514,6 @@ export class NaslServer {
             }
         }
         if (fileNode instanceof Logic) {
-            // 判断逻辑是否已经删除
-            if (fileNode.parentNode instanceof App && !fileNode.parentNode.logics.includes(fileNode))
-                return diagnostics;
-
             fileNode?.sourceMap.forEach((value, node) => {
                 //OQL支持返回复合类型数据了
                 // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
@@ -1214,6 +1526,24 @@ export class NaslServer {
                 //     node.tsErrorDetail = diagnostic;
                 //     diagnostics.push(diagnostic);
                 // }
+                if (node instanceof OqlQueryComponent) {
+                    // 自动推导情况
+                    const typeAnnotation = type2TypeAnnotation((node as any).__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 Return || node instanceof Variable) {
                     if (!node.typeAnnotation && !node.__TypeAnnotation) {
                         const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
@@ -1257,7 +1587,7 @@ export class NaslServer {
         return diagnostics;
     }
 
-    checkNodeError(node: BaseNode, diagnostics: Diagnostic[]) {
+    checkNodeError(node: BaseNode, diagnostics: Diagnostic[]): any {
         if (!node)
             return;
         // 如果节点是match的看看节点里是不是有重复的
@@ -1313,6 +1643,19 @@ export class NaslServer {
                 }
             });
         }
+        if (node instanceof MatchCase && (node.getAncestor('Match') as Match)?.isExpression && node.body.length === 0) {
+            // 如果不是其他就标红
+            if ((node?.getIndexOfParent() !== ((node.getAncestor('Match') as 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 MatchCase) {
             const matchNode = node.getAncestor('Match');
@@ -1385,11 +1728,55 @@ export class NaslServer {
             const diagnostic = {
                 node,
                 severity: 'error',
-                message: `类型不一致，当前内置函数${node.calleeName || ''}无返回值。`,
+                message: `类型不匹配，传入类型：void`,
             };
             node.tsErrorDetail = diagnostic;
             diagnostics.push(diagnostic);
         }
+        // newMap key或者value没填都要有报错
+        if (node instanceof 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 Assignment && !node.tsErrorDetail) {
+            const leftType = node.left?.__TypeAnnotation || {} as TypeAnnotation;
+            const rightType = node.right?.__TypeAnnotation || {} as 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;
+                    }
+                    const diagnostic = {
+                        node: node.right,
+                        severity: 'error',
+                        message: `左右参数类型不一致！左边类型：${leftType.typeChineseTitle}，右边类型：${rightType.typeChineseTitle}。`,
+                    };
+                    node.right.tsErrorDetail = diagnostic;
+                    diagnostics.push(diagnostic);
+                }
+            }
+        }
     }
 
     /* 接口导入查找 */
@@ -1457,7 +1844,7 @@ export class NaslServer {
      */
     _resolveDiagnostic(diagnostic: tsProtocol.DiagnosticWithFileName, fileNode: FileNode, record: DiagnosticRecord): Diagnostic {
         // 拓展模块中的翻译先过滤掉，因为有错用户也不能修改
-        if ((fileNode as any).module)
+        if ((fileNode as any).module && !(fileNode instanceof ConfigProperty))
             return;
 
         const minRange = this._findMinRange(diagnostic, fileNode);
@@ -1684,6 +2071,53 @@ export class NaslServer {
                 refsList = [...methodRefs];
             }
         }
+        if (node instanceof 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 as FileNode).getEmbeddedFilePath(),
+                    line: lsp2tspNumber(currentSource.range.start.line),
+                    offset: lsp2tspNumber(currentSource.range.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
+        if (node instanceof 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 as FileNode).getEmbeddedFilePath(),
+                    line: lsp2tspNumber(currentSource.range.start.line),
+                    offset: 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;
     }
@@ -2334,6 +2768,7 @@ export class NaslServer {
         // 如果没有sourceMap,就继续向上找 ,或者到module结束
         // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
         // 如果当前节点是view就不要向上查找了
+        // 配置参数的ConfigProperty也不需要向上找
         while (
             !sourceMap
             && fileNode
@@ -2341,6 +2776,7 @@ export class NaslServer {
             && !(fileNode.parentNode instanceof Module)
             && !(fileNode.parentNode instanceof DataSource)
             && !(fileNode instanceof View)
+            && !(fileNode instanceof ConfigProperty)
         ) {
             fileNode = fileNode.parentNode;
             sourceMap = fileNode?.sourceMap;
@@ -2434,7 +2870,7 @@ export class NaslServer {
      * @returns 不需要去查就可以返回类型的节点
      */
     getCurrentNodeKnownTypeAnnotation(node: BaseNode) {
-        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':
@@ -2544,6 +2980,9 @@ export class NaslServer {
                 'NewComposite',
                 'NewList',
                 'NewMap',
+                'OqlQueryComponent',
+                'QueryFieldExpression',
+                'QueryGroupByExpression',
             ].includes(node.concept))
                 return;
             // 要去ls那边获取的
@@ -2575,7 +3014,7 @@ export class NaslServer {
                     indexOf = subStr.length - lastLen;
                 }
                 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;
@@ -2596,6 +3035,8 @@ export class NaslServer {
                 let newCode = item.code.substring(0, indexOf);
                 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);
         });
@@ -2648,11 +3089,27 @@ export class NaslServer {
                 // 因为node可能是经过处理的TypeAnnotation
                 node.__isCorrectTypeAnnotation = true;
                 if (value) {
+                    if (node instanceof OqlQueryComponent) {
+                        // 自动推导情况
+                        const typeAnnotation = value as TypeAnnotation;
+                        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 TypeAnnotation) {
                         node.__TypeAnnotation = (Object.freeze(value) as TypeAnnotation);
                     } else if (value.typeAnnotation) {
                         node.__TypeAnnotation = (Object.freeze(value.typeAnnotation) as TypeAnnotation);
                     }
+                } else {
+                    // 清空原来已经赋值上去的类型，可能原来有现在没有了
+                    node.__TypeAnnotation = null;
                 }
             } catch (err) {
                 if (globalThis.window) {
@@ -2878,6 +3335,10 @@ export class NaslServer {
                     jsonNode.typeAnnotation = (value as TypeAnnotation).toJSON();
                 }
             }
+            if (node instanceof NewComposite && node.typeAnnotation.typeKind === 'anonymousStructure') {
+                const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                jsonNode.typeAnnotation = (value as TypeAnnotation).toJSON();
+            }
         });
     }
 
@@ -3023,6 +3484,13 @@ export 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一个小内容，要覆盖全部内容
             // 其余要删除的都是把原来的file节点的内容全部覆盖一把
@@ -3054,13 +3522,17 @@ export class NaslServer {
             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 as any).__init) {
             // 清除临时状态, 完成本次创建
             delete (targetNode as any).__init;
-            if (fileNode === targetNode && this.filesToCheck.size > 1) {
+            if (fileNode === targetNode && files.size > 1) {
                 const confirmParms = {
                     actionType: 'createEstablishConnection',
                     node: fileNode,