@lcap/nasl 3.4.0-beta.6 → 3.5.0-alpha.1

package/src/concepts/Namespace__.ts

@@ -1,37 +1,37 @@
-import Interface from './Interface__';
+import type Interface from './Interface__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
-import Process from './Process__';
-import Structure from './Structure__';
-import Enum from './Enum__';
-import Logic from './Logic__';
-import Function from './Function__';
-import AbstractInterface from './AbstractInterface__';
-import View from './View__';
-import Variable from './Variable__';
-import ViewComponent from './ViewComponent__';
-import ProcessComponent from './ProcessComponent__';
+import type Process from './Process__';
+import type Structure from './Structure__';
+import type Enum from './Enum__';
+import type Logic from './Logic__';
+import type Function from './Function__';
+import type AbstractInterface from './AbstractInterface__';
+import type View from './View__';
+import type Variable from './Variable__';
+import type ViewComponent from './ViewComponent__';
+import type ProcessComponent from './ProcessComponent__';
 
 /**
  * 命名空间
  */
-@className
 @concept('命名空间')
-// @ts-ignore
 export class Namespace extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'Namespace';
+  static readonly ConceptName: string = 'Namespace';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -44,28 +44,24 @@ export class Namespace extends BaseNode {
    * 表示是从实体还是流程等概念产生的
    */
   @property()
-  // @ts-ignore
   originConcept!: string;
 
   /**
    * 命名空间名称
    */
   @property()
-  // @ts-ignore
   name!: string;
 
   /**
    * 命名空间标题
    */
   @property()
-  // @ts-ignore
   title!: string;
 
   /**
    * 命名空间描述
    */
   @property()
-  // @ts-ignore
   description!: string;
 
   /**
@@ -245,6 +241,7 @@ export class Namespace extends BaseNode {
   _insertNamespaceAt(options: string | Partial<Namespace> | Namespace, index: number) {
     const namespaceOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'children' };
+    const Namespace = getConceptConstructor('Namespace');
     let namespace: Namespace;
     if (!options) {
       namespace = Namespace.from(
@@ -264,7 +261,7 @@ export class Namespace extends BaseNode {
         this,
         'children',
       );
-    } else if (options instanceof Namespace) {
+    } else if (asserts.isNamespace(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       namespace = options;
       Object.assign(namespace, relationOptions);
@@ -398,6 +395,7 @@ export class Namespace extends BaseNode {
   _insertProcessAt(options: string | Partial<Process> | Process, index: number) {
     const processOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'processes' };
+    const Process = getConceptConstructor('Process');
     let process: Process;
     if (!options) {
       process = Process.from(
@@ -417,7 +415,7 @@ export class Namespace extends BaseNode {
         this,
         'processes',
       );
-    } else if (options instanceof Process) {
+    } else if (asserts.isProcess(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       process = options;
       Object.assign(process, relationOptions);
@@ -551,6 +549,7 @@ export class Namespace extends BaseNode {
   _insertStructureAt(options: string | Partial<Structure> | Structure, index: number) {
     const structureOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'structures' };
+    const Structure = getConceptConstructor('Structure');
     let structure: Structure;
     if (!options) {
       structure = Structure.from(
@@ -570,7 +569,7 @@ export class Namespace extends BaseNode {
         this,
         'structures',
       );
-    } else if (options instanceof Structure) {
+    } else if (asserts.isStructure(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       structure = options;
       Object.assign(structure, relationOptions);
@@ -704,6 +703,7 @@ export class Namespace extends BaseNode {
   _insertEnumAt(options: string | Partial<Enum> | Enum, index: number) {
     const enumerationOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'enums' };
+    const Enum = getConceptConstructor('Enum');
     let enumeration: Enum;
     if (!options) {
       enumeration = Enum.from(
@@ -723,7 +723,7 @@ export class Namespace extends BaseNode {
         this,
         'enums',
       );
-    } else if (options instanceof Enum) {
+    } else if (asserts.isEnum(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       enumeration = options;
       Object.assign(enumeration, relationOptions);
@@ -857,6 +857,7 @@ export class Namespace extends BaseNode {
   _insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
     const logicOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'logics' };
+    const Logic = getConceptConstructor('Logic');
     let logic: Logic;
     if (!options) {
       logic = Logic.from(
@@ -876,7 +877,7 @@ export class Namespace extends BaseNode {
         this,
         'logics',
       );
-    } else if (options instanceof Logic) {
+    } else if (asserts.isLogic(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logic = options;
       Object.assign(logic, relationOptions);
@@ -1010,6 +1011,7 @@ export class Namespace extends BaseNode {
   _insertFunctionAt(options: string | Partial<Function> | Function, index: number) {
     const funcOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'functions' };
+    const Function = getConceptConstructor('Function');
     let func: Function;
     if (!options) {
       func = Function.from(
@@ -1029,7 +1031,7 @@ export class Namespace extends BaseNode {
         this,
         'functions',
       );
-    } else if (options instanceof Function) {
+    } else if (asserts.isFunction(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       func = options;
       Object.assign(func, relationOptions);
@@ -1173,6 +1175,7 @@ export class Namespace extends BaseNode {
   _insertViewAt(options: string | Partial<View> | View, index: number) {
     const viewOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'views' };
+    const View = getConceptConstructor('View');
     let view: View;
     if (!options) {
       view = View.from(
@@ -1192,7 +1195,7 @@ export class Namespace extends BaseNode {
         this,
         'views',
       );
-    } else if (options instanceof View) {
+    } else if (asserts.isView(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       view = options;
       Object.assign(view, relationOptions);
@@ -1328,6 +1331,7 @@ export class Namespace extends BaseNode {
   _insertVariableInFrontendVariablesAt(options: string | Partial<Variable> | Variable, index: number) {
     const variableOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'frontendVariables' };
+    const Variable = getConceptConstructor('Variable');
     let variable: Variable;
     if (!options) {
       variable = Variable.from(
@@ -1347,7 +1351,7 @@ export class Namespace extends BaseNode {
         this,
         'frontendVariables',
       );
-    } else if (options instanceof Variable) {
+    } else if (asserts.isVariable(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       variable = options;
       Object.assign(variable, relationOptions);
@@ -1473,6 +1477,7 @@ export class Namespace extends BaseNode {
   _insertVariableInVariablesAt(options: string | Partial<Variable> | Variable, index: number) {
     const variableOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'variables' };
+    const Variable = getConceptConstructor('Variable');
     let variable: Variable;
     if (!options) {
       variable = Variable.from(
@@ -1492,7 +1497,7 @@ export class Namespace extends BaseNode {
         this,
         'variables',
       );
-    } else if (options instanceof Variable) {
+    } else if (asserts.isVariable(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       variable = options;
       Object.assign(variable, relationOptions);
@@ -1628,6 +1633,7 @@ export class Namespace extends BaseNode {
   _insertViewComponentAt(options: string | Partial<ViewComponent> | ViewComponent, index: number) {
     const viewComponentOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'viewComponents' };
+    const ViewComponent = getConceptConstructor('ViewComponent');
     let viewComponent: ViewComponent;
     if (!options) {
       viewComponent = ViewComponent.from(
@@ -1647,7 +1653,7 @@ export class Namespace extends BaseNode {
         this,
         'viewComponents',
       );
-    } else if (options instanceof ViewComponent) {
+    } else if (asserts.isViewComponent(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       viewComponent = options;
       Object.assign(viewComponent, relationOptions);
@@ -1783,6 +1789,7 @@ export class Namespace extends BaseNode {
   _insertProcessComponentAt(options: string | Partial<ProcessComponent> | ProcessComponent, index: number) {
     const processComponentOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'processComponents' };
+    const ProcessComponent = getConceptConstructor('ProcessComponent');
     let processComponent: ProcessComponent;
     if (!options) {
       processComponent = ProcessComponent.from(
@@ -1802,7 +1809,7 @@ export class Namespace extends BaseNode {
         this,
         'processComponents',
       );
-    } else if (options instanceof ProcessComponent) {
+    } else if (asserts.isProcessComponent(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       processComponent = options;
       Object.assign(processComponent, relationOptions);
@@ -2637,6 +2644,7 @@ export class Namespace extends BaseNode {
   _insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
     const itfaceOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'interfaces' };
+    const Interface = getConceptConstructor('Interface');
     let itface: Interface;
     if (!options) {
       itface = Interface.from(
@@ -2656,7 +2664,7 @@ export class Namespace extends BaseNode {
         this,
         'interfaces',
       );
-    } else if (options instanceof Interface) {
+    } else if (asserts.isInterface(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       itface = options;
       Object.assign(itface, relationOptions);

package/src/concepts/NewComposite__.ts

@@ -10,40 +10,39 @@ import {
   TranslatorGenerator,
 } from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
-import MemberExpression from './MemberExpression__';
-import StructureProperty from './StructureProperty__';
-import App from './App__';
+import type MemberExpression from './MemberExpression__';
+import type StructureProperty from './StructureProperty__';
+import type App from './App__';
 import { genHash } from '../generator';
-import ForEachStatement from './ForEachStatement__';
-import Logic from './Logic__';
+import type ForEachStatement from './ForEachStatement__';
+import type Logic from './Logic__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
-import BaseNode from '../common/BaseNode';
-import TypeAnnotation from './TypeAnnotation__';
-import Identifier from './Identifier__';
-import SelectMembers from './SelectMembers__';
-import AssignmentLine from './AssignmentLine__';
 import LogicItem from './LogicItem__';
+import type TypeAnnotation from './TypeAnnotation__';
+import type Identifier from './Identifier__';
+import type SelectMembers from './SelectMembers__';
+import type AssignmentLine from './AssignmentLine__';
 
 /**
  * 实体/（匿名）数据结构构造器
  */
-@className
 @concept('实体/（匿名）数据结构构造器')
-// @ts-ignore
 export class NewComposite extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'NewComposite';
+  static readonly ConceptName: string = 'NewComposite';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -58,7 +57,6 @@ export class NewComposite extends LogicItem {
   @property({
     objectRef: 'TypeAnnotation',
   })
-  // @ts-ignore
   typeAnnotation!: TypeAnnotation;
 
   /**
@@ -241,6 +239,7 @@ export class NewComposite extends LogicItem {
   _insertIdentifierAt(options: string | Partial<Identifier> | Identifier, index: number) {
     const identifierOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'properties' };
+    const Identifier = getConceptConstructor('Identifier');
     let identifier: Identifier;
     if (!options) {
       identifier = Identifier.from(
@@ -260,7 +259,7 @@ export class NewComposite extends LogicItem {
         this,
         'properties',
       );
-    } else if (options instanceof Identifier) {
+    } else if (asserts.isIdentifier(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       identifier = options;
       Object.assign(identifier, relationOptions);
@@ -394,6 +393,7 @@ export class NewComposite extends LogicItem {
   _insertSelectMembersAt(options: string | Partial<SelectMembers> | SelectMembers, index: number) {
     const selectMembersOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'rights' };
+    const SelectMembers = getConceptConstructor('SelectMembers');
     let selectMembers: SelectMembers;
     if (!options) {
       selectMembers = SelectMembers.from(
@@ -413,7 +413,7 @@ export class NewComposite extends LogicItem {
         this,
         'rights',
       );
-    } else if (options instanceof SelectMembers) {
+    } else if (asserts.isSelectMembers(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       selectMembers = options;
       Object.assign(selectMembers, relationOptions);
@@ -549,6 +549,7 @@ export class NewComposite extends LogicItem {
   _insertAssignmentLineAt(options: string | Partial<AssignmentLine> | AssignmentLine, index: number) {
     const assignmentLineOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'assignmentLines' };
+    const AssignmentLine = getConceptConstructor('AssignmentLine');
     let assignmentLine: AssignmentLine;
     if (!options) {
       assignmentLine = AssignmentLine.from(
@@ -568,7 +569,7 @@ export class NewComposite extends LogicItem {
         this,
         'assignmentLines',
       );
-    } else if (options instanceof AssignmentLine) {
+    } else if (asserts.isAssignmentLine(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       assignmentLine = options;
       Object.assign(assignmentLine, relationOptions);
@@ -905,6 +906,7 @@ export class NewComposite extends LogicItem {
   async newConnection(addRightIndex?: number) {
     const leftLineSet = new Set();
     const lineArr: Array<AssignmentLine> = [];
+    const AssignmentLine = getConceptConstructor('AssignmentLine');
     // 系统属性不可自动连线
     ['id', 'createdTime', 'updatedTime', 'createdBy', 'updatedBy'].forEach((name) => leftLineSet.add(name));
     // 左边已连线的下标
@@ -1017,6 +1019,7 @@ export class NewComposite extends LogicItem {
         ({ leftIndex: index }) => !(newLeftIndex[0] === index[0] && newLeftIndex[1] === index[1]),
       );
     }
+    const AssignmentLine = getConceptConstructor('AssignmentLine');
     const Line: AssignmentLine = new AssignmentLine({
       leftIndex: newLeftIndex,
       rightIndex: newRightIndex,
@@ -1176,11 +1179,18 @@ export class NewComposite extends LogicItem {
         rightIndex[1] !== undefined
           ? this.rights[rightIndex[0]].members[rightIndex[1]]
           : this.rights[rightIndex[0]].expression;
-      code += `return ${obj.toJS(shiftState(state, code, { inline: true }))};\n`;
+      code += `return ${obj.toJS(state)};\n`;
     } else if (typeAnnotation.typeKind !== 'anonymousStructure') {
-      code += `const obj = this.$genInitFromSchema('${
-        typeAnnotation.sortedTypeKey
-      }', this.$utils['New'](${typeAnnotation.toJS(shiftState(state, code, { inline: true }))}));\n`;
+      // 实体、数据结构默认值使用new时需要改成vue.prototype才能获取到方法
+      if (state?.getVuePrototype) {
+        code += `const obj = Vue.prototype.$genInitFromSchema('${
+          typeAnnotation.sortedTypeKey
+        }', Vue.prototype.$utils['New'](${typeAnnotation.toJS(state)}));\n`;
+      } else {
+        code += `const obj = this.$genInitFromSchema('${
+          typeAnnotation.sortedTypeKey
+        }', this.$utils['New'](${typeAnnotation.toJS(state)}));\n`;
+      }
       const rightMap = new Map();
       this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
         const rightIndexJson = JSON.stringify(rightIndex);
@@ -1199,7 +1209,7 @@ export class NewComposite extends LogicItem {
         leftItems.forEach((leftItem: Identifier) => {
           code += `obj.${leftItem.name} = `;
         });
-        code += `${rightItem.toJS(shiftState(state, code, { inline: true }))}`;
+        code += `${rightItem.toJS(state)}`;
         code += ';\n';
       });
       code += 'return obj;\n';
@@ -1226,7 +1236,7 @@ export class NewComposite extends LogicItem {
         leftItems.forEach((leftItem: Identifier) => {
           code += `obj.${leftItem.name} = `;
         });
-        code += `${rightItem.toJS(shiftState(state, code, { inline: true }))}`;
+        code += `${rightItem.toJS(state)}`;
         code += ';\n';
       });
       code += 'return obj;\n';
@@ -1318,9 +1328,12 @@ export class NewComposite extends LogicItem {
               ? self.rights[rightFirst].members[rightSecond]
               : self.rights[rightFirst].expression;
           const rightTs = rightMap.get(rightItem);
-          code += `${indent2}nasl.core.compareNew(`;
-          code += `${['__IDENTIFIER__', '__IDENTIFIER__()'].includes(rightTs) ? 'null' : rightMap.get(rightItem)}, `;
-          code += `${yield* leftItem.toEmbeddedTS(shiftState(state, code, { inline: true }), { isNewcomposite: true })});\n`;
+          code += `${indent2}`;
+          code += `${yield* leftItem.toEmbeddedTS(shiftState(state, code, { inline: true }), {
+            isNewcomposite: true,
+          })}`;
+          code += ' = ';
+          code += `${['__IDENTIFIER__', '__IDENTIFIER__()'].includes(rightTs) ? 'null' : rightMap.get(rightItem)};\n`;
         });
       }
       code += `${indent2}return __obj;\n`;
@@ -1547,6 +1560,7 @@ export class NewComposite extends LogicItem {
   __addIdentifier(name: string, typeAnnotation: TypeAnnotation) {
     const newName = name || 'property1';
     const newType = typeAnnotation || null;
+    const StructureProperty = getConceptConstructor('StructureProperty');
     this.app.emit('collect:start', {
       actionMsg: '添加匿名数据结构属性',
     });
@@ -1586,6 +1600,7 @@ export class NewComposite extends LogicItem {
   *getForeachCode(code: string) {
     // ForEachStatement 内部变量需要替换处理，如 item、index
     const forEachStatement = this.getAncestor('ForEachStatement') as ForEachStatement;
+    const Logic = getConceptConstructor('Logic');
     if (forEachStatement && code) {
       code = code.replaceAll('\n', ' ');
       code = yield* new Logic().handleForEachCode(code, forEachStatement);

package/src/concepts/NewList__.ts

@@ -9,33 +9,32 @@ import {
   withGenerator,
   TranslatorGenerator,
 } from '../translator';
-import ForEachStatement from './ForEachStatement__';
-import Logic from './Logic__';
+import type ForEachStatement from './ForEachStatement__';
+import type Logic from './Logic__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
-import BaseNode from '../common/BaseNode';
-import TypeAnnotation from './TypeAnnotation__';
 import LogicItem from './LogicItem__';
+import type TypeAnnotation from './TypeAnnotation__';
 
 /**
  * 列表构造器
  */
-@className
 @concept('列表构造器')
-// @ts-ignore
 export class NewList extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'NewList';
+  static readonly ConceptName: string = 'NewList';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -50,7 +49,6 @@ export class NewList extends LogicItem {
   @property({
     objectRef: 'TypeAnnotation',
   })
-  // @ts-ignore
   typeAnnotation!: TypeAnnotation;
 
   /**
@@ -135,6 +133,7 @@ export class NewList extends LogicItem {
   _insertItemAt(options: string | Partial<LogicItem> | LogicItem, index: number) {
     const logicItemOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'items' };
+    const LogicItem = getConceptConstructor('LogicItem');
     let logicItem: LogicItem;
     if (!options) {
       logicItem = LogicItem.from(
@@ -154,7 +153,7 @@ export class NewList extends LogicItem {
         this,
         'items',
       );
-    } else if (options instanceof LogicItem) {
+    } else if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);
@@ -378,7 +377,7 @@ export class NewList extends LogicItem {
     this.items.forEach((value, index) => {
       if (index >= 10) return;
       if (index) code += '，';
-      if (value instanceof LogicItem) {
+      if (asserts.isLogicItem(value)) {
         code += value.toBrief();
       }
     });
@@ -407,7 +406,7 @@ export class NewList extends LogicItem {
     }
     code += 'const arr = [\n';
     this.items.forEach((item, index) => {
-      code += item.toJS(shiftState(state, code, { inline: true }));
+      code += item.toJS(state);
       if (index + 1 < this.items.length) code += ', ';
     });
     code += '\n];\n';
@@ -435,7 +434,7 @@ export class NewList extends LogicItem {
     const indent2 = indent((state?.tabSize || 0) + 2);
     const typeCode = function* typeCode(codestr: string) {
       codestr += `nasl.util.New<`;
-      codestr += `${yield * self.typeAnnotation.toEmbeddedTS(shiftState(state, codestr, { inline: true }))}`;
+      codestr += `${yield* self.typeAnnotation.toEmbeddedTS(shiftState(state, codestr, { inline: true }))}`;
       codestr += `>()`;
       return codestr;
     };
@@ -552,6 +551,7 @@ export class NewList extends LogicItem {
   *getForeachCode(code: string) {
     // ForEachStatement 内部变量需要替换处理，如 item、index
     const forEachStatement = this.getAncestor('ForEachStatement') as ForEachStatement;
+    const Logic = getConceptConstructor('Logic');
     if (forEachStatement && code) {
       code = code.replaceAll('\n', ' ');
       code = yield* new Logic().handleForEachCode(code, forEachStatement);