@lcap/nasl 3.4.0-beta.5 → 3.4.0-beta.6

package/src/server/naslServer.ts

@@ -79,17 +79,17 @@ import {
   CallAuthInterface,
   Connector,
   AuthInterface,
-  SyntaxNode,
   Connection,
   TriggerLauncher,
   CallConnector,
   DefaultValue,
   I18nInfo,
-  InterfaceFromExample,
-  MetadataType
+  MetadataType,
+  UnaryExpression,
+  SyntaxNode,
 } from '../concepts';
 
-import { lsp2tspNumber, SourceMap, SourceMapItem, isSameRange } from '../translator';
+import { lsp2tspNumber, SourceMap, SourceMapItem, isSameRange, Range } from '../translator';
 import axios from '../service/storage';
 import { translateDiagnosticMessage, naslNodeTranslateMessage, MinRange, checkAStructure_ } from './translator';
 import { EventPayload, invokeCommand, registerCommand } from '../common';
@@ -104,7 +104,6 @@ import { EventEmitter } from '../common/EventEmitter';
 
 import { traverse } from '../utils';
 import { withQueueExecute } from '../decorators';
-
 import { getNodeByNodeCallee } from '../automate/engine/utils';
 
 const EmbeddedTSFileLineMap: { [name: string]: number } = {
@@ -123,11 +122,7 @@ const SentryMessager = sentryMonitorTSWorkerMessager(Messager);
 
 export interface FileNode extends BaseNode {
   getEmbeddedFilePath(name?: string): string;
-  toEmbeddedTSFile(): {
-    filePath: string;
-    code: string;
-    sourceMap: SourceMap;
-  };
+  toEmbeddedTSFile(): utils.EmbeddedTSFileGenerator;
 }
 
 interface RenameMinRange extends MinRange {
@@ -144,6 +139,7 @@ interface QuoteNode {
 
 // 批量查找节点位置的节点信息类型
 type QuickInfoNodes = Array<{ filePath: string; node: BaseNode; item: SourceMapItem }>;
+type QuickInfoMap = Map<BaseNode, TypeAnnotation | { typeAnnotation: TypeAnnotation; option: any }>;
 
 let isChangeInterface = false; // 判断是否导入接口
 type ActionNode = { target: Variable; typeannotation: TypeAnnotation };
@@ -188,7 +184,6 @@ export function getDisplayString2Type(displayString: string) {
   return typeList;
 }
 
-
 function isCoreDateTimeType(n : Argument): boolean {
   return n?.expression?.__TypeAnnotation?.typeName === 'DateTime' &&
           n?.expression?.__TypeAnnotation?.typeNamespace === 'nasl.core';
@@ -199,7 +194,6 @@ function isFunctionWithFixedTimeZoneParam(calleeName : string): boolean {
   return fns.includes(calleeName);
 }
 
-
 const timeZoneArgumentIndexMap = new Map<string, number>([
   ['ToString', 1],
   ['CurrDateTime', 0],
@@ -284,7 +278,7 @@ class NaslServer {
       handleMessage: async ({ data }: any) => {
         if (data && data.event === 'publishDiagnostics') {
           const records = await this._resolveDiagnosticRecords(data.records);
-          this.diagnosticManager.pushAll(records);
+          await this.diagnosticManager.pushAll(records);
           try {
             // 结束诊断和标注
             invokeCommand('naslServer:endWork');
@@ -380,308 +374,145 @@ class NaslServer {
     await this.getDiagnosticRecordsAndPushAll();
   }
 
-  contentToFile(module: Module | App | Connector, results: Array<ReturnType<Structure['toEmbeddedTSFile']>>) {
-    // 禁用的依赖库不生成代码 区分 undefined 和 false
-    if (module instanceof Module && module.type === 'extension' && module.enable === false) {
-      return;
-    }
-    module.structures.forEach((structure) => {
-      try {
-        const result = structure.toEmbeddedTSFile();
-        results.push(result);
-        // sourceMap都存在目录级别内容下，在页面层级下去找
-        structure.sourceMap = result.sourceMap;
-        this.file2NodeMap.set(result.filePath, structure);
-      } catch (err) {}
-    });
-    module.metadataTypes?.forEach((metadataType) => {
-      try {
-        const result = metadataType.toEmbeddedTSFile();
-        results.push(result);
-        // sourceMap都存在目录级别内容下，在页面层级下去找
-        metadataType.sourceMap = result.sourceMap;
-        this.file2NodeMap.set(result.filePath, metadataType);
-      } catch (err) {}
-    });
-    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();
-          results.push(result);
-          // sourceMap都存在目录级别内容下，在页面层级下去找
-          frontend.sourceMap = result.sourceMap;
-          this.file2NodeMap.set(result.filePath, frontend);
-        } catch (err) {
-          console.log(err);
-        }
-        frontend.variables?.forEach((frontendVariable) => {
-          try {
-            const result = frontendVariable.toEmbeddedTSFile();
-            results.push(result);
-            // sourceMap都存在目录级别内容下，在页面层级下去找
-            frontendVariable.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, frontendVariable);
-          } catch (err) {
-            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);
-        }
-        frontend.componentDependencies?.forEach((item) => this.contentToFile(item, results));
-      });
-    } else {
-      module.frontends?.forEach((frontend) => {
-        try {
-          frontend.logics.forEach((logic) => {
-            const result = logic.toEmbeddedTSFile();
-            results.push(result);
-            // sourceMap都存在目录级别内容下，在页面层级下去找
-            logic.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, logic);
-          });
-        } catch (err) {
-          console.log(err);
-        }
-      });
+  private *contentToFile(module: Module | App | Connector): Generator<any, utils.EmbeddedTSFileResult[], any> {
+    if (!module) {
+      return[];
     }
 
-    (module as App).dataSources?.forEach((dataSource) => {
-      // 本身dataSource也要生成一个文件用于改名
-      try {
-        const result = dataSource.toEmbeddedTSFile();
-        results.push(result);
-        // sourceMap都存在目录级别内容下，在页面层级下去找
-        dataSource.sourceMap = result.sourceMap;
-        this.file2NodeMap.set(result.filePath, dataSource);
-      } catch (err) {}
-      dataSource.entities.forEach((entity) => {
-        try {
-          const result = entity.toEmbeddedTSFile();
-          results.push(result);
-          // sourceMap都存在目录级别内容下，在页面层级下去找
-          entity.sourceMap = result.sourceMap;
-          this.file2NodeMap.set(result.filePath, entity);
-        } catch (err) {}
-      });
-    });
+    const self = this;
+    const results: utils.EmbeddedTSFileResult[] = [];
+    const getTsFile = function* getTsFile(node: FileNode, name: string, pre?: Function) {
+      const isContinue = pre ? (input: unknown) => input instanceof pre : () => true;
 
-    module?.interfaces?.forEach((_itf) => {
       try {
-        // interface 接口可能为 InterfaceFromExample 类型，因此这里需要做兼容
-        let _interface: Interface;
-        if (_itf instanceof InterfaceFromExample) {
-          _interface = _itf.inter as Interface;
-        } else {
-          _interface = _itf as Interface;
+        if (!isContinue(node)) {
+          return;
         }
-        const result = _interface.toEmbeddedTSFile();
-        results.push(result);
-        // sourceMap都存在目录级别内容下，在页面层级下去找
-        _interface.sourceMap = result.sourceMap;
-        this.file2NodeMap.set(result.filePath, _interface);
-      } catch (err) {}
-    });
-    module?.enums?.forEach((_enum) => {
-      try {
-        const result = _enum.toEmbeddedTSFile();
-        results.push(result);
-        // sourceMap都存在目录级别内容下，在页面层级下去找
-        _enum.sourceMap = result.sourceMap;
-        this.file2NodeMap.set(result.filePath, _enum);
-      } catch (err) {}
-    });
-    module?.logics?.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)?.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) {}
-    });
+        const result = yield* node.toEmbeddedTSFile();
 
-    (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) {}
-    });
+        node.sourceMap = result.sourceMap;
+        self.file2NodeMap.set(result.filePath, node);
+      } catch (err) {
+        if (process.env.NODE_ENV === 'development') {
+          console.warn(node.nodePath ? node.nodePath : name, '代码转换失败', err);
+        }
+      }
+    };
+    const getTsFiles = function* getTsFiles(nodes: FileNode[], name: string, pre?: Function) {
+      for (const node of nodes ?? []) {
+        yield* getTsFile(node, name, pre);
+      }
+    };
+    const concat = <T, K extends keyof T>(arr: T[], key: K): T[K] => {
+      return arr.reduce((ans, item) => ans.concat(item[key]), []) as any;
+    };
+    const view2TSFile = function* view2TSFile(views: View[]): Generator<void, void, any> {
+      if (!views || views.length === 0) {
+        return;
+      }
 
-    module.processes?.forEach((process) => {
-      try {
-        const result = process.toEmbeddedTSFile();
-        results.push(result);
-        process.sourceMap = result.sourceMap;
-        this.file2NodeMap.set(result.filePath, process);
-      } catch (err) {}
-    });
+      for (const view of views) {
+        yield* getTsFile(view, 'view');
 
-    if (module instanceof Connector) {
-      try {
-        module.triggerLaunchers?.forEach((launcher) => {
-          const result = launcher.toEmbeddedTSFile();
-          results.push(result);
-          // sourceMap都存在目录级别内容下，在页面层级下去找
-          launcher.sourceMap = result.sourceMap;
-          this.file2NodeMap.set(result.filePath, launcher);
-        });
-        module.namespaces?.forEach?.((namespace) => {
-          namespace.logics.forEach((logic) => {
-              const result = logic.toEmbeddedTSFile();
-              results.push(result);
-              // sourceMap都存在目录级别内容下，在页面层级下去找
-              logic.sourceMap = result.sourceMap;
-              this.file2NodeMap.set(result.filePath, logic);
-          });
-        })
-        module?.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) {}
-        });
-      } catch (error) {
-        console.error(error);
+        if (view.children) {
+          yield* view2TSFile(view.children);
+        }
       }
+    };
+
+    // 禁用的依赖库不生成代码 区分 undefined 和 false
+    if (module instanceof Module && module.type === 'extension' && module.enable === false) {
+      return [];
     }
 
+    const {
+      structures = [],
+      metadataTypes = [],
+      frontends = [],
+      interfaces = [],
+      enums = [],
+      logics = [],
+      authLogics = [],
+      authLogicsForCallInterface = [],
+      processes = [],
+      dataSources = [],
+      triggerLaunchers = [],
+      connections = [],
+      roles = [],
+      overriddenLogics = [],
+      backend,
+      configuration,
+    } = module as App;
+
+    const {
+      namespaces = [],
+    } = module as Connector;
+
+    yield* getTsFiles(structures, 'structure');
+    yield* getTsFiles(metadataTypes, 'metadataType');
+
     if (module instanceof App) {
-      module?.roles?.forEach((role) => {
-        try {
-          const result = role.toEmbeddedTSFile();
-          results.push(result);
-          // sourceMap都存在目录级别内容下，在页面层级下去找
-          role.sourceMap = result.sourceMap;
-          this.file2NodeMap.set(result.filePath, role);
-        } catch (err) {}
-      });
+      yield* getTsFiles(overriddenLogics, 'overriddenLogic', OverriddenLogic);
+      yield* getTsFiles(backend?.variables ?? [], 'backend_variable');
+
+      for (const frontend of frontends) {
+        yield* getTsFile(frontend, 'frontend');
+        yield* getTsFiles(frontend.variables, 'frontend_variable');
+        yield* getTsFiles(concat(frontend.bindEvents, 'logics'), 'frontend_bindEvent_logic');
+
+        if (!config.closeViews) {
+          yield* view2TSFile(frontend.views);
+        }
+
+        for (const dep of frontend.componentDependencies) {
+          results.push(...(yield* self.contentToFile(dep)));
+        }
+      }
+    } else {
+      yield* getTsFiles(concat(frontends, 'logics' as any), 'frontend_logic');
+    }
+
+    yield* getTsFiles(dataSources, 'dataSource');
+    yield* getTsFiles(concat(dataSources, 'entities'), 'dataSource_entity');
+    yield* getTsFiles(interfaces as FileNode[], 'interface');
+    yield* getTsFiles(enums, 'enum');
+    yield* getTsFiles(logics, 'logic');
+    yield* getTsFiles(authLogics, 'authLogic', Logic);
+    yield* getTsFiles(authLogicsForCallInterface, 'authLogicForCallInterface', Logic);
+    yield* getTsFiles(processes, 'process');
+
+    if (module instanceof Connector) {
+      yield* getTsFiles(triggerLaunchers, 'triggerLauncher');
+      yield* getTsFiles(authLogicsForCallInterface, 'authLogicForCallInterface');
+      yield* getTsFiles(concat(namespaces, 'logics'), 'namespaces_logic');
     }
 
     if (module instanceof App) {
-      module.connections?.forEach?.((connection) => {
-        try {
-          const result = connection.toEmbeddedTSFile();
-          results.push(result);
-          // sourceMap都存在目录级别内容下，在页面层级下去找
-          connection.sourceMap = result.sourceMap;
-          this.file2NodeMap.set(result.filePath, connection);
-        } catch (err) {}
-      });
-      module.triggerLaunchers?.forEach?.((triggerLauncher) => {
-        try {
-          const result = triggerLauncher.toEmbeddedTSFile();
-          results.push(result);
-          // sourceMap都存在目录级别内容下，在页面层级下去找
-          triggerLauncher.sourceMap = result.sourceMap;
-          this.file2NodeMap.set(result.filePath, triggerLauncher);
-        } catch (err) {}
-      });
+      yield* getTsFiles(roles, 'role');
+      yield* getTsFiles(connections, 'connection');
+      yield* getTsFiles(triggerLaunchers, 'triggerLauncher');
     }
 
-    module.configuration?.groups?.forEach((_group) => {
-      if (_group.name === 'custom') {
-        _group.properties.forEach((_property) => {
-          try {
-            const result = _property.toEmbeddedTSFile();
-            results.push(result);
-            // sourceMap都存在目录级别内容下，在页面层级下去找
-            _property.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, _property);
-          } catch (err) {}
-        });
+    for (const group of configuration?.groups ?? []) {
+      if (group.name === 'custom') {
+        yield* getTsFiles(group?.properties ?? [], 'configuration_group_property');
       }
-    });
-  }
-
-  view2TSFile(viewsChildren: View[], results: Array<ReturnType<Structure['toEmbeddedTSFile']>>) {
-    // 如果有子页面
-    if (viewsChildren && viewsChildren.length) {
-      viewsChildren.forEach((view) => {
-        try {
-          const result = view.toEmbeddedTSFile();
-          results.push(result);
-          view.sourceMap = result.sourceMap;
-          this.file2NodeMap.set(result.filePath, view);
-          if (view.children.length) {
-            this.view2TSFile(view.children, results);
-          }
-        } catch (err) {}
-      });
     }
+
+    return results;
   }
 
   async openApp(app: App) {
     console.time('生成 TS 文件');
-    const results: Array<ReturnType<Structure['toEmbeddedTSFile']>> = [];
-    try {
-      // app的创建内容
-      this.contentToFile(app, results);
-      // 其他模块的创建内容
-      app.integration?.connectors?.forEach((item) => this.contentToFile(item, results));
-      app.dependencies.forEach((item) => this.contentToFile(item, results));
-      app.interfaceDependencies.forEach((item) => this.contentToFile(item, results));
-    } catch (err) {
-      console.log(err);
-    }
-
+    const self = this;
+    const results = await utils.timeSlicingWithGenerator(getAllTsFiles());
     const files = results.map((result) => ({
       file: result.filePath,
       fileContent: result.code,
     }));
+
     await this.writeFiles(files);
     this._debugInFileStorage(app, files);
     // 修改名称回调
@@ -693,6 +524,21 @@ class NaslServer {
       callback();
     });
     console.timeEnd('生成 TS 文件');
+
+    function* getAllTsFiles() {
+      const files = yield* self.contentToFile(app);
+      const otherModules = [
+        ...app.integration?.connectors ?? [],
+        ...app.dependencies ?? [],
+        ...app.interfaceDependencies ?? [],
+      ];
+
+      for (const item of otherModules) {
+        files.push(...yield* self.contentToFile(item));
+      }
+
+      return files;
+    }
   }
 
   async refreshApp(app: App) {
@@ -723,13 +569,19 @@ class NaslServer {
     __naslStdlibFileCacheMap.set(options.file, options);
   }
 
-  /** u
+  /**
    * 只新增文件
    * @param {*} files
    */
   writeFiles(files: Array<tsProtocol.OpenRequestArgs>) {
     files.forEach(({ file, fileContent }) => this.tsFiles.set(file, fileContent));
-    return this.messager.requestCommand('writeFiles', files);
+    const noRepeatFiles = Array.from(this.tsFiles.entries()).map(([key, value]) => ({
+      file: key,
+      fileContent: value,
+    }));
+    // const newFiles = require('/Users/sufangzhou/dev/neteast/lcap-ide/packages/nasl/tmp/files-original.json');
+    // debugger;
+    return this.messager.requestCommand('writeFiles', noRepeatFiles);
   }
 
   /**
@@ -837,7 +689,7 @@ class NaslServer {
    */
   async getConvertTypeInfo(node: BaseNode) {
     if (node && node instanceof BaseNode) {
-      const callFunction = node.parentNode.parentNode;
+      const callFunction = node.parentNode.parentNode as BaseNode;
       /**
        * currentSource callFunction 的节点，要去到当前节点的位置
        * nasl.util.Convert(xxx),所以取到的位置要 + `nasl.util.C` 的长度
@@ -1077,26 +929,29 @@ class NaslServer {
     node.tsErrorDetail = tsErrorDetail;
   }
 
-  /**
-   * 处理诊断结果
-   * @param records 结果
-   * @returns 过滤或者转换后的诊断结果
-   */
-  @withQueueExecute('diagnostic')
-  async _resolveDiagnosticRecords(records: Array<DiagnosticRecord>) {
+  private *_resolveDiagnosticRecordsWithGenerator(records: Array<DiagnosticRecord>) {
     // 热更新类型标注
     if (records.length) {
-      await this.IncrementalAnnotationJSON(records);
+      yield* this._incrementalAnnotationJSONWithGenerator(records);
     }
-    await Promise.all(
-      records.map(async (record) => {
-        const {node} = record;
-        if (!node) return;
 
-        // 先获取原来的节点先清除一下之前有异常的节点，下面重新赋值
-        const oldRecord = this.diagnosticManager.getRecord?.(record.id);
+    const self = this;
 
-        oldRecord?.semanticDiagnostics.forEach((item) => {
+    console.time('处理诊断数据');
+
+    yield* utils.wrapForEachToGenerator(records, function* resolveRecord(record) {
+      if (!record || !record.node) {
+        return;
+      }
+
+      const { node } = record;
+
+      // 先获取原来的节点先清除一下之前有异常的节点，下面重新赋值
+      const oldRecord = self.diagnosticManager.getRecord?.(record.id);
+
+      // 处理旧数据
+      if (oldRecord) {
+        yield* utils.wrapForEachToGenerator(oldRecord.semanticDiagnostics, (item) => {
           if (item.node) {
             delete item.node.tsErrorDetail;
             // 如果logic中有报错就把标识置为true
@@ -1106,8 +961,7 @@ class NaslServer {
           }
         });
 
-        // 清空一些状态
-        oldRecord?.suggestionDiagnostics.forEach((item) => {
+        yield* utils.wrapForEachToGenerator(oldRecord.suggestionDiagnostics, (item) => {
           if (item.node) {
             delete item.node.tsErrorDetail;
             if (item.node && item.node instanceof Logic) {
@@ -1115,146 +969,173 @@ class NaslServer {
             }
           }
         });
+      }
 
-        // 语义诊断
-        if (isChangeInterface) {
-          this.existStructureFix(record.semanticDiagnostics, record.node as FileNode, this);
-        }
+      // 语义诊断
+      if (isChangeInterface) {
+        yield* self.existStructureFix(record.semanticDiagnostics, record.node as FileNode, self);
+      }
 
-        // 单独处理 oql 语义错误提示
-        if (record.node instanceof Logic) {
-          record?.syntaxDiagnostics.forEach((item) => {
-            const minRange = this._findMinRange(item as unknown as tsProtocol.DiagnosticWithFileName, record.node as FileNode);
-            if (minRange?.node instanceof OqlQueryComponent) {
-              if (item.text === 'Invalid character.') {
-                record.semanticDiagnostics.push(item);
-              }
+      // 单独处理 oql 语义错误提示
+      if (record.node instanceof Logic) {
+        yield* utils.wrapForEachToGenerator(record?.syntaxDiagnostics, function *test(item) {
+          const minRange = yield* self._findMinRangeWithGenerator(item as unknown as tsProtocol.DiagnosticWithFileName, record.node as FileNode);
+          if (minRange?.node instanceof OqlQueryComponent) {
+            if (item.text === 'Invalid character.') {
+              record.semanticDiagnostics.push(item);
             }
-          });
-        }
+          }
+        });
+      }
+
+      // 记录结构体数据
+      yield* utils.wrapForEachToGenerator(record.semanticDiagnostics, (diag) => {
+        checkAStructure_(diag.text);
+      });
 
-        // 记录结构体数据
-        record.semanticDiagnostics.forEach((diag) => checkAStructure_(diag.text));
-
-        record.semanticDiagnostics = record.semanticDiagnostics
-          .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, record.node as FileNode, record))
-          .filter((diag) => !!diag);
-        record.semanticDiagnostics.push(...(await this._attachDiagnostics(node)));
-
-        // 报错降级逻辑
-        record.semanticDiagnostics = record.semanticDiagnostics
-          .map((diagnostic) => {
-            // 错误降级如果属于草稿态的就降级
-            if (diagnostic?.node) {
-              let currentNode = diagnostic.node;
-              if (diagnostic.severity === 'warning') {
+      record.semanticDiagnostics = (
+        yield*
+        utils.wrapMapToGenerator(record.semanticDiagnostics, function* (diag) {
+          return yield* self._resolveDiagnosticWithGenerator(
+            diag as unknown as tsProtocol.DiagnosticWithFileName,
+            record.node as FileNode,
+            record
+          );
+        })
+      ).filter((diag) => !!diag);
+
+      record.semanticDiagnostics.push(...(yield* self._attachDiagnosticsWithGenerator(node)));
+
+      // 报错降级逻辑
+      record.semanticDiagnostics = (
+        yield*
+        utils.wrapMapToGenerator(record.semanticDiagnostics, (diagnostic) => {
+          // 错误降级如果属于草稿态的就降级
+          if (diagnostic?.node) {
+            let currentNode = diagnostic.node;
+            if (diagnostic.severity === 'warning') {
+              record.suggestionDiagnostics.push(diagnostic);
+              return null;
+            } if (currentNode.concept === 'OqlQueryComponent') {
+              // OQL别名错误降级为警告
+              if (diagnostic.originalDiagnostic && diagnostic.originalDiagnostic?.text.includes('__OQL_ALIAS_WARNING__')) {
+                // 重置 图标和错误等级
+                diagnostic.severity = 'warning';
+                if (diagnostic.node?.tsErrorDetail) {
+                  // 重置组件节点上的错误信息
+                  diagnostic.node.tsErrorDetail.severity = 'warning';
+                }
                 record.suggestionDiagnostics.push(diagnostic);
                 return null;
-              } if (currentNode.concept === 'OqlQueryComponent') {
-                // OQL别名错误降级为警告
-                if (diagnostic.originalDiagnostic && diagnostic.originalDiagnostic?.text.includes('__OQL_ALIAS_WARNING__')) {
-                  // 重置 图标和错误等级
-                  diagnostic.severity = 'warning';
-                  if (diagnostic.node?.tsErrorDetail) {
-                    // 重置组件节点上的错误信息
-                    diagnostic.node.tsErrorDetail.severity = 'warning';
-                  }
-                  record.suggestionDiagnostics.push(diagnostic);
-                  return null;
-                }
               }
-              while (currentNode && currentNode?.parentNode?.concept !== 'App') {
-                if (currentNode.parentKey?.toLowerCase()?.includes('playground')) {
-                  // 草稿区降级
-                  // 重置 图标和错误等级
-                  diagnostic.severity = 'warning';
-                  if (diagnostic.node?.tsErrorDetail) {
-                    // 重置组件节点上的错误信息
-                    diagnostic.node.tsErrorDetail.severity = 'warning';
-                  }
-                  record.suggestionDiagnostics.push(diagnostic);
-                  return null;
+            }
+            while (currentNode && currentNode?.parentNode?.concept !== 'App') {
+              if (currentNode.parentKey?.toLowerCase()?.includes('playground')) {
+                // 草稿区降级
+                // 重置 图标和错误等级
+                diagnostic.severity = 'warning';
+                if (diagnostic.node?.tsErrorDetail) {
+                  // 重置组件节点上的错误信息
+                  diagnostic.node.tsErrorDetail.severity = 'warning';
                 }
-                currentNode = currentNode.parentNode;
+                record.suggestionDiagnostics.push(diagnostic);
+                return null;
               }
+              currentNode = currentNode.parentNode as BaseNode;
+            }
 
-              // 没有降级的继续遍历，如果在logic中，logic本身需要有error状态
-              // 如果logic中有报错就把标识置为true
-              if ((diagnostic.node as any)?.logic) {
-                (diagnostic.node as any).logic.haveError = true;
-              }
+            // 没有降级的继续遍历，如果在logic中，logic本身需要有error状态
+            // 如果logic中有报错就把标识置为true
+            if ((diagnostic.node as any)?.logic) {
+              (diagnostic.node as any).logic.haveError = true;
             }
-            return diagnostic;
-          })
-          .filter((diag) => !!diag);
-
-        // 处理后的警告异常提示信息
-        record.suggestionDiagnostics = record.suggestionDiagnostics
-          .map((diag) => {
-            // 上面错误降级下来的
-            if (diag?.node) {
-              return diag;
-              // 一些已知警告的单独处理
-            } if (
-              [
-                `'__LogicEmpty' is declared but its value is never read.`,
-                `'__destinationEmpty__' is declared but its value is never read.`,
-                `'__devConfigValueEmpty' is declared but its value is never read.`,
-                `'__onlineConfigValueEmpty' is declared but its value is never read.`,
-                `'__UpdateNoProperty__' is declared but its value is never read.`,
-              ].includes(diag.text)
-            ) {
-              return this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, record.node as FileNode, record);
-            } if (diag.text.includes(` is declared but its value is never read.`)) {
-              // 局部变量和输入变量未使用的警告
-              const fromModule = record.node.parentNode.concept === 'Module';
-              const fromConnector = record.node.parentNode.concept === 'Connector';
-              if ((record.node.concept === 'View' || record.node.concept === 'Logic') && !(fromModule || fromConnector)) {
+          }
+          return diagnostic;
+        })
+      )
+        .filter((diag) => !!diag);
+
+      // 处理后的警告异常提示信息
+      record.suggestionDiagnostics = (
+        yield*
+        utils.wrapMapToGenerator(record.suggestionDiagnostics, function * resolveSuggestionDiagnostic(diag) {
+          // 上面错误降级下来的
+          if (diag?.node) {
+            return diag;
+            // 一些已知警告的单独处理
+          } if (
+            [
+              `'__LogicEmpty' is declared but its value is never read.`,
+              `'__destinationEmpty__' is declared but its value is never read.`,
+              `'__devConfigValueEmpty' is declared but its value is never read.`,
+              `'__onlineConfigValueEmpty' is declared but its value is never read.`,
+              `'__UpdateNoProperty__' is declared but its value is never read.`,
+            ].includes(diag.text)
+          ) {
+            return yield* self._resolveDiagnosticWithGenerator(diag as unknown as tsProtocol.DiagnosticWithFileName, record.node as FileNode, record);
+          } if (diag.text.includes(` is declared but its value is never read.`)) {
+            // 局部变量和输入变量未使用的警告
+            const fromModule = record.node.parentNode.concept === 'Module';
+            const fromConnector = record.node.parentNode.concept === 'Connector';
+            if ((record.node.concept === 'View' || record.node.concept === 'Logic') && !(fromModule || fromConnector)) {
+              /**
+               * javalogic不用提示
+               */
+              if (record.node.concept === 'Logic' && self._isJavalogic(record.node as Logic)) {
+                return null;
+              }
+              const minRange = yield* self._findMinRangeWithGenerator(diag as unknown as tsProtocol.DiagnosticWithFileName, record.node as FileNode);
+              if (minRange) {
                 /**
-                 * javalogic不用提示
+                 * 如果节点是入参类型
+                 * 而且不是foreach中
+                 * 而且不是事件逻辑的入参
                  */
-                if (record.node.concept === 'Logic' && this._isJavalogic(record.node as Logic)) {
-                  return null;
-                }
-                const minRange = this._findMinRange(diag as unknown as tsProtocol.DiagnosticWithFileName, record.node as FileNode);
-                if (minRange) {
-                  /**
-                   * 如果节点是入参类型
-                   * 而且不是foreach中
-                   * 而且不是事件逻辑的入参
-                   */
-                  if (
-                    minRange.node instanceof Param &&
-                    minRange.node.parentNode.concept !== 'ForEachStatement' &&
-                    !minRange.node.getAncestor('BindEvent')
-                  ) {
-                    const diagnostic = {
-                      node: minRange.node,
-                      severity: 'warning',
-                      message: `未使用的输入参数${minRange.node.name}`,
-                    };
-                    return diagnostic;
-                  } if (minRange.node instanceof Variable) {
-                    const diagnostic = {
-                      node: minRange.node,
-                      severity: 'warning',
-                      message: `未使用的变量${minRange.node.name}`,
-                    };
-                    return diagnostic;
-                  }
+                if (
+                  minRange.node instanceof Param &&
+                  minRange.node.parentNode.concept !== 'ForEachStatement' &&
+                  !minRange.node.getAncestor('BindEvent')
+                ) {
+                  const diagnostic = {
+                    node: minRange.node,
+                    severity: 'warning',
+                    message: `未使用的输入参数${minRange.node.name}`,
+                  };
+                  return diagnostic;
+                } if (minRange.node instanceof Variable) {
+                  const diagnostic = {
+                    node: minRange.node,
+                    severity: 'warning',
+                    message: `未使用的变量${minRange.node.name}`,
+                  };
+                  return diagnostic;
                 }
               }
             }
-            return null;
-          })
-          .filter((diag) => !!diag);
+          }
+          return null;
+        })
+      )
+        .filter((diag) => !!diag);
+
+      record.suggestionDiagnostics.push(...yield* self._attachSuggestionDiagnosticsWithGenerator(node));
+    });
+
+    console.timeEnd('处理诊断数据');
 
-        record.suggestionDiagnostics.push(...this._attachSuggestionDiagnostics(node));
-      })
-    );
     return records;
   }
 
+  /**
+   * 处理诊断结果
+   * @param records 结果
+   * @returns 过滤或者转换后的诊断结果
+   */
+  @withQueueExecute('diagnostic')
+  private _resolveDiagnosticRecords(records: Array<DiagnosticRecord>) {
+    return utils.timeSlicingWithGenerator(this._resolveDiagnosticRecordsWithGenerator(records));
+  }
+
   /**
    * 判断是否是Javalogic
    */
@@ -1272,7 +1153,7 @@ class NaslServer {
    * @param fileNode 文件级别的节点
    * @returns 诊断结果
    */
-  _attachSuggestionDiagnostics(fileNode: BaseNode): Diagnostic[] {
+  private *_attachSuggestionDiagnosticsWithGenerator(fileNode: BaseNode) {
     const diagnostics: Diagnostic[] = [];
     if (fileNode instanceof Logic || fileNode instanceof View) {
       fileNode?.sourceMap.forEach((value, node) => {
@@ -1634,31 +1515,53 @@ class NaslServer {
   }
 
   /** 是否被 触发器依赖, 如果存在，返回第一个触发器对应的名称 */
-  async isRefedByTriggerAndReturnFirstRef(fileNode: BaseNode): Promise<{
+  isRefedByTriggerAndReturnFirstRef(fileNode: BaseNode): Promise<{
     isRefedByTrigger: boolean;
     fRefName: string;
   }> {
-    const refs = await this._isHaveRef(fileNode);
-    const basePath = TriggerLauncher.getEmbeddedFileBasePath(fileNode.rootNode as App);
-    let flag = false;
-    let fRefName = '';
-    try {
-      for (const ref of refs) {
-        const { file } = ref;
-        if (file.startsWith(basePath)) {
-          flag = true;
-          // file: /embedded/tttta/triggerLaunchers/订阅配置_asd.ts
-          fRefName = file.split(basePath)[1].split('.')[0];
-          break;
+    return this._isHaveRef(fileNode).then((refs) => {
+      const basePath = TriggerLauncher.getEmbeddedFileBasePath(fileNode.rootNode as App);
+      let flag = false;
+      let fRefName = '';
+      try {
+        for (const ref of refs) {
+          const { file } = ref;
+          if (file.startsWith(basePath)) {
+            flag = true;
+            // file: /embedded/tttta/triggerLaunchers/订阅配置_asd.ts
+            fRefName = file.split(basePath)[1].split('.')[0];
+            break;
+          }
         }
+      } catch (error) {
+        console.error(error, refs);
       }
-    } catch (error) {
-      console.error(error, refs);
-    }
-    return {
-      isRefedByTrigger: flag,
-      fRefName,
-    };
+      return {
+        isRefedByTrigger: flag,
+        fRefName,
+      };
+    });
+    // const refs = await this._isHaveRef(fileNode);
+    // const basePath = TriggerLauncher.getEmbeddedFileBasePath(fileNode.rootNode as App);
+    // let flag = false;
+    // let fRefName = '';
+    // try {
+    //   for (const ref of refs) {
+    //     const { file } = ref;
+    //     if (file.startsWith(basePath)) {
+    //       flag = true;
+    //       // file: /embedded/tttta/triggerLaunchers/订阅配置_asd.ts
+    //       fRefName = file.split(basePath)[1].split('.')[0];
+    //       break;
+    //     }
+    //   }
+    // } catch (error) {
+    //   console.error(error, refs);
+    // }
+    // return {
+    //   isRefedByTrigger: flag,
+    //   fRefName,
+    // };
   }
 
   /**
@@ -1689,15 +1592,18 @@ class NaslServer {
    * @param fileNode 文件级别的节点
    * @returns 诊断结果
    */
-  async _attachDiagnostics(fileNode: BaseNode): Promise<Diagnostic[]> {
+  private *_attachDiagnosticsWithGenerator(fileNode: BaseNode) {
     // 每次诊断前先清空这个Set
     this.logicSetWithComponentLogic = new Set<string>();
+
+    const self = this;
     const diagnostics: Diagnostic[] = [];
+
     if (fileNode instanceof View) {
-      fileNode?.sourceMap.forEach((value, node) => {
+      yield* utils.wrapIteratorToGenerator(fileNode.sourceMap.entries(), function* attachView([node, value]) {
         if (node instanceof ViewElement && node.view === fileNode) {
           if (node.tag) {
-            node.bindAttrs.forEach((bindAttr) => {
+            yield* utils.wrapForEachToGenerator(node.bindAttrs, (bindAttr) => {
               if ((bindAttr.model || bindAttr.sync) && bindAttr.expression) {
                 const bindExpression = bindAttr.expression;
                 let diagnostic;
@@ -1740,7 +1646,7 @@ class NaslServer {
           if (!node.typeAnnotation && !node.__TypeAnnotation) {
             const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
             let msg;
-            fileNode.traverseChildren((nodeIn) => {
+            yield* fileNode.traverseChildrenGenerator((nodeIn) => {
               if (nodeIn && (nodeIn instanceof BatchAssignment || (nodeIn instanceof Assignment && nodeIn.left?.name))) {
                 // 子页面内部逻辑过滤
                 if (nodeIn.view !== fileNode) return;
@@ -1797,11 +1703,11 @@ class NaslServer {
             node.tsErrorDetail = diagnostic;
             diagnostics.push(diagnostic);
           }
-          const fileSourceCode = this.getNodeCode(fileNode, value);
+          const fileSourceCode = self.getNodeCode(fileNode, value);
           if (fileSourceCode.includes('|') && fileSourceCode.includes('.metadataTypes.')) {
             const typeAnnotation = node.typeAnnotation.toJSON()
-            this._treeMetadataType2CoreType(typeAnnotation, (node.rootNode as App))
-            const isDuplicate = this._isDuplicateCoreType(typeAnnotation)
+            self._treeMetadataType2CoreType(typeAnnotation, (node.rootNode as App))
+            const isDuplicate = self._isDuplicateCoreType(typeAnnotation)
             if (isDuplicate) {
                 const diagnostic = {
                   node: node,
@@ -1813,7 +1719,7 @@ class NaslServer {
           }
         } else if (node instanceof BindAttribute || node instanceof BindDirective || node instanceof BindStyle) {
           if (Array.isArray(node.bindExpressions)) {
-            const exp = node.bindExpressions.find((bindExpression) => this.hasComponentLogics(bindExpression));
+            const exp = node.bindExpressions.find((bindExpression) => self.hasComponentLogics(bindExpression));
             if (exp) {
               // const element: any = node.getAncestor('ViewElement');
               // const api = config.allNodesAPI[element?.tag];
@@ -1836,7 +1742,7 @@ class NaslServer {
             }
           }
         } else if (node instanceof CallInterface) {
-          const isAuthInterface = this.hasAuth(node);
+          const isAuthInterface = self.hasAuth(node);
           const interfaceName = node.calleewholeKey.slice(node.calleewholeKey.lastIndexOf('.') + 1);
           if (isAuthInterface) {
             const errorMsg = `${interfaceName} 接口有鉴权方式，不支持在前端调用`;
@@ -1862,15 +1768,16 @@ class NaslServer {
             node.tsErrorDetail = diagnostic;
           }
         } else {
-          this.checkNodeError(node, diagnostics);
+          self.checkNodeError(node, diagnostics);
         }
       });
-    } else if (fileNode instanceof DataSource) {
+    }
+    else if (fileNode instanceof DataSource) {
       const dataSourceGroup = (fileNode.rootNode as App).configuration?.getGroup('dataSource');
       if (dataSourceGroup) {
         const property = dataSourceGroup.getProperty(fileNode.name);
         if (property && property.values) {
-          property.values.forEach((propertyValue) => {
+          yield* utils.wrapForEachToGenerator(property.values, (propertyValue) => {
             if (!propertyValue.value && fileNode.name !== 'defaultDS') {
               const diagnostic = {
                 node: fileNode,
@@ -2166,8 +2073,9 @@ class NaslServer {
         });
       }
     }
-    if (fileNode instanceof Logic || fileNode instanceof OverriddenLogic) {
-      const { isRefedByTrigger, fRefName } = await this.isRefedByTriggerAndReturnFirstRef(fileNode);
+    else if (fileNode instanceof Logic || fileNode instanceof OverriddenLogic) {
+      const { isRefedByTrigger, fRefName } = yield this.isRefedByTriggerAndReturnFirstRef(fileNode);
+
       if (isRefedByTrigger && !this.isTriggerRule(fileNode)) {
         const diagnostic = {
           node: fileNode,
@@ -2176,18 +2084,8 @@ class NaslServer {
         };
         diagnostics.push(diagnostic);
       }
-      fileNode?.sourceMap.forEach((value, node) => {
-        // OQL支持返回复合类型数据了
-        // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
-        // if ((node instanceof OqlQueryComponent || node instanceof SqlQueryComponent) && (node as SqlQueryComponent).getTypeBanError()) {
-        //     const diagnostic = {
-        //         node,
-        //         severity: 'error',
-        //         message: 'SQL查询：返回类型内部,不支持复杂类型。',
-        //     };
-        //     node.tsErrorDetail = diagnostic;
-        //     diagnostics.push(diagnostic);
-        // }
+
+      yield* utils.wrapIteratorToGenerator(fileNode.sourceMap.entries(), ([node, value]) => {
         if (node instanceof OqlQueryComponent) {
           // 自动推导情况
           const typeAnnotation = type2TypeAnnotation((node as any).__nodeType);
@@ -2206,8 +2104,7 @@ class NaslServer {
             }
           }
         }
-
-        if (node instanceof Return || node instanceof Variable) {
+        else if (node instanceof Return || node instanceof Variable) {
           const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
           if (!node.typeAnnotation && !node.__TypeAnnotation) {
             let used = false;
@@ -2259,7 +2156,7 @@ class NaslServer {
             }
           }
         }
-        if (node instanceof Param) {
+        else if (node instanceof Param) {
           const fileSourceCode = this.getNodeCode(fileNode, value);
           if (fileSourceCode.includes('|') && fileSourceCode.includes('.metadataTypes.')) {
             const typeAnnotation = node.typeAnnotation.toJSON()
@@ -2277,8 +2174,9 @@ class NaslServer {
         }
         this.checkNodeError(node, diagnostics);
       });
-    } else if (fileNode instanceof Process) {
-      fileNode?.sourceMap.forEach((value, node) => {
+    }
+    else if (fileNode instanceof Process) {
+      yield* utils.wrapIteratorToGenerator(fileNode.sourceMap.entries(), ([node, value]) => {
         this.checkNodeError(node, diagnostics);
       });
     } else if (fileNode instanceof Connection) {
@@ -2315,7 +2213,7 @@ class NaslServer {
       } else if (hasEmptyConfig(fileNode)) {
         diagnostics.push(diagnostic);
       }
-      
+
     } else if (fileNode instanceof MetadataType) {
       fileNode?.sourceMap.forEach((value, node) => {
         const rulesMap: any = {};
@@ -2359,6 +2257,7 @@ class NaslServer {
         }
       })
     }
+
     return diagnostics;
   }
 
@@ -2653,9 +2552,10 @@ class NaslServer {
   }
 
   /* 接口导入查找 */
-  existStructureFix(semanticDiagnostics: Diagnostic[], node: FileNode, that: any) {
+  private *existStructureFix(semanticDiagnostics: Diagnostic[], node: FileNode, that: any) {
     let module: Module;
-    semanticDiagnostics.map((diag) => {
+
+    yield* utils.wrapForEachToGenerator(semanticDiagnostics, (diag) => {
       const minRange = this._findMinRange(diag as unknown as tsProtocol.DiagnosticWithFileName, node);
       if (diag.text?.includes('has no exported member named')) {
         if (minRange.node instanceof Logic) {
@@ -2686,9 +2586,8 @@ class NaslServer {
         }
         return null;
       }
-        return diag;
-
     });
+
     if (actionArr.length) {
       if (timer) return;
       timer = window.setTimeout(() => {
@@ -2715,50 +2614,54 @@ class NaslServer {
    * @param fileNode 页面节点
    * @returns 处理后的结果
    */
-  _resolveDiagnostic(diagnostic: tsProtocol.DiagnosticWithFileName, fileNode: FileNode, record: DiagnosticRecord): Diagnostic {
+  private *_resolveDiagnosticWithGenerator(diagnostic: tsProtocol.DiagnosticWithFileName, fileNode: FileNode, record: DiagnosticRecord) {
     // 拓展模块中的翻译先过滤掉，因为有错用户也不能修改
     if (((fileNode as any).module || (fileNode as any).connector) && !(fileNode instanceof ConfigProperty)) {
       return;
     }
-    // 过滤掉java依赖库的报错
-    // 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 minRange = yield* this._findMinRangeWithGenerator(diagnostic, fileNode);
     const tsErrorDetail = {
       severity: diagnostic.category === 'error' ? 'error' : 'warning',
       message: translateDiagnosticMessage(diagnostic.text),
       // 保留原来的内容方便查询一些问题
       originalDiagnostic: diagnostic,
     };
+    yield;
 
     let result: Diagnostic;
     if (minRange) {
       // 节点的error要置为true
       result = naslNodeTranslateMessage(minRange, tsErrorDetail);
+      yield;
     } else {
       // 没找到节点， 先把问题暴露出来
       result = tsErrorDetail;
     }
-    if (result)
+
+    if (result) {
       result.id = record.filePath + (result ? JSON.stringify({ start: result.originalDiagnostic.start, end: result.originalDiagnostic.end }) : '');
+    }
+
     return result;
   }
 
   /**
-   * 通过节点诊断反过来查找节点
-   * @param diagnostic 诊断信息
-   * @param fileNode 文件级别节点
-   * @returns 找到的节点
+   * 查找节点
+   *
+   * @description 生成器原型函数
    */
-  _findMinRange(diagnostic: tsProtocol.DiagnosticWithFileName | tsProtocol.ReferencesResponseItem, fileNode: FileNode) {
+  private *_findMinRangeWithGenerator(
+    diagnostic: tsProtocol.DiagnosticWithFileName | tsProtocol.ReferencesResponseItem,
+    fileNode: FileNode
+  ): Generator<void, MinRange> {
     let minRange: MinRange;
-    const {sourceMap} = fileNode;
+    const { sourceMap } = fileNode;
     // 是否找到了行内准确的，是的话，就不走多行的
     let haveLineNode = false;
+
     for (const [node, item] of sourceMap.entries()) {
       /**
        * 当前内容的开始行 <= 诊断开始的行 &&
@@ -2815,16 +2718,31 @@ class NaslServer {
           }
         }
       }
+
+      yield;
     }
+
     if (!minRange) {
       if (fileNode instanceof View) {
-        return { node: fileNode, item: sourceMap.get(fileNode) };
+        return { node: fileNode, item: sourceMap.get(fileNode) } as MinRange;
+      }
+      if (process.env.NODE_ENV === 'development') {
+        console.log(minRange, '需要特殊看下，为什么没找到内容-------------');
       }
-      console.log(minRange, '需要特殊看下，为什么没找到内容-------------');
     }
+
     return minRange;
   }
 
+  /**
+   * 查找节点
+   *
+   * @description 同步模式
+   */
+  _findMinRange(...args: Parameters<NaslServer['_findMinRangeWithGenerator']>) {
+    return utils.runGeneratorSync(this._findMinRangeWithGenerator(...args));
+  }
+
   /**
    * 查看当前节点是不是有引用
    * @param node 节点
@@ -2860,11 +2778,11 @@ class NaslServer {
           refsList.unshift(newRefs.refs[0]);
         }
       }
-    } else if (node instanceof Connector) { 
+    } else if (node instanceof Connector) {
       // Conenctor 虽为 Module 的子类，但是具体引用逻辑与Module 并不一致，因此这边单独处理
       // 由于 在与后端定义 Connector Namespace 前缀时， Logics 相关定义为 connector,
       // 其余定义为 extension, 因此这边查找引用时，需要分别查找并去重复
-      // 这里选择 logic 与 interface 作为 查找源，因为一个 Connector 必定至少含有一个 logic 和 interface  
+      // 这里选择 logic 与 interface 作为 查找源，因为一个 Connector 必定至少含有一个 logic 和 interface
       const logicList = node.namespaces.find((ns) => ns.logics.length > 0)?.logics || [];
       const interfaceList = node.interfaces;
       const moduleName = (fileNode as FileNode).getEmbeddedFilePath();
@@ -3177,7 +3095,7 @@ class NaslServer {
         // });
         // refsList = [...refsList, ...parentRefs.refs];
         // console.log(parentRefs.refs)
-  
+
         // 流程任务出参查找引用比较特殊，需要查找到 const process = {...} 的引用
         const code = this.getNodeCode(fileNode, currentSource);
         const prefix = '__ProcessIdentification__';
@@ -3805,7 +3723,7 @@ class NaslServer {
     while (parantNode && !(parantNode instanceof App)) {
       // 找到上一级 在map对象中构造出他的子集
       currentNode = parantNode;
-      parantNode = parantNode.parentNode;
+      parantNode = parantNode.parentNode as BaseNode;
       // 如果第一次就塞入子集和父节点，以后就只用父节点了
       // 因为部分节点没有name，先过滤掉
       // if (currentNode.name) {
@@ -3914,7 +3832,9 @@ class NaslServer {
   getCurrentSource(node: BaseNode) {
     if (node instanceof App || node instanceof Theme) return { fileNode: null };
     let {sourceMap} = node;
-    let fileNode = node;
+    let fileNode = node as FileNode & SyntaxNode;
+    // 连接器 操作，上层结构是 Namespace， Namespace 并无含义，因此需要过滤掉
+    const isConnectorLogic = node.getAncestor('Connector') && node.concept === 'Logic' && node.parentNode instanceof Namespace;
     // 如果没有sourceMap,就继续向上找 ,或者到module结束
     // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
     // 如果当前节点是view就不要向上查找了
@@ -3928,11 +3848,11 @@ class NaslServer {
       !(fileNode.parentNode instanceof DataSource) &&
       !(fileNode.parentNode instanceof Frontend) &&
       !(fileNode.parentNode instanceof Backend) &&
-      !(fileNode.parentNode instanceof Namespace) &&
+      !isConnectorLogic &&
       !(fileNode instanceof View) &&
       !(fileNode instanceof ConfigProperty)
     ) {
-      fileNode = fileNode.parentNode;
+      fileNode = fileNode.parentNode as FileNode & SyntaxNode;
       sourceMap = fileNode?.sourceMap;
     }
     const currentSource = sourceMap && sourceMap.get(node);
@@ -3976,7 +3896,6 @@ class NaslServer {
         getFieldKey: fieldKey,
       });
     }
-
   }
 
   _getFieldKeySelectCompletion(args: any) {
@@ -4048,6 +3967,10 @@ class NaslServer {
       }
       return TypeAnnotation.createPrimitive(type);
     }
+    // 如果是一元表达式，那么就是布尔值
+    if (node instanceof UnaryExpression) {
+      return TypeAnnotation.createPrimitive('Boolean');
+    }
     // 这些原有类型的 比较的 返回值肯定就是布尔值，就不去调用ls
     if (node instanceof BinaryExpression && ['==', '!=', '>', '<', '>=', '<='].includes(node.operator)) {
       return TypeAnnotation.createPrimitive('Boolean');
@@ -4086,256 +4009,251 @@ class NaslServer {
   }
 
   /**
-   * 获取传入节点的TypeAnnotation
-   * @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结果
+   * 获取传入节点的 TypeAnnotation
+   *
+   * @description 生成器模式原型
    */
-  async getQuickInfoNodesTypeMap(nodes: QuickInfoNodes, lotFlag?: boolean) {
+  private *_getQuickInfoNodesTypeMapWithGenerator(nodes: QuickInfoNodes): Generator<any, QuickInfoMap, any> {
     interface argDetail {
       file: string;
       line: number;
       offset: number;
     }
+
+    const self = this;
     const args: Array<argDetail> = [];
     // 要通过自己或者依赖关系拿的
-    const getFromOthers: Map<BaseNode, TypeAnnotation | { typeAnnotation: TypeAnnotation; option: any }> = new Map();
+    const getFromOthers: QuickInfoMap = new Map();
     // 总共要返回出去的
-    const types: Map<BaseNode, TypeAnnotation | { typeAnnotation: TypeAnnotation; option: any }> = new Map();
+    const types: QuickInfoMap = new Map();
     const newQuickInfoNodes: QuickInfoNodes = [];
 
-    await utils.timeSlicing(
-      nodes,
-      (itemDetail) => {
-        const { node, filePath, item } = itemDetail;
-        // 先按照顺序占位
-        types.set(node, null);
+    yield* utils.wrapForEachToGenerator(nodes, function* getQuickInfoPosition(itemDetail, index) {
+      const { node, filePath, item } = itemDetail;
+      // 先按照顺序占位
+      types.set(node, null);
 
-        // 获取已知节点类型的类型
-        const nodeTypeAnnotation = this.getCurrentNodeKnownTypeAnnotation(node);
-        if (nodeTypeAnnotation) {
-          types.set(node, nodeTypeAnnotation);
-          return;
-        }
-        // 要通过自己或者依赖关系拿的，二次遍历
-        if (['Argument', 'Assignment', 'MatchCase'].includes(node.concept)) {
-          getFromOthers.set(node, null);
-        }
-        if (['Return', 'Variable'].includes(node.concept) && (node as Variable).typeAnnotation) {
-          types.set(node, (node as Variable).typeAnnotation);
-          return;
-        }
-        // 如果 入参不是虚拟节点的，就不去请求类型
-        // 只有虚拟节点的入参，才没有类型
-        if (node.concept === 'Param' && (node.parentKey !== 'virtualParams' && node.parentKey !== 'item' && node.parentNode.concept !== 'AnonymousFunction')) {
-          return;
-        }
-        if (
-          ![
-            'Identifier',
-            'UnaryExpression',
-            'BinaryExpression',
-            'CallLogic',
-            'CallFunction',
-            'CallInterface',
-            'MemberExpression',
-            'Return',
-            'Variable',
-            'Match',
-            'NewComposite',
-            'NewList',
-            'NewMap',
-            'OqlQueryComponent',
-            'QueryFieldExpression',
-            'QueryGroupByExpression',
-            'Param',
-            'BackendVariable',
-            'CallAuthInterface',
-          ].includes(node.concept)
-        )
-          return;
+      // 获取已知节点类型的类型
+      const nodeTypeAnnotation = self.getCurrentNodeKnownTypeAnnotation(node);
 
-        // 要去ls那边获取的
-        newQuickInfoNodes.push(itemDetail);
-        const fileDetail = {
-          file: filePath,
-          line: lsp2tspNumber(item.start.line),
-          offset: lsp2tspNumber(item.start.character),
-        };
+      yield;
 
-        const getCode = (range: SourceMapItem) => {
-          return this.tsFiles.get(filePath)?.slice(range.start.offset, range.end.offset) ?? '';
-        };
+      if (nodeTypeAnnotation) {
+        types.set(node, nodeTypeAnnotation);
+        return;
+      }
+      // 要通过自己或者依赖关系拿的，二次遍历
+      if (['Argument', 'Assignment', 'MatchCase'].includes(node.concept)) {
+        getFromOthers.set(node, null);
+      }
+      if (['Return', 'Variable'].includes(node.concept) && (node as Variable).typeAnnotation) {
+        types.set(node, (node as Variable).typeAnnotation);
+        return;
+      }
+      // 如果 入参不是虚拟节点的，就不去请求类型
+      // 只有虚拟节点的入参，才没有类型
+      if (node.concept === 'Param' && (node.parentKey !== 'virtualParams' && node.parentKey !== 'item' && node.parentNode.concept !== 'AnonymousFunction')) {
+        return;
+      }
+      if (
+        ![
+          'Identifier',
+          'BinaryExpression',
+          'CallLogic',
+          'CallFunction',
+          'CallInterface',
+          'MemberExpression',
+          'Return',
+          'Variable',
+          'Match',
+          'NewComposite',
+          'NewList',
+          'NewMap',
+          'OqlQueryComponent',
+          'QueryFieldExpression',
+          'QueryGroupByExpression',
+          'Param',
+          'BackendVariable',
+          'CallAuthInterface',
+        ].includes(node.concept)
+      )
+        return;
+
+      // 要去ls那边获取的
+      newQuickInfoNodes.push(itemDetail);
+      const fileDetail = {
+        file: filePath,
+        line: lsp2tspNumber(item.start.line),
+        offset: lsp2tspNumber(item.start.character),
+      };
 
-        // 位置计算偏移
-        if ('getQuickInfoOffset' in node) {
-          Object.assign(fileDetail, (node as any).getQuickInfoOffset(fileDetail, getCode(item)));
-        }
+      const getCode = (range: SourceMapItem) => {
+        return self.tsFiles.get(filePath)?.slice(range.start.offset, range.end.offset) ?? '';
+      };
 
-        // 位置计算偏移2
-        // TODO: 之后考虑把这些偏移量计算全都挪到节点内部去
-        if (
-          node.concept === 'BinaryExpression' ||
-          node.concept === 'CallFunction' ||
-          node.concept === 'CallInterface'
-        ) {
-          const code = getCode(item);
-          // 如果没有括号 ，括号就在外面，就 -1
-          // 有括号就找到括号的位置 然后 -1
-          let indexOf = 0;
-          if (!code.includes('(')) {
-            indexOf = -1;
-          } else {
-            // 如果有泛型先往前找一找
-            if (code.includes('<')) {
-              indexOf = Math.min(code.indexOf('<'), code.indexOf('('));
-            } else {
-              indexOf = code.indexOf('(');
-            }
-            const subStr = code.substring(0, indexOf);
-            const codeArr = subStr?.split('.');
-            const lastLen = codeArr?.[codeArr.length - 1]?.length;
-            indexOf = subStr.length - lastLen;
-          }
-          fileDetail.offset += indexOf;
-        } else if (
-          node.concept === 'MemberExpression' ||
-          node.concept === 'Identifier' ||
-          node.concept === 'QueryFieldExpression' ||
-          node.concept === 'QueryGroupByExpression'
-        ) {
-          const code = getCode(item);
-          if (code.includes('.')) {
-            const codeArr = code?.split('.');
-            const lastLen = codeArr?.[codeArr.length - 1]?.length;
-            // MemberExpression取最后一位当做类型
-            const indexOf = code.length - lastLen;
-            fileDetail.offset = fileDetail.offset + indexOf;
-          }
-        } else if (node.concept === 'Match') {
-          const code = getCode(item);
-          // 去查return 后面的返回值，变成函数调用
-          if (code?.endsWith(';\n')) {
-            fileDetail.line = item.end.line - 1;
+      // 位置计算偏移
+      if ('getQuickInfoOffset' in node) {
+        Object.assign(fileDetail, (node as any).getQuickInfoOffset(fileDetail, getCode(item)));
+      }
+
+      yield;
+
+      // 位置计算偏移2
+      // TODO: 之后考虑把这些偏移量计算全都挪到节点内部去
+      if (
+        node.concept === 'BinaryExpression' ||
+        node.concept === 'CallFunction' ||
+        node.concept === 'CallInterface'
+      ) {
+        const code = getCode(item);
+        // 如果没有括号 ，括号就在外面，就 -1
+        // 有括号就找到括号的位置 然后 -1
+        let indexOf = 0;
+        if (!code.includes('(')) {
+          indexOf = -1;
+        } else {
+          // 如果有泛型先往前找一找
+          if (code.includes('<')) {
+            indexOf = Math.min(code.indexOf('<'), code.indexOf('('));
           } else {
-            fileDetail.line = item.end.line;
-          }
-          const indexOf = code.indexOf('return __MatchExpressionFuntion');
-          let newCode = code.substring(0, indexOf);
-          newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
-          fileDetail.offset = newCode.length + 'return '.length;
-        } else if (['NewComposite', 'NewList', 'NewMap'].includes(node.concept)) {
-          let type;
-          switch (node.concept) {
-            case 'NewComposite':
-              type = '__newComposite';
-              break;
-            case 'NewList':
-              type = '__newList';
-              break;
-            case 'NewMap':
-              type = '__newMap';
-              break;
-            default:
+            indexOf = code.indexOf('(');
           }
-          const code = getCode(item);
+          const subStr = code.substring(0, indexOf);
+          const codeArr = subStr?.split('.');
+          const lastLen = codeArr?.[codeArr.length - 1]?.length;
+          indexOf = subStr.length - lastLen;
+        }
+        fileDetail.offset += indexOf;
+      } else if (
+        node.concept === 'MemberExpression' ||
+        node.concept === 'Identifier' ||
+        node.concept === 'QueryFieldExpression' ||
+        node.concept === 'QueryGroupByExpression'
+      ) {
+        const code = getCode(item);
+        if (code.includes('.')) {
+          const codeArr = code?.split('.');
+          const lastLen = codeArr?.[codeArr.length - 1]?.length;
+          // MemberExpression取最后一位当做类型
+          const indexOf = code.length - lastLen;
+          fileDetail.offset = fileDetail.offset + indexOf;
+        }
+      } else if (node.concept === 'Match') {
+        const code = getCode(item);
+        // 去查return 后面的返回值，变成函数调用
+        if (code?.endsWith(';\n')) {
+          fileDetail.line = item.end.line - 1;
+        } else {
           fileDetail.line = item.end.line;
-          const indexOf = code.indexOf(`return ${type}`);
-          let newCode = code.substring(0, indexOf);
-          newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
-          fileDetail.offset = newCode.length + 'return '.length;
-        } else if (['OqlQueryComponent'].includes(node.concept)) {
-          fileDetail.offset += 10;
         }
-        args.push(fileDetail);
-      },
-      { minimum: 1000 },
-    );
-
-    const resultMap: any = (await this.getNaslNodeTypeFull(args))?.response;
-    await utils.timeSlicing(args, ({ file, line, offset }, index) => {
+        const indexOf = code.indexOf('return __MatchExpressionFuntion');
+        let newCode = code.substring(0, indexOf);
+        newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
+        fileDetail.offset = newCode.length + 'return '.length;
+      } else if (['NewComposite', 'NewList', 'NewMap'].includes(node.concept)) {
+        let type;
+        switch (node.concept) {
+          case 'NewComposite':
+            type = '__newComposite';
+            break;
+          case 'NewList':
+            type = '__newList';
+            break;
+          case 'NewMap':
+            type = '__newMap';
+            break;
+          default:
+        }
+        const code = getCode(item);
+        fileDetail.line = item.end.line;
+        const indexOf = code.indexOf(`return ${type}`);
+        let newCode = code.substring(0, indexOf);
+        newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
+        fileDetail.offset = newCode.length + 'return '.length;
+      } else if (['OqlQueryComponent'].includes(node.concept)) {
+        fileDetail.offset += 10;
+      }
+      args.push(fileDetail);
+    });
+    const resultMap: any = (yield this.getNaslNodeTypeFull(args))?.response;
+    yield* utils.wrapForEachToGenerator(args, ({ file, line, offset }, index) => {
       const item = (resultMap as any)?.[file]?.[line]?.[offset];
       const itemType = item?.[0]?.nodeType;
       const nodeTypeAnnotation = type2TypeAnnotation(itemType);
       const {node} = newQuickInfoNodes[index];
 
-        types.set(node, Object.freeze(nodeTypeAnnotation) as TypeAnnotation);
+      types.set(node, Object.freeze(nodeTypeAnnotation) as TypeAnnotation);
 
-        const type = itemType ? (Object.isFrozen(itemType) ? itemType : Object.freeze(itemType)) : null;
-        if (type) {
-          (node as any).__nodeType = type;
-        } else {
-          delete (node as any).__nodeType;
+      const type = itemType ? (Object.isFrozen(itemType) ? itemType : Object.freeze(itemType)) : null;
+      if (type) {
+        (node as any).__nodeType = type;
+      } else {
+        delete (node as any).__nodeType;
+      }
+    });
+    yield* utils.wrapIteratorToGenerator(getFromOthers.entries(), function* ([node]) {
+      if (node instanceof Assignment) {
+        if (!types.get(node.left)) {
+          types.set(node.left, types.get(node.right));
         }
-      },
-      { minimum: 100 },
-    );
-    await utils.timeSlicing(
-      Array.from(getFromOthers.entries()),
-      ([node]) => {
-        if (node instanceof Assignment) {
-          if (!types.get(node.left)) {
-            types.set(node.left, types.get(node.right));
-          }
-        } else if (node instanceof Argument) {
-          // 如果Argument，但是没可以用的类型，就用原来logic的参数类型
-          const argType = this.getArgumentTypeAnnotation(node, newQuickInfoNodes, types as any);
-          types.set(node, argType);
-        } else if (node instanceof MatchCase) {
-          // matchCase的类型
-          // 直接从最后一项的返回值取，有就有没有就没有
-          if (node.body?.length) {
-            const last = node.body[node.body.length - 1];
-            if (types.get(last)) {
-              types.set(node, types.get(last));
-            }
+      } else if (node instanceof Argument) {
+        // 如果Argument，但是没可以用的类型，就用原来logic的参数类型
+        const argType = yield* self.getArgumentTypeAnnotationWithGenerator(node, newQuickInfoNodes, types as any);
+        types.set(node, argType);
+      } else if (node instanceof MatchCase) {
+        // matchCase的类型
+        // 直接从最后一项的返回值取，有就有没有就没有
+        if (node.body?.length) {
+          const last = node.body[node.body.length - 1];
+          if (types.get(last)) {
+            types.set(node, types.get(last));
           }
         }
-      },
-      { minimum: 100 },
-    );
-    await utils.timeSlicing(
-      Array.from(types.entries()),
-      ([node, value]) => {
-        try {
-          // 因为node可能是经过处理的TypeAnnotation
-          node.__isCorrectTypeAnnotation = true;
-          if (value) {
-            if (node instanceof OqlQueryComponent) {
-              // 自动推导情况
-              const typeAnnotation = value as TypeAnnotation;
-              if (!node.typeAnnotation && typeAnnotation) {
-                if (typeAnnotation.typeName === 'List' && typeAnnotation.typeKind === 'generic') {
-                  const {typeArguments} = typeAnnotation;
-                  if (typeArguments.length && typeArguments[0].isComplexType()) {
-                    delete node.__TypeAnnotation;
-                    return;
-                  }
+      }
+    });
+    yield* utils.wrapIteratorToGenerator(types.entries(), ([node, value]) => {
+      try {
+        // 因为node可能是经过处理的TypeAnnotation
+        node.__isCorrectTypeAnnotation = true;
+        if (value) {
+          if (node instanceof OqlQueryComponent) {
+            // 自动推导情况
+            const typeAnnotation = value as TypeAnnotation;
+            if (!node.typeAnnotation && typeAnnotation) {
+              if (typeAnnotation.typeName === 'List' && typeAnnotation.typeKind === 'generic') {
+                const {typeArguments} = typeAnnotation;
+                if (typeArguments.length && typeArguments[0].isComplexType()) {
+                  delete node.__TypeAnnotation;
+                  return;
                 }
               }
             }
-            if (value instanceof TypeAnnotation) {
-              node.__TypeAnnotation = value;
-            } else if (value.typeAnnotation) {
-              node.__TypeAnnotation = value.typeAnnotation;
-            }
-          } else {
-            // 清空原来已经赋值上去的类型，可能原来有现在没有了
-            delete node.__TypeAnnotation;
           }
-        } catch (err) {
-          // if (globalThis.window) {
-          //   console.log(err);
-          // }
+          if (value instanceof TypeAnnotation) {
+            node.__TypeAnnotation = value;
+          } else if (value.typeAnnotation) {
+            node.__TypeAnnotation = value.typeAnnotation;
+          }
+        } else {
+          // 清空原来已经赋值上去的类型，可能原来有现在没有了
+          delete node.__TypeAnnotation;
         }
-      },
-      { minimum: 100 },
-    );
+      } catch (err) {
+        // if (globalThis.window) {
+        //   console.log(err);
+        // }
+      }
+    });
     return types;
   }
 
+  /**
+   * 获取传入节点的 TypeAnnotation
+   */
+  getQuickInfoNodesTypeMap(nodes: QuickInfoNodes, flag?: boolean) {
+    return utils.runGeneratorAsync(this._getQuickInfoNodesTypeMapWithGenerator(nodes));
+  }
+
   // 全量标注并且返回json
   @withQueueExecute('annotation')
   async getNaslAnnotatedJSON(app: App, releaseFlag: boolean) {
@@ -4360,6 +4278,7 @@ class NaslServer {
     console.timeEnd('全量标注');
 
     const json = app.toJSON();
+    console.log(json)
 
     if (releaseFlag) {
       // 全量标注后对json进行一些修改，为了服务端翻译处理
@@ -4370,28 +4289,35 @@ class NaslServer {
   }
 
   // 增量标注
-  @withQueueExecute('annotation')
-  async IncrementalAnnotationJSON(records: DiagnosticRecord[]) {
+  private *_incrementalAnnotationJSONWithGenerator(records: DiagnosticRecord[]) {
     console.time('增量标注');
     const nodes: QuickInfoNodes = [];
-    records.forEach((record) => {
-      const fileNode = this.file2NodeMap.get(record.filePath);
-      if (!fileNode) return;
+    const self = this;
+
+    yield* utils.wrapForEachToGenerator(records, function *findNodePosition (record) {
+      const fileNode = self.file2NodeMap.get(record.filePath);
+
+      if (!fileNode) {
+        return;
+      }
+
       record.id = fileNode.id;
       record.node = fileNode;
-      if (!['Structure', 'DataSource', 'Entity', 'Enum', 'Role', 'MetadataType'].includes(fileNode.concept)) {
-        fileNode.sourceMap &&
-          fileNode.sourceMap.forEach((item, nodeItem) => {
-            nodes.push({
-              filePath: record.filePath,
-              node: nodeItem,
-              item,
-            });
-          });
+
+      if (['Structure', 'DataSource', 'Entity', 'Enum', 'Role', 'MetadataType'].includes(fileNode.concept) || !fileNode.sourceMap) {
+        return;
       }
+
+      yield* utils.wrapIteratorToGenerator(fileNode.sourceMap.entries(), ([nodeItem, item]) => {
+        nodes.push({
+          filePath: record.filePath,
+          node: nodeItem,
+          item,
+        });
+      });
     });
 
-    await this.getQuickInfoNodesTypeMap(nodes);
+    yield* this._getQuickInfoNodesTypeMapWithGenerator(nodes);
     console.timeEnd('增量标注');
   }
 
@@ -4410,6 +4336,12 @@ class NaslServer {
       // 如果节点本身有类型就不去在塞一遍了
       // 有值而且没有类型再去设置
       // 但是Identifier 和 MemberExpression 都用标注出来的因为本身是变量，有类型也需要覆盖一下
+      if (value && (node instanceof Argument ) && node.getAncestor('Connector')?.concept === 'Connector') {
+        const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+        if (jsonNode) {
+            jsonNode.typeAnnotation = (value as TypeAnnotation)?.toJSON();
+        }
+      }
       if (value && (!(node as any).typeAnnotation || node instanceof Identifier || node instanceof MemberExpression)) {
         const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
         if (jsonNode) {
@@ -4528,7 +4460,11 @@ class NaslServer {
    * 如果内部表达式的，就用表达式的，如果没有就试试用默认值的
    * 获取logic的默认值和原来Arg的类型和默认值对应
    */
-  getArgumentTypeAnnotation(node: Argument, QuickInfoNodes: QuickInfoNodes, types: Map<BaseNode, TypeAnnotation>) {
+  *getArgumentTypeAnnotationWithGenerator(
+    node: Argument,
+    QuickInfoNodes: QuickInfoNodes,
+    types: Map<BaseNode, TypeAnnotation>,
+  ): Generator<void, TypeAnnotation, void> {
     // 直接复用内部expression的type类型
     if (
       node.parentNode instanceof CallLogic &&
@@ -4545,6 +4481,7 @@ class NaslServer {
           return nodeTypeAnnotation
         }
       }
+      yield;
     }
     // 获取返回值结果里找到父级的callLogic || CallInterface的类型填充进去Argument
     const App = node.app;
@@ -4556,7 +4493,8 @@ class NaslServer {
       }
     }
     // 用户自己声明的用用户的
-    const callObj = App.findNodeByCompleteName(`${parent.calleeNamespace  }.${  parent.calleeName}`);
+    const callObj = App.findNodeByCompleteName(`${parent.calleeNamespace}.${parent.calleeName}`);
+    yield;
     const index = parent.arguments.indexOf(node);
     const param = callObj?.params?.[index] || {};
     // 取出参数的类型
@@ -4644,7 +4582,7 @@ class NaslServer {
    * @param targetNode 当前操作的节点
    * @param result toTs生成的内容
    */
-  async handleDelete(fileNode: BaseNode, targetNode: BaseNode, result: ReturnType<Structure['toEmbeddedTSFile']>) {
+  async handleDelete(fileNode: BaseNode, targetNode: BaseNode, result: utils.EmbeddedTSFileResult) {
     const filePath = (fileNode as FileNode).getEmbeddedFilePath();
     // 如果要删除，而且当前要删Logic就直接删除并且清除错误
     /**
@@ -4684,7 +4622,7 @@ class NaslServer {
    * @param targetNode 触发修改的节点
    * @param result 生成代码的code 和位置信息
    */
-  async handleChange(fileNode: BaseNode, targetNode: BaseNode, result: ReturnType<Structure['toEmbeddedTSFile']>, action: string) {
+  async handleChange(fileNode: BaseNode, targetNode: BaseNode, result: utils.EmbeddedTSFileResult, action: string) {
     this.file2NodeMap.set(result.filePath, fileNode);
 
     const outputFiles = [{ file: result.filePath, fileContent: result.code }];
@@ -4729,7 +4667,7 @@ class NaslServer {
    * @param isRename 是不是修改名字
    * @param oldFilePath 如果是改名，文件级别的才会有这个参数，用于文件新增替换
    */
-  async handleRename(fileNode: BaseNode, targetNode: BaseNode, result: ReturnType<Structure['toEmbeddedTSFile']>, oldFilePath?: string) {
+  async handleRename(fileNode: BaseNode, targetNode: BaseNode, result: utils.EmbeddedTSFileResult, oldFilePath?: string) {
     // rename 场景
     const outputFiles = [{ file: result.filePath, fileContent: result.code }];
     // 如果是要修改顶级文件名
@@ -4833,7 +4771,7 @@ class NaslServer {
         const fileNodeChildren = [...fileNode.views, ...fileNode.variables];
         for (let i = 0; i < fileNodeChildren.length; i++) {
           const fileNodeItem = fileNodeChildren[i];
-          const result = (fileNodeItem as FileNode).toEmbeddedTSFile();
+          const result = await utils.timeSlicingWithGenerator((fileNodeItem as FileNode).toEmbeddedTSFile());
           fileNodeItem.sourceMap = result.sourceMap;
           if (action === 'create') {
             await this.handleChange(fileNodeItem, fileNodeItem, result, action);
@@ -4856,7 +4794,7 @@ class NaslServer {
         const fileNodeChildren = fileNode.children;
         for (let i = 0; i < fileNodeChildren.length; i++) {
           const fileNodeItem = fileNodeChildren[i];
-          const result = (fileNodeItem as FileNode).toEmbeddedTSFile();
+          const result = await utils.timeSlicingWithGenerator((fileNodeItem as FileNode).toEmbeddedTSFile());
           fileNodeItem.sourceMap = result.sourceMap;
           if (action === 'create') {
             await this.handleChange(fileNodeItem, fileNodeItem, result, action);
@@ -4880,8 +4818,7 @@ class NaslServer {
           isChangeInterface = true;
         }
         const module: Module = targetNode as Module;
-        const results: Array<ReturnType<Structure['toEmbeddedTSFile']>> = [];
-        this.contentToFile(module, results);
+        const results = await utils.timeSlicingWithGenerator(this.contentToFile(module));
         for (let i = 0; i < results.length; i++) {
           const result = results[i];
           const node = this.file2NodeMap.get(result.filePath);
@@ -4908,7 +4845,7 @@ class NaslServer {
       if (fileNode instanceof DataSource) {
         (fileNode as DataSource).entities.forEach(async (entity) => {
           try {
-            const result = entity.toEmbeddedTSFile();
+            const result = await utils.timeSlicingWithGenerator(entity.toEmbeddedTSFile());
             const parentPath = oldpath.replace('.ts', '/');
             const currentOldPath = `${parentPath  }/entities/${  entity.name  }.ts`;
             // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
@@ -4924,9 +4861,35 @@ class NaslServer {
   async receiveHandleChange($event: EventPayload) {
     this.singleFileChangeIng = true;
     // 行为
-    const {action} = $event;
+    const { action, oldObject = {}, object = {} } = $event;
+
+    // 根据行为跳过更新文件
+    // 如果更新国际化key，不需要修改ts文件
+    if (Object.keys(object || {}).length === 1 && Object.keys(oldObject).length === 1) {
+      if (object.i18nKey && !oldObject.i18nKey) {
+        return;
+      } else if (object.i18nInfo && !oldObject.i18nInfo) {
+        return;
+      } else if (!object.i18nKey && oldObject.i18nKey) {
+        // 撤销重做 也跳过更新
+        return;
+      } else if (!object.i18nInfo && oldObject.i18nInfo) {
+        // 撤销重做 也跳过更新
+        return;
+      }
+    }
+
     const targetNode = $event.target;
     console.log(targetNode, 'targetNode')
+    // 连接器namespace 没有真实文件，不需要走删除
+    if (targetNode instanceof Namespace && targetNode.parentNode instanceof Connector) {
+      return;
+    }
+    // 连接器本身没有真实文件，也不需要删除
+    if (targetNode instanceof Connector) {
+      return;
+    }
+    
     // Connection 相关配置的更新不需要写入文件
     // i18nInfo 更新不需要写入文件
     if (targetNode?.parentNode instanceof Connection || targetNode instanceof I18nInfo) {
@@ -4947,21 +4910,25 @@ class NaslServer {
       return;
     }
 
+    // debugger;
     if (process.env.NODE_ENV === 'development') {
       console.time('重新生成 TS 文件');
     }
-    // 部分节点如 Namespace 可能不存在对应的方法
-    const result = (fileNode as FileNode)?.toEmbeddedTSFile();
+
+    const fileTsPath = fileNode.getEmbeddedFilePath();
+    const result = await utils.timeSlicingWithGenerator(fileNode.toEmbeddedTSFile());
+
     if (process.env.NODE_ENV === 'development') {
       console.timeEnd('重新生成 TS 文件');
-      console.log('重新生成 TS 文件', (fileNode as FileNode).getEmbeddedFilePath());
+      console.log('重新生成 TS 文件', fileTsPath);
     }
 
     // 当前操作的节点
     // 如果当前没有生成tsFile
-    if (!result) {
+    if (!result.sourceMap) {
       return;
     }
+
     // 修改触发修改文件
     this._debugInFileStorage(targetNode, [
       {
@@ -4971,6 +4938,7 @@ class NaslServer {
     ]);
 
     fileNode.sourceMap = result.sourceMap;
+
     if (action === 'update' || action === 'create') {
       if ($event?.field !== 'name') {
         await this.handleChange(fileNode, targetNode, result, action);