@lcap/nasl 2.20.1-beta.2 → 2.21.0-beta.1

package/src/concepts/InterfaceParam__.ts

@@ -94,6 +94,9 @@ export class InterfaceParam extends BaseNode {
         super(source);
         super.subConstructor(source);
     }
+    getClassName() {
+        return 'InterfaceParam';
+    }
 
     static from(source: any, parentNode?: any, parentKey?: string): InterfaceParam {
         return super.from(source, parentNode, parentKey) as InterfaceParam;

package/src/concepts/Interface__.ts

@@ -2,6 +2,7 @@ import { TranslatorState, shiftState, withSourceMap, createCompilerState } from
 import Namespace from './Namespace__';
 import TypeAnnotation from './TypeAnnotation__';
 import Structure from './Structure__';
+import Param from './Param__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -92,6 +93,9 @@ export class Interface extends BaseNode {
         super(source);
         super.subConstructor(source);
     }
+    getClassName() {
+        return 'Interface';
+    }
 
     static from(source: any, parentNode?: any, parentKey?: string): Interface {
         return super.from(source, parentNode, parentKey) as Interface;
@@ -514,6 +518,18 @@ export class Interface extends BaseNode {
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
 
+    /**
+     * 协议
+     */
+    @property()
+    protocol: string = undefined;
+
+    /**
+     * 协议参数列表
+     */
+    @property('Param')
+    protocolParams: Array<Param> = [];
+
     /**
      * 是否可编辑
      * */
@@ -545,6 +561,21 @@ export class Interface extends BaseNode {
         });
     }
 
+    // 更新所有调用接口
+    async updateAllRefCallInterface() {
+        const refs = await this.findUsage();
+        refs.forEach((val: any) => {
+            const loopFindNode = (item: any) => {
+                if (item.children) {
+                    item.children.forEach((i: any) => loopFindNode(i));
+                } else {
+                    item.node.setCallee(this);
+                }
+            };
+            loopFindNode(val);
+        });
+    }
+
     /* 删除空数据模块 */
     deleteLogincAndModule() {
         this.rootNode.emit('collect:start', {
@@ -823,6 +854,36 @@ export class Interface extends BaseNode {
         return [...this.params, ...this.returns].filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
 
+    // 递归找出 response/request 的 Body/Returns 引用的数据结构
+    getRefStructures(structures: Structure[] = []): Set<Structure> {
+        const structuresSet: Set<Structure> = new Set();
+        const loopSaveStructure = (typeAnnotation: TypeAnnotation) => {
+            if (!typeAnnotation)
+                return;
+            if (typeAnnotation.typeKind === 'reference') {
+                const targetStructure = structures.find((s) => s.name === typeAnnotation.typeName);
+                if (targetStructure && !structuresSet.has(targetStructure)) {
+                    structuresSet.add(targetStructure);
+                    targetStructure?.properties.forEach((prop) => {
+                        loopSaveStructure(prop.typeAnnotation);
+                    });
+                }
+            } else if (typeAnnotation.typeKind === 'generic') {
+                typeAnnotation.typeArguments.forEach(loopSaveStructure);
+            }
+        };
+
+        const { params = [], returns = [] } = this;
+        [...params, ...returns].forEach((p) => {
+            if ('in' in p && p.in === 'cookie') {
+                p.in = 'header';
+                return;
+            }
+            loopSaveStructure(p?.typeAnnotation);
+        });
+        return structuresSet;
+    }
+
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/JSBlock__.ts

@@ -45,6 +45,9 @@ export class JSBlock extends LogicItem {
         super(source);
         super.subConstructor(source);
     }
+    getClassName() {
+        return 'JSBlock';
+    }
 
     static from(source: any, parentNode?: any, parentKey?: string): JSBlock {
         return super.from(source, parentNode, parentKey) as JSBlock;

package/src/concepts/LogicItem__.ts

@@ -30,7 +30,7 @@ export class LogicItem extends BaseNode {
      * 产品概念
      */
     @property()
-    concept: 'LogicItem' | 'Start' | 'End' | 'IfStatement' | 'SwitchStatement' | 'SwitchCase' | 'ForEachStatement' | 'WhileStatement' | 'Assignment' | 'BatchAssignment' | 'Comment' | 'CallLogic' | 'CallFunction' | 'CallInterface' | 'Destination' | 'ExternalDestination' | 'ValidationRule' | 'Argument' | 'Anchor' | 'JSBlock' | 'Identifier' | 'NullLiteral' | 'BooleanLiteral' | 'StringLiteral' | 'StringInterpolation' | 'NumericLiteral' | 'BinaryExpression' | 'MatchCase' | 'Match' | 'UnaryExpression' | 'MemberExpression' | 'Unparsed' | 'New' | 'NewComposite' | 'NewList' | 'NewMap' | 'CallQueryComponent' | 'QueryFromExpression' | 'QueryJoinExpression' | 'QueryFieldExpression' | 'QueryAggregateExpression' | 'QueryOrderByExpression' | 'QueryGroupByExpression' | 'QuerySelectExpression' | 'QueryLimitExpression' | 'SqlQueryComponent' | 'OqlQueryComponent' | 'ProcessOutcome' | 'Assignee' | 'ProcessOutcomes' = 'LogicItem';
+    concept: 'LogicItem' | 'Abort' | 'Start' | 'End' | 'IfStatement' | 'SwitchStatement' | 'SwitchCase' | 'ForEachStatement' | 'WhileStatement' | 'Assignment' | 'BatchAssignment' | 'Comment' | 'CallLogic' | 'CallFunction' | 'CallInterface' | 'Destination' | 'ExternalDestination' | 'ValidationRule' | 'Argument' | 'Anchor' | 'JSBlock' | 'Identifier' | 'NullLiteral' | 'BooleanLiteral' | 'StringLiteral' | 'StringInterpolation' | 'NumericLiteral' | 'BinaryExpression' | 'MatchCase' | 'Match' | 'UnaryExpression' | 'MemberExpression' | 'Unparsed' | 'New' | 'NewComposite' | 'NewList' | 'NewMap' | 'CallQueryComponent' | 'QueryFromExpression' | 'QueryJoinExpression' | 'QueryFieldExpression' | 'QueryAggregateExpression' | 'QueryOrderByExpression' | 'QueryGroupByExpression' | 'QuerySelectExpression' | 'QueryLimitExpression' | 'SqlQueryComponent' | 'OqlQueryComponent' | 'ProcessOutcome' | 'Assignee' | 'ProcessOutcomes' | 'NewList' = 'LogicItem';
 
     /**
      * 逻辑项标题
@@ -113,6 +113,9 @@ export class LogicItem extends BaseNode {
         super(source);
         super.subConstructor(source);
     }
+    getClassName() {
+        return 'LogicItem';
+    }
 
     static from(source: any, parentNode?: any, parentKey?: string): LogicItem {
         return super.from(source, parentNode, parentKey) as LogicItem;
@@ -165,10 +168,6 @@ export class LogicItem extends BaseNode {
         });
     }
 
-    
-
-    
-
     //================================================================================
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。

package/src/concepts/Logic__.ts

@@ -166,6 +166,9 @@ export class Logic extends BaseNode {
         super(source);
         super.subConstructor(source);
     }
+    getClassName() {
+        return 'Logic';
+    }
 
     static from(source: any, parentNode?: any, parentKey?: string): Logic {
         return super.from(source, parentNode, parentKey) as Logic;
@@ -246,7 +249,7 @@ export class Logic extends BaseNode {
         });
     }
 
-    getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
+        getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.typeParams as TypeParam[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -387,6 +390,7 @@ export class Logic extends BaseNode {
         return node;
     }
 
+
     getParamUniqueName(name = 'param1') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
@@ -524,6 +528,7 @@ export class Logic extends BaseNode {
         return node;
     }
 
+
     getReturnUniqueName(name = 'result') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
@@ -661,6 +666,7 @@ export class Logic extends BaseNode {
         return node;
     }
 
+
     getVariableUniqueName(name = 'variable1') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
@@ -798,6 +804,11 @@ export class Logic extends BaseNode {
         return node;
     }
 
+
+
+
+    
+
     /**
     * 插入逻辑项
     * @internal
@@ -830,6 +841,8 @@ export class Logic extends BaseNode {
         return logicItem;
     }
 
+    
+
     /**
      * 插入逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -852,6 +865,8 @@ export class Logic extends BaseNode {
         return node;
     }
 
+    
+
     /**
      * 添加逻辑项
      * @internal
@@ -871,6 +886,8 @@ export class Logic extends BaseNode {
         return this._insertItemInBodyAt(options as any, index);
     }
 
+    
+
     /**
      * 添加逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -894,6 +911,8 @@ export class Logic extends BaseNode {
         return node;
     }
 
+    
+
     /**
     * 插入逻辑项
     * @internal
@@ -926,6 +945,8 @@ export class Logic extends BaseNode {
         return logicItem;
     }
 
+    
+
     /**
      * 插入逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -948,6 +969,8 @@ export class Logic extends BaseNode {
         return node;
     }
 
+    
+
     /**
      * 添加逻辑项
      * @internal
@@ -967,6 +990,8 @@ export class Logic extends BaseNode {
         return this._insertItemInPlaygroundAt(options as any, index);
     }
 
+    
+
     /**
      * 添加逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -990,6 +1015,9 @@ export class Logic extends BaseNode {
         return node;
     }
 
+
+    
+
     /**
     * 删除事务
     * @param name 事务名称
@@ -1038,6 +1066,8 @@ export class Logic extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除类型参数
     * @param name 类型参数名称
@@ -1086,6 +1116,8 @@ export class Logic extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除输入参数
     * @param name 输入参数名称
@@ -1134,6 +1166,8 @@ export class Logic extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除输出参数
     * @param name 输出参数名称
@@ -1182,6 +1216,8 @@ export class Logic extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除变量
     * @param name 变量名称
@@ -1230,6 +1266,8 @@ export class Logic extends BaseNode {
         return params;
     }
 
+
+
     /**
      * 删除逻辑项
      * @param logicItem 已有的逻辑项实例
@@ -1237,10 +1275,12 @@ export class Logic extends BaseNode {
     removeItemInBody(logicItem: LogicItem): void;
 
     removeItemInBody(options: LogicItem) {
-        const logicItem: LogicItem = options;
+        let logicItem: LogicItem = options;
         return logicItem.delete();
     }
 
+    
+
     /**
      * 删除逻辑项
      * @param logicItem 已有的逻辑项实例
@@ -1248,7 +1288,7 @@ export class Logic extends BaseNode {
     removeItemInPlayground(logicItem: LogicItem): void;
 
     removeItemInPlayground(options: LogicItem) {
-        const logicItem: LogicItem = options;
+        let logicItem: LogicItem = options;
         return logicItem.delete();
     }
 
@@ -1648,14 +1688,12 @@ export class Logic extends BaseNode {
             Promise.all(needGetSourceMapOqlList).then(() => {
                 // 触发一下更新重新生成代码
                 (this.app as any)?.naslServer?.embeddedTSEmitter.emit('change', {
-                    value: [
-                        {
-                            originEvent: {
-                                action: 'update',
-                                target: this,
-                            },
+                    value: [{
+                        originEvent: {
+                            action: 'update',
+                            target: this,
                         },
-                    ],
+                    }],
                 });
             });
         }
@@ -1667,13 +1705,11 @@ export class Logic extends BaseNode {
         code += '{\n';
 
         // 用于虚拟节点的查找引用
-        this.virtualParams
-            && Array.isArray(this.virtualParams)
-            && this.virtualParams.forEach((param) => {
-                code += indent((state?.tabSize || 0) + 1);
-                code += param.toEmbeddedNameTS(shiftState(state, code, { inline: true }));
-                code += '\n';
-            });
+        this.virtualParams && Array.isArray(this.virtualParams) && this.virtualParams.forEach((param) => {
+            code += indent((state?.tabSize || 0) + 1);
+            code += param.toEmbeddedNameTS(shiftState(state, code, { inline: true }));
+            code += '\n';
+        });
 
         this.variables.forEach((variable) => {
             if (!advanceMap.get(variable)) {
@@ -1697,12 +1733,12 @@ export class Logic extends BaseNode {
             code += node.toEmbeddedTS(shiftState(state, code, { inline: true }));
             if (assignment instanceof BatchAssignment) {
                 assignment.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
-                    const leftCode
-                        = leftIndex.length === 1 ? assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true })) : assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                    const leftCode = leftIndex.length === 1 ? assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true })) : assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
                     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.ideVersion !== '2.11')) {
+                        if (rightNode?.typeAnnotation
+                            && !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')) {
                             code += ': ';
                             code += rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) || 'null';
                         } else {
@@ -1723,7 +1759,8 @@ export class Logic extends BaseNode {
             } else {
                 const rightNode: any = assignment.right;
                 // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
-                if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')) {
+                if (rightNode?.typeAnnotation
+                    && !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')) {
                     code += ': ';
                     code += rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) || 'null';
                 } else {
@@ -1733,7 +1770,7 @@ export class Logic extends BaseNode {
                     if (rightNode && rightNode instanceof Identifier && rightNode.namespace && rightNode.namespace.endsWith('enums')) {
                         rightCode += 'new ';
                     }
-                    rightCode += rightNode && rightNode.toEmbeddedTS ? rightNode.toEmbeddedTS(shiftState(state, code, { inline: true })) : '__RIGHT__';
+                    rightCode += (rightNode && rightNode.toEmbeddedTS) ? rightNode.toEmbeddedTS(shiftState(state, code, { inline: true })) : '__RIGHT__';
                     code += this.getRightCode(rightCode, assignment, rightNode);
                 }
             }
@@ -1834,7 +1871,7 @@ export class Logic extends BaseNode {
             code = this.handleReplaceCode(code, item.name, eachTSCode === '__IDENTIFIER__' ? eachTSCode : `${eachTSCode}.__get(0)`);
         }
         if (code.includes(index.name))
-            code = this.handleReplaceCode(code, index.name, 'new nasl.core.Integer(0)');
+            code = this.handleReplaceCode(code, index.name, 'new nasl.core.Long(0)');
 
         const parentForEachStatement = forEachStatement.getAncestor('ForEachStatement') as ForEachStatement;
         if (parentForEachStatement) {
@@ -1878,10 +1915,7 @@ export class Logic extends BaseNode {
                 arr.push(parentName);
             }
             let namespace = arr.join('.');
-            if (
-                !['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace)
-                && !namespace.includes('.logics')
-            ) {
+            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace) && !namespace.includes('.logics')) {
                 namespace = `${namespace}.logics`;
             }
             return namespace;
@@ -1898,10 +1932,7 @@ export class Logic extends BaseNode {
                 arr.push(parentName);
             }
             let namespace = arr.join('.');
-            if (
-                !['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace)
-                && !namespace.includes('.logics')
-            ) {
+            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace) && !namespace.includes('.logics')) {
                 namespace = `${namespace}.logics`;
             }
             return namespace;
@@ -2044,9 +2075,55 @@ export class Logic extends BaseNode {
     // 虚拟输入参数列表
     virtualParams: Array<Param> = [];
 
-    get getLogicBelongTo() {
-        const [, belongTo] = this.calleewholeKey.split('.');
-        return belongTo;
+    /* 零时用  需要删除*/
+    addParamsFunction() {
+        this.addParam({
+            name: 'param5',
+            typeAnnotation: TypeAnnotation.from({
+                typeKind: 'function',
+                typeName: 'String',
+                typeNamespace: 'nasl.core',
+                returnType: [TypeAnnotation.from({
+                    typeKind: 'primitive',
+                    typeName: 'Boolean',
+                    typeNamespace: 'nasl.core',
+                })],
+                typeArguments: [
+                    TypeAnnotation.from({
+                        typeKind: 'primitive',
+                        typeName: 'String',
+                        typeNamespace: 'nasl.core',
+                    }),
+                    TypeAnnotation.from({
+                        typeKind: 'primitive',
+                        typeName: 'Boolean',
+                        typeNamespace: 'nasl.core',
+                    }),
+                ],
+            }),
+
+        });
+    }
+
+    // 校验logic的返回值是不是有error类型
+    static checkLogicReturnTypeHasError(logic: Logic) {
+        let findHasError = false;
+        if (!logic) {
+            return findHasError;
+        }
+        if (logic.returns?.length && logic.returns[0]?.typeAnnotation) {
+            // 如果新导入的logic还有Error类型
+            const logicType = logic.returns[0].typeAnnotation;
+            if (logicType.typeNamespace === 'nasl.ui' && logicType.typeName === 'Error') {
+                findHasError = true;
+            } else if (logicType.typeNamespace === 'nasl.core' && logicType.typeKind === 'union') {
+                // 如果 logic 有 returns 而且，也有typeArguments的长度
+                findHasError = Boolean(logicType.typeArguments?.find((item) => (
+                    item?.typeNamespace === 'nasl.ui' && item?.typeName === 'Error'
+                )));
+            }
+        }
+        return findHasError;
     }
 
     //================================================================================

package/src/concepts/MatchCase__.ts

@@ -58,6 +58,9 @@ export class MatchCase extends LogicItem {
         super(source);
         super.subConstructor(source);
     }
+    getClassName() {
+        return 'MatchCase';
+    }
 
     static from(source: any, parentNode?: any, parentKey?: string): MatchCase {
         return super.from(source, parentNode, parentKey) as MatchCase;

package/src/concepts/Match__.ts

@@ -59,6 +59,9 @@ export class Match extends LogicItem {
         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;
@@ -352,17 +355,89 @@ export class Match extends LogicItem {
 
     // 设置 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();
+        await this.autoGenCases(oldExpression);
         this.app.emit('collect:end');
     }
 
     // 自动生成分支
-    async autoGenCases() {
+    async autoGenCases(oldExpression: LogicItem) {
+        const expression = this.expression;
+        // 没有新的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;
+        }
+
+        // 如果不可枚举 变 不可枚举，都会保留分支
+        // 原来不是 布尔类型 也不是枚举类型， 现在 也不是布尔类型 也不是枚举类型
+        // 就满足了
+        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;
+            // }
+        }
+
+        // 修改分支
+        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.expression;
         const currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
         let cases: MatchCase[] = [];

package/src/concepts/MemberExpression__.ts

@@ -54,6 +54,9 @@ export class MemberExpression extends LogicItem {
         super(source);
         super.subConstructor(source);
     }
+    getClassName() {
+        return 'MemberExpression';
+    }
 
     static from(source: any, parentNode?: any, parentKey?: string): MemberExpression {
         return super.from(source, parentNode, parentKey) as MemberExpression;