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

package/src/server/naslServer.ts

@@ -72,11 +72,15 @@ import {
     LogicItem,
     JSBlock,
     NewComposite,
+    OverriddenLogic,
     Integration,
+    Backend,
+    CallAuthInterface,
+    AuthLogicForCallInterface,
 } from '../concepts';
 import { lsp2tspNumber, SourceMap, SourceMapItem } from '../translator';
 import axios from '../service/storage';
-import { translateDiagnosticMessage, naslNodeTranslateMessage, MinRange } from './translator';
+import { translateDiagnosticMessage, naslNodeTranslateMessage, MinRange, checkAStructure_ } from './translator';
 import { EventPayload, invokeCommand, registerCommand } from '../common';
 import { DiagnosticRecord, Diagnostic, DiagnosticManager } from '../manager/diagnostic';
 import formatUiTs from './createUiTs';
@@ -97,6 +101,8 @@ const EmbeddedTSFileLineMap: { [name: string]: number } = {
 
 const EmbeddedTSFileOffsetMap: { [name: string]: number } = {
     Variable: 12,
+    // Backend:12,
+    BackendVariable: 12,
     ConfigProperty: 12,
 };
 
@@ -139,7 +145,7 @@ let timer: number = null; //超时器用于收集导入接口相关
 // 联合类型切割取出类型
 export function getDisplayString2Type(displayString: string) {
     const targetString = displayString.match(/value:\s(\S+)\)/)[1];
-    let targetType:string = null;
+    let targetType: string = null;
     if (targetString.startsWith('nasl.core.')) {
         targetType = targetString.slice(10);
     }
@@ -247,8 +253,8 @@ export 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的也直接保留
@@ -257,13 +263,21 @@ export class NaslServer {
                     const changeEvent = item.originEvent;
                     const changeNode = changeEvent.target;
                     const { fileNode } = this.getCurrentSource(changeNode);
-                    if (changeNode !== fileNode || !changeEvent.field) {
-                        const findLastIndex = (this.changeStackList as any).findLastIndex((changeStackItem: EventPayload) => {
-                            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: EventPayload) => {
+                        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();
                         }
                     }
@@ -323,6 +337,29 @@ export class NaslServer {
             }
         });
         if (module instanceof App) {
+            module.overriddenLogics?.forEach?.((logic) => {
+                try {
+                    if (!(logic instanceof 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();
@@ -344,6 +381,20 @@ export class NaslServer {
                         console.log(err);
                     }
                 });
+                frontend.bindEvents.forEach((bindEvent) => {
+                    if (bindEvent?.logics && bindEvent?.logics?.length > 0) {
+                        bindEvent.logics.forEach((logic: 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.closeViews) {
                     this.view2TSFile(frontend.views, results);
@@ -420,6 +471,30 @@ export class NaslServer {
             }
         });
 
+        (module as App)?.authLogics?.forEach?.((logic) => {
+            try {
+                if (!(logic instanceof Logic))
+                    return;
+                const result = logic.toEmbeddedTSFile();
+                results.push(result);
+                logic.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, logic);
+            } catch (err) {
+            }
+        });
+
+        (module as App)?.authLogicsForCallInterface?.forEach?.((logic) => {
+            try {
+                if (!(logic instanceof 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();
@@ -508,6 +583,8 @@ export class NaslServer {
     async refreshApp(app: App) {
         // 清除所有问题
         this.diagnosticManager.clear();
+        // 刷新要清除文件列表
+        this.file2NodeMap.clear();
         await this.deleteDirectoryFiles({ directoryName: '/embedded' });
         // 清楚check count的数量
         await this.messager.requestCommand('_clearTimeout');
@@ -519,32 +596,32 @@ export class NaslServer {
     }
 
     /**
-     * 初始化之前添加文件
-     */
+ * 初始化之前添加文件
+ */
     addFile(file: tsProtocol.OpenRequestArgs) {
         return this.messager.requestCommand('addFile', file);
     }
 
-    /**
-     * 只新增文件
-     * @param {*} files
-     */
+    /**u
+ * 只新增文件
+ * @param {*} files
+ */
     writeFiles(files: Array<tsProtocol.OpenRequestArgs>) {
         return this.messager.requestCommand('writeFiles', files);
     }
 
     /**
-     * 新增、修改
-     * 删除文件 文件用修改内容为空模拟，防止报错
-     * @param {*} args
-     */
+ * 新增、修改
+ * 删除文件 文件用修改内容为空模拟，防止报错
+ * @param {*} args
+ */
     updateFiles(args: { outputFiles: Array<tsProtocol.OpenRequestArgs> }) {
         return this.messager.requestCommand('updateFiles', args);
     }
 
     /**
-     * 清除一个目录下的所有文件
-     */
+ * 清除一个目录下的所有文件
+ */
     deleteDirectoryFiles(args: { directoryName: string }) {
         return this.messager.requestCommand('deleteDirectoryFiles', args);
     }
@@ -590,6 +667,7 @@ export class NaslServer {
     }
 
     async references(args: tsProtocol.FileLocationRequestArgs) {
+        // debugger
         return ((await this.messager.requestCommand('references', args)) as any)?.response as tsProtocol.ReferencesResponseBody;
     }
 
@@ -624,10 +702,10 @@ export class NaslServer {
         if (node && node instanceof 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 [];
@@ -782,10 +860,10 @@ export class NaslServer {
     }
 
     /**
-     * ts的 quickInfo方法，查询指定位置的详情
-     * @param args 文件信息数组
-     * @returns 查询到的
-     */
+ * ts的 quickInfo方法，查询指定位置的详情
+ * @param args 文件信息数组
+ * @returns 查询到的
+ */
     _getTypeQuickinfo(args: any) {
         return this.messager.requestCommand('quickInfo', args) as unknown as { responseRequired: boolean; response: tsProtocol.QuickInfoResponseBody };
     }
@@ -824,11 +902,11 @@ export class NaslServer {
     }
 
     /**
-     * 获取已经选中的内容的 下一级的内容
-     * @param node 已经选中的内容
-     * @param noFilterList 不过滤的key 的数据
-     * @returns 可以选择的数据数组
-     */
+ * 获取已经选中的内容的 下一级的内容
+ * @param node 已经选中的内容
+ * @param noFilterList 不过滤的key 的数据
+ * @returns 可以选择的数据数组
+ */
     getSelectNextCompletion(node: BaseNode, noFilterList?: Array<string>) {
         const { currentSource, fileNode } = this.getCurrentSource(node);
         // console.log(currentSource, fileNode);
@@ -867,8 +945,8 @@ export class NaslServer {
     }
 
     /**
-     * 节点异常是只能挂载单个，如果已经了就不赋值了
-     */
+ * 节点异常是只能挂载单个，如果已经了就不赋值了
+ */
     baseNodeAssignmentTsError(node: BaseNode, tsErrorDetail: Diagnostic) {
         if (node.tsErrorDetail)
             return;
@@ -927,6 +1005,7 @@ export class NaslServer {
                     }
                 });
             }
+            record.semanticDiagnostics.forEach((diag) => checkAStructure_(diag.text));
             record.semanticDiagnostics = record.semanticDiagnostics
                 .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode, record))
                 .filter((diag) => !!diag);
@@ -1062,6 +1141,7 @@ export class NaslServer {
      * @param fileNode 文件级别的节点
      * @returns 诊断结果
      */
+
     _attachSuggestionDiagnostics(fileNode: BaseNode): Diagnostic[] {
         const diagnostics: Diagnostic[] = [];
         if (fileNode instanceof Logic || fileNode instanceof View) {
@@ -1308,6 +1388,9 @@ export class NaslServer {
                     if ((node as JSBlock).code === `location.href = '/';`) {
                         return null;
                     }
+                    if ((node as JSBlock)?.code?.includes('use JSBlock')) {
+                        return null;
+                    }
                     const diagnostic = {
                         node,
                         severity: 'warning',
@@ -1406,10 +1489,10 @@ export class NaslServer {
     }
 
     /**
-     * 额外的诊断
-     * @param fileNode 文件级别的节点
-     * @returns 诊断结果
-     */
+ * 额外的诊断
+ * @param fileNode 文件级别的节点
+ * @returns 诊断结果
+ */
     _attachDiagnostics(fileNode: BaseNode): Diagnostic[] {
         // 每次诊断前先清空这个Set
         this.logicSetWithComponentLogic = new Set<string>();
@@ -2056,18 +2139,18 @@ export 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 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') {
@@ -2198,11 +2281,11 @@ export class NaslServer {
     }
 
     /**
-     * 单个问题的诊断处理
-     * @param diagnostic 诊断问题
-     * @param fileNode 页面节点
-     * @returns 处理后的结果
-     */
+ * 单个问题的诊断处理
+ * @param diagnostic 诊断问题
+ * @param fileNode 页面节点
+ * @returns 处理后的结果
+ */
     _resolveDiagnostic(diagnostic: tsProtocol.DiagnosticWithFileName, fileNode: FileNode, record: DiagnosticRecord): Diagnostic {
         // 拓展模块中的翻译先过滤掉，因为有错用户也不能修改
         if ((fileNode as any).module && !(fileNode instanceof ConfigProperty)) {
@@ -2212,7 +2295,9 @@ export 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',
@@ -2235,11 +2320,11 @@ export class NaslServer {
     }
 
     /**
-     * 通过节点诊断反过来查找节点
-     * @param diagnostic 诊断信息
-     * @param fileNode 文件级别节点
-     * @returns 找到的节点
-     */
+ * 通过节点诊断反过来查找节点
+ * @param diagnostic 诊断信息
+ * @param fileNode 文件级别节点
+ * @returns 找到的节点
+ */
     _findMinRange(diagnostic: tsProtocol.DiagnosticWithFileName | tsProtocol.ReferencesResponseItem, fileNode: FileNode) {
         let minRange: MinRange;
         const sourceMap: SourceMap = fileNode.sourceMap;
@@ -2279,7 +2364,13 @@ export 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 };
                         }
                     }
@@ -2304,8 +2395,8 @@ export class NaslServer {
         const { currentSource, fileNode } = this.getCurrentSource(node);
         let refsList: tsProtocol.ReferencesResponseItem[] = [];
         /**
-         * 未完成创建的节点 ，或者异常情况 可能找不到节点
-         */
+     * 未完成创建的节点 ，或者异常情况 可能找不到节点
+     */
         if (currentSource) {
             const newRefs = await this.references({
                 file: (fileNode as FileNode).getEmbeddedFilePath(),
@@ -2341,12 +2432,12 @@ export class NaslServer {
                 const dataSourceFile = (fileNode as 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)) {
@@ -2407,12 +2498,12 @@ export class NaslServer {
             refsList = [...refsList, ...filterViewRefs];
         }
         /**
-         * 暂时不要了， 因为生成的结构发生了变化
-         * view 因为不是嵌套的，所以不能用最前面的变量查找，所以要单独处理一下
-         * 找到第一个 { 之前的变量 进行修改
-         * 如果是VIew的查找，比较特殊，他查的是当前抛出的 {} 大括号前的
-         * 最后一个，因为生成的规则不一样
-         */
+     * 暂时不要了， 因为生成的结构发生了变化
+     * view 因为不是嵌套的，所以不能用最前面的变量查找，所以要单独处理一下
+     * 找到第一个 { 之前的变量 进行修改
+     * 如果是VIew的查找，比较特殊，他查的是当前抛出的 {} 大括号前的
+     * 最后一个，因为生成的规则不一样
+     */
         // if (node instanceof View) {
         //     const code = currentSource.code;
         //     const viewIndex = code.indexOf(' {');
@@ -2424,8 +2515,8 @@ export class NaslServer {
         //     refsList = [...viewRefs.refs];
         // }
         /**
-         * elements 需要查的是__elements.后面的那个内容,过滤两个为了生成内容的节点
-         */
+     * elements 需要查的是__elements.后面的那个内容,过滤两个为了生成内容的节点
+     */
         if (node instanceof ViewElement) {
             if (currentSource) {
                 const code = currentSource.code;
@@ -2565,13 +2656,13 @@ export class NaslServer {
     }
 
     /**
-     * 查找引用，并且做一些 修改前的准备工作，
-     * 有引用有的话，就返回集合
-     * @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: BaseNode, refsList: any[], newValue: string) {
         const oldName = node?.name;
         const result = refsList
@@ -2714,7 +2805,9 @@ export class NaslServer {
                         // 如果是修改实体，引发节点依赖实体发生改变的
                         if (minRange.node instanceof EntityProperty) {
                             minRange.setTypeMethods = 'setRelationEntity';
-                        } else if (minRange.node instanceof QueryFieldExpression || minRange.node instanceof QueryGroupByExpression) {
+                        } else if (minRange.node instanceof QueryFieldExpression) {
+                            minRange.setTypeMethods = 'setEntityAsNameAndEffect';
+                        } else if (minRange.node instanceof QueryGroupByExpression) {
                             minRange.setTypeMethods = 'setEntityAsName';
                         } else if (minRange.node instanceof QueryFromExpression || minRange.node instanceof QueryJoinExpression) {
                             minRange.setTypeMethods = 'setEntityName';
@@ -2941,12 +3034,17 @@ export class NaslServer {
                     if (minRange.node instanceof BindEvent && node instanceof Param) {
                         return null;
                     }
+
+                    if (minRange.node instanceof Argument && node instanceof Param) {
+                        minRange.setTypeMethods = 'setKeyword';
+                    }
+
                     /**
-                     * 理论上 logic setName只能自己触发，别的地方查到引用都不用重命名
-                     * 流程改名不触发Logic改名
-                     * 如果是修改param查找到logic就不操作
-                     * 除非想在内部修改别的内容所以暂时屏蔽掉
-                     */
+                 * 理论上 logic setName只能自己触发，别的地方查到引用都不用重命名
+                 * 流程改名不触发Logic改名
+                 * 如果是修改param查找到logic就不操作
+                 * 除非想在内部修改别的内容所以暂时屏蔽掉
+                 */
                     if (minRange.node instanceof Logic && node !== minRange.node) {
                         return null;
                     }
@@ -2993,7 +3091,17 @@ export 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;
     }
 
@@ -3007,8 +3115,20 @@ export class NaslServer {
             const minRange: MinRange = this._findMinRange(record, fileNode as FileNode);
             if (minRange) {
                 // 如果找到节点是callLogic就去更新
-                if ((minRange.node instanceof CallLogic || minRange.node instanceof Destination) && node instanceof Param) {
-                    minRange.node.addCalleeArg(parantNode as any);
+                if (node instanceof Param) {
+                    if (minRange.node instanceof CallLogic) {
+                        minRange.node.addCalleeArg(parantNode as any);
+                    } else if (minRange.node instanceof Destination) {
+                        // 跳转页面，可能在父级下增加参数，子的跳转页面也可以查找到引用
+                        // 精准匹配子页面的内容
+                        const viewNode = node.parentNode;
+                        if (viewNode instanceof View) {
+                            const viewNamespace = viewNode.getNamespace();
+                            if (viewNamespace === minRange.node.viewNamespace && viewNode.name === minRange.node.viewName) {
+                                minRange.node.addCalleeArg(parantNode as any);
+                            }
+                        }
+                    }
                 }
             }
         });
@@ -3178,11 +3298,11 @@ export class NaslServer {
     }
 
     /**
-     * 处理tree的队列，把相同节点进行合并
-     * 这里把当前二维数组进行一个整合
-     * @param arr 当前页面下的queue的二维数组，一个数组下有多条链路
-     * @returns 最后要使用到的节点和对应的子集
-     */
+ * 处理tree的队列，把相同节点进行合并
+ * 这里把当前二维数组进行一个整合
+ * @param arr 当前页面下的queue的二维数组，一个数组下有多条链路
+ * @returns 最后要使用到的节点和对应的子集
+ */
     handleTreeQueue(queueLists: Array<Array<QuoteNode>>) {
         const map = new Map<QuoteNode, Array<QuoteNode>>();
         let root: QuoteNode = null;
@@ -3210,11 +3330,11 @@ export class NaslServer {
     }
 
     /**
-     * 递归调用输出结果
-     * @param root 一个根节点
-     * @param map 当前所有节点的map对象
-     * @returns 当前节点，最后输出所有节点
-     */
+ * 递归调用输出结果
+ * @param root 一个根节点
+ * @param map 当前所有节点的map对象
+ * @returns 当前节点，最后输出所有节点
+ */
     _recursionCreateResult(root: QuoteNode, map: Map<QuoteNode, Array<QuoteNode>>) {
         const children = (map.get(root) || []).map((item: QuoteNode) => this._recursionCreateResult(item, map));
         if (children && children.length) {
@@ -3224,9 +3344,9 @@ export class NaslServer {
     }
 
     /**
-     *  获取
-     *  当前this上下文 的Source 和 父级文件级别的节点
-     */
+ *  获取
+ *  当前this上下文 的Source 和 父级文件级别的节点
+ */
     getCurrentSource(node: BaseNode) {
         if (node instanceof App || node instanceof Theme)
             return { fileNode: null };
@@ -3243,6 +3363,7 @@ export class NaslServer {
             && !(fileNode.parentNode instanceof Module)
             && !(fileNode.parentNode instanceof DataSource)
             && !(fileNode.parentNode instanceof Frontend)
+            && !(fileNode.parentNode instanceof Backend)
             && !(fileNode instanceof View)
             && !(fileNode instanceof ConfigProperty)
         ) {
@@ -3334,9 +3455,9 @@ export class NaslServer {
     }
 
     /**获取当前节点的已知类型
-     * @param node 当前要获取类型的节点
-     * @returns 不需要去查就可以返回类型的节点
-     */
+ * @param node 当前要获取类型的节点
+ * @returns 不需要去查就可以返回类型的节点
+ */
     getCurrentNodeKnownTypeAnnotation(node: BaseNode) {
         if (node.concept === 'StringLiteral' || node.concept === 'StringInterpolation' || node.concept === 'BooleanLiteral' || node.concept === 'NullLiteral') {
             let type = 'String';
@@ -3457,6 +3578,11 @@ export class NaslServer {
                 'QueryFieldExpression',
                 'QueryGroupByExpression',
                 'Param',
+                'AuthLogic',
+                'AuthLogic',
+                'BackendVariable',
+                'AuthLogicForCallInterface',
+                'CallAuthInterface',
             ].includes(node.concept))
                 return;
 
@@ -3798,7 +3924,7 @@ export class NaslServer {
                     jsonNode.typeAnnotation = (value as TypeAnnotation).toJSON();
                 }
             }
-            if (node instanceof NewComposite && node.typeAnnotation?.typeKind === 'anonymousStructure') {
+            if (node instanceof NewComposite && (node.typeAnnotation?.typeKind === 'anonymousStructure' || node.typeAnnotation?.typeKind === 'generic')) {
                 const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
                 jsonNode.typeAnnotation = (value as TypeAnnotation).toJSON();
             }
@@ -3806,10 +3932,10 @@ export class NaslServer {
     }
 
     /**
-     * 获取getArgument的参数位的类型
-     * 如果内部表达式的，就用表达式的，如果没有就试试用默认值的
-     * 获取logic的默认值和原来Arg的类型和默认值对应
-     */
+ * 获取getArgument的参数位的类型
+ * 如果内部表达式的，就用表达式的，如果没有就试试用默认值的
+ * 获取logic的默认值和原来Arg的类型和默认值对应
+ */
     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') {
@@ -3935,8 +4061,8 @@ export class NaslServer {
         const filePath = (fileNode as FileNode).getEmbeddedFilePath();
         // 如果要删除，而且当前要删Logic就直接删除并且清除错误
         /**
-         * 删除节点中的一个内容,删除了以后，就查一下引用的地方一起查一下异常
-         */
+     * 删除节点中的一个内容,删除了以后，就查一下引用的地方一起查一下异常
+     */
         let outputFiles: any = [];
         // 删除之前先查一下内容的依赖
         const newRefs = await this.references({
@@ -4063,7 +4189,7 @@ export class NaslServer {
             // }
         } else if (targetNode instanceof ViewElement) {
             /**
-             * 因为页面组件比较特殊
+             * 因为平台类型比较特殊
              * 修改之后只用查页面本身就好了
              */
             // 更新文件之后
@@ -4188,8 +4314,8 @@ export class NaslServer {
                 }
             }
             /**
-         * DataSource只会重命名时候，需要把子集全部重新生成一下
-         */
+     * DataSource只会重命名时候，需要把子集全部重新生成一下
+     */
             if (fileNode instanceof DataSource) {
                 (fileNode as DataSource).entities.forEach(async (entity) => {
                     try {