@lcap/nasl 2.16.1 → 2.17.1

package/src/server/naslServer.ts

@@ -53,6 +53,7 @@ import {
     NumericLiteral,
     BinaryExpression,
     CallFunction,
+    BatchAssignment,
 } from '../concepts';
 import { lsp2tspNumber, SourceMap, SourceMapItem, embeddedTSEmitter } from '../translator';
 import axios from '../service/storage';
@@ -61,8 +62,7 @@ import { EventPayload, invokeCommand, registerCommand } from '../common';
 import { DiagnosticRecord, Diagnostic, default as diagnosticManager } from '../manager/diagnostic';
 import formatUiTs from './createUiTs';
 import { primitiveTypeList } from '../concepts/basics/types/coreTypeList';
-import { traverse } from '../utils';
-import { getPlatformType, displayString2TypeAnnotation } from './formatTsUtils';
+import { getPlatformType, type2TypeAnnotation } from './formatTsUtils';
 import naslStdlibMap from './naslStdlibMap';
 import * as jsoner from '../service/storage/jsoner';
 
@@ -106,9 +106,10 @@ const messager = new Messager({
     context: this,
     getReceiver: () => worker as any,
     getSender: () => worker as any,
-    handleMessage({ data }: any) {
+    handleMessage: async ({ data }: any) => {
         if (data && data.event === 'publishDiagnostics') {
-            diagnosticManager.pushAll(naslServer._resolveDiagnosticRecords(data.records));
+            const records = await naslServer._resolveDiagnosticRecords(data.records);
+            diagnosticManager.pushAll(records);
         }
     },
 });
@@ -322,6 +323,8 @@ const naslServer = {
         await naslServer.openApp(app);
         // 重新check一遍所有内容
         await naslServer.getDiagnosticRecordsAndPushAll();
+        // 重新补一遍标注
+        await naslServer.createdNaslAnnotatedJSON(app);
     },
     /**
      * 初始化之前添加文件
@@ -439,7 +442,7 @@ const naslServer = {
      * @param node 传入当前已经选择的变量
      * @returns 可以选择的类型数组
      */
-    async getTypeQuickinfo(node: BaseNode) {
+    async getConvertTypeInfo(node: BaseNode) {
         if (node && node instanceof BaseNode) {
             const callFunction = node.parentNode.parentNode;
             /**
@@ -500,10 +503,19 @@ const naslServer = {
         });
         if (quickInfo.responseRequired) {
             const displayString = quickInfo?.response?.displayString || '';
+
             const flag = displayString.includes('<') && displayString.includes('>');
             const types = /\<([^()]+)\>/g.exec(displayString);
             let typeStr = types && types[1];
+
             if (flag) {
+                // 自定义结构的展示
+                if (typeStr.includes('__name: "AStructure_')) {
+                    return typeStr.replaceAll(' ', '')
+                        .replaceAll('\n', '')
+                        .replace(/__name:"AStructure_\w{8}";/g, '')
+                        .replace(/dataSources.([^.]+).entities.([^;]+)/g, ($1, $2, $3) => (`${$3}(${$2})`));
+                }
                 let str = '';
                 // 取出T的值
                 typeStr = getPlatformType(typeStr);
@@ -548,6 +560,20 @@ const naslServer = {
         const result = await this._getQuickInfoFull(args);
         return result;
     },
+    _getTypeFull(args: Array<any>) {
+        return this.messager.requestCommand('typeFull', args) as unknown as { responseRequired: boolean; response: tsProtocol.QuickInfoResponseBody };
+    },
+    _getTypeBatch(args: Array<any>) {
+        return this.messager.requestCommand('typeBatch', args) as unknown as { responseRequired: boolean; response: tsProtocol.QuickInfoResponseBody };
+    },
+    async getNaslNodeTypeFull(args: Array<any>) {
+        const result = await this._getTypeFull(args);
+        return result;
+    },
+    async getNaslNodeTypeBatch(args: Array<any>) {
+        const result = await this._getTypeBatch(args);
+        return result;
+    },
     /**
      * 获取已经选中的内容的 下一级的内容
      * @param node 已经选中的内容
@@ -580,7 +606,8 @@ const naslServer = {
      */
     async getDiagnosticRecords(fileNames?: Array<string>): Promise<Array<DiagnosticRecord>> {
         const records = (await this.messager.requestCommand('getDiagnosticRecords', fileNames)) as Array<DiagnosticRecord>;
-        return this._resolveDiagnosticRecords(records);
+        const diagnosticRecords = await this._resolveDiagnosticRecords(records);
+        return diagnosticRecords;
     },
     async getDiagnosticRecordsAndPushAll(fileNames?: Array<string>) {
         const records = await this.getDiagnosticRecords(fileNames);
@@ -591,13 +618,16 @@ const naslServer = {
      * @param records 结果
      * @returns 过滤或者转换后的诊断结果
      */
-    _resolveDiagnosticRecords(records: Array<DiagnosticRecord>) {
+    async _resolveDiagnosticRecords(records: Array<DiagnosticRecord>) {
+        // 热更新类型标注
+        if (records.length) {
+            await this.IncrementalAnnotationJSON(records);
+        }
+
         records.forEach((record) => {
-            const node = this.file2NodeMap.get(record.filePath);
+            const node = record.node;
             if (!node)
                 return;
-            record.id = node.id;
-            record.node = node;
 
             // 先获取原来的节点先清除一下之前有异常的节点，下面重新赋值
             const oldRecord = diagnosticManager.getRecord(record.id);
@@ -647,7 +677,6 @@ const naslServer = {
                 .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode, record))
                 .filter((diag) => !!diag);
         });
-
         return records;
     },
     /**
@@ -658,21 +687,87 @@ const naslServer = {
     _attachDiagnostics(fileNode: BaseNode): Diagnostic[] {
         const diagnostics: Diagnostic[] = [];
         if (fileNode instanceof View) {
-            traverse((current) => {
-                if (current.node.tag) {
-                    current.node.bindAttrs.forEach((bindAttr) => {
-                        if ((bindAttr.model || bindAttr.sync) && bindAttr.expression && bindAttr.expression.concept !== 'Identifier' && bindAttr.expression.concept !== 'MemberExpression') {
-                            const diagnostic = {
-                                node: bindAttr,
-                                severity: 'error',
-                                message: '页面元素双向绑定：只允许绑定可赋值的变量和字段。',
-                            };
-                            bindAttr.tsErrorDetail = diagnostic;
-                            diagnostics.push(diagnostic);
-                        }
-                    });
+            // 判断页面是否已经删除
+            let removed = false;
+            let curNode: View | App = fileNode;
+            // 递归检查，防止从顶层页面开始删除影响子页面内容检查
+            while (curNode instanceof View && !removed) {
+                if (curNode.parentNode instanceof View && !curNode.parentNode.children.includes(curNode)
+                || curNode.parentNode instanceof App && !curNode.parentNode.views.includes(curNode)) {
+                    removed = true;
                 }
-            }, { node: { children: fileNode.elements } as ViewElement });
+                curNode = curNode.parentNode as View | App;
+            }
+            if (removed)
+                return diagnostics;
+
+            fileNode.traverseChildren((node) => {
+                if (node instanceof ViewElement && node.view === fileNode) {
+                    if (node.tag) {
+                        node.bindAttrs.forEach((bindAttr) => {
+                            if ((bindAttr.model || bindAttr.sync) && bindAttr.expression && bindAttr.expression.concept !== 'Identifier' && bindAttr.expression.concept !== 'MemberExpression') {
+                                const diagnostic = {
+                                    node: bindAttr,
+                                    severity: 'error',
+                                    message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
+                                };
+                                bindAttr.tsErrorDetail = diagnostic;
+                                diagnostics.push(diagnostic);
+                            }
+                        });
+                    }
+                } else if ((node instanceof Variable || node instanceof Return) && node.view === fileNode) {
+                    if (!node.typeAnnotation && !node.__TypeAnnotation) {
+                        const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
+                        let msg;
+                        fileNode.traverseChildren((nodeIn) => {
+                            if (nodeIn && (nodeIn instanceof BatchAssignment || (nodeIn instanceof Assignment && nodeIn.left?.name))) {
+                                // 子页面内部逻辑过滤
+                                if (nodeIn.view !== fileNode)
+                                    return;
+                                // 跟变量无关的赋值过滤
+                                const tsCode = nodeIn.toEmbeddedTS();
+                                if (!tsCode.includes(`${node.name} = `))
+                                    return;
+                                // 逻辑内局部变量、输出参数、输入参数过滤
+                                if ((nodeIn.logic?.variables || []).find((lVar) => tsCode.includes(`${lVar.name} = `))
+                                    || (nodeIn.logic?.returns || []).find((lRet) => tsCode.includes(`${lRet.name} = `))
+                                    || (nodeIn.logic?.params || []).find((lPar) => tsCode.includes(`${lPar.name} = `)))
+                                    return;
+                                if (node instanceof Variable && node.parentNode instanceof View) {
+                                    // 直接赋值 logic 内局部变量、输入参数直接提示系统无法推断类型
+                                    let hasVar = false;
+                                    nodeIn.logic?.params.forEach((param) => {
+                                        if (tsCode.includes(param.name))
+                                            hasVar = true;
+                                    });
+                                    if (!hasVar) {
+                                        nodeIn.logic?.variables.forEach((variable) => {
+                                            if (tsCode.includes(variable.name))
+                                                hasVar = true;
+                                        });
+                                    }
+                                    if (hasVar)
+                                        msg = '系统无法推断类型。';
+                                } else {
+                                    msg = '必须赋值有返回值的内容。';
+                                }
+                            }
+                        });
+                        if (!msg)
+                            msg = '未设置类型或未赋值，直接赋值系统会自动推断类型。';
+                        const diagnostic = {
+                            node,
+                            severity: 'error',
+                            message: `${nodeTypeName} ${node.name} ${msg}`,
+                        };
+                        node.tsErrorDetail = diagnostic;
+                        diagnostics.push(diagnostic);
+                    } else {
+                        node.tsErrorDetail = undefined;
+                    }
+                }
+            });
         }
         if (fileNode instanceof DataSource) {
             const dataSourceGroup = (fileNode.rootNode as App).configuration?.getGroup('dataSource');
@@ -701,6 +796,10 @@ const naslServer = {
             }
         }
         if (fileNode instanceof Logic) {
+            // 判断逻辑是否已经删除
+            if (fileNode.parentNode instanceof App && !fileNode.parentNode.logics.includes(fileNode))
+                return diagnostics;
+
             fileNode?.sourceMap.forEach((value, node) => {
                 // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
                 if (node instanceof SqlQueryComponent && node.getTypeBanError()) {
@@ -712,6 +811,29 @@ const naslServer = {
                     node.tsErrorDetail = diagnostic;
                     diagnostics.push(diagnostic);
                 }
+                if (node instanceof Return || node instanceof Variable) {
+                    if (!node.typeAnnotation && !node.__TypeAnnotation) {
+                        const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
+                        let used = false;
+                        fileNode?.sourceMap.forEach((valueIn, nodeIn) => {
+                            if (nodeIn
+                                && (nodeIn instanceof BatchAssignment || (nodeIn instanceof Assignment && nodeIn.left?.name))
+                                && nodeIn.toEmbeddedTS().includes(`${node.name} = `)) {
+                                used = true;
+                            }
+                        });
+                        const msg = used ? '必须赋值有返回值的内容。' : '未设置类型或未赋值。直接赋值系统可以自动推断类型。';
+                        const diagnostic = {
+                            node,
+                            severity: 'error',
+                            message: `${nodeTypeName} ${node.name} ${msg}`,
+                        };
+                        node.tsErrorDetail = diagnostic;
+                        diagnostics.push(diagnostic);
+                    } else {
+                        node.tsErrorDetail = undefined;
+                    }
+                }
             });
         }
 
@@ -1008,7 +1130,7 @@ const naslServer = {
                 refsList = [...methodRefs];
             }
         }
-        console.log(refsList, 'refsList');
+        // console.log(refsList, 'refsList');
         return refsList;
     },
     /**
@@ -1295,7 +1417,7 @@ const naslServer = {
                             minRange.setTypeMethods = 'setDefaultValue';
                         }
                     }
-                    // 如果修改的是dataSource字段
+                    // 如果修改的是dataSource属性
                     if (node instanceof DataSource) {
                         const setTypeNamespace = (typeNamespace: string, record: any) => {
                             // 先看下标位置
@@ -1415,7 +1537,6 @@ const naslServer = {
             })
             // 过滤掉不需要操作的
             .filter((item) => !!item);
-        console.log(result);
         return result;
     },
     // 增加参数的副作用，用于更新logic和view
@@ -1427,7 +1548,6 @@ const naslServer = {
                 return null;
             const minRange: MinRange = this._findMinRange(record, fileNode as FileNode);
             if (minRange) {
-                console.log(minRange, 222)
                 // 如果找到节点是callLogic就去更新
                 if (minRange.node instanceof CallLogic && node instanceof Param) {
                     minRange.node.setCalleeArgName(parantNode as Logic);
@@ -1488,14 +1608,12 @@ const naslServer = {
                     naslServer._getTreeMap(minRange, fileNode, resMap, nodeMap);
                 }
             });
-            console.log(resMap, 'resMap');
             if (resMap.size > 0) {
                 result = naslServer.handleTreeMap(resMap);
             }
         } catch (err) {
             console.log(err);
         }
-        console.log(result);
         return result;
     },
     // 获取节点的上层渲染
@@ -1762,25 +1880,48 @@ const naslServer = {
      * @param nodes {filePath: string, node: BaseNode, item: SourceMapItem}
      * @returns Map<BaseNode, TypeAnnotation | { typeAnnotation: TypeAnnotation, option: any }>
      * 普通的TypeAnnotation，额外的可能携带 option
+     * 这里会处理callloigc callinterface 和 callfuntion 的 argment的参数一起携带回去，
+     * 也就是说如果 只传入了这个也会一起返回argment的节点，所以返回map最好去get结果
      */
-    async getNodesType(nodes: QuickInfoNodes) {
-        const args: Array<argDetail> = [];
-        const types: Map<BaseNode, TypeAnnotation | { typeAnnotation: TypeAnnotation, option: any }> = new Map();
+    async getQuickInfoNodesTypeMap(nodes: QuickInfoNodes, lotFlag?: boolean) {
         interface argDetail {
             file: string;
             line: number;
             offset: number;
         }
+        const args: Array<argDetail> = [];
+        // 要通过自己或者依赖关系拿的
+        const getFromOthers: Map<BaseNode, TypeAnnotation | { typeAnnotation: TypeAnnotation, option: any }> = new Map();
+        // 总共要返回出去的
+        const types: Map<BaseNode, TypeAnnotation | { typeAnnotation: TypeAnnotation, option: any }> = new Map();
+
         const newQuickInfoNodes: QuickInfoNodes = [];
         nodes.forEach((itemDetail) => {
             const { node, filePath, item } = itemDetail;
+            // 先按照顺序占位
+            types.set(node, null);
+
             // 获取已知节点类型的类型
             const nodeTypeAnnotation = this.getCurrentNodeKnownTypeAnnotation(node);
             if (nodeTypeAnnotation) {
                 types.set(node, nodeTypeAnnotation);
+                node.__TypeAnnotation = nodeTypeAnnotation;
+                return;
+            }
+            // 要通过自己或者依赖关系拿的，二次遍历
+            if ([
+                'Argument',
+                'Assignment',
+            ].includes(node.concept)) {
+                getFromOthers.set(node, null);
+            }
+            if ([
+                'Return',
+                'Variable',
+            ].includes(node.concept) && (node as Return | Variable).typeAnnotation) {
+                node.__TypeAnnotation = (node as Return | Variable).typeAnnotation;
                 return;
             }
-            // 要去ls那边获取的
             if (![
                 'Identifier',
                 'UnaryExpression',
@@ -1788,10 +1929,13 @@ const naslServer = {
                 'CallLogic',
                 'CallFunction',
                 'CallInterface',
-                'Argument',
                 'MemberExpression',
+                'Return',
+                'Variable',
+                'Match',
             ].includes(node.concept))
                 return;
+            // 要去ls那边获取的
             newQuickInfoNodes.push(itemDetail);
             const fileDetail = {
                 file: filePath,
@@ -1809,74 +1953,125 @@ const naslServer = {
                     indexOf = -1;
                 } else {
                     if (item.code.includes('>(')) {
-                        indexOf = item.code.indexOf('<') - 1;
+                        indexOf = item.code.indexOf('<');
                     } else {
-                        indexOf = item.code.indexOf('(') - 1;
+                        indexOf = item.code.indexOf('(');
                     }
+                    const subStr = item.code.substring(0, indexOf);
+                    const codeArr = subStr?.split('.');
+                    const lastLen = codeArr?.[codeArr.length - 1]?.length;
+                    indexOf = subStr.length - lastLen;
                 }
                 fileDetail.offset = fileDetail.offset + indexOf;
-            }
-            if (node.concept === 'MemberExpression') {
+            } else if (node.concept === 'MemberExpression') {
+                const codeArr = item.code?.split('.');
+                const lastLen = codeArr?.[codeArr.length - 1]?.length;
                 // MemberExpression取最后一位当做类型
-                const indexOf = item.code.length - 1;
+                const indexOf = item.code.length - lastLen;
+
                 fileDetail.offset = fileDetail.offset + indexOf;
+            } else if (node.concept === 'Match') {
+                // 去查return 后面的返回值，变成函数调用
+                fileDetail.line = item.range.end.line - 1;
+                const indexOf = item.code.indexOf('return __MatchExpressionFuntion');
+                let newCode = item.code.substring(0, indexOf);
+                newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
+                fileDetail.offset = newCode.length + 'return '.length;
             }
+            //if (fileDetail.file === '/embedded/lq1227/logics/logic1.ts' && fileDetail.offset === 9) {
+            //    console.log(fileDetail);
+            //    //fileDetail.offset = 8;
+            //}
             args.push(fileDetail);
         });
-        console.time('批量请求');
-        const result = (await this.getNaslNodeQuickInfoFull(args)).response;
-        newQuickInfoNodes.forEach((itemDetail, index) => {
-            const { node, filePath } = itemDetail;
-
-            if (!result[index] || node.concept === 'Argument')
-                return;
-            // console.log(result[index].displayString, node);
-            /**
-             * 这个前缀是给会自动省略命名空间的内容设置的，下个版本干掉，应急的方法
-             */
-            let parentPrefix;
-            if (filePath && (filePath.split('/').length > 3)) {
-                const arr = filePath.split('/');
-                if (arr[3] === 'dependencies' || arr[3] === 'interfaceDependencies' || arr[3] === 'componentDependencies') {
-                    const map = {
-                        dependencies: 'extensions',
-                        interfaceDependencies: 'apis',
-                        componentDependencies: 'components',
-                    };
-                    parentPrefix = `${map[arr[3]]}.${arr[4]}.`;
+        const resultMap = (await this.getNaslNodeTypeFull(args)).response;
+
+        // console.log(resultMap);
+
+        // const result = (await this.getNaslNodeQuickInfoFull(args)).response;
+        args.forEach((arg, index) => {
+            const { file, line, offset } = arg;
+            const item = (resultMap as any)?.[file]?.[line]?.[offset];
+            //const displayString1 = resule1[index]?.displayString;
+            // console.log('位置：', file, line, offset);
+            // console.log('原始：', displayString);
+            // console.log('方案2：', item?.[0]?.nodeType);
+            const nodeTypeAnnotation = type2TypeAnnotation(item?.[0]?.nodeType);
+            // console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, nodeTypeAnnotation?.typeKey)
+            types.set(newQuickInfoNodes[index].node, nodeTypeAnnotation);
+            newQuickInfoNodes[index].node.__TypeAnnotation = nodeTypeAnnotation;
+            (newQuickInfoNodes[index].node as any).__nodeType = item?.[0]?.nodeType;
+
+            // console.log('方案1：', displayString1);
+        });
+        getFromOthers.forEach((type, node) => {
+            if (node instanceof Assignment) {
+                if (!types.get(node.left)) {
+                    types.set(node.left, types.get(node.right));
+                    node.left.__TypeAnnotation = (types.get(node.right) as TypeAnnotation);
                 }
             }
-            const nodeTypeAnnotation = displayString2TypeAnnotation(result[index].displayString, parentPrefix);
-            // console.log(result[index].displayString, items[index], '************', typeAnnotation);
-            // console.log(node, index, items[index].code, result[index].displayString, '+++++++++++++++++++++++++++', typeAnnotation && typeAnnotation.typeKey)
-            try {
-                types.set(node, nodeTypeAnnotation);
-                /**
-                * 没有类型标注的情况
-                * 1.void 没有返回值
-                * 2.Argment
-                */
-                // if (!typeAnnotation) {
-                //     console.log(items[index].code, jsonNode, result[index]);
-                //     console.log(result[index].displayString)
-                // }
-            } catch (e) {
-                console.log(node, node.getNodePath(false));
-            }
-        });
-        // Argument的标注，因为这个位置上可能放任何东西所以直接在其内部去取
-        newQuickInfoNodes.forEach((itemDetail, index) => {
-            const { node } = itemDetail;
             if (node instanceof Argument) {
                 // 如果Argument，但是没可以用的类型，就用原来logic的参数类型
-                const argType = this.getArgumentTypeAnnotation(node, newQuickInfoNodes, result, (types as any));
+                const argType = this.getArgumentTypeAnnotation(node, newQuickInfoNodes, (types as any));
                 types.set(node, argType);
+                node.__TypeAnnotation = argType.typeAnnotation;
             }
         });
+
+        // newQuickInfoNodes.forEach((itemDetail, index) => {
+        //     const { node, filePath } = itemDetail;
+
+        //     if (!result[index] || node.concept === 'Argument')
+        //         return;
+        //     // console.log(result[index].displayString, node);
+        //     /**
+        //      * 这个前缀是给会自动省略命名空间的内容设置的，下个版本干掉，应急的方法
+        //      */
+        //     let parentPrefix;
+        //     if (filePath && (filePath.split('/').length > 3)) {
+        //         const arr = filePath.split('/');
+        //         if (arr[3] === 'dependencies' || arr[3] === 'interfaceDependencies' || arr[3] === 'componentDependencies') {
+        //             const map = {
+        //                 dependencies: 'extensions',
+        //                 interfaceDependencies: 'apis',
+        //                 componentDependencies: 'components',
+        //             };
+        //             parentPrefix = `${map[arr[3]]}.${arr[4]}.`;
+        //         }
+        //     }
+        //     const nodeTypeAnnotation = displayString2TypeAnnotation(result[index].displayString, parentPrefix);
+        //     // console.log(result[index].displayString, items[index], '************', typeAnnotation);
+        //     // console.log(node, index, items[index].code, result[index].displayString, '+++++++++++++++++++++++++++', typeAnnotation && typeAnnotation.typeKey)
+        //     try {
+        //         types.set(node, nodeTypeAnnotation);
+        //         /**
+        //         * 没有类型标注的情况
+        //         * 1.void 没有返回值
+        //         * 2.Argment
+        //         */
+        //         // if (!typeAnnotation) {
+        //         //     console.log(items[index].code, jsonNode, result[index]);
+        //         //     console.log(result[index].displayString)
+        //         // }
+        //     } catch (e) {
+        //         console.log(node, node.getNodePath(false));
+        //     }
+        // });
+        // // Argument的标注，因为这个位置上可能放任何东西所以直接在其内部去取
+        // newQuickInfoNodes.forEach((itemDetail, index) => {
+        //     const { node } = itemDetail;
+        //     if (node instanceof Argument) {
+        //         // 如果Argument，但是没可以用的类型，就用原来logic的参数类型
+        //         const argType = this.getArgumentTypeAnnotation(node, newQuickInfoNodes, result, (types as any));
+        //         types.set(node, argType);
+        //     }
+        // });
         console.timeEnd('批量请求');
         return types;
     },
-    async getNaslAnnotatedString(app: App) {
+    // 全量标注
+    async getNaslAnnotatedJSON(app: App) {
         // 全量标注
         console.time('全量标注');
 
@@ -1893,14 +2088,69 @@ const naslServer = {
                 });
             }
         });
-        const types = await this.getNodesType(nodes);
+        const typesMap = await this.getQuickInfoNodesTypeMap(nodes, true);
+        // console.log(typesMap, 'typesMap')
+        console.timeEnd('全量标注');
+        //console.log('一共处理节点数：', types.size);
+
         const json = app.toJSON();
+
+        // 全量标注后替换app上的json
+        this.annitationToJson(typesMap, json);
+        return json;
+    },
+    // 加载全量nasl节点标注
+    async createdNaslAnnotatedJSON(app: App) {
+        // 全量标注
+        console.time('全量标注');
+
+        const nodes: QuickInfoNodes = [];
+        naslServer.file2NodeMap.forEach((fileNode, filePath) => {
+            // 先不排除view，传递给后端的时候，去除views下的标注
+            if (!['Structure', 'DataSource', 'Entity', 'Enum', 'Role'].includes(fileNode.concept)) {
+                fileNode.sourceMap.forEach((item, node) => {
+                    nodes.push({
+                        filePath,
+                        node,
+                        item,
+                    });
+                });
+            }
+        });
+        await this.getQuickInfoNodesTypeMap(nodes, true);
         console.timeEnd('全量标注');
-        console.log('标注节点数：', types.size);
-        types.forEach((value, node) => {
+    },
+    // 增量标注
+    async IncrementalAnnotationJSON(records: DiagnosticRecord[]) {
+        const nodes: QuickInfoNodes = [];
+        records.forEach((record) => {
+            const fileNode = this.file2NodeMap.get(record.filePath);
+            if (!fileNode)
+                return;
+            record.id = fileNode.id;
+            record.node = fileNode;
+            if (!['Structure', 'DataSource', 'Entity', 'Enum', 'Role'].includes(fileNode.concept)) {
+                fileNode.sourceMap.forEach((item, nodeItem) => {
+                    nodes.push({
+                        filePath: record.filePath,
+                        node: nodeItem,
+                        item,
+                    });
+                });
+            }
+        });
+
+        await this.getQuickInfoNodesTypeMap(nodes);
+    },
+    annitationToJson(typesMap: Map<BaseNode, TypeAnnotation | {
+        typeAnnotation: TypeAnnotation;
+        option: any;
+    }>, json: {}) {
+        typesMap.forEach((value, node) => {
             // 如果节点本身有类型就不去在塞一遍了
             // 有值而且没有类型再去设置
-            if (value && !(node as any).typeAnnotation) {
+            // 但是Identifier 和 MemberExpression 都用标注出来的因为本身是变量，有类型也需要覆盖一下
+            if (value && (!(node as any).typeAnnotation || node instanceof Identifier || node instanceof MemberExpression)) {
                 const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
                 if (jsonNode) {
                     if (node instanceof Argument) {
@@ -1911,19 +2161,74 @@ const naslServer = {
                     }
                 }
             }
+            if (node instanceof CallQueryComponent && node.ideVersion !== '2.11' && node.typeAnnotation.properties
+                && (node.typeAnnotation.properties.length !== 2 || node.typeAnnotation.properties[0].name !== 'list')
+            ) {
+                const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                jsonNode.typeAnnotation = {
+                    concept: 'TypeAnnotation',
+                    typeKind: 'anonymousStructure',
+                    typeNamespace: null,
+                    typeName: null,
+                    typeArguments: [],
+                    inferred: false,
+                    ruleMap: null,
+                    properties: [{
+                        concept: 'StructureProperty',
+                        name: 'list',
+                        label: null,
+                        description: null,
+                        typeAnnotation: {
+                            concept: 'TypeAnnotation',
+                            typeKind: 'generic',
+                            typeNamespace: 'nasl.collection',
+                            typeName: 'List',
+                            typeArguments: [jsonNode.typeAnnotation],
+                            inferred: null,
+                        },
+                        required: null,
+                        defaultValue: null,
+                    }, {
+                        concept: 'StructureProperty',
+                        name: 'total',
+                        label: null,
+                        description: null,
+                        typeAnnotation: {
+                            concept: 'TypeAnnotation',
+                            typeKind: 'primitive',
+                            typeNamespace: 'nasl.core',
+                            typeName: 'Integer',
+                            typeArguments: null,
+                            inferred: null,
+                        },
+                        required: null,
+                        defaultValue: null,
+                    }],
+                };
+            }
         });
-        const jsonString = JSON.stringify(json);
-        console.log(jsonString);
-        console.log(jsonString.length / 1024 / 1024 + ' MB');
-        return jsonString;
     },
     /**
      * 获取getArgument的参数位的类型
      * 如果内部表达式的，就用表达式的，如果没有就试试用默认值的
      * 获取logic的默认值和原来Arg的类型和默认值对应
      */
-    getArgumentTypeAnnotation(node: Argument, QuickInfoNodes: QuickInfoNodes, result: tsProtocol.QuickInfoResponseBody[], types: Map<BaseNode, TypeAnnotation>) {
+    getArgumentTypeAnnotation(node: Argument, QuickInfoNodes: QuickInfoNodes, types: Map<BaseNode, TypeAnnotation>) {
         // 直接复用内部expression的type类型
+        if (node.parentNode instanceof CallLogic && node.parentNode.calleeNamespace.includes('entities') && node.parentNode.calleeNamespace.includes('logics') && node.parentNode.calleeName === 'delete') {
+            const nodeType = (node.parentNode as any)?.__nodeType;
+            if (nodeType && Array.isArray(nodeType.fnParams)) {
+                const index = node.parentNode.arguments.indexOf(node);
+                const type = nodeType.fnParams[index]?.typeInfo;
+                const nodeTypeAnnotation = type2TypeAnnotation(type);
+                if (nodeTypeAnnotation) {
+                    return {
+                        typeAnnotation: nodeTypeAnnotation,
+                        option: {},
+                    };
+                }
+            }
+        }
         if (types.get(node.expression)) {
             return {
                 typeAnnotation: types.get(node.expression),
@@ -1931,58 +2236,77 @@ const naslServer = {
             };
         }
         // 获取返回值结果里找到父级的callLogic || CallInterface的类型填充进去Argument
-        const CallLogic = node.parentNode;
-        const findIndex = QuickInfoNodes.findIndex((item) => item.node === CallLogic);
-        const CallLogicPlayString = result[findIndex] || {};
-        const callLogicDisplayString = (CallLogicPlayString as any)?.displayString || '';
-        // console.log(jsonNode, jsonNode.typeAnnotation, CallLogicPlayString, 'CallLogicPlayString');
-
-        // 处理类型默认值字符串取出类型和默认值
-        // 因为这里是字符串，就采取比较暴力的字符串截取
-        /**
-         * function app.logics.logic2(param1: String, param2: nasl.core.Decimal, param3: nasl.core.Text, param4: nasl.core.DateTime, param5: Boolean, __defaultValues?: {
-            param1: "1111";
-            param2: "2222";
-            param3: "3333";
-            param4: "2022-11-01 00:00:00";
-            param5: "true";
-        }): void
-            */
-        // 取出前面参数的类型
-        if (callLogicDisplayString.includes('__defaultValues')) {
-            // 分割字符串，分为两部分一个是前面的参数位
-            // 一个是后面的defaultValue
-            const paramsStr = callLogicDisplayString.substring(callLogicDisplayString.indexOf('(') + 1, callLogicDisplayString.indexOf(', __defaultValues'));
-            const defaultStr = callLogicDisplayString.substring(callLogicDisplayString.indexOf(', __defaultValues?: {') + ', __defaultValues?: {'.length, callLogicDisplayString.lastIndexOf('})'));
-            // 参数切割
-            const params = paramsStr.split(', ');
-            // 默认值切割
-            const defaults = defaultStr.replaceAll('\n', '').split(';');
-
-            const argumentIndex = (node.parentNode as CallLogic).arguments.findIndex((item) => item === node);
-            // 取出Arg在callLogic中的位数
-            if (argumentIndex === 0 || argumentIndex) {
-                // console.log(argumentIndex)
-                // console.log(params, defaults)
-                // console.log(callLogicDisplayString, '========================', paramsStr,'========================', defaultStr);
-                // 取出参数的str
-                const paramStr = params[argumentIndex] || '';
-                const typeAnnotation = displayString2TypeAnnotation(paramStr);
-                // 取出默认值的str
-                const defaultValueStr = defaults[argumentIndex];
-                // 匹配字符串中的""号
-                const valueMatch = defaultValueStr.match(/".*"/);
-                // 取出默认值
-                const defaultValue = ((valueMatch && valueMatch[0]) || '').replaceAll('"', '').replaceAll(';', '');
-
-                // 设置类型
-                return {
-                    typeAnnotation,
-                    // 设置默认值
-                    option: { defaultValue },
-                };
-            }
+        const App = node.app;
+        const parent = (node.parentNode) as CallLogic;
+        const callObj = App.findNodeByCompleteName(parent.calleeNamespace + '.' + parent.calleeName);
+        const index = parent.arguments.indexOf(node);
+        const param = callObj?.params[index] || {};
+        // 取出参数的类型
+        // 设置类型
+        return {
+            typeAnnotation: param.typeAnnotation,
+            // 设置默认值
+            option: { defaultValue: param.defaultValue },
+        };
+    },
+    async getCurrentTypeAnnotation(node: BaseNode) {
+        if (node.__TypeAnnotation) {
+            return node.__TypeAnnotation;
         }
+        return new Promise((resolve, reject) => {
+            const mySetInterval = setInterval(() => {
+                if (node.__TypeAnnotation) {
+                    resolve(node.__TypeAnnotation);
+                    clearInterval(mySetInterval);
+                }
+            }, 50);
+        });
+        // const res = new Promise((resolve, reject) => {
+        //     Object.defineProperty(node, '__TypeAnnotation', {
+        //         //修改  // 若只指定get方法，不指定set方法，那就默认该属性是只读的
+        //         get() {
+        //             return this.__newTypeAnnotation;
+        //         },
+        //         set: (__TypeAnnotation) => {
+        //             try {
+        //                 if (__TypeAnnotation) {
+        //                     (this as any).__newTypeAnnotation = __TypeAnnotation;
+        //                     resolve(__TypeAnnotation);
+        //                     return;
+        //                 }
+        //                 // 如果一直没变化 500毫秒后就返回没查找到
+        //                 setTimeout(() => {
+        //                     (this as any).__newTypeAnnotation = __TypeAnnotation;
+        //                     resolve(__TypeAnnotation || null);
+        //                 }, 500);
+        //             } catch (err) {
+        //                 console.log(err);
+        //             }
+        //         },
+        //     });
+        // });
+        // res.then((item) => { console.log(item) });
+        // return res;
+    },
+    // 获取节点标注，去动态查
+    async getBaseNodesTypeMap(nodes: Array<BaseNode>) {
+        const args = nodes.map((item) => {
+            const { currentSource, fileNode } = item.getCurrentSource();
+            return {
+                filePath: (fileNode as FileNode).getEmbeddedFilePath(),
+                node: item,
+                item: currentSource,
+            };
+        });
+        const typesMap = await naslServer.getQuickInfoNodesTypeMap(args);
+        return typesMap;
+    },
+    _getTypeStrFull(args: Array<any>) {
+        return this.messager.requestCommand('typeStrFull', args) as unknown as { responseRequired: boolean; response: tsProtocol.QuickInfoResponseBody };
+    },
+    async getNaslNodeTypeStrFull(args: Array<any>) {
+        const result = await this._getTypeStrFull(args);
+        return result;
     },
 };
 /**
@@ -2296,7 +2620,6 @@ embeddedTSEmitter.on('change', ($event: EventPayload) => {
             if (stackList.length) {
                 next();
             } else {
-                console.log('filesToCheck', filesToCheck, filesToCheck.size);
                 await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
                 filesToCheck.clear();
             }