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

package/src/concepts/Logic__.ts

@@ -18,19 +18,19 @@ import {
   withGenerator,
   TranslatorGenerator,
 } from '../translator';
-import Namespace from './Namespace__';
-import CallQueryComponent from './CallQueryComponent__';
-import ForEachStatement from './ForEachStatement__';
-import Assignment from './Assignment__';
-import Identifier from './Identifier__';
-import BindEvent from './BindEvent__';
-import BatchAssignment from './BatchAssignment__';
-import OqlQueryComponent from './OqlQueryComponent__';
-import Match from './Match__';
-import MatchCase from './MatchCase__';
-import TypeAnnotation from './TypeAnnotation__';
-import CallInterface from './CallInterface__';
-import CallLogic from './CallLogic__';
+import type Namespace from './Namespace__';
+import type CallQueryComponent from './CallQueryComponent__';
+import type ForEachStatement from './ForEachStatement__';
+import type Assignment from './Assignment__';
+import type Identifier from './Identifier__';
+import type BindEvent from './BindEvent__';
+import type BatchAssignment from './BatchAssignment__';
+import type OqlQueryComponent from './OqlQueryComponent__';
+import type Match from './Match__';
+import type MatchCase from './MatchCase__';
+import type TypeAnnotation from './TypeAnnotation__';
+import type CallInterface from './CallInterface__';
+import type CallLogic from './CallLogic__';
 import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 import type Interface from './Interface__';
 
@@ -39,37 +39,37 @@ import type Interface from './Interface__';
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 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 Transactional from './Transactional__';
-import TypeParam from './TypeParam__';
-import Param from './Param__';
-import Return from './Return__';
-import Variable from './Variable__';
-import LogicItem from './LogicItem__';
-import Module from './Module__';
-import Connector from './Connector__';
-import View from './View__';
-import ProcessElement from './ProcessElement__';
-import App from './App__';
-import Frontend from './Frontend__';
-import Process from './Process__';
+import type Transactional from './Transactional__';
+import type TypeParam from './TypeParam__';
+import type Param from './Param__';
+import type Return from './Return__';
+import type Variable from './Variable__';
+import type LogicItem from './LogicItem__';
+import type Module from './Module__';
+import type Connector from './Connector__';
+import type View from './View__';
+import type ProcessElement from './ProcessElement__';
+import type App from './App__';
+import type Frontend from './Frontend__';
+import type Process from './Process__';
 
 /**
  * 逻辑
  */
-@className
 @concept('逻辑')
-// @ts-ignore
 export class Logic extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'Logic';
+  static readonly ConceptName: string = 'Logic';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -82,42 +82,36 @@ export class Logic extends BaseNode {
    * 逻辑名称
    */
   @property()
-  // @ts-ignore
   name!: string;
 
   /**
    * 逻辑标题
    */
   @property()
-  // @ts-ignore
   title!: string;
 
   /**
    * 逻辑描述
    */
   @property()
-  // @ts-ignore
   description!: string;
 
   /**
    * 触发方式
    */
   @property()
-  // @ts-ignore
   triggerType!: string;
 
   /**
    * 定时任务表达式
    */
   @property()
-  // @ts-ignore
   cron!: string;
 
   /**
    * 是否可覆写
    */
   @property()
-  // @ts-ignore
   overridable!: boolean;
 
   /**
@@ -126,7 +120,6 @@ export class Logic extends BaseNode {
   @property({
     objectRef: 'Transactional',
   })
-  // @ts-ignore
   transactional!: Transactional;
 
   /**
@@ -376,6 +369,7 @@ export class Logic extends BaseNode {
   _insertTypeParamAt(options: string | Partial<TypeParam> | TypeParam, index: number) {
     const typeParamOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'typeParams' };
+    const TypeParam = getConceptConstructor('TypeParam');
     let typeParam: TypeParam;
     if (!options) {
       typeParam = TypeParam.from(
@@ -395,7 +389,7 @@ export class Logic extends BaseNode {
         this,
         'typeParams',
       );
-    } else if (options instanceof TypeParam) {
+    } else if (asserts.isTypeParam(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       typeParam = options;
       Object.assign(typeParam, relationOptions);
@@ -525,6 +519,7 @@ export class Logic extends BaseNode {
   _insertParamAt(options: string | Partial<Param> | Param, index: number) {
     const paramOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'params' };
+    const Param = getConceptConstructor('Param');
     let param: Param;
     if (!options) {
       param = Param.from(
@@ -544,7 +539,7 @@ export class Logic extends BaseNode {
         this,
         'params',
       );
-    } else if (options instanceof Param) {
+    } else if (asserts.isParam(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       param = options;
       Object.assign(param, relationOptions);
@@ -674,6 +669,7 @@ export class Logic extends BaseNode {
   _insertReturnAt(options: string | Partial<Return> | Return, index: number) {
     const retOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'returns' };
+    const Return = getConceptConstructor('Return');
     let ret: Return;
     if (!options) {
       ret = Return.from(
@@ -693,7 +689,7 @@ export class Logic extends BaseNode {
         this,
         'returns',
       );
-    } else if (options instanceof Return) {
+    } else if (asserts.isReturn(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       ret = options;
       Object.assign(ret, relationOptions);
@@ -823,6 +819,7 @@ export class Logic extends BaseNode {
   _insertVariableAt(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(
@@ -842,7 +839,7 @@ export class Logic extends BaseNode {
         this,
         'variables',
       );
-    } else if (options instanceof Variable) {
+    } else if (asserts.isVariable(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       variable = options;
       Object.assign(variable, relationOptions);
@@ -961,8 +958,9 @@ export class Logic extends BaseNode {
   _insertItemInBodyAt(options: Partial<LogicItem> | LogicItem, index: number) {
     const logicItemOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'body' };
+    const LogicItem = getConceptConstructor('LogicItem');
     let logicItem: LogicItem;
-    if (options instanceof LogicItem) {
+    if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);
@@ -1061,8 +1059,9 @@ export class Logic extends BaseNode {
   _insertItemInPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
     const logicItemOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'playground' };
+    const LogicItem = getConceptConstructor('LogicItem');
     let logicItem: LogicItem;
-    if (options instanceof LogicItem) {
+    if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);
@@ -1501,6 +1500,7 @@ export class Logic extends BaseNode {
    * 创建的时候 打开事务 通过开关设置数据库事务
    */
   openTransactional(flag: boolean) {
+    const Transactional = getConceptConstructor('Transactional');
     if (flag) {
       const transactional = new Transactional({
         enabled: flag,
@@ -1575,7 +1575,7 @@ export class Logic extends BaseNode {
     if (Array.isArray(this.params)) {
       this.params.forEach((param) => {
         code += `${indent((state?.tabSize || 0) + 1)}`;
-        code += param.toJS(shiftState(state, code, { inline: true }));
+        code += param.toJS(state);
         code += ';\n';
       });
     }
@@ -1583,7 +1583,7 @@ export class Logic extends BaseNode {
     if (Array.isArray(this.variables)) {
       this.variables.forEach((variable) => {
         code += `${indent((state?.tabSize || 0) + 1)}let `;
-        code += variable.toJS(shiftState(state, code, { inline: true }));
+        code += variable.toJS(state);
         code += ';\n';
       });
     }
@@ -1592,7 +1592,7 @@ export class Logic extends BaseNode {
     if (Array.isArray(this.returns)) {
       this.returns.forEach((ret) => {
         code += `${indent((state?.tabSize || 0) + 1)}let `;
-        code += ret.toJS(shiftState(state, code, { inline: true }));
+        code += ret.toJS(state);
         code += ';\n';
       });
     }
@@ -1732,13 +1732,10 @@ export class Logic extends BaseNode {
     let code = '';
     if (!prefix) code += `${noName ? '' : `${self.name}:`} function(`;
     else code += `function ${self.name}(`; // 加空格会导致无法查询到引用
-    yield* wrapForEach(
-      self.params,
-      function* warpForEachGenerator(param, index) {
-        code += yield* param.toEmbeddedTS(shiftState(state, code, { inline: true }));
-        if (index !== self.params.length - 1) code += ', ';
-      },
-    );
+    yield* wrapForEach(self.params, function* warpForEachGenerator(param, index) {
+      code += yield* param.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      if (index !== self.params.length - 1) code += ', ';
+    });
     code += `) {\n`;
     code += prependCode || '';
     code += '\n';
@@ -1762,14 +1759,15 @@ export class Logic extends BaseNode {
         }
       } else if (
         self.body.length <= 2 &&
-        !(self.parentNode instanceof Namespace) &&
-        !(self.parentNode instanceof Process)
+        !asserts.isNamespace(self.parentNode) &&
+        !asserts.isProcess(self.parentNode)
       ) {
         code += indent((state?.tabSize || 0) + 1);
         code += `${indent(state?.tabSize || 0 + 4)}const __LogicEmpty: any = null;`;
       }
       yield* wrapForEach(self.body, function* warpForEachGenerator(item) {
-        code += yield* item.toEmbeddedTS?.(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 })) ?? returnOrigin('');
+        code += yield* item.toEmbeddedTS?.(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 })) ??
+          returnOrigin('');
         code += ';\n';
       });
     }
@@ -1837,8 +1835,8 @@ export class Logic extends BaseNode {
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
     // const needGetSourceMapOqlList: Promise<any>[] = [];
     yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (el && (el instanceof BatchAssignment || (el instanceof Assignment && el.left?.name))) {
-        if (el instanceof Assignment) {
+      if (el && (asserts.isBatchAssignment(el) || (asserts.isAssignment(el) && el.left?.name))) {
+        if (asserts.isAssignment(el)) {
           const advanceVar = self.variables?.find(
             (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
           );
@@ -1849,12 +1847,13 @@ export class Logic extends BaseNode {
           if (advanceRn && !advanceMap.get(advanceRn)) {
             advanceMap.set(advanceRn, el);
           }
-        } else if (el instanceof BatchAssignment) {
+        } else if (asserts.isBatchAssignment(el)) {
           yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
             const leftCode =
               leftIndex.length === 1
                 ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-                : yield* el.left.members[leftIndex[1]]?.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,
             );
@@ -1872,7 +1871,8 @@ export class Logic extends BaseNode {
     // 兼容 return 没有类型情况
     if (self.returns.length && self.returns[0].typeAnnotation) {
       code += ': ';
-      code += yield* self.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
+      code += yield* self.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+        returnOrigin('');
     }
     code += '{\n';
     // 用于虚拟节点的查找引用
@@ -1918,19 +1918,20 @@ export class Logic extends BaseNode {
       code += `${indent((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
       code += `${indent((state?.tabSize || 0) + 1)}let `;
       code += yield* node.toEmbeddedTS(shiftState(state, code, { inline: true }));
-      if (assignment instanceof BatchAssignment) {
+      if (asserts.isBatchAssignment(assignment)) {
         yield* wrapForEach(assignment.assignmentLines, function* warpForEachGenerator({ leftIndex, rightIndex }) {
           const leftCode =
             leftIndex.length === 1
               ? yield* assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-              : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
+              : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                  returnOrigin('');
           if (leftCode === node.name) {
             const rightNode: any =
               rightIndex.length === 1
                 ? assignment.rights[rightIndex[0]]?.expression
                 : assignment.rights[rightIndex[0]]?.members[rightIndex[1]];
             // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
-            if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent && !rightNode.isAutoInfer())) {
+            if (rightNode?.typeAnnotation && !(asserts.isCallQueryComponent(rightNode) && !rightNode.isAutoInfer())) {
               if (rightNode.concept === 'NewComposite' && rightNode.typeAnnotation?.typeKind === 'anonymousStructure') {
                 code += '= ';
                 code += (yield* rightNode.getInitCode(shiftState(state, code, { inline: true }))) || 'null';
@@ -1939,11 +1940,13 @@ export class Logic extends BaseNode {
                 code += (yield* rightNode.getNewCompositeCode(shiftState(state, code, { inline: true }))) || 'null';
               } else {
                 code += ': ';
-                code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('null');
+                code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                  returnOrigin('null');
               }
             } else {
               code += ' = ';
-              const rightCode = yield* rightNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
+              const rightCode = yield* rightNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                returnOrigin('');
               code += yield* self.getRightCode(rightCode, assignment, rightNode);
             }
           }
@@ -1968,20 +1971,21 @@ export class Logic extends BaseNode {
       ) {
         const rightNode: any = assignment.right;
         code += ' = ';
-        code += (yield* rightNode.getNewCompositeCode(shiftState(state, code, { inline: true })));
+        code += yield* rightNode.getNewCompositeCode(shiftState(state, code, { inline: true }));
       } else {
         const rightNode: any = assignment.right;
         // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
-        if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent && !rightNode.isAutoInfer())) {
+        if (rightNode?.typeAnnotation && !(asserts.isCallQueryComponent(rightNode) && !rightNode.isAutoInfer())) {
           code += ': ';
-          code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('null');
+          code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+            returnOrigin('null');
         } else {
           code += ' = ';
           let rightCode = '';
           // 因为右侧枚举要赋值就得new 一下；
           if (
             rightNode &&
-            rightNode instanceof Identifier &&
+            asserts.isIdentifier(rightNode) &&
             rightNode.namespace &&
             rightNode.namespace.endsWith('enums')
           ) {
@@ -2010,7 +2014,7 @@ export class Logic extends BaseNode {
       code += `${indent((state?.tabSize || 0) + 1)}return ${this.returns[0].name};\n`;
     } else {
       // 如果长度小于2 并且不是虚拟节点就 加 报错，
-      if (self.body.length <= 2 && !(self.parentNode instanceof Namespace)) {
+      if (self.body.length <= 2 && !asserts.isNamespace(self.parentNode)) {
         if (self.body.length && self.body[0].concept === 'JavaLogic') {
           code += '';
         } else {
@@ -2019,7 +2023,8 @@ export class Logic extends BaseNode {
         }
       }
       yield* wrapForEach(self.body, function* warpForEachGenerator(item) {
-        code += yield* item.toEmbeddedTS?.(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 })) ?? returnOrigin('');
+        code += yield* item.toEmbeddedTS?.(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 })) ??
+          returnOrigin('');
         code += ';\n';
       });
     }
@@ -2103,7 +2108,7 @@ ${indent(state.tabSize)} */\n`;
     // 需要类型推导的局部变量/返回值需要调整申明顺序
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
     this.traverseChildren((el) => {
-      if (el && (el instanceof BatchAssignment || (el instanceof Assignment && el.left?.name))) {
+      if (el && (asserts.isBatchAssignment(el) || (asserts.isAssignment(el) && el.left?.name))) {
         const jsCode = el.toJS();
         const advanceVar = this.variables?.find(
           (variable) => !variable.typeAnnotation && jsCode.includes(`${variable.name} = `),
@@ -2170,10 +2175,10 @@ ${indent(state.tabSize)} */\n`;
 
   *getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any) {
     code = code.replaceAll('\n', ' ');
-    if (assignment instanceof Assignment && !assignment.right) return code;
+    if (asserts.isAssignment(assignment) && !assignment.right) return code;
 
     // 调用接口，参数替换成 null
-    if (rightNode instanceof CallInterface) {
+    if (asserts.isCallInterface(rightNode)) {
       const { _interface } = rightNode.getModuleInterface();
       return _interface
         ? `${rightNode.tsCalleeKey}(${(_interface as unknown as Interface).params.map(() => 'null').join(',')})`
@@ -2181,7 +2186,7 @@ ${indent(state.tabSize)} */\n`;
     }
 
     // 调用服务端逻辑，参数替换成 null
-    if (rightNode instanceof CallLogic && rightNode.calleeNamespace === 'app.logics') {
+    if (asserts.isCallLogic(rightNode) && rightNode.calleeNamespace === 'app.logics') {
       const calleeName = rightNode?.calleeName;
       const calleeLogic = this.app.logics.find((l) => l.name === calleeName);
       return calleeLogic ? `app.logics.${calleeName}(${calleeLogic.params.map(() => 'null').join(',')})` : null;
@@ -2246,7 +2251,7 @@ ${indent(state.tabSize)} */\n`;
     if (code.includes(expressionTsCode)) {
       let typeCode = '';
       yield* wrapForEach(matchCase.patterns, function* wrapForEach(pattern, index) {
-        if (pattern instanceof TypeAnnotation) {
+        if (asserts.isTypeAnnotation(pattern)) {
           if (index === 0) {
             typeCode += yield* pattern.toEmbeddedTS();
           } else {
@@ -2362,7 +2367,7 @@ ${indent(state.tabSize)} */\n`;
         _path = `/${this.connector.parentKey}/${this.connector.name}`;
       }
     }
-    if (this.parentNode instanceof FrontendLibrary) {
+    if (asserts.isFrontendLibrary(this.parentNode)) {
       _path += `/frontends/${this.parentNode.type}`;
     } else if (this.parentNode.concept === 'BindEvent' && this.parentNode?.parentNode.concept === 'Frontend') {
       _path += `/frontends/${this.parentNode.parentNode.name}/bindEvents/${name}.ts`;
@@ -2416,7 +2421,7 @@ ${indent(state.tabSize)} */\n`;
     const set = new Set();
     utils.traverse(
       ({ node }) => {
-        if (node instanceof CallQueryComponent) {
+        if (asserts.isCallQueryComponent(node)) {
           set.add(node);
         }
       },
@@ -2433,6 +2438,7 @@ ${indent(state.tabSize)} */\n`;
 
   // 通过开关设置数据库事务
   setTransactionEnabled(flag: boolean) {
+    const Transactional = getConceptConstructor('Transactional');
     this.setTransactional(
       new Transactional({
         enabled: flag,
@@ -2530,7 +2536,7 @@ ${indent(state.tabSize)} */\n`;
 
   // 获取bindEvent下的logic的名称
   getEventLogicName(type?: string) {
-    if (this.parentNode instanceof BindEvent) {
+    if (asserts.isBindEvent(this.parentNode)) {
       if (type === 'chinese') {
         const bindEvent = this.parentNode;
         const bindChineseName = bindEvent.getPageViewEventChineseName();

package/src/concepts/MatchCase__.ts

@@ -9,9 +9,9 @@ import {
   withGenerator,
   TranslatorGenerator,
 } from '../translator';
-import Match from './Match__';
-import MemberExpression from './MemberExpression__';
-import BooleanLiteral from './BooleanLiteral__';
+import type Match from './Match__';
+import type MemberExpression from './MemberExpression__';
+import type BooleanLiteral from './BooleanLiteral__';
 import { ElementToVueOptions } from './ViewElement__';
 
 //================================================================================
@@ -19,26 +19,25 @@ import { ElementToVueOptions } from './ViewElement__';
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 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 LogicItem from './LogicItem__';
-import TypeAnnotation from './TypeAnnotation__';
+import type TypeAnnotation from './TypeAnnotation__';
 
 /**
  * 匹配分支
  */
-@className
 @concept('匹配分支')
-// @ts-ignore
 export class MatchCase extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'MatchCase';
+  static readonly ConceptName: string = 'MatchCase';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -142,6 +141,7 @@ export class MatchCase extends LogicItem {
   _insertLogicItemInPatternsAt(options: string | Partial<LogicItem> | LogicItem, index: number) {
     const logicItemOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'patterns' };
+    const LogicItem = getConceptConstructor('LogicItem');
     let logicItem: LogicItem;
     if (!options) {
       logicItem = LogicItem.from(
@@ -161,7 +161,7 @@ export class MatchCase extends LogicItem {
         this,
         'patterns',
       );
-    } else if (options instanceof LogicItem) {
+    } else if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);
@@ -280,8 +280,9 @@ export class MatchCase extends LogicItem {
   _insertItemInBodyAt(options: Partial<LogicItem> | LogicItem, index: number) {
     const logicItemOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'body' };
+    const LogicItem = getConceptConstructor('LogicItem');
     let logicItem: LogicItem;
-    if (options instanceof LogicItem) {
+    if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);
@@ -397,6 +398,7 @@ export class MatchCase extends LogicItem {
   _insertTypeAnnotationAt(options: string | Partial<TypeAnnotation> | TypeAnnotation, index: number) {
     const typeAnnotationOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'patterns' };
+    const TypeAnnotation = getConceptConstructor('TypeAnnotation');
     let typeAnnotation: TypeAnnotation;
     if (!options) {
       typeAnnotation = TypeAnnotation.from(
@@ -416,7 +418,7 @@ export class MatchCase extends LogicItem {
         this,
         'patterns',
       );
-    } else if (options instanceof TypeAnnotation) {
+    } else if (asserts.isTypeAnnotation(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       typeAnnotation = options;
       Object.assign(typeAnnotation, relationOptions);
@@ -661,10 +663,10 @@ export class MatchCase extends LogicItem {
             const { patterns } = caseItem || {};
             if (Array.isArray(patterns)) {
               patterns.forEach((pattern) => {
-                if (pattern instanceof TypeAnnotation) {
+                if (asserts.isTypeAnnotation(pattern)) {
                   const patternTypeKey = pattern.typeKey;
                   map[patternTypeKey] = true;
-                } else if (pattern instanceof MemberExpression || pattern instanceof BooleanLiteral) {
+                } else if (asserts.isMemberExpression(pattern) || asserts.isBooleanLiteral(pattern)) {
                   const patternValue = pattern.getValue();
                   map[patternValue] = true;
                 }
@@ -747,7 +749,7 @@ export class MatchCase extends LogicItem {
     if (Array.isArray(this.patterns)) {
       const patternStrArr = this.patterns.map((pattern) => {
         let patternStr = '';
-        if (pattern instanceof TypeAnnotation) {
+        if (asserts.isTypeAnnotation(pattern)) {
           patternStr += `this.$isInstanceOf(${expression.toJS?.()}, '${pattern.sortedTypeKey}')`;
         } else {
           patternStr += `this.$global.isEqual(${expression.toJS?.()}, ${pattern.toJS?.()})`;
@@ -796,7 +798,7 @@ export class MatchCase extends LogicItem {
         if (Array.isArray(self.patterns) && self.patterns.length) {
           yield* wrapForEach(self.patterns, function* warpForEachGenerator(pattern, index) {
             // nasl.code.isUnionType<typeof ccc, List<Integer> | List<Boolean>>
-            if (pattern instanceof TypeAnnotation) {
+            if (asserts.isTypeAnnotation(pattern)) {
               if (index === 0) {
                 code += `nasl.core.isUnionType<typeof `;
                 code += `${parentCode},`;
@@ -892,7 +894,7 @@ export class MatchCase extends LogicItem {
         if (Array.isArray(this.patterns) && this.patterns.length) {
           this.patterns.forEach((pattern, index) => {
             // nasl.code.isUnionType<typeof ccc, List<Integer> | List<Boolean>>
-            if (pattern instanceof TypeAnnotation) {
+            if (asserts.isTypeAnnotation(pattern)) {
               if (index === 0) {
                 code += `nasl.core.isUnionType<typeof `;
                 code += `${parentCode},`;