@lcap/nasl 3.6.0-beta.1 → 3.7.0-beta.1

package/src/concepts/Logic__.ts

@@ -35,13 +35,15 @@ import type CallLogic from './CallLogic__';
 import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 import type Interface from './Interface__';
 import type BusinessComponent from './BusinessComponent__';
-
-import Module from './Module__';
-import Connector from './Connector__';
-import View from './View__';
-import Frontend from './Frontend__';
-import ProcessElement from './ProcessElement__';
-import Process from './Process__';
+import type AnonymousFunction from './AnonymousFunction__';
+
+import type Module from './Module__';
+import type Connector from './Connector__';
+import type View from './View__';
+import type Frontend from './Frontend__';
+import type ProcessElement from './ProcessElement__';
+import type Process from './Process__';
+import type CallFunction from './CallFunction__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -68,6 +70,13 @@ import LogicItem from './LogicItem__';
 export class Logic extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'Logic';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -1632,28 +1641,42 @@ export class Logic extends BaseNode {
       code += '()';
     }
     // 需要类型推导的局部变量/返回值需要调整申明顺序
-    const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
+    const advanceMap: Map<Return | Variable, Assignment | BatchAssignment | CallFunction> = new Map();
     // const needGetSourceMapOqlList: Promise<any>[] = [];
     yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      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,
-          );
+      if (el && (
+        // 批量赋值
+        asserts.isBatchAssignment(el)
+        // 赋值
+        || (asserts.isAssignment(el) && el.left?.name)
+        // 内置函数对集合类型的推导
+        || (
+          asserts.isCallFunction(el) && el.derivablecollection?.name
+        )
+      )) {
+        if (asserts.isAssignment(el) || asserts.isCallFunction(el)) {
+          let expression: LogicItem;
+          if (asserts.isAssignment(el)) {
+            // 需要被推导的赋值左侧
+            expression = el.left;
+          } else if (asserts.isCallFunction(el)) {
+            // 需要被推导的集合
+            expression = el.derivablecollection;
+          }
+          // 宽泛意义上的变量（变量+出参）
+          const advanceVar = [...(self.variables || []), ...(self.returns || [])].find((variable) => {
+            return !variable.typeAnnotation && expression?.name === variable.name;
+          });
           if (advanceVar && !advanceMap.get(advanceVar)) {
             advanceMap.set(advanceVar, el);
           }
-          const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
-          if (advanceRn && !advanceMap.get(advanceRn)) {
-            advanceMap.set(advanceRn, el);
-          }
         } 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('');
+                returnOrigin('');
             const advanceVar = self.variables?.find(
               (variable) => !variable.typeAnnotation && leftCode === variable.name,
             );
@@ -1716,6 +1739,26 @@ export class Logic extends BaseNode {
         return;
       }
       code += `${indent((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
+      if (asserts.isCallFunction(assignment)) {
+        yield* wrapForEach([
+          {
+            key: 'key',
+            node: assignment.keyOfCollection
+          },
+          {
+            key: 'item',
+            node: assignment.itemOfCollection
+          }
+        ], function* warpForEachGenerator({ key, node: itemNode }) {
+          if (itemNode) {
+            code += `const __${key}_${node?.name} = `;
+            const itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
+            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            code += ';\n';
+          }
+        });
+      }
       code += `${indent((state?.tabSize || 0) + 1)}let `;
       code += yield* node.toEmbeddedTS(shiftState(state, code, { inline: true }));
       if (asserts.isBatchAssignment(assignment)) {
@@ -1724,7 +1767,7 @@ export class Logic extends BaseNode {
             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('');
+              returnOrigin('');
           if (leftCode === node.name) {
             const rightNode: any =
               rightIndex.length === 1
@@ -1752,28 +1795,37 @@ export class Logic extends BaseNode {
           }
         });
       } else if (
-        ['NewList', 'NewMap'].includes(assignment.right?.concept) &&
-        !(assignment.right as any)?.typeAnnotation
+        ['NewList', 'NewMap'].includes((assignment as Assignment).right?.concept) &&
+        !((assignment as Assignment).right as any)?.typeAnnotation
       ) {
-        const rightNode: any = assignment.right;
+        const rightNode: any = (assignment as Assignment).right;
         code += ' = ';
         code += yield* rightNode.getInitCode(shiftState(state, code, { inline: true }));
       } else if (
-        assignment.right?.concept === 'NewComposite' &&
-        (assignment.right as any)?.typeAnnotation?.typeKind === 'anonymousStructure'
+        (assignment as Assignment).right?.concept === 'NewComposite' &&
+        ((assignment as Assignment).right as any)?.typeAnnotation?.typeKind === 'anonymousStructure'
       ) {
-        const rightNode: any = assignment.right;
+        const rightNode: any = (assignment as Assignment).right;
         code += ' = ';
         code += yield* rightNode.getInitCode(shiftState(state, code, { inline: true }));
       } else if (
-        assignment.right?.concept === 'NewComposite' &&
-        (assignment.right as any)?.typeAnnotation?.typeKind === 'generic'
+        (assignment as Assignment).right?.concept === 'NewComposite' &&
+        ((assignment as Assignment).right as any)?.typeAnnotation?.typeKind === 'generic'
       ) {
-        const rightNode: any = assignment.right;
+        const rightNode: any = (assignment as Assignment).right;
         code += ' = ';
         code += yield* rightNode.getNewCompositeCode(shiftState(state, code, { inline: true }));
+      } else if (asserts.isCallFunction((assignment as CallFunction))) {
+        const nodeName = node?.name;
+        const keyNode = (assignment as CallFunction).keyOfCollection;
+        const itemNode = (assignment as CallFunction).itemOfCollection;
+        if ((assignment as CallFunction).isDerivableMap && keyNode && itemNode) {
+          code += `: nasl.collection.Map<typeof __key_${nodeName}, typeof __item_${nodeName}>`;
+        } else if ((assignment as CallFunction).isDerivableList && itemNode) {
+          code += `: nasl.collection.List<typeof __item_${nodeName}>;`;
+        }
       } else {
-        const rightNode: any = assignment.right;
+        const rightNode: any = (assignment as Assignment).right;
         // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
         if (rightNode?.typeAnnotation && !(asserts.isCallQueryComponent(rightNode) && !rightNode.isAutoInfer())) {
           code += ': ';
@@ -1975,9 +2027,15 @@ ${indent(state.tabSize)} */\n`;
     return code;
   }
 
-  *getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any) {
+  *getRightCode(code: string, assignment: Assignment | BatchAssignment | CallFunction, rightNode: any) {
     code = code.replaceAll('\n', ' ');
-    if (asserts.isAssignment(assignment) && !assignment.right) return code;
+    // 赋值语句的右侧或者集合内置函数的参数
+    if (
+      (asserts.isAssignment(assignment) && !assignment.right)
+      || (asserts.isCallFunction(assignment) && ((assignment.isDerivableList && !assignment.itemOfCollection) || (assignment.isDerivableMap && !(assignment.keyOfCollection && assignment.itemOfCollection))))
+    ) {
+      return code;
+    }
 
     // 调用接口，参数替换成 null
     if (asserts.isCallInterface(rightNode)) {
@@ -1999,6 +2057,12 @@ ${indent(state.tabSize)} */\n`;
     if (forEachStatement) {
       code = yield* this.handleForEachCode(code, forEachStatement);
     }
+    // 可迭代的集合
+    const callFunction = assignment.getAncestor('CallFunction') as CallFunction;
+    if (callFunction && callFunction.isLoopCollection) {
+      const anonymousFunction = assignment.getAncestor('AnonymousFunction') as AnonymousFunction;
+      code = yield* this.handleCollectionCode(code, anonymousFunction, callFunction);
+    }
     // Match 需要针对分支缩小类型范围
     const matchCase = assignment.getAncestor('MatchCase') as MatchCase;
     if (matchCase) {
@@ -2047,6 +2111,31 @@ ${indent(state.tabSize)} */\n`;
     return code;
   }
 
+  *handleCollectionCode(code: string, anonymousFunction: AnonymousFunction, callFunction: CallFunction): Generator<any, string, any> {
+    const { collection } = callFunction;
+    const self = this;
+    yield* wrapForEach(anonymousFunction.params, function* warpForEachGenerator(param, index) {
+      if (code.includes(param?.name)) {
+        const collectionTSCode = collection ? yield* collection.toEmbeddedTS() : '__IDENTIFIER__';
+        code = self.handleReplaceCode(
+          code,
+          param.name,
+          collectionTSCode === '__IDENTIFIER__' ? collectionTSCode : callFunction.isLoopMap && index === 0 ? `${collectionTSCode}.__getKey(0)` : `${collectionTSCode}.__get(0)`,
+        );
+      }
+    });
+    const parentForEachStatement = callFunction.getAncestor('ForEachStatement') as ForEachStatement;
+    if (parentForEachStatement) {
+      code = yield* this.handleForEachCode(code, parentForEachStatement);
+    }
+    const parentCallFunction = callFunction.getAncestor('CallFunction') as CallFunction;
+    if (parentCallFunction?.isLoopCollection) {
+      const parentAnonymousFunction = callFunction.getAncestor('AnonymousFunction') as AnonymousFunction;
+      code = yield* this.handleCollectionCode(code, parentAnonymousFunction, parentCallFunction);
+    }
+    return code;
+  }
+
   *handleMatchCaseCode(code: string, matchCase: MatchCase): Generator<any, string, any> {
     const match = matchCase.getAncestor('Match') as Match;
     const expressionTsCode = yield* match.expression.toEmbeddedTS();
@@ -2172,9 +2261,8 @@ ${indent(state.tabSize)} */\n`;
     if (asserts.isFrontendLibrary(this.parentNode)) {
       _path += `/frontends/${this.parentNode.type}`;
     } else if (this.parentNode.concept === 'BindEvent' && this.getAncestor('Frontend')) {
-      _path += `/frontendTypes/${this.getAncestor('FrontendType')?.name}/frontends/${
-        this.getAncestor('Frontend')?.name
-      }/bindEvents/${name}.ts`;
+      _path += `/frontendTypes/${this.getAncestor('FrontendType')?.name}/frontends/${this.getAncestor('Frontend')?.name
+        }/bindEvents/${name}.ts`;
     }
     return `/embedded/${this.getAncestor('App')?.name}${_path}/logics/${name}.ts`;
   }

package/src/concepts/MatchCase__.ts

@@ -36,6 +36,13 @@ import TypeAnnotation from './TypeAnnotation__';
 export class MatchCase extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'MatchCase';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -777,7 +784,7 @@ export class MatchCase extends LogicItem {
               }),
             )}`;
 
-            code += ';\n'
+            code += ';\n';
           });
         }
         code += `${indent(state?.tabSize || 0)}}\n`;
@@ -796,7 +803,7 @@ export class MatchCase extends LogicItem {
               }),
             )}`;
 
-            code += ';\n'
+            code += ';\n';
           });
         }
         code += `${indent(state?.tabSize || 0)}}\n`;
@@ -814,7 +821,7 @@ export class MatchCase extends LogicItem {
             }),
           )}`;
 
-          code += ';\n'
+          code += ';\n';
         });
       }
       code += '\n';

package/src/concepts/Match__.ts

@@ -42,6 +42,13 @@ import MatchCase from './MatchCase__';
 export class Match extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'Match';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -118,7 +125,7 @@ export class Match extends LogicItem {
           ...options,
         },
         this,
-        'cases'
+        'cases',
       );
     }
     this.cases.splice(index, 0, matchCase);
@@ -462,7 +469,7 @@ export class Match extends LogicItem {
             new MatchCase({
               patterns: [enumerableItem],
               isMatchedTypeEnumable,
-            })
+            }),
         );
       }
     }

package/src/concepts/MemberExpression__.ts

@@ -47,6 +47,13 @@ import LogicItem from './LogicItem__';
 export class MemberExpression extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'MemberExpression';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/MetadataType__.ts

@@ -36,6 +36,13 @@ import LogicItem from './LogicItem__';
 export class MetadataType extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'MetadataType';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/MicroApp__.ts

@@ -18,6 +18,13 @@ import BaseNode from '../common/BaseNode';
 export class MicroApp extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'MicroApp';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/Module__.ts

@@ -42,6 +42,13 @@ import MetadataType from './MetadataType__';
 export class Module extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'Module';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/MsgTriggerEvent__.ts

@@ -25,6 +25,13 @@ import TriggerEvent from './TriggerEvent__';
 export class MsgTriggerEvent extends TriggerEvent {
   /** 类名 */
   static readonly ConceptName: string = 'MsgTriggerEvent';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['TriggerEvent', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/MsgTriggerLauncher__.ts

@@ -21,6 +21,13 @@ import TriggerLauncher from './TriggerLauncher__';
 export class MsgTriggerLauncher extends TriggerLauncher {
   /** 类名 */
   static readonly ConceptName: string = 'MsgTriggerLauncher';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['TriggerLauncher', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/MultiApprovalPolicy__.ts

@@ -18,6 +18,13 @@ import BaseNode from '../common/BaseNode';
 export abstract class MultiApprovalPolicy extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'MultiApprovalPolicy';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = true;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念