@lcap/nasl 3.2.0-beta.4 → 3.3.0-alpha

package/src/concepts/Match__.ts

@@ -1,3 +1,4 @@
+import { v4 as uuidv4 } from 'uuid';
 import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
 import TypeAnnotation, { isUnion } from './TypeAnnotation__';
 import BooleanLiteral from './BooleanLiteral__';
@@ -6,15 +7,14 @@ import { formatEnums } from '../server/getMemberIdentifier';
 import Identifier from './Identifier__';
 import ViewElement, { ElementToVueOptions } from './ViewElement__';
 
-//================================================================================
+//= ===============================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//================================================================================
+//= ===============================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
-import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import LogicItem from './LogicItem__';
@@ -25,698 +25,767 @@ import MatchCase from './MatchCase__';
  */
 @concept('匹配')
 export class Match extends LogicItem {
-    /**
-     * 产品概念
-     */
-    @property()
-    concept: 'Match' = 'Match';
-
-    /**
-     * 逻辑项
-     */
-    @property('LogicItem')
-    expression: LogicItem = undefined;
-
-    /**
-     * 是否表达式形态
-     */
-    @property()
-    isExpression: boolean = false;
-
-    /**
-     * 匹配分支列表
-     */
-    @property('MatchCase')
-    cases: Array<MatchCase> = [];
-
-    
-
-    /**
-     * @param source 需要合并的部分参数
-     */
-    constructor(source?: Partial<Match>) {
-        source = Object.assign({}, Match.getDefaultOptions(), source);
-        super(source);
-        super.subConstructor(source);
-    }
-    getClassName() {
-        return 'Match';
-    }
-
-    static from(source: any, parentNode?: any, parentKey?: string): Match {
-        return super.from(source, parentNode, parentKey) as Match;
-    }
-
-    
-    
-
-    
-
-    
-
-    /**
-    * 插入匹配分支
-    * @internal
-    * @param matchCaseOptions 匹配分支参数
-    */
-    _insertMatchCaseAt(matchCaseOptions: Partial<MatchCase>, index: number): MatchCase;
-
-    /**
-    * 插入匹配分支
-    * @internal
-    * @param matchCase 已有的匹配分支实例
-    */
-    _insertMatchCaseAt(matchCase: MatchCase, index: number): MatchCase;
-
-    _insertMatchCaseAt(options: Partial<MatchCase> | MatchCase, index: number) {
-        const matchCaseOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'cases' };
-        let matchCase: MatchCase;
-        if (options instanceof MatchCase) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            matchCase = options;
-            Object.assign(matchCase, relationOptions);
-        } else {
-            matchCase = MatchCase.from({
-                ...matchCaseOptions,
-                ...options,
-            }, this, 'cases');
-        }
-        this.cases.splice(index, 0, matchCase);
-        return matchCase;
-    }
-
-    
-
-    /**
-     * 插入匹配分支
-     * @param matchCaseOptions 匹配分支参数
-     */
-    insertMatchCaseAt(matchCaseOptions: Partial<MatchCase>, index: number): MatchCase;
-
-    /**
-     * 插入匹配分支
-     * @param matchCase 已有的匹配分支实例
-     */
-    insertMatchCaseAt(matchCase: MatchCase, index: number): MatchCase;
-
-    insertMatchCaseAt(options: Partial<MatchCase> | MatchCase, index: number) {
-        const node = this._insertMatchCaseAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'cases',
-        });
-        return node;
-    }
-
-    
-
-    /**
-     * 添加匹配分支
-     * @internal
-     * @param matchCaseOptions 匹配分支参数
-     */
-    _addMatchCase(matchCaseOptions: Partial<MatchCase>): MatchCase;
-
-    /**
-     * 添加匹配分支
-     * @internal
-     * @param matchCase 已有的匹配分支实例
-     */
-    _addMatchCase(matchCase: MatchCase): MatchCase;
-
-    _addMatchCase(options?: Partial<MatchCase> | MatchCase) {
-        const index = this.cases.length;
-        return this._insertMatchCaseAt(options as any, index);
-    }
-
-    
-
-    /**
-     * 添加匹配分支
-     * @param matchCaseOptions 匹配分支参数
-     */
-    addMatchCase(matchCaseOptions: Partial<MatchCase>): MatchCase;
-
-    /**
-     * 添加匹配分支
-     * @param matchCase 已有的匹配分支实例
-     */
-    addMatchCase(matchCase: MatchCase): MatchCase;
-
-    addMatchCase(options?: Partial<MatchCase> | MatchCase) {
-        const node = this._addMatchCase(options as any);
-        const index = this.cases.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'cases',
-        });
-        return node;
+  /**
+   * 产品概念
+   */
+  @property()
+  concept: 'Match' = 'Match';
+
+  /**
+   * 逻辑项
+   */
+  @property('LogicItem')
+  expression: LogicItem = undefined;
+
+  /**
+   * 是否表达式形态
+   */
+  @property()
+  isExpression: boolean = false;
+
+  /**
+   * 匹配分支列表
+   */
+  @property('MatchCase')
+  cases: Array<MatchCase> = [];
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<Match>) {
+    // @ts-ignore
+    source = { ...Match.getDefaultOptions(), ...source };
+    super(source);
+    super.subConstructor(source);
+  }
+
+  getClassName() {
+    return 'Match';
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): Match {
+    return super.from(source, parentNode, parentKey) as Match;
+  }
+
+  /**
+   * 插入匹配分支
+   * @internal
+   * @param matchCaseOptions 匹配分支参数
+   */
+  _insertMatchCaseAt(matchCaseOptions: Partial<MatchCase>, index: number): MatchCase;
+
+  /**
+   * 插入匹配分支
+   * @internal
+   * @param matchCase 已有的匹配分支实例
+   */
+  _insertMatchCaseAt(matchCase: MatchCase, index: number): MatchCase;
+
+  _insertMatchCaseAt(options: Partial<MatchCase> | MatchCase, index: number) {
+    const matchCaseOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'cases' };
+    let matchCase: MatchCase;
+    if (options instanceof MatchCase) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      matchCase = options;
+      Object.assign(matchCase, relationOptions);
+    } else {
+      matchCase = MatchCase.from(
+        {
+          ...matchCaseOptions,
+          ...options,
+        },
+        this,
+        'cases'
+      );
     }
-
-
-    
-
-    /**
-    * 删除逻辑项
-    * @param name 逻辑项名称
-    */
-    removeExpression(name: string): void;
-
-    /**
-     * 删除逻辑项
-     * @param expression 已有的逻辑项实例
-     */
-    removeExpression(expression: LogicItem): void;
-
-    removeExpression(options: string | LogicItem) {
-        let expression: LogicItem;
-        if (typeof options === 'string') {
-            expression = this.expression;
-            if (!expression) {
-                throw new Error('找不到逻辑项 ' + options);
-            }
-        } else {
-            expression = options;
-        }
-        return expression.delete();
-    }
-
-    
-
-    /**
-     * 删除匹配分支
-     * @param matchCase 已有的匹配分支实例
-     */
-    removeMatchCaseInCases(matchCase: MatchCase): void;
-
-    removeMatchCaseInCases(options: MatchCase) {
-        let matchCase: MatchCase = options;
-        return matchCase.delete();
-    }
-
-    __removeLogicItem(logicItem: LogicItem) {
-        const parentKey = logicItem.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: logicItem,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(logicItem);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === logicItem) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-    //================================================================================
-    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
-    // 自动生成的代码已结束。下面可以手动编写。
-    //================================================================================
-    enumerableItems: Array<LogicItem | TypeAnnotation>
-
-    get isEnumerable() {
-        return !!this.enumerableItems?.length;
-    }
-
-    async cacheStatus() {
-        this.enumerableItems = await this.getEnumerableItems();
-    }
-
-    /**
-     * 是否允许新建case
-     */
-    get canAddCase() {
-        const cases = this?.cases;
-        if (Array.isArray(cases) && cases.length > 1) {
-            const enumerableItems = this.enumerableItems;
-            if (Array.isArray(enumerableItems)) {
-                const map: any = {};
-                cases.forEach((caseItem) => {
-                    const { patterns } = caseItem || {};
-                    if (Array.isArray(patterns)) {
-                        patterns.forEach((pattern) => {
-                            if (pattern instanceof TypeAnnotation) {
-                                const patternTypeKey = pattern.typeKey;
-                                map[patternTypeKey] = true;
-                            } else if (pattern instanceof MemberExpression || pattern instanceof BooleanLiteral) {
-                                const patternValue = pattern.getValue();
-                                map[patternValue] = true;
-                            }
-                        });
-                    }
-                });
-                const enumerableKeys = Object.keys(map);
-                if (enumerableKeys.length === enumerableItems.length) {
-                    return false;
-                }
-            }
-        }
-        return true;
+    this.cases.splice(index, 0, matchCase);
+    return matchCase;
+  }
+
+  /**
+   * 插入匹配分支
+   * @param matchCaseOptions 匹配分支参数
+   */
+  insertMatchCaseAt(matchCaseOptions: Partial<MatchCase>, index: number): MatchCase;
+
+  /**
+   * 插入匹配分支
+   * @param matchCase 已有的匹配分支实例
+   */
+  insertMatchCaseAt(matchCase: MatchCase, index: number): MatchCase;
+
+  insertMatchCaseAt(options: Partial<MatchCase> | MatchCase, index: number) {
+    const node = this._insertMatchCaseAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'cases',
+    });
+    return node;
+  }
+
+  /**
+   * 添加匹配分支
+   * @internal
+   * @param matchCaseOptions 匹配分支参数
+   */
+  _addMatchCase(matchCaseOptions: Partial<MatchCase>): MatchCase;
+
+  /**
+   * 添加匹配分支
+   * @internal
+   * @param matchCase 已有的匹配分支实例
+   */
+  _addMatchCase(matchCase: MatchCase): MatchCase;
+
+  _addMatchCase(options?: Partial<MatchCase> | MatchCase) {
+    const index = this.cases.length;
+    return this._insertMatchCaseAt(options as any, index);
+  }
+
+  /**
+   * 添加匹配分支
+   * @param matchCaseOptions 匹配分支参数
+   */
+  addMatchCase(matchCaseOptions: Partial<MatchCase>): MatchCase;
+
+  /**
+   * 添加匹配分支
+   * @param matchCase 已有的匹配分支实例
+   */
+  addMatchCase(matchCase: MatchCase): MatchCase;
+
+  addMatchCase(options?: Partial<MatchCase> | MatchCase) {
+    const node = this._addMatchCase(options as any);
+    const index = this.cases.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'cases',
+    });
+    return node;
+  }
+
+  /**
+   * 删除逻辑项
+   * @param name 逻辑项名称
+   */
+  removeExpression(name: string): void;
+
+  /**
+   * 删除逻辑项
+   * @param expression 已有的逻辑项实例
+   */
+  removeExpression(expression: LogicItem): void;
+
+  removeExpression(options: string | LogicItem) {
+    let expression: LogicItem;
+    if (typeof options === 'string') {
+      expression = this.expression;
+      if (!expression) {
+        throw new Error(`找不到逻辑项 ${options}`);
+      }
+    } else {
+      expression = options;
     }
-
-    // 获取可枚举项
-    async getEnumerableItems(typeAnnotation?: TypeAnnotation) {
-        const expression = this.expression;
-        let currTypeAnnotation = typeAnnotation;
-        if (!currTypeAnnotation) {
-            currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
-        }
-        const { typeKind, typeNamespace, typeName, typeArguments } = currTypeAnnotation || {};
-        if (typeKind === 'union' && Array.isArray(typeArguments)) {
-            return typeArguments.map((typeArg) => {
-                let typeArgJson: any = typeArg;
-                if (typeArg instanceof TypeAnnotation) {
-                    typeArgJson = typeArg.toJSON();
-                }
-                return new TypeAnnotation(typeArgJson);
+    return expression.delete();
+  }
+
+  /**
+   * 删除匹配分支
+   * @param matchCase 已有的匹配分支实例
+   */
+  removeMatchCaseInCases(matchCase: MatchCase): void;
+
+  removeMatchCaseInCases(options: MatchCase) {
+    const matchCase: MatchCase = options;
+    return matchCase.delete();
+  }
+
+  __removeLogicItem(logicItem: LogicItem) {
+    const { parentKey } = logicItem;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: logicItem,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(logicItem);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === logicItem) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  //= ===============================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //= ===============================================================================
+  enumerableItems: Array<LogicItem | TypeAnnotation>;
+
+  get isEnumerable() {
+    return !!this.enumerableItems?.length;
+  }
+
+  async cacheStatus() {
+    this.enumerableItems = await this.getEnumerableItems();
+  }
+
+  /**
+   * 是否允许新建case
+   */
+  get canAddCase() {
+    const cases = this?.cases;
+    if (Array.isArray(cases) && cases.length > 1) {
+      const { enumerableItems } = this;
+      if (Array.isArray(enumerableItems)) {
+        const map: any = {};
+        cases.forEach((caseItem) => {
+          const { patterns } = caseItem || {};
+          if (Array.isArray(patterns)) {
+            patterns.forEach((pattern) => {
+              if (pattern instanceof TypeAnnotation) {
+                const patternTypeKey = pattern.typeKey;
+                map[patternTypeKey] = true;
+              } else if (pattern instanceof MemberExpression || pattern instanceof BooleanLiteral) {
+                const patternValue = pattern.getValue();
+                map[patternValue] = true;
+              }
             });
-        } else if (typeKind === 'reference') {
-            const nameArr = [typeName];
-            if (typeNamespace) {
-                nameArr.unshift(typeNamespace);
-            }
-            const typeNode = this.app.findNodeByCompleteName(nameArr.join('.')) || {};
-            if (typeNode.concept === 'Enum') {
-                const enums = formatEnums([typeNode]);
-                const { children } = enums?.[0] || {};
-                if (Array.isArray(children)) {
-                    return children.map((child) => child?.expression);
-                }
-            }
-        } else if (typeKind === 'primitive' && typeNamespace === 'nasl.core' && typeName === 'Boolean') {
-            return [
-                new BooleanLiteral({
-                    value: 'true',
-                }),
-                new BooleanLiteral({
-                    value: 'false',
-                }),
-            ];
+          }
+        });
+        const enumerableKeys = Object.keys(map);
+        if (enumerableKeys.length === enumerableItems.length) {
+          return false;
         }
+      }
     }
-
-    setIsExpression(isExpression: boolean) {
-        const object = {
-            isExpression,
-        };
-        this.update({
-            ...object,
-        });
+    return true;
+  }
+
+  // 获取可枚举项
+  async getEnumerableItems(typeAnnotation?: TypeAnnotation) {
+    const { expression } = this;
+    let currTypeAnnotation = typeAnnotation;
+    if (!currTypeAnnotation) {
+      currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
     }
-
-    /**
-     * 设置逻辑项
-     */
-    setExpression(expression: LogicItem) {
-        if (expression) {
-            expression._delete();
-            const relationOptions = { parentNode: this, parentKey: 'expression' };
-            Object.assign(expression, relationOptions);
+    const { typeKind, typeNamespace, typeName, typeArguments } = currTypeAnnotation || {};
+    if (typeKind === 'union' && Array.isArray(typeArguments)) {
+      return typeArguments.map((typeArg) => {
+        let typeArgJson: any = typeArg;
+        if (typeArg instanceof TypeAnnotation) {
+          typeArgJson = typeArg.toJSON();
         }
-        const object: any = {
-            expression,
-        };
-        this.update({
-            ...object,
-        });
+        return new TypeAnnotation(typeArgJson);
+      });
     }
-
-    // 设置 expression ，如果 expression 是可枚举类型，加上默认匹配条件
-    async setExpressionWitchCase(expression: LogicItem) {
-        const oldExpression = this.expression;
-        this.app.emit('collect:start', {
-            actionMsg: `修改${this?.name || this?.label || (this?.constructor as any)?.nodeTitle}`,
-        });
-        this.setExpression(expression);
-        // expression切换并且自动生成分支
-        await this.autoGenCases(oldExpression);
-        this.app.emit('collect:end');
-    }
-
-    // 自动生成分支
-    async autoGenCases(oldExpression: LogicItem) {
-        const expression = this.expression;
-        // 没有新的expression要保留分支不去更新
-        if (!expression) {
-            return;
+    if (typeKind === 'reference') {
+      const nameArr = [typeName];
+      if (typeNamespace) {
+        nameArr.unshift(typeNamespace);
+      }
+      const typeNode = this.app.findNodeByCompleteName(nameArr.join('.')) || {};
+      if (typeNode.concept === 'Enum') {
+        const enums = formatEnums([typeNode]);
+        const { children } = enums?.[0] || {};
+        if (Array.isArray(children)) {
+          return children.map((child) => child?.expression);
         }
-        // 如果没有旧的oldExpression， 但是已有就分支了，就不去更新了
-        if (!oldExpression && this.cases.length) {
-            // 而且case的 patterns 有长度，就说明里面是有值的，就不去更新了，其余就去更新
-            if (this.cases.some((item) => item.patterns.length)) {
-                return;
-            }
-        }
-        // 如果新旧nasl一样，就算类型变了也不重新计算
-        if (JSON.stringify(oldExpression?.toJSON()) === JSON.stringify(expression?.toJSON())) {
-            return;
-        }
-        const oldTypeAnnotation = oldExpression?.__TypeAnnotation;
-        const currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
+      }
+    } else if (typeKind === 'primitive' && typeNamespace === 'nasl.core' && typeName === 'Boolean') {
+      return [
+        new BooleanLiteral({
+          value: 'true',
+        }),
+        new BooleanLiteral({
+          value: 'false',
+        }),
+      ];
+    }
+  }
+
+  setIsExpression(isExpression: boolean) {
+    const object = {
+      isExpression,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置逻辑项
+   */
+  setExpression(expression: LogicItem) {
+    if (expression) {
+      expression._delete();
+      const relationOptions = { parentNode: this, parentKey: 'expression' };
+      Object.assign(expression, relationOptions);
+    }
+    const object: any = {
+      expression,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  // 设置 expression ，如果 expression 是可枚举类型，加上默认匹配条件
+  async setExpressionWitchCase(expression: LogicItem) {
+    const oldExpression = this.expression;
+    this.app.emit('collect:start', {
+      actionMsg: `修改${this?.name || this?.label || (this?.constructor as any)?.nodeTitle}`,
+    });
+    this.setExpression(expression);
+    // expression切换并且自动生成分支
+    await this.autoGenCases(oldExpression);
+    this.app.emit('collect:end');
+  }
+
+  // 自动生成分支
+  async autoGenCases(oldExpression: LogicItem) {
+    const { expression } = this;
+    // 没有新的expression要保留分支不去更新
+    if (!expression) {
+      return;
+    }
+    // 如果没有旧的oldExpression， 但是已有就分支了，就不去更新了
+    if (!oldExpression && this.cases.length) {
+      // 而且case的 patterns 有长度，就说明里面是有值的，就不去更新了，其余就去更新
+      if (this.cases.some((item) => item.patterns.length)) {
+        return;
+      }
+    }
+    // 如果新旧nasl一样，就算类型变了也不重新计算
+    if (JSON.stringify(oldExpression?.toJSON()) === JSON.stringify(expression?.toJSON())) {
+      return;
+    }
+    const oldTypeAnnotation = oldExpression?.__TypeAnnotation;
+    const currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
 
-        // 如果nasl变了，但是新旧类型都是union就return
-        if (currTypeAnnotation?.typeKind === 'union' && oldTypeAnnotation?.typeKind === 'union') {
-            return;
-        }
+    // 如果nasl变了，但是新旧类型都是union就return
+    if (currTypeAnnotation?.typeKind === 'union' && oldTypeAnnotation?.typeKind === 'union') {
+      return;
+    }
 
-        // 如果不可枚举 变 不可枚举，都会保留分支
-        // 原来不是 布尔类型 也不是枚举类型， 现在 也不是布尔类型 也不是枚举类型
-        // 就满足了
-        if (expression && oldExpression && currTypeAnnotation && oldTypeAnnotation) {
-            const { typeName: oldTypeName, typeNamespace: oldTypeNamespace, typeKind: oldTypeKind } = oldTypeAnnotation;
-            const { typeName, typeNamespace, typeKind } = currTypeAnnotation;
-            // 类型的 name 和 namespace都有值，而且都不是 可枚举
-            if (oldTypeName && oldTypeNamespace && typeName && typeNamespace && oldTypeName !== 'Boolean' && !oldTypeNamespace.endsWith('enums') && oldTypeKind !== 'union' && typeName !== 'Boolean' && !typeNamespace.endsWith('enums') && typeKind !== 'union') {
-                return;
-            } else if (oldTypeName && oldTypeNamespace && oldTypeName !== 'Boolean' && !oldTypeNamespace.endsWith('enums') && oldTypeKind !== 'union' && typeKind === 'anonymousStructure') {
-                /**
-                 * 新旧都是匿名数据结构
-                 * 匿名到 可枚举 动
-                 * 可枚举到匿名 动
-                 * 匿名到 不可枚举 不动
-                 * 不可枚举到匿名 不动
-                 * 匿名到匿名 不动
-                 * 因为不能在match上不能直接 匿名数据结构替换匿名数据结构
-                 * 而且 匿名数据结构不能 直接换别的分支，所以下面的直留 不可枚举到匿名数据结构的情况
-                 *  */
-                // 不可枚举到匿名 不动
-                return;
-            } else if ((typeKind === 'anonymousStructure' && oldTypeKind === typeKind)) {
-                // 匿名到匿名 不动
-                return;
-            }
-            //  else if (currTypeName && typeNamespace && currTypeName !== 'Boolean' && !typeNamespace.endsWith('enums') && oldTypeKind === 'anonymousStructure') {
-            //     // 匿名到 不可枚举 不动
-            //     return;
-            // }
-        }
+    // 如果不可枚举 变 不可枚举，都会保留分支
+    // 原来不是 布尔类型 也不是枚举类型， 现在 也不是布尔类型 也不是枚举类型
+    // 就满足了
+    if (expression && oldExpression && currTypeAnnotation && oldTypeAnnotation) {
+      const { typeName: oldTypeName, typeNamespace: oldTypeNamespace, typeKind: oldTypeKind } = oldTypeAnnotation;
+      const { typeName, typeNamespace, typeKind } = currTypeAnnotation;
+      // 类型的 name 和 namespace都有值，而且都不是 可枚举
+      if (
+        oldTypeName &&
+        oldTypeNamespace &&
+        typeName &&
+        typeNamespace &&
+        oldTypeName !== 'Boolean' &&
+        !oldTypeNamespace.endsWith('enums') &&
+        oldTypeKind !== 'union' &&
+        typeName !== 'Boolean' &&
+        !typeNamespace.endsWith('enums') &&
+        typeKind !== 'union'
+      ) {
+        return;
+      }
+      if (
+        oldTypeName &&
+        oldTypeNamespace &&
+        oldTypeName !== 'Boolean' &&
+        !oldTypeNamespace.endsWith('enums') &&
+        oldTypeKind !== 'union' &&
+        typeKind === 'anonymousStructure'
+      ) {
+        /**
+         * 新旧都是匿名数据结构
+         * 匿名到 可枚举 动
+         * 可枚举到匿名 动
+         * 匿名到 不可枚举 不动
+         * 不可枚举到匿名 不动
+         * 匿名到匿名 不动
+         * 因为不能在match上不能直接 匿名数据结构替换匿名数据结构
+         * 而且 匿名数据结构不能 直接换别的分支，所以下面的直留 不可枚举到匿名数据结构的情况
+         *  */
+        // 不可枚举到匿名 不动
+        return;
+      }
+      if (typeKind === 'anonymousStructure' && oldTypeKind === typeKind) {
+        // 匿名到匿名 不动
+        return;
+      }
+      //  else if (currTypeName && typeNamespace && currTypeName !== 'Boolean' && !typeNamespace.endsWith('enums') && oldTypeKind === 'anonymousStructure') {
+      //     // 匿名到 不可枚举 不动
+      //     return;
+      // }
+    }
 
-        // 修改分支
-        await this.changeGenCases();
+    // 修改分支
+    await this.changeGenCases();
+  }
+
+  // jflow缓存模式下的传过来参数
+  async autoGenCasesAST({ oldAst, cacheType }: any) {
+    let obj;
+    try {
+      obj = JSON.parse(oldAst);
+    } catch (err) {}
+    const oldExpression = LogicItem.from(obj);
+    oldExpression.__TypeAnnotation = cacheType;
+    await this.autoGenCases(oldExpression);
+  }
+
+  async changeGenCases() {
+    const { expression } = this;
+    const currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
+    let cases: MatchCase[] = [];
+    let isMatchedTypeEnumable = false;
+    if (currTypeAnnotation) {
+      cases = [new MatchCase()];
+      const enumerableItems = await this.getEnumerableItems();
+      if (Array.isArray(enumerableItems) && enumerableItems.length) {
+        isMatchedTypeEnumable = true;
+        cases = enumerableItems.map(
+          (enumerableItem) =>
+            new MatchCase({
+              patterns: [enumerableItem],
+              isMatchedTypeEnumable,
+            })
+        );
+      }
     }
-    // jflow缓存模式下的传过来参数
-    async autoGenCasesAST({ oldAst, cacheType }: any) {
-        let obj;
-        try {
-            obj = JSON.parse(oldAst);
-        } catch (err) {
-        }
-        const oldExpression = LogicItem.from(obj);
-        oldExpression.__TypeAnnotation = cacheType;
-        await this.autoGenCases(oldExpression);
-    }
-    async changeGenCases() {
-        const expression = this.expression;
-        const currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
-        let cases: MatchCase[] = [];
-        let isMatchedTypeEnumable = false;
-        if (currTypeAnnotation) {
-            cases = [new MatchCase()];
-            const enumerableItems = await this.getEnumerableItems();
-            if (Array.isArray(enumerableItems) && enumerableItems.length) {
-                isMatchedTypeEnumable = true;
-                cases = enumerableItems.map((enumerableItem) => new MatchCase({
-                    patterns: [enumerableItem],
-                    isMatchedTypeEnumable,
-                }));
-            }
-        }
-        // body的暂存数组
-        const bodys: any[] = [];
-        // 最后一项的body
-        let lastCaseBody;
-        if (Array.isArray(this.cases) && this.cases.length) {
-            // 将原分支body中存在的内容拿出来
-            this.cases.forEach((caseItem, index) => {
-                const { body } = caseItem || {};
-                if (Array.isArray(body) && body.length) {
-                    // “其他”分支单独处理
-                    if (index < this.cases.length - 1) {
-                        bodys.push({
-                            body,
-                            isMatchedTypeEnumable: currTypeAnnotation ? isMatchedTypeEnumable : true,
-                        });
-                    } else {
-                        lastCaseBody = body;
-                    }
-                }
-            });
-            // 将原分支body中存在的内容拿出来赋到新的分支中去
-            bodys.forEach(({ body, isMatchedTypeEnumable }, index) => {
-                let caseItem = cases[index];
-                if (!caseItem) {
-                    caseItem = new MatchCase({
-                        isMatchedTypeEnumable,
-                    });
-                    cases.push(caseItem);
-                }
-                caseItem.update({
-                    body,
-                });
+    // body的暂存数组
+    const bodys: any[] = [];
+    // 最后一项的body
+    let lastCaseBody;
+    if (Array.isArray(this.cases) && this.cases.length) {
+      // 将原分支body中存在的内容拿出来
+      this.cases.forEach((caseItem, index) => {
+        const { body } = caseItem || {};
+        if (Array.isArray(body) && body.length) {
+          // “其他”分支单独处理
+          if (index < this.cases.length - 1) {
+            bodys.push({
+              body,
+              isMatchedTypeEnumable: currTypeAnnotation ? isMatchedTypeEnumable : true,
             });
+          } else {
+            lastCaseBody = body;
+          }
         }
-        // 如果分支项存在时，加上“其他”项
-        if (cases.length) {
-            const otherCase = new MatchCase();
-            // “其他”项body存在内容时,给新的分支上加上内容
-            if (lastCaseBody) {
-                otherCase.update({
-                    body: lastCaseBody,
-                });
-            }
-            cases.push(otherCase);
+      });
+      // 将原分支body中存在的内容拿出来赋到新的分支中去
+      bodys.forEach(({ body, isMatchedTypeEnumable }, index) => {
+        let caseItem = cases[index];
+        if (!caseItem) {
+          caseItem = new MatchCase({
+            isMatchedTypeEnumable,
+          });
+          cases.push(caseItem);
         }
-        this.update({
-            cases,
+        caseItem.update({
+          body,
         });
+      });
     }
-
-    public static getDefaultOptions() {
-        return {
-            label: '匹配',
-        };
+    // 如果分支项存在时，加上“其他”项
+    if (cases.length) {
+      const otherCase = new MatchCase();
+      // “其他”项body存在内容时,给新的分支上加上内容
+      if (lastCaseBody) {
+        otherCase.update({
+          body: lastCaseBody,
+        });
+      }
+      cases.push(otherCase);
     }
-
-    async isTypeMatching() {
-        if (this.expression) {
-            const typeAnnotation = await this.expression.getCurrentTypeAnnotation();
-            const { typeKind, typeArguments } = typeAnnotation || {};
-            if (typeKind === 'union' && Array.isArray(typeArguments)) {
-                return true;
-            }
-        }
-        return false;
+    this.update({
+      cases,
+    });
+  }
+
+  public static getDefaultOptions() {
+    return {
+      label: '匹配',
+    };
+  }
+
+  async isTypeMatching() {
+    if (this.expression) {
+      const typeAnnotation = await this.expression.getCurrentTypeAnnotation();
+      const { typeKind, typeArguments } = typeAnnotation || {};
+      if (typeKind === 'union' && Array.isArray(typeArguments)) {
+        return true;
+      }
     }
-
-    onChange($event?: EventPayload): void {
-        const { action, object, eventList } = $event || {};
-        // expression修改时，通知tsserver，让tsserver重新生成ts文件，为了后续能获取expression的类型
-        if (action === 'update' && object.hasOwnProperty('expression')) {
-            (this.app as any)?.naslServer?.embeddedTSEmitter.emit('change', {
-                value: eventList,
-            });
-        }
-        this.emit('change', $event);
-    }
-
-
-    // 获取在页面中的名字
-    get expressionNameInView() {
-        const nameList: string[] = [];
-        let node: BaseNode = this;
-        while (node) {
-            if (node === this) {
-                nameList.unshift('viewMatchExpression');
-            } else {
-                nameList.unshift(node.name);
-            }
-            if (node.concept === 'ViewElement') {
-                node = null;
-            } else {
-                nameList.unshift(node.parentKey);
-                node = node.parentNode;
-            }
-        }
-        return nameList.join('_').replace(/-/g, '_');
+    return false;
+  }
+
+  onChange($event?: EventPayload): void {
+    const { action, object, eventList } = $event || {};
+    // expression修改时，通知tsserver，让tsserver重新生成ts文件，为了后续能获取expression的类型
+    if (action === 'update' && object.hasOwnProperty('expression')) {
+      (this.app as any)?.naslServer?.embeddedTSEmitter.emit('change', {
+        value: eventList,
+      });
+    }
+    this.emit('change', $event);
+  }
+
+  // 获取在页面中的名字
+  get expressionNameInView() {
+    const nameList: string[] = [];
+    let node: BaseNode = this;
+    while (node) {
+      if (node === this) {
+        nameList.unshift('viewMatchExpression');
+      } else {
+        nameList.unshift(node.name);
+      }
+      if (node.concept === 'ViewElement') {
+        node = null;
+      } else {
+        nameList.unshift(node.parentKey);
+        node = node.parentNode;
+      }
+    }
+    return nameList.join('_').replace(/-/g, '_');
+  }
+
+  getViewMatchExpressionBuilder() {
+    return `gen${this.expressionNameInView}`;
+  }
+
+  getInViewMethod(state?: TranslatorState) {
+    const viewElement = this?.getAncestor('ViewElement');
+    const argsList = [];
+    let parent = viewElement?.parentNode;
+    let index = 0;
+    while (parent && parent.concept !== 'View') {
+      if ((parent as ViewElement).slotScope) {
+        argsList.unshift(index === 0 ? 'current' : `current${index}`);
+        index++;
+      }
+      parent = parent.parentNode;
     }
 
-    getViewMatchExpressionBuilder() {
-        return `gen${this.expressionNameInView}`;
+    let code = '';
+    code += `${this.getViewMatchExpressionBuilder()} (${argsList.join(', ')}) {\n`;
+    code += `return ${this.toJS()}`;
+    code += `;\n`;
+    code += '}';
+    return code;
+  }
+
+  setIsExpressionCustom(isExpression: boolean) {
+    if (isExpression === this.isExpression) {
+      return;
+    }
+    this.update({
+      isExpression,
+    });
+    this.cases.forEach((c) => {
+      c.update({
+        body: [],
+      });
+    });
+  }
+
+  toVue(state?: TranslatorState): string {
+    if (state?.finalCode === false) {
+      return this.toUI();
+    }
+    const viewElement = this?.getAncestor('ViewElement');
+    const argsList = [];
+    let parent = viewElement?.parentNode;
+    let index = 0;
+    while (parent && parent.concept !== 'View') {
+      if ((parent as ViewElement).slotScope) {
+        argsList.unshift(index === 0 ? 'current' : `current${index}`);
+        index++;
+      }
+      parent = parent.parentNode;
+    }
+    return `${this.getViewMatchExpressionBuilder()}(${argsList.join(', ')})`;
+
+    //        let code = 'await (async () => {\n';
+    //        if (this.expression && Array.isArray(this.cases)) {
+    //            this.cases.forEach((item, index) => {
+    //                code += item?.toJS?.(this.expression, index, this.cases.length);
+    //            });
+    //        }
+    //        code += `})()`;
+    //        return code;
+  }
+
+  toUI(state?: TranslatorState): string {
+    let code = '匹配 ';
+    if (this.expression) {
+      code += this.expression.toUI?.();
+    }
+    if (Array.isArray(this.cases)) {
+      code += ' { ';
+      this.cases.forEach((item, index) => {
+        code += item?.toUI?.();
+      });
+      code += '}';
+    }
+    return code;
+  }
+
+  toJS(state?: TranslatorState): string {
+    // let code = 'await (async () => {\n';
+    // if (this.expression && Array.isArray(this.cases)) {
+    //    this.cases.forEach((item, index) => {
+    //        code += item?.toJS?.(this.expression, index, this.cases.length);
+    //    });
+    // }
+    // code += `})()`;
+    // return code;
+
+    let code = '';
+    // 祖先逻辑
+    const ancestorLogic = this.getAncestor('Logic');
+    if (this.isExpression || !ancestorLogic) {
+      if (ancestorLogic) {
+        code += 'await (async () => {\n';
+      } else {
+        code += '(() => {\n';
+      }
+    }
+    if (this.expression && Array.isArray(this.cases)) {
+      this.cases.forEach((item, index) => {
+        code += item?.toJS?.(this.expression, index, this.cases.length);
+      });
     }
+    if (this.isExpression || !ancestorLogic) {
+      code += '})()';
+    }
+    return code;
+  }
 
-    getInViewMethod(state?: TranslatorState) {
-        const viewElement = this?.getAncestor('ViewElement');
-        const argsList = [];
-        let parent = viewElement?.parentNode;
-        let index = 0;
-        while (parent && parent.concept !== 'View') {
-            if ((parent as ViewElement).slotScope) {
-                argsList.unshift(index === 0 ? 'current' : 'current' + index);
-                index++;
-            }
-            parent = parent.parentNode;
-        }
+  @withSourceMap()
+  toEmbeddedTS(state?: TranslatorState): string {
+    let code = '';
 
-        let code = '';
-        code += `${this.getViewMatchExpressionBuilder()} (${argsList.join(', ')}) {\n`;
-        code += `return ${this.toJS()}`;
-        code += `;\n`;
-        code += '}';
-        return code;
-    }
-
-    toVue(state?: TranslatorState): string {
-        if (state?.finalCode === false) {
-            return this.toUI();
-        } else {
-            const viewElement = this?.getAncestor('ViewElement');
-            const argsList = [];
-            let parent = viewElement?.parentNode;
-            let index = 0;
-            while (parent && parent.concept !== 'View') {
-                if ((parent as ViewElement).slotScope) {
-                    argsList.unshift(index === 0 ? 'current' : 'current' + index);
-                    index++;
-                }
-                parent = parent.parentNode;
-            }
-            return `${this.getViewMatchExpressionBuilder()}(${argsList.join(', ')})`;
-
-            //        let code = 'await (async () => {\n';
-            //        if (this.expression && Array.isArray(this.cases)) {
-            //            this.cases.forEach((item, index) => {
-            //                code += item?.toJS?.(this.expression, index, this.cases.length);
-            //            });
-            //        }
-            //        code += `})()`;
-            //        return code;
-        }
+    if (this.parentNode.concept === 'Logic') {
+      code += '\n';
     }
-
-    toUI(state?: TranslatorState): string {
-        let code = '匹配 ';
-        if (this.expression) {
-            code += this.expression.toUI?.();
-        }
-        if (Array.isArray(this.cases)) {
-            code += ' { ';
-            this.cases.forEach((item, index) => {
-                code += item?.toUI?.();
-            });
-            code += '}';
-        }
-        return code;
-    }
-
-    toJS(state?: TranslatorState): string {
-        //let code = 'await (async () => {\n';
-        //if (this.expression && Array.isArray(this.cases)) {
-        //    this.cases.forEach((item, index) => {
-        //        code += item?.toJS?.(this.expression, index, this.cases.length);
-        //    });
-        //}
-        //code += `})()`;
-        //return code;
-
-        let code = '';
-        // 祖先逻辑
-        const ancestorLogic = this.getAncestor('Logic');
-        if (this.isExpression || !ancestorLogic) {
-            if (ancestorLogic) {
-                code += 'await (async () => {\n';
-            } else {
-                code += '(() => {\n';
-            }
-        }
-        if (this.expression && Array.isArray(this.cases)) {
-            this.cases.forEach((item, index) => {
-                code += item?.toJS?.(this.expression, index, this.cases.length);
-            });
-        }
-        if (this.isExpression || !ancestorLogic) {
-            code += '})()';
-        }
-        return code;
+    code += indent(state?.tabSize || 0);
+    code += '(() => { \n';
+    let parentCode: string;
+    if (this.expression) {
+      code += indent(state?.tabSize || 0);
+      // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
+      if (this.expression instanceof Identifier || this.expression instanceof MemberExpression) {
+        code += parentCode = this.expression.toEmbeddedTS(shiftState(state, code));
+      } else {
+        parentCode = '__matchExpression';
+        code += `let ${parentCode} = `;
+        code += this.expression.toEmbeddedTS(shiftState(state, code));
+      }
+      code += ';\n';
+    } else {
+      code += '__IDENTIFIER__;\n';
+    }
+    code += indent(state?.tabSize + 1 || 0);
+    code += ' function __MatchExpressionFuntion() {\n';
+
+    //  最后一项是else
+    this.cases.forEach((item, index) => {
+      // 如果是最后一项
+      code += item.toEmbeddedTS(shiftState(state, code, { tabSize: state?.tabSize || 0 }), index, parentCode);
+    });
+    code += indent(state?.tabSize || 0);
+    code += '};\n';
+    code += indent(state?.tabSize || 0);
+    code += 'return __MatchExpressionFuntion();\n';
+    code += indent(state?.tabSize || 0);
+    code += '})()';
+
+    if (
+      this.parentNode.concept !== 'Argument' &&
+      this.parentKey !== 'test' &&
+      this.parentKey !== 'patterns' &&
+      this.parentNode.concept !== 'Assignment' &&
+      this.parentNode.concept !== 'ForEachStatement' &&
+      this.parentNode.concept !== 'SelectMembers' &&
+      this.parentNode.concept !== 'UnaryExpression' &&
+      this.parentNode.concept !== 'BinaryExpression' &&
+      this.parentNode.concept !== 'StringInterpolation' &&
+      this.parentNode.concept !== 'MemberExpression' &&
+      !['NewMap', 'NewList'].includes(this.parentNode.concept) &&
+      this.parentKey !== 'returnExpression'
+    ) {
+      code += ';\n';
     }
+    return code;
+  }
 
-    @withSourceMap()
-    toEmbeddedTS(state?: TranslatorState): string {
-        let code = '';
+  @withSourceMap()
+  toNaturalTS(state?: TranslatorState): string {
+    let code = '';
 
-        if (this.parentNode.concept === 'Logic') {
-            code += '\n';
-        }
-        code += indent((state?.tabSize || 0));
-        code += '(() => { \n';
-        let parentCode: string;
-        if (this.expression) {
-            code += indent((state?.tabSize || 0));
-            // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
-            if ((this.expression instanceof Identifier) || (this.expression instanceof MemberExpression)) {
-                code += parentCode = this.expression.toEmbeddedTS(shiftState(state, code));
-            } else {
-                parentCode = '__matchExpression';
-                code += `let ${parentCode} = `;
-                code += this.expression.toEmbeddedTS(shiftState(state, code));
-            }
-            code += ';\n';
-        } else {
-            code += '__IDENTIFIER__;\n';
-        }
-        code += indent((state?.tabSize + 1 || 0));
-        code += ' function __MatchExpressionFuntion() {\n';
+    if (this.parentNode?.concept === 'Logic') {
+      code += '\n';
+    }
+    code += indent(state.tabSize);
+    code += '(function match(_value) { \n';
+    let parentCode: string;
+    if (this.expression) {
+      code += indent(state.tabSize + 1);
+      // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
+      if ((this.expression instanceof Identifier) || (this.expression instanceof MemberExpression)) {
+        parentCode = this.expression.toNaturalTS(shiftState(state, code, { inline: true }));
+      } else {
+        parentCode = '_value';
+      }
+    }
 
-        //  最后一项是else
-        this.cases.forEach((item, index) => {
-            // 如果是最后一项
-            code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) }), index, parentCode);
-        });
-        code += indent((state?.tabSize || 0));
-        code += '};\n';
-        code += indent((state?.tabSize || 0));
-        code += 'return __MatchExpressionFuntion();\n';
-        code += indent((state?.tabSize || 0));
-        code += '})()';
-
-        if (this.parentNode.concept !== 'Argument'
-            && this.parentKey !== 'test'
-            && this.parentKey !== 'patterns'
-            && this.parentNode.concept !== 'Assignment'
-            && this.parentNode.concept !== 'ForEachStatement'
-            && this.parentNode.concept !== 'SelectMembers'
-            && this.parentNode.concept !== 'UnaryExpression'
-            && this.parentNode.concept !== 'BinaryExpression'
-            && this.parentNode.concept !== 'StringInterpolation'
-            && this.parentNode.concept !== 'MemberExpression'
-            && !['NewMap', 'NewList'].includes(this.parentNode.concept)
-            && this.parentKey !== 'returnExpression') {
-            code += ';\n';
-        }
-        return code;
+    // 最后一项是else
+    this.cases.forEach((item, index) => {
+      // 如果是最后一项
+      code += item.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }), index, parentCode);
+    });
+    code += indent(state.tabSize);
+    code += `})(${this.expression.toNaturalTS(shiftState(state, code, { inline: true }))})`;
+
+    if (this.parentNode?.concept !== 'Argument'
+      && this.parentKey !== 'test'
+      && this.parentKey !== 'patterns'
+      && this.parentNode?.concept !== 'Assignment'
+      && this.parentNode?.concept !== 'ForEachStatement'
+      && this.parentNode?.concept !== 'SelectMembers'
+      && this.parentNode?.concept !== 'BinaryExpression'
+      && this.parentNode?.concept !== 'StringInterpolation'
+      && this.parentNode?.concept !== 'MemberExpression'
+      && !['NewMap', 'NewList'].includes(this.parentNode.concept)
+      && this.parentKey !== 'returnExpression') {
+      code += ';\n';
     }
+    return code;
+  }
 
-    //================================================================================
-    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
-    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-    //================================================================================
+  //= ===============================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //= ===============================================================================
 }
 
 classMap.Match = Match;
 export default Match;
-//================================================================================
+//= ===============================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//================================================================================
+//= ===============================================================================
 // @ts-check