@lcap/nasl 3.3.3-beta.5 → 3.3.3-beta.7

package/src/server/naslServer.ts

@@ -80,14 +80,14 @@ import {
   AuthLogicForCallInterface,
   Connector,
   AuthInterface,
-  SyntaxNode,
   Connection,
   TriggerLauncher,
   CallConnector,
-  MetadataType
+  MetadataType,
+  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';
@@ -102,7 +102,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 } = {
@@ -121,11 +120,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 {
@@ -142,6 +137,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 };
@@ -186,7 +182,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';
@@ -197,7 +192,6 @@ function isFunctionWithFixedTimeZoneParam(calleeName : string): boolean {
   return fns.includes(calleeName);
 }
 
-
 const timeZoneArgumentIndexMap = new Map<string, number>([
   ['ToString', 1],
   ['CurrDateTime', 0],
@@ -282,7 +276,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');
@@ -378,301 +372,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;
+  private *contentToFile(module: Module | App | Connector): Generator<any, utils.EmbeddedTSFileResult[], any> {
+    if (!module) {
+      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) => {
+
+    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;
+
       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);
+        if (!isContinue(node)) {
+          return;
         }
-        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);
+
+        const result = yield* node.toEmbeddedTSFile();
+
+        results.push(result);
+        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);
         }
-        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);
+      }
+    };
+    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;
+      }
+
+      for (const view of views) {
+        yield* getTsFile(view, 'view');
+
+        if (view.children) {
+          yield* view2TSFile(view.children);
         }
-      });
-    }
+      }
+    };
 
-    (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) {}
-      });
-    });
+    // 禁用的依赖库不生成代码 区分 undefined 和 false
+    if (module instanceof Module && module.type === 'extension' && module.enable === false) {
+      return [];
+    }
 
-    module?.interfaces?.forEach((_interface) => {
-      try {
-        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) {}
-    });
+    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');
 
-    (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) {}
-    });
+    if (module instanceof App) {
+      yield* getTsFiles(overriddenLogics, 'overriddenLogic', OverriddenLogic);
+      yield* getTsFiles(backend?.variables ?? [], 'backend_variable');
 
-    (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) {}
-    });
+      for (const frontend of frontends) {
+        yield* getTsFile(frontend, 'frontend');
+        yield* getTsFiles(frontend.variables, 'frontend_variable');
+        yield* getTsFiles(concat(frontend.bindEvents, 'logics'), 'frontend_bindEvent_logic');
 
-    module.processes?.forEach((process) => {
-      try {
-        const result = process.toEmbeddedTSFile();
-        results.push(result);
-        process.sourceMap = result.sourceMap;
-        this.file2NodeMap.set(result.filePath, process);
-      } catch (err) {}
-    });
+        if (!config.closeViews) {
+          yield* view2TSFile(frontend.views);
+        }
 
-    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);
+        for (const dep of frontend.componentDependencies) {
+          results.push(...(yield* self.contentToFile(dep)));
+        }
       }
+    } else {
+      yield* getTsFiles(concat(frontends, 'logics' as any), 'frontend_logic');
     }
 
-    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(dataSources, 'dataSource');
+    yield* getTsFiles(concat(dataSources, 'entities'), 'dataSource_entity');
+    yield* getTsFiles(interfaces, '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);
     // 修改名称回调
@@ -684,6 +522,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) {
@@ -714,13 +567,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);
   }
 
   /**
@@ -1068,26 +927,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;
+
+    console.time('处理诊断数据');
 
-        oldRecord?.semanticDiagnostics.forEach((item) => {
+    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
@@ -1097,8 +959,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) {
@@ -1106,146 +967,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;
+            }
 
-              // 没有降级的继续遍历，如果在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
    */
@@ -1263,7 +1151,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) => {
@@ -1625,31 +1513,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,
+    // };
   }
 
   /**
@@ -1680,15 +1590,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;
@@ -1731,7 +1644,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;
@@ -1788,11 +1701,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,
@@ -1804,7 +1717,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];
@@ -1827,7 +1740,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} 接口有鉴权方式，不支持在前端调用`;
@@ -1853,15 +1766,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,
@@ -2157,8 +2071,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,
@@ -2167,18 +2082,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);
@@ -2197,8 +2102,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;
@@ -2250,7 +2154,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()
@@ -2268,11 +2172,13 @@ 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 MetadataType) {
+    }
+    else if (fileNode instanceof MetadataType) {
       fileNode?.sourceMap.forEach((value, node) => {
         const rulesMap: any = {};
         const { rules, typeAnnotation } = node as MetadataType;
@@ -2315,6 +2221,7 @@ class NaslServer {
         }
       })
     }
+
     return diagnostics;
   }
 
@@ -2609,9 +2516,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) {
@@ -2642,9 +2550,8 @@ class NaslServer {
         }
         return null;
       }
-        return diag;
-
     });
+
     if (actionArr.length) {
       if (timer) return;
       timer = window.setTimeout(() => {
@@ -2671,50 +2578,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()) {
       /**
        * 当前内容的开始行 <= 诊断开始的行 &&
@@ -2771,16 +2682,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 节点
@@ -2924,6 +2850,7 @@ class NaslServer {
         line: lsp2tspNumber(currentSource.start.line),
         offset: lsp2tspNumber(currentSource.start.character),
       });
+      // console.log(parentRefs.refs)
       refsList = [...refsList, ...parentRefs.refs];
     }
 
@@ -3078,12 +3005,22 @@ class NaslServer {
     if (node instanceof Return && node.parentNode instanceof ProcessElement) {
       const { currentSource, fileNode } = this.getCurrentSource(node.parentNode);
       if (currentSource) {
+        // 流程任务出参查找引用需要查找到流程任务完成逻辑
+        // const parentRefs = await this.references({
+        //   file: (fileNode as FileNode).getEmbeddedFilePath(),
+        //   line: lsp2tspNumber(currentSource.start.line),
+        //   offset: lsp2tspNumber(currentSource.start.character),
+        // });
+        // refsList = [...refsList, ...parentRefs.refs];
+        // console.log(parentRefs.refs)
+
+        // 流程任务出参查找引用比较特殊，需要查找到 const process = {...} 的引用
         const code = this.getNodeCode(fileNode, currentSource);
         const prefix = '__ProcessIdentification__';
         const positions = [];
         let pos = code.indexOf(prefix);
         // 需要再次定位到processelement对象上，避免process上存在同名参数
-        pos = code.indexOf(node.parentNode.name, pos + prefix.length);
+        pos = pos === -1 ? pos : code.indexOf(node.parentNode.name, pos + prefix.length);
         pos = pos === -1 ? pos : code.indexOf(node.name, pos + prefix.length);
         // pos === -1：两种情况：
         // 1、找到最后一个节点了，继续找找不下去了。
@@ -3813,7 +3750,7 @@ 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;
     // 如果没有sourceMap,就继续向上找 ,或者到module结束
     // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
     // 如果当前节点是view就不要向上查找了
@@ -3829,7 +3766,7 @@ class NaslServer {
       !(fileNode instanceof View) &&
       !(fileNode instanceof ConfigProperty)
     ) {
-      fileNode = fileNode.parentNode;
+      fileNode = fileNode.parentNode as FileNode & SyntaxNode;
       sourceMap = fileNode?.sourceMap;
     }
     const currentSource = sourceMap && sourceMap.get(node);
@@ -3873,7 +3810,6 @@ class NaslServer {
         getFieldKey: fieldKey,
       });
     }
-
   }
 
   _getFieldKeySelectCompletion(args: any) {
@@ -3983,245 +3919,238 @@ 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);
+      yield;
 
-        // 要去ls那边获取的
-        newQuickInfoNodes.push(itemDetail);
-        const fileDetail = {
-          file: filePath,
-          line: lsp2tspNumber(item.start.line),
-          offset: lsp2tspNumber(item.start.character),
-        };
+      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;
+
+      // 要去ls那边获取的
+      newQuickInfoNodes.push(itemDetail);
+      const fileDetail = {
+        file: filePath,
+        line: lsp2tspNumber(item.start.line),
+        offset: lsp2tspNumber(item.start.character),
+      };
 
-        const getCode = (range: SourceMapItem) => {
-          return this.tsFiles.get(filePath)?.slice(range.start.offset, range.end.offset) ?? '';
-        };
+      const getCode = (range: SourceMapItem) => {
+        return self.tsFiles.get(filePath)?.slice(range.start.offset, range.end.offset) ?? '';
+      };
 
-        // 位置计算偏移
-        if ('getQuickInfoOffset' in node) {
-          Object.assign(fileDetail, (node as any).getQuickInfoOffset(fileDetail, getCode(item)));
-        }
+      // 位置计算偏移
+      if ('getQuickInfoOffset' in node) {
+        Object.assign(fileDetail, (node as any).getQuickInfoOffset(fileDetail, getCode(item)));
+      }
 
-        // 位置计算偏移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;
+      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;
+            indexOf = code.indexOf('(');
           }
-          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)) {
-          const code = getCode(item);
-          fileDetail.line = item.end.line;
-          const indexOf = code.indexOf('return __newComposite');
-          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;
+          const subStr = code.substring(0, indexOf);
+          const codeArr = subStr?.split('.');
+          const lastLen = codeArr?.[codeArr.length - 1]?.length;
+          indexOf = subStr.length - lastLen;
         }
-        args.push(fileDetail);
-      },
-      { minimum: 1000 },
-    );
-
-    const resultMap: any = (await this.getNaslNodeTypeFull(args))?.response;
-    await utils.timeSlicing(
-      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);
-
-        const type = itemType ? (Object.isFrozen(itemType) ? itemType : Object.freeze(itemType)) : null;
-        if (type) {
-          (node as any).__nodeType = type;
+        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 {
-          delete (node as any).__nodeType;
+          fileDetail.line = item.end.line;
         }
-      },
-      { 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));
-            }
+        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)) {
+        const code = getCode(item);
+        fileDetail.line = item.end.line;
+        const indexOf = code.indexOf('return __newComposite');
+        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);
+
+      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));
+        }
+      } 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) {
@@ -4256,28 +4185,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,7 +4346,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: TypeAnnotation; option: object }, void> {
     // 直接复用内部expression的type类型
     if (
       node.parentNode instanceof CallLogic &&
@@ -4430,6 +4370,7 @@ class NaslServer {
           };
         }
       }
+      yield;
     }
     // 获取返回值结果里找到父级的callLogic || CallInterface的类型填充进去Argument
     const App = node.app;
@@ -4444,7 +4385,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] || {};
     // 取出参数的类型
@@ -4536,7 +4478,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就直接删除并且清除错误
     /**
@@ -4576,7 +4518,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 }];
@@ -4621,7 +4563,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 }];
     // 如果是要修改顶级文件名
@@ -4725,7 +4667,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);
@@ -4748,7 +4690,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);
@@ -4772,8 +4714,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);
@@ -4800,7 +4741,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`;
             // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
@@ -4837,20 +4778,25 @@ class NaslServer {
       return;
     }
 
+    // debugger;
     if (process.env.NODE_ENV === 'development') {
       console.time('重新生成 TS 文件');
     }
-    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, [
       {
@@ -4860,6 +4806,7 @@ class NaslServer {
     ]);
 
     fileNode.sourceMap = result.sourceMap;
+
     if (action === 'update' || action === 'create') {
       if ($event?.field !== 'name') {
         await this.handleChange(fileNode, targetNode, result, action);