@lcap/nasl 2.22.0-beta.5 → 3.0.0-beta.1

package/out/server/naslServer.js

@@ -56,6 +56,8 @@ const EmbeddedTSFileLineMap = {
 };
 const EmbeddedTSFileOffsetMap = {
     Variable: 12,
+    // Backend:12,
+    BackendVariable: 12,
     ConfigProperty: 12,
 };
 const SentryMessager = (0, sentry_1.sentryMonitorTSWorkerMessager)(Messager_1.default);
@@ -162,8 +164,8 @@ class NaslServer {
                 /**
                  * 多个行为进行合并
                  * 合并规则是
-                 * 1.[a,b,c,c] 在cc的时候，在已有一个c，又来一个c的时候，如果他们不都是file级别的节点
-                 *   就可以前面的内容去掉，只保留最后一个
+                 * 1.[a,b,c,c] 在cc的时候，在已有一个c，又来一个c的时候，file级别的节点
+                 *   就可以前面的内容去掉，只保留最后一个, 但是如果前面那个有携带file
                  * 2.[a,b,c,b,c] 在bc已存在，又来了bc 这就都要保留，因为可能顺序有相关性，不能去掉
                  * 理论上只处理同时几个操作 合并，
                  * 3.有field的也直接保留
@@ -172,13 +174,22 @@ class NaslServer {
                     const changeEvent = item.originEvent;
                     const changeNode = changeEvent.target;
                     const { fileNode } = this.getCurrentSource(changeNode);
-                    if (changeNode !== fileNode || !changeEvent.field) {
-                        const findLastIndex = this.changeStackList.findLastIndex((changeStackItem) => {
-                            const target = changeStackItem.target;
-                            const { fileNode: targetFileNode } = this.getCurrentSource(target);
-                            return targetFileNode === fileNode;
-                        });
-                        if (findLastIndex === this.changeStackList.length - 1) {
+                    // 这个方法是 5.0 加入标准库的，但是这里 ts 版本是 4.x，ci 会挂，所以需要忽略
+                    // @ts-ignore
+                    const findLastIndex = this.changeStackList.findLastIndex((changeStackItem) => {
+                        const target = changeStackItem.target;
+                        const { fileNode: targetFileNode } = this.getCurrentSource(target);
+                        return targetFileNode === fileNode;
+                    });
+                    // 如果当前找到了节点，而且节点在数组的最后一项，说明此次可以合并
+                    if (findLastIndex !== -1 && findLastIndex === this.changeStackList.length - 1) {
+                        // 最后一项有field就直接保留，新的也不塞，直接return
+                        if (this.changeStackList[findLastIndex]?.field) {
+                            // 如果当前列表里有，这个文件节点，最后一个是field的话，直接return掉，不用塞这个update了
+                            return;
+                        }
+                        else {
+                            // 如果最后一项是普通的update的话，就可以去掉，后面那个会在塞过来
                             this.changeStackList.pop();
                         }
                     }
@@ -235,6 +246,31 @@ class NaslServer {
             }
         });
         if (module instanceof concepts_1.App) {
+            module.overriddenLogics?.forEach?.((logic) => {
+                try {
+                    if (!(logic instanceof concepts_1.OverriddenLogic))
+                        return;
+                    const result = logic.toEmbeddedTSFile();
+                    results.push(result);
+                    logic.sourceMap = result.sourceMap;
+                    this.file2NodeMap.set(result.filePath, logic);
+                }
+                catch (err) {
+                    console.error('err: ', err);
+                }
+            });
+            module?.backend?.variables?.forEach((backdndVariable) => {
+                try {
+                    const result = backdndVariable.toEmbeddedTSFile();
+                    results.push(result);
+                    // sourceMap都存在目录级别内容下，在页面层级下去找
+                    backdndVariable.sourceMap = result.sourceMap;
+                    this.file2NodeMap.set(result.filePath, backdndVariable);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
             module.frontends?.forEach((frontend) => {
                 try {
                     const result = frontend.toEmbeddedTSFile();
@@ -258,6 +294,21 @@ class NaslServer {
                         console.log(err);
                     }
                 });
+                frontend.bindEvents.forEach((bindEvent) => {
+                    if (bindEvent?.logics && bindEvent?.logics?.length > 0) {
+                        bindEvent.logics.forEach((logic) => {
+                            try {
+                                const result = logic.toEmbeddedTSFile();
+                                results.push(result);
+                                logic.sourceMap = result.sourceMap;
+                                this.file2NodeMap.set(result.filePath, logic);
+                            }
+                            catch (err) {
+                                console.error('err: ', err);
+                            }
+                        });
+                    }
+                });
                 // view的生成
                 if (!config_1.config.closeViews) {
                     this.view2TSFile(frontend.views, results);
@@ -338,6 +389,30 @@ class NaslServer {
             catch (err) {
             }
         });
+        module?.authLogics?.forEach?.((logic) => {
+            try {
+                if (!(logic instanceof concepts_1.Logic))
+                    return;
+                const result = logic.toEmbeddedTSFile();
+                results.push(result);
+                logic.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, logic);
+            }
+            catch (err) {
+            }
+        });
+        module?.authLogicsForCallInterface?.forEach?.((logic) => {
+            try {
+                if (!(logic instanceof concepts_1.Logic))
+                    return;
+                const result = logic.toEmbeddedTSFile();
+                results.push(result);
+                logic.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, logic);
+            }
+            catch (err) {
+            }
+        });
         module.processes.forEach((process) => {
             try {
                 const result = process.toEmbeddedTSFile();
@@ -425,6 +500,8 @@ class NaslServer {
     async refreshApp(app) {
         // 清除所有问题
         this.diagnosticManager.clear();
+        // 刷新要清除文件列表
+        this.file2NodeMap.clear();
         await this.deleteDirectoryFiles({ directoryName: '/embedded' });
         // 清楚check count的数量
         await this.messager.requestCommand('_clearTimeout');
@@ -435,29 +512,29 @@ class NaslServer {
         // check内容后，会自动走增量类型标注完善全部类型
     }
     /**
-     * 初始化之前添加文件
-     */
+ * 初始化之前添加文件
+ */
     addFile(file) {
         return this.messager.requestCommand('addFile', file);
     }
-    /**
-     * 只新增文件
-     * @param {*} files
-     */
+    /**u
+ * 只新增文件
+ * @param {*} files
+ */
     writeFiles(files) {
         return this.messager.requestCommand('writeFiles', files);
     }
     /**
-     * 新增、修改
-     * 删除文件 文件用修改内容为空模拟，防止报错
-     * @param {*} args
-     */
+ * 新增、修改
+ * 删除文件 文件用修改内容为空模拟，防止报错
+ * @param {*} args
+ */
     updateFiles(args) {
         return this.messager.requestCommand('updateFiles', args);
     }
     /**
-     * 清除一个目录下的所有文件
-     */
+ * 清除一个目录下的所有文件
+ */
     deleteDirectoryFiles(args) {
         return this.messager.requestCommand('deleteDirectoryFiles', args);
     }
@@ -500,6 +577,7 @@ class NaslServer {
         return this.messager.requestCommand('fileReferences', filePath);
     }
     async references(args) {
+        // debugger
         return (await this.messager.requestCommand('references', args))?.response;
     }
     getValueSelectCompletion(node, value, noFilterList) {
@@ -532,10 +610,10 @@ class NaslServer {
         if (node && node instanceof concepts_1.BaseNode) {
             const callFunction = node.parentNode.parentNode;
             /**
-             * currentSource callFunction 的节点，要去到当前节点的位置
-             * nasl.util.Convert(xxx),所以取到的位置要 + `nasl.util.C` 的长度
-             * fileNode
-             */
+         * currentSource callFunction 的节点，要去到当前节点的位置
+         * nasl.util.Convert(xxx),所以取到的位置要 + `nasl.util.C` 的长度
+         * fileNode
+         */
             const { currentSource, fileNode } = this.getCurrentSource(callFunction);
             if (!currentSource) {
                 return [];
@@ -692,10 +770,10 @@ class NaslServer {
         }
     }
     /**
-     * ts的 quickInfo方法，查询指定位置的详情
-     * @param args 文件信息数组
-     * @returns 查询到的
-     */
+ * ts的 quickInfo方法，查询指定位置的详情
+ * @param args 文件信息数组
+ * @returns 查询到的
+ */
     _getTypeQuickinfo(args) {
         return this.messager.requestCommand('quickInfo', args);
     }
@@ -727,11 +805,11 @@ class NaslServer {
         return result;
     }
     /**
-     * 获取已经选中的内容的 下一级的内容
-     * @param node 已经选中的内容
-     * @param noFilterList 不过滤的key 的数据
-     * @returns 可以选择的数据数组
-     */
+ * 获取已经选中的内容的 下一级的内容
+ * @param node 已经选中的内容
+ * @param noFilterList 不过滤的key 的数据
+ * @returns 可以选择的数据数组
+ */
     getSelectNextCompletion(node, noFilterList) {
         const { currentSource, fileNode } = this.getCurrentSource(node);
         // console.log(currentSource, fileNode);
@@ -767,8 +845,8 @@ class NaslServer {
         // diagnosticManager.pushAll(records);
     }
     /**
-     * 节点异常是只能挂载单个，如果已经了就不赋值了
-     */
+ * 节点异常是只能挂载单个，如果已经了就不赋值了
+ */
     baseNodeAssignmentTsError(node, tsErrorDetail) {
         if (node.tsErrorDetail)
             return;
@@ -823,6 +901,7 @@ class NaslServer {
                     }
                 });
             }
+            record.semanticDiagnostics.forEach((diag) => (0, translator_2.checkAStructure_)(diag.text));
             record.semanticDiagnostics = record.semanticDiagnostics
                 .map((diag) => this._resolveDiagnostic(diag, node, record))
                 .filter((diag) => !!diag);
@@ -1201,6 +1280,9 @@ class NaslServer {
                     if (node.code === `location.href = '/';`) {
                         return null;
                     }
+                    if (node?.code?.includes('use JSBlock')) {
+                        return null;
+                    }
                     const diagnostic = {
                         node,
                         severity: 'warning',
@@ -1303,10 +1385,10 @@ class NaslServer {
         return flag;
     }
     /**
-     * 额外的诊断
-     * @param fileNode 文件级别的节点
-     * @returns 诊断结果
-     */
+ * 额外的诊断
+ * @param fileNode 文件级别的节点
+ * @returns 诊断结果
+ */
     _attachDiagnostics(fileNode) {
         // 每次诊断前先清空这个Set
         this.logicSetWithComponentLogic = new Set();
@@ -1975,18 +2057,18 @@ class NaslServer {
             diagnostics.push(diagnostic);
         }
         /**
-         * 如果节点是内置函数
-         * 穷举在线上的情况，不在线上就void报错， callinterface 因为原来有报错，所以就忽略掉
-         * && 他在父级中，不在body
-         * && 也不再 if的线上
-         * && 也不再 switch的线上consequent
-         * && 也不再草稿区域
-         * && 不在 parentNode.parentNode（只用处理两层的，超过两层上就需要报错，只用直接是参数位第一层的需要） 是 callfunction 和 callInfterfase中，因为这两本身有强制类型，内置函数或者一些带T的声明那种，
-         * && 而且也没有类型，就说明在槽位里，就需要报错
-         *
-         * 如果是内置函数而且也不在线上
-         * 只有下面自己实现的函数才会报错
-         */
+     * 如果节点是内置函数
+     * 穷举在线上的情况，不在线上就void报错， callinterface 因为原来有报错，所以就忽略掉
+     * && 他在父级中，不在body
+     * && 也不再 if的线上
+     * && 也不再 switch的线上consequent
+     * && 也不再草稿区域
+     * && 不在 parentNode.parentNode（只用处理两层的，超过两层上就需要报错，只用直接是参数位第一层的需要） 是 callfunction 和 callInfterfase中，因为这两本身有强制类型，内置函数或者一些带T的声明那种，
+     * && 而且也没有类型，就说明在槽位里，就需要报错
+     *
+     * 如果是内置函数而且也不在线上
+     * 只有下面自己实现的函数才会报错
+     */
         if (node instanceof concepts_1.CallFunction && node.parentKey !== 'body' && node.parentKey !== 'alternate' && node.parentKey !== 'playground' && node.parentKey !== 'consequent' && node.parentNode?.parentNode?.concept !== 'CallInterface' && !node.__TypeAnnotation) {
             let showErr = false;
             if (node.parentNode?.parentNode?.concept === 'CallLogic') {
@@ -2117,11 +2199,11 @@ class NaslServer {
         }
     }
     /**
-     * 单个问题的诊断处理
-     * @param diagnostic 诊断问题
-     * @param fileNode 页面节点
-     * @returns 处理后的结果
-     */
+ * 单个问题的诊断处理
+ * @param diagnostic 诊断问题
+ * @param fileNode 页面节点
+ * @returns 处理后的结果
+ */
     _resolveDiagnostic(diagnostic, fileNode, record) {
         // 拓展模块中的翻译先过滤掉，因为有错用户也不能修改
         if (fileNode.module && !(fileNode instanceof concepts_1.ConfigProperty)) {
@@ -2131,6 +2213,9 @@ class NaslServer {
         // if ('compilerInfoMap' in fileNode && (fileNode as any).compilerInfoMap?.java) {
         //     return;
         // }
+        if (fileNode.concept === 'OverriddenLogic' && diagnostic.text === `'__LogicEmpty' is declared but its value is never read.`) {
+            return;
+        }
         const minRange = this._findMinRange(diagnostic, fileNode);
         const tsErrorDetail = {
             severity: diagnostic.category === 'error' ? 'error' : 'warning',
@@ -2152,11 +2237,11 @@ class NaslServer {
         return result;
     }
     /**
-     * 通过节点诊断反过来查找节点
-     * @param diagnostic 诊断信息
-     * @param fileNode 文件级别节点
-     * @returns 找到的节点
-     */
+ * 通过节点诊断反过来查找节点
+ * @param diagnostic 诊断信息
+ * @param fileNode 文件级别节点
+ * @returns 找到的节点
+ */
     _findMinRange(diagnostic, fileNode) {
         let minRange;
         const sourceMap = fileNode.sourceMap;
@@ -2199,7 +2284,14 @@ class NaslServer {
                         }
                     }
                     else if (item.range.end.line - item.range.start.line <= minRange.item.range.end.line - minRange.item.range.start.line) {
-                        if (minRange.item.range.start.line !== diagnostic.start.line) {
+                        // 行都一致 ，比较列
+                        if (minRange.item.range.start.line === item.range.start.line && minRange.item.range.end.line === item.range.end.line) {
+                            // 如果两个起始和结束的行都一样，那么就比较开始列， 要比原来大，说明更精准
+                            if (item.range.start.character > minRange.item.range.start.character) {
+                                minRange = { node, item };
+                            }
+                        }
+                        else {
                             minRange = { node, item };
                         }
                     }
@@ -2223,8 +2315,8 @@ class NaslServer {
         const { currentSource, fileNode } = this.getCurrentSource(node);
         let refsList = [];
         /**
-         * 未完成创建的节点 ，或者异常情况 可能找不到节点
-         */
+     * 未完成创建的节点 ，或者异常情况 可能找不到节点
+     */
         if (currentSource) {
             const newRefs = await this.references({
                 file: fileNode.getEmbeddedFilePath(),
@@ -2260,12 +2352,12 @@ class NaslServer {
                 const dataSourceFile = fileNode.getEmbeddedFilePath();
                 const entityFilePrefix = dataSourceFile.replace('.ts', '');
                 /**
-                 * 特殊处理,因为关联属性或者关联实体等等都是在实体里,在实体中因为自己不可以是自己的类型
-                 * 所以全部过滤掉了,
-                 * 但是在datasource里面在实体里会有大量的引用,不需要全部修改.只需要处理除了11个函数之外的引用
-                 * 所以底部内容是11个函数,所以这里就 用entity的行数 减去11个函数的行数,然后其余的在进行处理
-                 * 进行过滤
-                 */
+             * 特殊处理,因为关联属性或者关联实体等等都是在实体里,在实体中因为自己不可以是自己的类型
+             * 所以全部过滤掉了,
+             * 但是在datasource里面在实体里会有大量的引用,不需要全部修改.只需要处理除了11个函数之外的引用
+             * 所以底部内容是11个函数,所以这里就 用entity的行数 减去11个函数的行数,然后其余的在进行处理
+             * 进行过滤
+             */
                 // 不要数据源下面的实体里的引用 ,保留原始的节点内容
                 let flag = false;
                 if (item.file.includes(entityFilePrefix)) {
@@ -2324,12 +2416,12 @@ class NaslServer {
             refsList = [...refsList, ...filterViewRefs];
         }
         /**
-         * 暂时不要了， 因为生成的结构发生了变化
-         * view 因为不是嵌套的，所以不能用最前面的变量查找，所以要单独处理一下
-         * 找到第一个 { 之前的变量 进行修改
-         * 如果是VIew的查找，比较特殊，他查的是当前抛出的 {} 大括号前的
-         * 最后一个，因为生成的规则不一样
-         */
+     * 暂时不要了， 因为生成的结构发生了变化
+     * view 因为不是嵌套的，所以不能用最前面的变量查找，所以要单独处理一下
+     * 找到第一个 { 之前的变量 进行修改
+     * 如果是VIew的查找，比较特殊，他查的是当前抛出的 {} 大括号前的
+     * 最后一个，因为生成的规则不一样
+     */
         // if (node instanceof View) {
         //     const code = currentSource.code;
         //     const viewIndex = code.indexOf(' {');
@@ -2341,8 +2433,8 @@ class NaslServer {
         //     refsList = [...viewRefs.refs];
         // }
         /**
-         * elements 需要查的是__elements.后面的那个内容,过滤两个为了生成内容的节点
-         */
+     * elements 需要查的是__elements.后面的那个内容,过滤两个为了生成内容的节点
+     */
         if (node instanceof concepts_1.ViewElement) {
             if (currentSource) {
                 const code = currentSource.code;
@@ -2480,13 +2572,13 @@ class NaslServer {
         return refsList;
     }
     /**
-     * 查找引用，并且做一些 修改前的准备工作，
-     * 有引用有的话，就返回集合
-     * @param node 当前重命名的节点
-     * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
-     * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
-     * @returns 找到的引用
-     */
+ * 查找引用，并且做一些 修改前的准备工作，
+ * 有引用有的话，就返回集合
+ * @param node 当前重命名的节点
+ * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
+ * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
+ * @returns 找到的引用
+ */
     _renamePrepare(node, refsList, newValue) {
         const oldName = node?.name;
         const result = refsList
@@ -2631,7 +2723,10 @@ class NaslServer {
                     if (minRange.node instanceof concepts_1.EntityProperty) {
                         minRange.setTypeMethods = 'setRelationEntity';
                     }
-                    else if (minRange.node instanceof concepts_1.QueryFieldExpression || minRange.node instanceof concepts_1.QueryGroupByExpression) {
+                    else if (minRange.node instanceof concepts_1.QueryFieldExpression) {
+                        minRange.setTypeMethods = 'setEntityAsNameAndEffect';
+                    }
+                    else if (minRange.node instanceof concepts_1.QueryGroupByExpression) {
                         minRange.setTypeMethods = 'setEntityAsName';
                     }
                     else if (minRange.node instanceof concepts_1.QueryFromExpression || minRange.node instanceof concepts_1.QueryJoinExpression) {
@@ -2861,12 +2956,15 @@ class NaslServer {
                 if (minRange.node instanceof concepts_1.BindEvent && node instanceof concepts_1.Param) {
                     return null;
                 }
+                if (minRange.node instanceof concepts_1.Argument && node instanceof concepts_1.Param) {
+                    minRange.setTypeMethods = 'setKeyword';
+                }
                 /**
-                 * 理论上 logic setName只能自己触发，别的地方查到引用都不用重命名
-                 * 流程改名不触发Logic改名
-                 * 如果是修改param查找到logic就不操作
-                 * 除非想在内部修改别的内容所以暂时屏蔽掉
-                 */
+             * 理论上 logic setName只能自己触发，别的地方查到引用都不用重命名
+             * 流程改名不触发Logic改名
+             * 如果是修改param查找到logic就不操作
+             * 除非想在内部修改别的内容所以暂时屏蔽掉
+             */
                 if (minRange.node instanceof concepts_1.Logic && node !== minRange.node) {
                     return null;
                 }
@@ -2914,7 +3012,18 @@ class NaslServer {
             return minRange;
         })
             // 过滤掉不需要操作的
-            .filter((item) => !!item);
+            .filter((item) => !!item)
+            // 排序：
+            // QueryFieldExpression依赖Entity，把Entity放在QueryFieldExpression前，
+            .sort((a, b) => {
+            if (a.node.concept === 'QueryFieldExpression') {
+                return 1;
+            }
+            else if (b.node.concept === 'QueryFieldExpression') {
+                return -1;
+            }
+            return 0;
+        });
         return result;
     }
     // 增加参数的副作用，用于更新logic和view
@@ -2927,8 +3036,21 @@ class NaslServer {
             const minRange = this._findMinRange(record, fileNode);
             if (minRange) {
                 // 如果找到节点是callLogic就去更新
-                if ((minRange.node instanceof concepts_1.CallLogic || minRange.node instanceof concepts_1.Destination) && node instanceof concepts_1.Param) {
-                    minRange.node.addCalleeArg(parantNode);
+                if (node instanceof concepts_1.Param) {
+                    if (minRange.node instanceof concepts_1.CallLogic) {
+                        minRange.node.addCalleeArg(parantNode);
+                    }
+                    else if (minRange.node instanceof concepts_1.Destination) {
+                        // 跳转页面，可能在父级下增加参数，子的跳转页面也可以查找到引用
+                        // 精准匹配子页面的内容
+                        const viewNode = node.parentNode;
+                        if (viewNode instanceof concepts_1.View) {
+                            const viewNamespace = viewNode.getNamespace();
+                            if (viewNamespace === minRange.node.viewNamespace && viewNode.name === minRange.node.viewName) {
+                                minRange.node.addCalleeArg(parantNode);
+                            }
+                        }
+                    }
                 }
             }
         });
@@ -3094,11 +3216,11 @@ class NaslServer {
         return treeNodeMap;
     }
     /**
-     * 处理tree的队列，把相同节点进行合并
-     * 这里把当前二维数组进行一个整合
-     * @param arr 当前页面下的queue的二维数组，一个数组下有多条链路
-     * @returns 最后要使用到的节点和对应的子集
-     */
+ * 处理tree的队列，把相同节点进行合并
+ * 这里把当前二维数组进行一个整合
+ * @param arr 当前页面下的queue的二维数组，一个数组下有多条链路
+ * @returns 最后要使用到的节点和对应的子集
+ */
     handleTreeQueue(queueLists) {
         const map = new Map();
         let root = null;
@@ -3126,11 +3248,11 @@ class NaslServer {
         return children;
     }
     /**
-     * 递归调用输出结果
-     * @param root 一个根节点
-     * @param map 当前所有节点的map对象
-     * @returns 当前节点，最后输出所有节点
-     */
+ * 递归调用输出结果
+ * @param root 一个根节点
+ * @param map 当前所有节点的map对象
+ * @returns 当前节点，最后输出所有节点
+ */
     _recursionCreateResult(root, map) {
         const children = (map.get(root) || []).map((item) => this._recursionCreateResult(item, map));
         if (children && children.length) {
@@ -3139,9 +3261,9 @@ class NaslServer {
         return root;
     }
     /**
-     *  获取
-     *  当前this上下文 的Source 和 父级文件级别的节点
-     */
+ *  获取
+ *  当前this上下文 的Source 和 父级文件级别的节点
+ */
     getCurrentSource(node) {
         if (node instanceof concepts_1.App || node instanceof concepts_1.Theme)
             return { fileNode: null };
@@ -3157,6 +3279,7 @@ class NaslServer {
             && !(fileNode.parentNode instanceof concepts_1.Module)
             && !(fileNode.parentNode instanceof concepts_1.DataSource)
             && !(fileNode.parentNode instanceof concepts_1.Frontend)
+            && !(fileNode.parentNode instanceof concepts_1.Backend)
             && !(fileNode instanceof concepts_1.View)
             && !(fileNode instanceof concepts_1.ConfigProperty)) {
             fileNode = fileNode.parentNode;
@@ -3242,9 +3365,9 @@ class NaslServer {
         return [...fileNodes];
     }
     /**获取当前节点的已知类型
-     * @param node 当前要获取类型的节点
-     * @returns 不需要去查就可以返回类型的节点
-     */
+ * @param node 当前要获取类型的节点
+ * @returns 不需要去查就可以返回类型的节点
+ */
     getCurrentNodeKnownTypeAnnotation(node) {
         if (node.concept === 'StringLiteral' || node.concept === 'StringInterpolation' || node.concept === 'BooleanLiteral' || node.concept === 'NullLiteral') {
             let type = 'String';
@@ -3355,6 +3478,11 @@ class NaslServer {
                 'QueryFieldExpression',
                 'QueryGroupByExpression',
                 'Param',
+                'AuthLogic',
+                'AuthLogic',
+                'BackendVariable',
+                'AuthLogicForCallInterface',
+                'CallAuthInterface',
             ].includes(node.concept))
                 return;
             // 要去ls那边获取的
@@ -3693,17 +3821,17 @@ class NaslServer {
                     jsonNode.typeAnnotation = value.toJSON();
                 }
             }
-            if (node instanceof concepts_1.NewComposite && node.typeAnnotation?.typeKind === 'anonymousStructure') {
+            if (node instanceof concepts_1.NewComposite && (node.typeAnnotation?.typeKind === 'anonymousStructure' || node.typeAnnotation?.typeKind === 'generic')) {
                 const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
                 jsonNode.typeAnnotation = value.toJSON();
             }
         });
     }
     /**
-     * 获取getArgument的参数位的类型
-     * 如果内部表达式的，就用表达式的，如果没有就试试用默认值的
-     * 获取logic的默认值和原来Arg的类型和默认值对应
-     */
+ * 获取getArgument的参数位的类型
+ * 如果内部表达式的，就用表达式的，如果没有就试试用默认值的
+ * 获取logic的默认值和原来Arg的类型和默认值对应
+ */
     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') {
@@ -3825,8 +3953,8 @@ class NaslServer {
         const filePath = fileNode.getEmbeddedFilePath();
         // 如果要删除，而且当前要删Logic就直接删除并且清除错误
         /**
-         * 删除节点中的一个内容,删除了以后，就查一下引用的地方一起查一下异常
-         */
+     * 删除节点中的一个内容,删除了以后，就查一下引用的地方一起查一下异常
+     */
         let outputFiles = [];
         // 删除之前先查一下内容的依赖
         const newRefs = await this.references({
@@ -3943,7 +4071,7 @@ class NaslServer {
         }
         else if (targetNode instanceof concepts_1.ViewElement) {
             /**
-             * 因为页面组件比较特殊
+             * 因为平台类型比较特殊
              * 修改之后只用查页面本身就好了
              */
             // 更新文件之后
@@ -4071,8 +4199,8 @@ class NaslServer {
                 }
             }
             /**
-         * DataSource只会重命名时候，需要把子集全部重新生成一下
-         */
+     * DataSource只会重命名时候，需要把子集全部重新生成一下
+     */
             if (fileNode instanceof concepts_1.DataSource) {
                 fileNode.entities.forEach(async (entity) => {
                     try {