@lcap/nasl 2.16.1 → 2.17.1

package/out/server/naslServer.js

@@ -41,7 +41,6 @@ const common_1 = require("../common");
 const diagnostic_1 = __importDefault(require("../manager/diagnostic"));
 const createUiTs_1 = __importDefault(require("./createUiTs"));
 const coreTypeList_1 = require("../concepts/basics/types/coreTypeList");
-const utils_1 = require("../utils");
 const formatTsUtils_1 = require("./formatTsUtils");
 const naslStdlibMap_1 = __importDefault(require("./naslStdlibMap"));
 const jsoner = __importStar(require("../service/storage/jsoner"));
@@ -69,9 +68,10 @@ const messager = new Messager_1.default({
     context: this,
     getReceiver: () => worker,
     getSender: () => worker,
-    handleMessage({ data }) {
+    handleMessage: async ({ data }) => {
         if (data && data.event === 'publishDiagnostics') {
-            diagnostic_1.default.pushAll(naslServer._resolveDiagnosticRecords(data.records));
+            const records = await naslServer._resolveDiagnosticRecords(data.records);
+            diagnostic_1.default.pushAll(records);
         }
     },
 });
@@ -273,6 +273,8 @@ const naslServer = {
         await naslServer.openApp(app);
         // 重新check一遍所有内容
         await naslServer.getDiagnosticRecordsAndPushAll();
+        // 重新补一遍标注
+        await naslServer.createdNaslAnnotatedJSON(app);
     },
     /**
      * 初始化之前添加文件
@@ -394,7 +396,7 @@ const naslServer = {
      * @param node 传入当前已经选择的变量
      * @returns 可以选择的类型数组
      */
-    async getTypeQuickinfo(node) {
+    async getConvertTypeInfo(node) {
         if (node && node instanceof concepts_1.BaseNode) {
             const callFunction = node.parentNode.parentNode;
             /**
@@ -462,6 +464,13 @@ const naslServer = {
             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 = (0, formatTsUtils_1.getPlatformType)(typeStr);
@@ -508,6 +517,20 @@ const naslServer = {
         const result = await this._getQuickInfoFull(args);
         return result;
     },
+    _getTypeFull(args) {
+        return this.messager.requestCommand('typeFull', args);
+    },
+    _getTypeBatch(args) {
+        return this.messager.requestCommand('typeBatch', args);
+    },
+    async getNaslNodeTypeFull(args) {
+        const result = await this._getTypeFull(args);
+        return result;
+    },
+    async getNaslNodeTypeBatch(args) {
+        const result = await this._getTypeBatch(args);
+        return result;
+    },
     /**
      * 获取已经选中的内容的 下一级的内容
      * @param node 已经选中的内容
@@ -541,7 +564,8 @@ const naslServer = {
      */
     async getDiagnosticRecords(fileNames) {
         const records = (await this.messager.requestCommand('getDiagnosticRecords', fileNames));
-        return this._resolveDiagnosticRecords(records);
+        const diagnosticRecords = await this._resolveDiagnosticRecords(records);
+        return diagnosticRecords;
     },
     async getDiagnosticRecordsAndPushAll(fileNames) {
         const records = await this.getDiagnosticRecords(fileNames);
@@ -552,13 +576,15 @@ const naslServer = {
      * @param records 结果
      * @returns 过滤或者转换后的诊断结果
      */
-    _resolveDiagnosticRecords(records) {
+    async _resolveDiagnosticRecords(records) {
+        // 热更新类型标注
+        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 = diagnostic_1.default.getRecord(record.id);
             oldRecord?.semanticDiagnostics.forEach((item) => {
@@ -615,21 +641,89 @@ const naslServer = {
     _attachDiagnostics(fileNode) {
         const diagnostics = [];
         if (fileNode instanceof concepts_1.View) {
-            (0, utils_1.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 = 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.App && !curNode.parentNode.views.includes(curNode)) {
+                    removed = true;
+                }
+                curNode = curNode.parentNode;
+            }
+            if (removed)
+                return diagnostics;
+            fileNode.traverseChildren((node) => {
+                if (node instanceof concepts_1.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 concepts_1.Variable || node instanceof concepts_1.Return) && node.view === fileNode) {
+                    if (!node.typeAnnotation && !node.__TypeAnnotation) {
+                        const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
+                        let msg;
+                        fileNode.traverseChildren((nodeIn) => {
+                            if (nodeIn && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.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 concepts_1.Variable && node.parentNode instanceof concepts_1.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;
+                    }
                 }
-            }, { node: { children: fileNode.elements } });
+            });
         }
         if (fileNode instanceof concepts_1.DataSource) {
             const dataSourceGroup = fileNode.rootNode.configuration?.getGroup('dataSource');
@@ -658,6 +752,9 @@ const 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) => {
                 // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
                 if (node instanceof concepts_1.SqlQueryComponent && node.getTypeBanError()) {
@@ -669,6 +766,30 @@ const naslServer = {
                     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 (nodeIn
+                                && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.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;
+                    }
+                }
             });
         }
         return diagnostics;
@@ -961,7 +1082,7 @@ const naslServer = {
                 refsList = [...methodRefs];
             }
         }
-        console.log(refsList, 'refsList');
+        // console.log(refsList, 'refsList');
         return refsList;
     },
     /**
@@ -1251,7 +1372,7 @@ const naslServer = {
                         minRange.setTypeMethods = 'setDefaultValue';
                     }
                 }
-                // 如果修改的是dataSource字段
+                // 如果修改的是dataSource属性
                 if (node instanceof concepts_1.DataSource) {
                     const setTypeNamespace = (typeNamespace, record) => {
                         // 先看下标位置
@@ -1373,7 +1494,6 @@ const naslServer = {
         })
             // 过滤掉不需要操作的
             .filter((item) => !!item);
-        console.log(result);
         return result;
     },
     // 增加参数的副作用，用于更新logic和view
@@ -1385,7 +1505,6 @@ const naslServer = {
                 return null;
             const minRange = this._findMinRange(record, fileNode);
             if (minRange) {
-                console.log(minRange, 222);
                 // 如果找到节点是callLogic就去更新
                 if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.Param) {
                     minRange.node.setCalleeArgName(parantNode);
@@ -1446,7 +1565,6 @@ const naslServer = {
                     naslServer._getTreeMap(minRange, fileNode, resMap, nodeMap);
                 }
             });
-            console.log(resMap, 'resMap');
             if (resMap.size > 0) {
                 result = naslServer.handleTreeMap(resMap);
             }
@@ -1454,7 +1572,6 @@ const naslServer = {
         catch (err) {
             console.log(err);
         }
-        console.log(result);
         return result;
     },
     // 获取节点的上层渲染
@@ -1719,20 +1836,41 @@ 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) {
+    async getQuickInfoNodesTypeMap(nodes, lotFlag) {
         const args = [];
+        // 要通过自己或者依赖关系拿的
+        const getFromOthers = new Map();
+        // 总共要返回出去的
         const types = new Map();
         const newQuickInfoNodes = [];
         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.typeAnnotation) {
+                node.__TypeAnnotation = node.typeAnnotation;
                 return;
             }
-            // 要去ls那边获取的
             if (![
                 'Identifier',
                 'UnaryExpression',
@@ -1740,10 +1878,13 @@ const naslServer = {
                 'CallLogic',
                 'CallFunction',
                 'CallInterface',
-                'Argument',
                 'MemberExpression',
+                'Return',
+                'Variable',
+                'Match',
             ].includes(node.concept))
                 return;
+            // 要去ls那边获取的
             newQuickInfoNodes.push(itemDetail);
             const fileDetail = {
                 file: filePath,
@@ -1762,75 +1903,122 @@ const naslServer = {
                 }
                 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?.[file]?.[line]?.[offset];
+            //const displayString1 = resule1[index]?.displayString;
+            // console.log('位置：', file, line, offset);
+            // console.log('原始：', displayString);
+            // console.log('方案2：', item?.[0]?.nodeType);
+            const nodeTypeAnnotation = (0, formatTsUtils_1.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.__nodeType = item?.[0]?.nodeType;
+            // console.log('方案1：', displayString1);
+        });
+        getFromOthers.forEach((type, node) => {
+            if (node instanceof concepts_1.Assignment) {
+                if (!types.get(node.left)) {
+                    types.set(node.left, types.get(node.right));
+                    node.left.__TypeAnnotation = types.get(node.right);
                 }
             }
-            const nodeTypeAnnotation = (0, formatTsUtils_1.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 concepts_1.Argument) {
                 // 如果Argument，但是没可以用的类型，就用原来logic的参数类型
-                const argType = this.getArgumentTypeAnnotation(node, newQuickInfoNodes, result, types);
+                const argType = this.getArgumentTypeAnnotation(node, newQuickInfoNodes, types);
                 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) {
+    // 全量标注
+    async getNaslAnnotatedJSON(app) {
         // 全量标注
         console.time('全量标注');
         const nodes = [];
@@ -1846,14 +2034,62 @@ 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) {
+        // 全量标注
+        console.time('全量标注');
+        const nodes = [];
+        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) {
+        const nodes = [];
+        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, json) {
+        typesMap.forEach((value, node) => {
             // 如果节点本身有类型就不去在塞一遍了
             // 有值而且没有类型再去设置
-            if (value && !node.typeAnnotation) {
+            // 但是Identifier 和 MemberExpression 都用标注出来的因为本身是变量，有类型也需要覆盖一下
+            if (value && (!node.typeAnnotation || node instanceof concepts_1.Identifier || node instanceof concepts_1.MemberExpression)) {
                 const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
                 if (jsonNode) {
                     if (node instanceof concepts_1.Argument) {
@@ -1865,19 +2101,73 @@ const naslServer = {
                     }
                 }
             }
+            if (node instanceof concepts_1.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, QuickInfoNodes, result, types) {
+    getArgumentTypeAnnotation(node, QuickInfoNodes, types) {
         // 直接复用内部expression的type类型
+        if (node.parentNode instanceof concepts_1.CallLogic && node.parentNode.calleeNamespace.includes('entities') && node.parentNode.calleeNamespace.includes('logics') && node.parentNode.calleeName === 'delete') {
+            const nodeType = node.parentNode?.__nodeType;
+            if (nodeType && Array.isArray(nodeType.fnParams)) {
+                const index = node.parentNode.arguments.indexOf(node);
+                const type = nodeType.fnParams[index]?.typeInfo;
+                const nodeTypeAnnotation = (0, formatTsUtils_1.type2TypeAnnotation)(type);
+                if (nodeTypeAnnotation) {
+                    return {
+                        typeAnnotation: nodeTypeAnnotation,
+                        option: {},
+                    };
+                }
+            }
+        }
         if (types.get(node.expression)) {
             return {
                 typeAnnotation: types.get(node.expression),
@@ -1885,55 +2175,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?.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.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 = (0, formatTsUtils_1.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);
+        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) {
+        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) {
+        const args = nodes.map((item) => {
+            const { currentSource, fileNode } = item.getCurrentSource();
+            return {
+                filePath: fileNode.getEmbeddedFilePath(),
+                node: item,
+                item: currentSource,
+            };
+        });
+        const typesMap = await naslServer.getQuickInfoNodesTypeMap(args);
+        return typesMap;
+    },
+    _getTypeStrFull(args) {
+        return this.messager.requestCommand('typeStrFull', args);
+    },
+    async getNaslNodeTypeStrFull(args) {
+        const result = await this._getTypeStrFull(args);
+        return result;
     },
 };
 /**
@@ -2237,7 +2549,6 @@ translator_1.embeddedTSEmitter.on('change', ($event) => {
                 next();
             }
             else {
-                console.log('filesToCheck', filesToCheck, filesToCheck.size);
                 await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
                 filesToCheck.clear();
             }