@lcap/nasl 3.7.3-beta.1 → 3.8.0-beta.2

package/src/concepts/ApplyAnnotation__.ts

@@ -0,0 +1,198 @@
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
+
+import * as utils from '../utils';
+import { createUUID } from '../utils/create';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
+import BaseNode from '../common/BaseNode';
+import Argument from './Argument__';
+
+/**
+ * 使用注解
+ */
+@concept('使用注解')
+export class ApplyAnnotation extends BaseNode {
+  /** 类名 */
+  static readonly ConceptName: string = 'ApplyAnnotation';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
+
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!: 'ApplyAnnotation';
+  /**
+   * 注解命名空间
+   */
+  @property()
+  annotationNamespace: string;
+
+  /**
+   * 注解名称
+   */
+  @property()
+  annotationName: string;
+
+  /**
+   * 实际参数
+   */
+  @property({
+    objectRef: 'Argument',
+    isArray: true,
+    defaultValue: [],
+  })
+  arguments: Array<Argument> = [];
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<ApplyAnnotation>) {
+    source = Object.assign({}, ApplyAnnotation.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): ApplyAnnotation {
+    return super.from(source, parentNode, parentKey) as ApplyAnnotation;
+  }
+
+  /**
+   * 插入实际参数
+   * @internal
+   * @param argumentOptions 实际参数参数
+   */
+  _insertArgumentAt(argumentOptions: Partial<Argument>, index: number): Argument;
+
+  /**
+   * 插入实际参数
+   * @internal
+   * @param argument 已有的实际参数实例
+   */
+  _insertArgumentAt(argument: Argument, index: number): Argument;
+
+  _insertArgumentAt(options: Partial<Argument> | Argument, index: number) {
+    const argumentOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'arguments' };
+    const Argument = getConceptConstructor('Argument');
+    let argument: Argument;
+    if (asserts.isArgument(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      argument = options;
+      Object.assign(argument, relationOptions);
+    } else {
+      argument = Argument.from(
+        {
+          ...argumentOptions,
+          ...options,
+        },
+        this,
+        'arguments',
+      );
+    }
+    this.arguments.splice(index, 0, argument);
+    return argument;
+  }
+
+  /**
+   * 插入实际参数
+   * @param argumentOptions 实际参数参数
+   */
+  insertArgumentAt(argumentOptions: Partial<Argument>, index: number): Argument;
+
+  /**
+   * 插入实际参数
+   * @param argument 已有的实际参数实例
+   */
+  insertArgumentAt(argument: Argument, index: number): Argument;
+
+  insertArgumentAt(options: Partial<Argument> | Argument, index: number) {
+    const node = this._insertArgumentAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'arguments',
+    });
+    return node;
+  }
+
+  /**
+   * 添加实际参数
+   * @internal
+   * @param argumentOptions 实际参数参数
+   */
+  _addArgument(argumentOptions: Partial<Argument>): Argument;
+
+  /**
+   * 添加实际参数
+   * @internal
+   * @param argument 已有的实际参数实例
+   */
+  _addArgument(argument: Argument): Argument;
+
+  _addArgument(options?: Partial<Argument> | Argument) {
+    const index = this.arguments.length;
+    return this._insertArgumentAt(options as any, index);
+  }
+
+  /**
+   * 添加实际参数
+   * @param argumentOptions 实际参数参数
+   */
+  addArgument(argumentOptions: Partial<Argument>): Argument;
+
+  /**
+   * 添加实际参数
+   * @param argument 已有的实际参数实例
+   */
+  addArgument(argument: Argument): Argument;
+
+  addArgument(options?: Partial<Argument> | Argument) {
+    const node = this._addArgument(options as any);
+    const index = this.arguments.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'arguments',
+    });
+    return node;
+  }
+
+  /**
+   * 删除实际参数
+   * @param argument 已有的实际参数实例
+   */
+  removeArgument(argument: Argument): void;
+
+  removeArgument(options: Argument) {
+    let argument: Argument = options;
+    return argument.delete();
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default ApplyAnnotation;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/concepts/Argument__.ts

@@ -14,6 +14,10 @@ import type TypeAnnotation from './TypeAnnotation__';
 import type NewList from './NewList__';
 import type DefaultValue from './DefaultValue__';
 import type CallFunction from './CallFunction__';
+import type SubLogic from './SubLogic__';
+import type Logic from './Logic__';
+
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -27,7 +31,6 @@ import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 
 import LogicItem from './LogicItem__';
-
 /**
  * 实际参数
  */
@@ -256,6 +259,147 @@ export class Argument extends LogicItem {
   // 参数是否必填
   paramRequired?: boolean = undefined;
 
+  /**
+   * 设置 子逻辑
+   */
+  createSubLogic(source: Partial<SubLogic>): SubLogic {
+    const SubLogicCreator = getConceptConstructor('SubLogic');
+    const subLogic = SubLogicCreator.from(source);
+    this.setExpression(subLogic);
+    return subLogic;
+  }
+
+  /**
+   * 重制Expression 为 空的Identifier
+   */
+  resetExpression() {
+    const Identifier = getConceptConstructor('Identifier');
+    this.setExpression(Identifier.from({}));
+  }
+
+  static getFormatType(baseType: TypeAnnotation, __TypeArguments: TypeAnnotation[], completeTypesName: string[]): Partial<TypeAnnotation> {
+    // 是否为真实为 类型: 有命名空间和类型名
+    const isRealType = baseType.typeNamespace && baseType.typeName;
+    let formatType: Partial<TypeAnnotation> = baseType;
+    if (!isRealType) {
+      // 如果不是真实类型，那么就是泛型，需要 先通过 __TypeArguments 获取具体的下标位置
+      // 再通过 completeTypesName 获取具体的类型
+      // 如果具体类型也为 范型，则默认赋值为String类型
+      const typeIndex = completeTypesName?.indexOf(baseType.typeName);
+      const realType = __TypeArguments?.[typeIndex];
+      const isRealArgumentType = realType?.typeNamespace && realType?.typeName;
+      if (realType && isRealArgumentType) {
+        formatType = realType;
+      } else {
+        formatType = {
+          typeName: 'String',
+          typeNamespace: 'nasl.core',
+          typeKind: "primitive",
+          concept: 'TypeAnnotation',
+        } as Partial<TypeAnnotation>;
+      }
+    }
+    return formatType;
+  }
+
+
+  /**
+   * 通过签名创建 SubLogic
+   */
+  fromSubLogicBySignature(typeAnnotation: TypeAnnotation): SubLogic {
+    if (!asserts.isTypeAnnotation(typeAnnotation)) return;
+    const parentLogic = this.getAncestor('Logic');
+    const callLogic = this.getAncestor('CallLogic');
+    if (!asserts.isCallLogic(callLogic)) return;
+
+    const { __TypeArguments } = callLogic;
+    const calleeNode = callLogic.getCallNode();
+
+    if (!asserts.isLogic(calleeNode)) return;
+    const { completeTypeParams } = calleeNode;
+    const completeTypesName = completeTypeParams?.map?.((type) => type.name) || [];
+
+    const Param = getConceptConstructor('Param');
+    const TypeAnnotation = getConceptConstructor('TypeAnnotation');
+    const Return = getConceptConstructor('Return');
+
+    // 获取类型签名中的 入参签名，并初始化 Params
+    const paramTypes = (typeAnnotation?.typeArguments || []).map(
+      (item, index) => {
+        const formatType = Argument.getFormatType(item, __TypeArguments, completeTypesName);
+        return Param.from({
+          typeAnnotation: TypeAnnotation.from(formatType?.toJSON?.() || formatType),
+          name: `param${index + 1}`
+        })
+      }
+    )
+    // 获取类型签名中的 出参签名，并初始化 Returns
+    const returnTypes = (typeAnnotation?.returnType || []).map(
+      (item) => {
+        const formatType = Argument.getFormatType(item, __TypeArguments, completeTypesName);
+        return Return.from({
+          typeAnnotation: TypeAnnotation.from(formatType?.toJSON?.() || formatType),
+          name: `result`
+        })
+      }
+    )
+
+    if (!asserts.isLogic(parentLogic)) return;
+    const uniqueName = parentLogic.getSubLogicUniqueName();
+    return this.createSubLogic({
+      name: uniqueName,
+      params: paramTypes,
+      returns: returnTypes
+    });
+  }
+
+  /**
+   * 通过签名创建 具名全局逻辑
+   */
+  fromNamedGlobalLogicBySignature(typeAnnotation: TypeAnnotation, logicName: string): Logic {
+    if (!asserts.isTypeAnnotation(typeAnnotation)) return;
+    const callLogic = this.getAncestor('CallLogic');
+    if (!asserts.isCallLogic(callLogic)) return;
+
+    const { __TypeArguments } = callLogic;
+    const calleeNode = callLogic.getCallNode();
+
+    if (!asserts.isLogic(calleeNode)) return;
+    const { completeTypeParams } = calleeNode;
+    const completeTypesName = completeTypeParams?.map?.((type) => type.name) || [];
+
+    const Param = getConceptConstructor('Param');
+    const TypeAnnotation = getConceptConstructor('TypeAnnotation');
+    const Return = getConceptConstructor('Return');
+
+    // 获取类型签名中的 入参签名，并初始化 Params
+    const paramTypes = (typeAnnotation?.typeArguments || []).map(
+      (item, index) => {
+        const formatType = Argument.getFormatType(item, __TypeArguments, completeTypesName);
+        return Param.from({
+          typeAnnotation: TypeAnnotation.from(formatType?.toJSON?.() || formatType),
+          name: `param${index + 1}`
+        })
+      }
+    )
+    // 获取类型签名中的 出参签名，并初始化 Returns
+    const returnTypes = (typeAnnotation?.returnType || []).map(
+      (item) => {
+        const formatType = Argument.getFormatType(item, __TypeArguments, completeTypesName);
+        return Return.from({
+          typeAnnotation: TypeAnnotation.from(formatType?.toJSON?.() || formatType),
+          name: `result`
+        })
+      }
+    )
+
+    return this.rootNode.addLogic({
+      name: logicName,
+      params: paramTypes,
+      returns: returnTypes
+    });
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓