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

package/src/concepts/View__.ts

@@ -1,5 +1,20 @@
+import {
+  wrapForEachToGenerator as wrapForEach,
+  wrapIteratorToGenerator as wrapIterator,
+  returnOrigin,
+} from '../utils/time-slicing';
+import type { EmbeddedTSFileGenerator } from '../utils';
 import Namespace from './Namespace__';
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import translator from '../bak/translator';
 import { ElementToVueOptions } from './ViewElement__';
 import { Structure } from './Structure__';
@@ -13,6 +28,11 @@ import CallLogic from './CallLogic__';
 import DefaultValue from './DefaultValue__';
 import type Interface from './Interface__';
 
+const getBranchCopyUniCode = () => (window as any)?.BranchCopyUniCode
+const removedViewElementCache : {
+  [key: string]: number | bigint;
+}= {} // 临时记录删除的页面元素计数的最大值
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -31,11 +51,8 @@ import BindEvent from './BindEvent__';
 import Module from './Module__';
 import Frontend from './Frontend__';
 import App from './App__';
+import { SyntaxNode } from './types__';
 
-const getBranchCopyUniCode = () => (window as any)?.BranchCopyUniCode
-const removedViewElementCache : {
-  [key: string]: number | bigint;
-}= {} // 临时记录删除的页面元素计数的最大值
 /**
  * 页面
  */
@@ -2037,8 +2054,9 @@ export class View extends BaseNode {
     }
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     function chineseTsName(name: string) {
       let tsName = name;
       // 匹配所有特殊字符都转为_
@@ -2047,16 +2065,15 @@ export class View extends BaseNode {
     }
     // 获取虚拟logic的参数和内容
     // 用作展示和tots查找引用
-    this.getElementLogicRoot();
-
-    let code = `export namespace ${this.tsName} {\n`;
+    self.getElementLogicRoot();
+    let code = `export namespace ${self.tsName} {\n`;
     // 角色
-    if (Array.isArray(this.bindRoles) && this.bindRoles.length) {
+    if (Array.isArray(self.bindRoles) && self.bindRoles.length) {
       code += indent((state?.tabSize || 0) + 1);
       code += 'export let __bindRoles = [\n';
-      this.bindRoles.forEach((role) => {
+      yield* wrapForEach(self.bindRoles, function* warpForEachGenerator(role) {
         code += indent((state?.tabSize || 0) + 1);
-        code += `${this.app.getNamespace()}.roles.${chineseTsName(role)}.${chineseTsName(role)},`;
+        code += `${self.app.getNamespace()}.roles.${chineseTsName(role)}.${chineseTsName(role)},`;
         code += '\n';
       });
       code += '\n';
@@ -2065,24 +2082,24 @@ export class View extends BaseNode {
     }
     // 需要类型推导的局部变量/返回值需要调整申明顺序
     const advanceMap: Map<Variable, Assignment | BatchAssignment> = new Map();
-    this.traverseChildren((el) => {
+    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
       if (el && (el instanceof BatchAssignment || (el instanceof Assignment && el.left?.name))) {
         // 子页面内部逻辑过滤
-        if (el.view !== this) return;
+        if (el.view !== self) return;
         if (el instanceof Assignment) {
-          const advanceVar = this.variables?.find(
+          const advanceVar = self.variables?.find(
             (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
           );
           if (advanceVar && !advanceMap.get(advanceVar)) {
             advanceMap.set(advanceVar, el);
           }
         } else if (el instanceof BatchAssignment) {
-          el.assignmentLines.forEach(({ leftIndex }) => {
+          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
             const leftCode =
               leftIndex.length === 1
-                ? el.left?.expression?.toEmbeddedTS(shiftState(state, code, { inline: true }))
-                : el.left?.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            const advanceVar = this.variables?.find(
+                ? yield* el.left?.expression?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('')
+                : yield* el.left?.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
+            const advanceVar = self.variables?.find(
               (variable) => !variable.typeAnnotation && leftCode === variable.name,
             );
             if (advanceVar && !advanceMap.get(advanceVar)) {
@@ -2094,51 +2111,51 @@ export class View extends BaseNode {
     });
 
     // 用来储存默认值翻译结构是__IDENTIFIER__或者__IDENTIFIER__()的节点
-    const IDENTIFIERMAP = new Set();
-    if (Array.isArray(this.params)) {
-      this.params.forEach((param) => {
+    const IDENTIFIERMAP = new Set<Variable>();
+    if (Array.isArray(self.params)) {
+      yield* wrapForEach(self.params, function* warpForEachGenerator(param) {
         code += `${indent((state?.tabSize || 0) + 1)}let `;
-        code += param.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += yield* param.toEmbeddedTS(shiftState(state, code, { inline: true }));
         code += ';\n';
       });
     }
-    if (Array.isArray(this.variables)) {
-      this.variables.forEach((variable) => {
-        const ts = variable.defaultValue?.toEmbeddedTS();
+    if (Array.isArray(self.variables)) {
+      yield* wrapForEach(self.variables, function* warpForEachGenerator(variable) {
+        const ts = yield* variable.defaultValue?.toEmbeddedTS?.() ?? returnOrigin('');
         if (['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
           IDENTIFIERMAP.add(variable);
         }
         if (!advanceMap.get(variable)) {
           code += `${indent((state?.tabSize || 0) + 1)}let `;
-          code += variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
+          code += yield* variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
           code += ';\n';
         }
       });
     }
-    advanceMap.forEach((assignment, variable) => {
+    yield* wrapIterator(advanceMap.entries(), function* warpForEachGenerator([variable, assignment]) {
       // 有默认值的用默认值来推导类型, 但是如果是__IDENTIFIER__或者__IDENTIFIER__()，就不需要默认值来推导了
       if (variable.defaultValue?.expression && !IDENTIFIERMAP.has(variable)) {
         code += `${indent((state?.tabSize || 0) + 1)}let `;
-        code += variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += yield* variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
         return;
       }
       code += `${indent((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
       code += `${indent((state?.tabSize || 0) + 1)}let `;
-      code += variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      code += yield* variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
       code += ' = ';
       if (assignment instanceof BatchAssignment) {
-        assignment.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
+        yield* wrapForEach(assignment.assignmentLines, function* warpForEachGenerator({ leftIndex, rightIndex }) {
           const leftCode =
             leftIndex.length === 1
-              ? assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-              : assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+              ? yield* assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
+              : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
           if (leftCode === variable.name) {
             const rightNode =
               rightIndex.length === 1
                 ? assignment.rights[rightIndex[0]]?.expression
                 : assignment.rights[rightIndex[0]]?.members[rightIndex[1]];
-            const rightCode = rightNode?.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            code += this.getRightCode(rightCode, assignment, rightNode);
+            const rightCode = yield* rightNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
+            code += yield* self.getRightCode(rightCode, assignment, rightNode);
           }
         });
       } else {
@@ -2154,18 +2171,17 @@ export class View extends BaseNode {
         }
         rightCode +=
           assignment.right && assignment.right.toEmbeddedTS
-            ? assignment.right.toEmbeddedTS(shiftState(state, code, { inline: true }))
+            ? yield* assignment.right.toEmbeddedTS(shiftState(state, code, { inline: true }))
             : '__RIGHT__';
-        code += this.getRightCode(rightCode, assignment, assignment.right);
+        code += yield* self.getRightCode(rightCode, assignment, assignment.right);
       }
       code += ';\n';
     });
-
     // elements类型声明定义
     code += `interface __elements {\n`;
     // 生成所有的name和类型定义
-    this.elements.forEach((element) => {
-      code += element.toEmbeddedTSDefinition(
+    yield* wrapForEach(self.elements, function* warpForEachGenerator(element) {
+      code += yield* element.toEmbeddedTSDefinition(
         shiftState(state, code, {
           tabSize: (state?.tabSize || 0) + 1,
         }),
@@ -2173,40 +2189,37 @@ export class View extends BaseNode {
     });
     code += `${indent((state?.tabSize || 0) + 1)}}\n`;
     code += `let __elements: __elements;\n`;
-
-    if (Array.isArray(this.elements)) {
+    if (Array.isArray(self.elements)) {
       code += `${indent((state?.tabSize || 0) + 1)}interface `;
       code += `__elements_completionProperty {\n`;
       const componentList: Array<ViewElement> = [];
-      this.elementsAttrs(this.elements, componentList);
+      self.elementsAttrs(self.elements, componentList);
       const variableList: string[] = [];
-      this.elements.forEach((item) => {
-        code += item.toEmbeddedTSVariableDefinition(shiftState(state, code, { inline: true }), variableList);
+      yield* wrapForEach(self.elements, function* warpForEachGenerator(item) {
+        code += yield* item.toEmbeddedTSVariableDefinition(shiftState(state, code, { inline: true }), variableList);
       });
       code += indent((state?.tabSize || 0) + 1) + `}\n`;
       code += indent((state?.tabSize || 0) + 1);
       code += `let __elements_completionProperty: __elements_completionProperty;\n`;
-
       code += indent((state?.tabSize || 0) + 1);
       code += `let __elements_variable_function = {\n`;
-      this.elements.forEach((item) => {
-        code += item.toEmbeddedTSVariableFunctionDefinition(shiftState(state, code, { inline: true }));
+      yield* wrapForEach(self.elements, function* warpForEachGenerator(item) {
+        code += yield* item.toEmbeddedTSVariableFunctionDefinition(shiftState(state, code, { inline: true }));
       });
       code += indent((state?.tabSize || 0) + 1) + `}\n`;
-
       code += indent((state?.tabSize || 0) + 1);
       code += `let __elements_stashFunctionVariable = {\n`;
-      variableList.forEach((item) => {
+      yield* wrapForEach(variableList, function* warpForEachGenerator(item) {
         code += indent((state?.tabSize || 0) + 2);
         code += `${item}`;
       });
       code += indent((state?.tabSize || 0) + 1) + `}\n`;
     }
     // 逻辑
-    if (Array.isArray(this.logics) && this.logics.length) {
+    if (Array.isArray(self.logics) && self.logics.length) {
       code += indent((state?.tabSize || 0) + 1);
-      this.logics.forEach((logic) => {
-        code += logic.toEmbeddedTS(
+      yield* wrapForEach(self.logics, function* warpForEachGenerator(logic) {
+        code += yield* logic.toEmbeddedTS(
           shiftState(state, code, {
             tabSize: (state?.tabSize || 0) + 2,
           }),
@@ -2217,9 +2230,9 @@ export class View extends BaseNode {
       code += indent((state?.tabSize || 0) + 1);
     }
     // 事件
-    if (Array.isArray(this.bindEvents)) {
-      this.bindEvents.forEach((event) => {
-        code += event.toEmbeddedTS(
+    if (Array.isArray(self.bindEvents)) {
+      yield* wrapForEach(self.bindEvents, function* warpForEachGenerator(event) {
+        code += yield* event.toEmbeddedTS(
           shiftState(state, code, {
             tabSize: state?.tabSize || 0,
           }),
@@ -2228,18 +2241,16 @@ export class View extends BaseNode {
         code += '\n';
       });
     }
-
     // render函数
     code += `\n${indent((state?.tabSize || 0) + 1)}`;
     code += `export function __render(`;
     code += `){\n`;
     code += indent(state?.tabSize || 0);
-
     // elements 元素
-    if (Array.isArray(this.elements)) {
+    if (Array.isArray(self.elements)) {
       // 生成嵌套式的内容
-      this.elements.forEach((element) => {
-        code += element.toEmbeddedTS(
+      yield* wrapForEach(self.elements, function* warpForEachGenerator(element) {
+        code += yield* element.toEmbeddedTS(
           shiftState(state, code, {
             tabSize: (state?.tabSize || 0) + 3,
           }),
@@ -2247,20 +2258,16 @@ export class View extends BaseNode {
         code += '\n';
       });
     }
-
     code += `\n${indent((state?.tabSize || 0) + 1)}}\n`;
-
-    if (Array.isArray(this.params)) {
+    if (Array.isArray(self.params)) {
       code += `${indent((state?.tabSize || 0) + 1)}export function $destination(options: {`;
-      this.params.forEach((param, index) => {
+      yield* wrapForEach(self.params, function* warpForEachGenerator(param, index) {
         code += `${param.name}?: `;
-        code += param.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+        code += yield* param.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         code += ', ';
       });
-
       // 锚点
       code += `_anchor?: nasl.core.String`;
-
       code += '}){}\n';
     }
 
@@ -2268,39 +2275,32 @@ export class View extends BaseNode {
     code += `${indent((state?.tabSize || 0) + 1)}export function __playground(){\n`;
 
     /* 参数的默认值是__IDENTIFIER__或者__IDENTIFIER__()时不赋默认值，但是需要ts翻译出来进行报错校验 */
-    IDENTIFIERMAP.forEach((node: Variable) => {
+    for (const node of IDENTIFIERMAP.values()) {
       code += `${indent((state?.tabSize || 0) + 2)}`;
-      code += node.defaultValue.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      code += yield* node.defaultValue.toEmbeddedTS(shiftState(state, code, { inline: true }));
       code += '; ';
-    });
-    code += '\n';
+    }
 
+    code += '\n';
     code += `${indent((state?.tabSize || 0) + 2)}return\n`;
 
-    if (this.variables.length) {
-      code += `${indent((state?.tabSize || 0) + 2)}/* -----以下是variables的默认值草稿------ */\n`;
-    }
-    this.variables.forEach((variable) => {
-      if (variable.defaultValue) {
-        variable.defaultValue.playground?.forEach((item) => {
-          code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 2 }));
-          code += ';\n';
-        });
+    function* setPlaygroundCode(arr: Variable[] | Param[], name: string) {
+      if (arr.length) {
+        code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是 ${name} 的默认值草稿------ */\n`;
       }
-    });
-    if (this.params.length) {
-      code += `${indent((state?.tabSize || 0) + 2)}/* -----以下是params的默认值草稿------ */\n`;
-    }
-    this.params.forEach((param) => {
-      if (param.defaultValue && param.defaultValue instanceof DefaultValue) {
-        param.defaultValue.playground?.forEach((item) => {
-          code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 2 }));
+
+      for (const item1 of arr) {
+        for (const item of item1.defaultValue?.playground ?? []) {
+          code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
           code += ';\n';
-        });
+        }
       }
-    });
-    code += `${indent((state?.tabSize || 0) + 1)}}\n`;
+    }
+
+    yield* setPlaygroundCode(self.variables, 'variables');
+    yield* setPlaygroundCode(self.params, 'params');
 
+    code += `${indent((state?.tabSize || 0) + 1)}}\n`;
     code += `${indent(state?.tabSize || 0)}}\n`;
     return code;
   }
@@ -2416,14 +2416,14 @@ ${indent(state.tabSize)}export function ${this.tsName}_view`;
     return code;
   }
 
-  toEmbeddedTSFile() {
+  *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
     let code = `namespace ${this.getTsNamespace()} {\n`;
     const state = createCompilerState(code, {
       tabSize: 1,
     });
 
     try {
-      code += this.toEmbeddedTS(state);
+      code += yield* this.toEmbeddedTS(state);
     } catch (err) {
       code += '';
       console.log(err);
@@ -2693,7 +2693,7 @@ ${indent(state.tabSize)}export function ${this.tsName}_view`;
     }
   }
 
-  getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any): string {
+  *getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any) {
     code = code.replaceAll('\n', ' ');
     const logic = assignment.logic;
     const logicRtn = logic?.returns[0];
@@ -2728,7 +2728,7 @@ ${indent(state.tabSize)}export function ${this.tsName}_view`;
 
     // 处理 current.item、current1.item 等数据
     if (/current(\d)*\.item/.test(code)) {
-      code = this.handleCurrentItemCode(code, logic);
+      code = yield* this.handleCurrentItemCode(code, logic);
       return code;
     }
 
@@ -2758,7 +2758,7 @@ ${indent(state.tabSize)}export function ${this.tsName}_view`;
   }
 
   getAncestorViewElementsWithDataSource(logic: Logic): ViewElement[] {
-    let element: BaseNode = logic;
+    let element: SyntaxNode = logic;
     const viewElements: ViewElement[] = [];
     while (element) {
       if (
@@ -2773,16 +2773,16 @@ ${indent(state.tabSize)}export function ${this.tsName}_view`;
     return viewElements;
   }
 
-  handleCurrentItemCode(code: string, logic: Logic): string {
+  *handleCurrentItemCode(code: string, logic: Logic) {
     const viewElementsWithDataSource: ViewElement[] = this.getAncestorViewElementsWithDataSource(logic);
-    viewElementsWithDataSource.forEach((viewElement, index) => {
+    yield* wrapForEach(viewElementsWithDataSource, function* wrapForEach(viewElement, index) {
       const currentIndex = viewElementsWithDataSource.length - 1 - index;
       const currentItemCode = `current${currentIndex === 0 ? '' : currentIndex}.item`;
       if (code.includes(currentItemCode)) {
         const dataSource = viewElement.bindAttrs.find((bAttr) => bAttr.name === 'data-source');
         if (dataSource) {
           const view = viewElement.getAncestor('View') as View;
-          const dataSourceTS = dataSource.expression.toEmbeddedTS();
+          const dataSourceTS = yield* dataSource.expression.toEmbeddedTS();
           const logic = view.logics.find((logic) => logic.name === dataSourceTS);
           if (logic) {
             code = code.replaceAll(

package/src/concepts/WhileStatement__.ts

@@ -1,4 +1,14 @@
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -281,29 +291,28 @@ export class WhileStatement extends LogicItem {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
     code += 'while (nasl.core.ensureBoolean(';
-    code += this.test
-      ? this.test.toEmbeddedTS(
+    code += self.test
+      ? yield* self.test.toEmbeddedTS(
           shiftState(state, code, {
             tabSize: 0,
           }),
         )
       : '__IDENTIFIER__';
     code += ')) {\n';
-
-    if (Array.isArray(this.body)) {
-      this.body.forEach((logicItem) => {
-        code += `${logicItem.toEmbeddedTS(
+    if (Array.isArray(self.body)) {
+      yield* wrapForEach(self.body, function* warpForEachGenerator(logicItem) {
+        code += `${yield* logicItem.toEmbeddedTS(
           shiftState(state, code, {
             tabSize: (state?.tabSize || 0) + 1,
           }),
         )};\n`;
       });
     }
-
     code += `${indent(state?.tabSize || 0)}}\n`;
     return code;
   }

package/src/concepts/index__.ts

@@ -43,7 +43,7 @@ export * from './LogicItem__';
 export * from './Function__';
 export * from './AnonymousFunction__';
 export * from './Interface__';
-export * from './InterfaceFromExample__';
+export * from './ImportedInterface__';
 export * from './InterfaceParam__';
 export * from './Transactional__';
 export * from './DefaultValue__';

package/src/concepts/types__.ts

@@ -32,7 +32,6 @@ import type { Logic } from './Logic__';
 import type { AuthLogic } from './AuthLogic__';
 import type { AuthLogicForCallInterface } from './AuthLogicForCallInterface__';
 import type { OverriddenLogic } from './OverriddenLogic__';
-import type { AbstractInterface } from './AbstractInterface__';
 import type { Param } from './Param__';
 import type { Return } from './Return__';
 import type { Variable } from './Variable__';
@@ -42,7 +41,6 @@ import type { Constant } from './Constant__';
 import type { Function } from './Function__';
 import type { AnonymousFunction } from './AnonymousFunction__';
 import type { Interface } from './Interface__';
-import type { InterfaceFromExample } from './InterfaceFromExample__';
 import type { InterfaceParam } from './InterfaceParam__';
 import type { Transactional } from './Transactional__';
 import type { DefaultValue } from './DefaultValue__';
@@ -161,7 +159,6 @@ export type SyntaxNode =
     | AuthLogic
     | AuthLogicForCallInterface
     | OverriddenLogic
-    | AbstractInterface
     | Param
     | Return
     | Variable
@@ -171,7 +168,6 @@ export type SyntaxNode =
     | Function
     | AnonymousFunction
     | Interface
-    | InterfaceFromExample
     | InterfaceParam
     | Transactional
     | DefaultValue
@@ -255,4 +251,4 @@ export type SyntaxNode =
     | CallConnector
     | Connection;
 
-export type SyntaxNodeConcept = SyntaxNode['concept'];
+export type SyntaxNodeConcept = SyntaxNode['concept'];

package/src/decorators/index.ts

@@ -82,7 +82,16 @@ export function getConceptPropertyMap(concept: string) {
 export function concept(nodeTitle: string) {
   return (target: any) => {
     target.nodeTitle = nodeTitle;
-    const metaMap = getConceptMeta(target.ConceptName ?? target.name);
+    const concept = target.ConceptName ?? target.name;
+    const metaMap = getConceptMeta(concept);
+    const prototypeTarget = Object.getPrototypeOf(target);
+    if (prototypeTarget) {
+      const propertyMap = getConceptPropertyMap(concept);
+      const prototypeMetaMap = getConceptPropertyMap(prototypeTarget.ConceptName ?? prototypeTarget.name);
+      prototypeMetaMap.forEach((prototypeMeta, key: string) => {
+        propertyMap.set(key, prototypeMeta);
+      });
+    }
     metaMap.constructor = target;
   };
 }
@@ -131,14 +140,6 @@ export function property(params?: any) {
   const { objectRef, isArray, defaultValue } = params || {};
   return function handle(target: SyntaxNode | BaseNode, key: string) {
     const metaMap = getConceptPropertyMap(target.concept ?? target.constructor.name);
-    const prototypeTarget = Object.getPrototypeOf(target);
-    const prototypeConstructor = prototypeTarget.constructor;
-    if (prototypeTarget && prototypeConstructor) {
-      const prototypeMetaMap = getConceptPropertyMap(prototypeTarget.concept ?? prototypeConstructor.name);
-      prototypeMetaMap.forEach((prototypeMeta, key: string) => {
-        metaMap.set(key, prototypeMeta);
-      });
-    }
     metaMap.set(key, {
       key,
       objectRef,

package/src/generator/genMetaData.ts

@@ -18,8 +18,7 @@ import {
   authStructures,
   httpStructures,
   MetadataType,
-  TypeAnnotation,
-  InterfaceFromExample,
+  TypeAnnotation
 } from '../concepts';
 import * as utils from '../utils';
 
@@ -71,10 +70,6 @@ function isInterface (node: BaseNode): node is Interface {
   return node instanceof Interface;
 }
 
-function isInterfaceFromExample(node: BaseNode): node is InterfaceFromExample {
-  return node instanceof InterfaceFromExample;
-}
-
 export function genMetaData(app: App, frontend: Frontend) {
   const modules: (Module | Connector)[] = [];
   const views: View[] = [];
@@ -285,12 +280,7 @@ export function genMetaData(app: App, frontend: Frontend) {
     }
   });
 
-  interfaces.forEach((interfaceItem: Interface | InterfaceFromExample) => {
-
-    // 兼容 InterfaceFromExample
-    if (isInterfaceFromExample(interfaceItem)) {
-      interfaceItem = interfaceItem.inter as Interface;
-    }
+  interfaces.forEach((interfaceItem: Interface) => {
     _custom[`${interfaceItem.getNamespace()}.${interfaceItem.name}`] = interfaceItem.toService();
   });
 

package/src/manager/diagnostic.ts

@@ -1,5 +1,6 @@
 import * as tsProtocol from 'typescript/lib/protocol';
-import { LogicItem, BaseNode } from '../concepts';
+import { BaseNode } from '../concepts';
+import { timeSlicingWithList } from '../utils';
 
 // export interface TypeCheckNote {
 //     status: string,
@@ -99,9 +100,7 @@ export class DiagnosticManager {
   }
 
   pushAll(records: DiagnosticRecord[]) {
-    for (const record of records) {
-      this.push(record);
-    }
+    return timeSlicingWithList(records, (record) => this.push(record));
   }
 
   filterDiagnostics(showTSError?: boolean) {