@lcap/nasl 3.5.0-alpha.1 → 3.5.0-beta.2

package/src/concepts/utils/asserts.ts

@@ -1,6 +1,7 @@
 import type { App } from '../App__';
 import type { Module } from '../Module__';
 import type { Namespace } from '../Namespace__';
+import type { FrontendType } from '../FrontendType__';
 import type { Frontend } from '../Frontend__';
 import type { Backend } from '../Backend__';
 import type { Integration } from '../Integration__';
@@ -24,6 +25,7 @@ import type { BindDirective } from '../BindDirective__';
 import type { BindEvent } from '../BindEvent__';
 import type { BindStyle } from '../BindStyle__';
 import type { ViewComponent } from '../ViewComponent__';
+import type { BusinessComponent } from '../BusinessComponent__';
 import type { Attribute } from '../Attribute__';
 import type { Event } from '../Event__';
 import type { Slot } from '../Slot__';
@@ -31,10 +33,12 @@ import type { Theme } from '../Theme__';
 import type { StaticString } from '../StaticString__';
 import type { Logic } from '../Logic__';
 import type { AuthLogic } from '../AuthLogic__';
+import type { BusinessLogic } from '../BusinessLogic__';
 import type { AuthLogicForCallInterface } from '../AuthLogicForCallInterface__';
 import type { OverriddenLogic } from '../OverriddenLogic__';
 import type { AbstractInterface } from '../AbstractInterface__';
 import type { Param } from '../Param__';
+import type { ParamWithGroup } from '../ParamWithGroup__';
 import type { Return } from '../Return__';
 import type { Variable } from '../Variable__';
 import type { BackendVariable } from '../BackendVariable__';
@@ -60,6 +64,7 @@ import type { Assignment } from '../Assignment__';
 import type { BatchAssignment } from '../BatchAssignment__';
 import type { Comment } from '../Comment__';
 import type { CallLogic } from '../CallLogic__';
+import type { CallEvent } from '../CallEvent__';
 import type { CallFunction } from '../CallFunction__';
 import type { CallInterface } from '../CallInterface__';
 import type { Destination } from '../Destination__';
@@ -213,6 +218,21 @@ export function isStrictNamespace(node: unknown): node is Namespace {
   return isBaseNode(node) && node.concept === 'Namespace';
 }
 
+/**
+ * 严格判断输入为 FrontendType 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictFrontendType(node)) {
+ *   // 在这个花括号内，node 的类型为 FrontendType
+ * }
+ * ```
+ */
+export function isStrictFrontendType(node: unknown): node is FrontendType {
+  return isBaseNode(node) && node.concept === 'FrontendType';
+}
+
 /**
  * 严格判断输入为 Frontend 节点
  *
@@ -558,6 +578,21 @@ export function isStrictViewComponent(node: unknown): node is ViewComponent {
   return isBaseNode(node) && node.concept === 'ViewComponent';
 }
 
+/**
+ * 严格判断输入为 BusinessComponent 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictBusinessComponent(node)) {
+ *   // 在这个花括号内，node 的类型为 BusinessComponent
+ * }
+ * ```
+ */
+export function isStrictBusinessComponent(node: unknown): node is BusinessComponent {
+  return isBaseNode(node) && node.concept === 'BusinessComponent';
+}
+
 /**
  * 严格判断输入为 Attribute 节点
  *
@@ -663,6 +698,21 @@ export function isStrictAuthLogic(node: unknown): node is AuthLogic {
   return isBaseNode(node) && node.concept === 'AuthLogic';
 }
 
+/**
+ * 严格判断输入为 BusinessLogic 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictBusinessLogic(node)) {
+ *   // 在这个花括号内，node 的类型为 BusinessLogic
+ * }
+ * ```
+ */
+export function isStrictBusinessLogic(node: unknown): node is BusinessLogic {
+  return isBaseNode(node) && node.concept === 'BusinessLogic';
+}
+
 /**
  * 严格判断输入为 AuthLogicForCallInterface 节点
  *
@@ -708,6 +758,21 @@ export function isStrictParam(node: unknown): node is Param {
   return isBaseNode(node) && node.concept === 'Param';
 }
 
+/**
+ * 严格判断输入为 ParamWithGroup 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictParamWithGroup(node)) {
+ *   // 在这个花括号内，node 的类型为 ParamWithGroup
+ * }
+ * ```
+ */
+export function isStrictParamWithGroup(node: unknown): node is ParamWithGroup {
+  return isBaseNode(node) && node.concept === 'ParamWithGroup';
+}
+
 /**
  * 严格判断输入为 Return 节点
  *
@@ -1053,6 +1118,21 @@ export function isStrictCallLogic(node: unknown): node is CallLogic {
   return isBaseNode(node) && node.concept === 'CallLogic';
 }
 
+/**
+ * 严格判断输入为 CallEvent 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictCallEvent(node)) {
+ *   // 在这个花括号内，node 的类型为 CallEvent
+ * }
+ * ```
+ */
+export function isStrictCallEvent(node: unknown): node is CallEvent {
+  return isBaseNode(node) && node.concept === 'CallEvent';
+}
+
 /**
  * 严格判断输入为 CallFunction 节点
  *
@@ -2171,6 +2251,27 @@ export function isNamespace(node: unknown): node is Namespace {
   );
 }
 
+/**
+ * 判断输入为 FrontendType 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，FrontendType 节点没有继承类，此判断等价于`isStrictFrontendType`
+ * @example
+ * ```ts
+ * if (isFrontendType(node)) {
+ *   // 在这个花括号内，node 的类型是 FrontendType 或者 FrontendType 继承类型
+ * }
+ * ```
+ */
+export function isFrontendType(node: unknown): node is FrontendType {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'FrontendType'
+    )
+  );
+}
+
 /**
  * 判断输入为 Frontend 节点实例
  *
@@ -2654,6 +2755,27 @@ export function isViewComponent(node: unknown): node is ViewComponent {
   );
 }
 
+/**
+ * 判断输入为 BusinessComponent 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，BusinessComponent 节点没有继承类，此判断等价于`isStrictBusinessComponent`
+ * @example
+ * ```ts
+ * if (isBusinessComponent(node)) {
+ *   // 在这个花括号内，node 的类型是 BusinessComponent 或者 BusinessComponent 继承类型
+ * }
+ * ```
+ */
+export function isBusinessComponent(node: unknown): node is BusinessComponent {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'BusinessComponent'
+    )
+  );
+}
+
 /**
  * 判断输入为 Attribute 节点实例
  *
@@ -2777,6 +2899,7 @@ export function isLogic(node: unknown): node is Type.LogicNode {
     (
       node.concept === 'Logic' ||
       node.concept === 'AuthLogic' ||
+      node.concept === 'BusinessLogic' ||
       node.concept === 'AuthLogicForCallInterface'
     )
   );
@@ -2804,6 +2927,27 @@ export function isAuthLogic(node: unknown): node is Type.AuthLogicNode {
   );
 }
 
+/**
+ * 判断输入为 BusinessLogic 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，BusinessLogic 节点没有继承类，此判断等价于`isStrictBusinessLogic`
+ * @example
+ * ```ts
+ * if (isBusinessLogic(node)) {
+ *   // 在这个花括号内，node 的类型是 BusinessLogic 或者 BusinessLogic 继承类型
+ * }
+ * ```
+ */
+export function isBusinessLogic(node: unknown): node is BusinessLogic {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'BusinessLogic'
+    )
+  );
+}
+
 /**
  * 判断输入为 AuthLogicForCallInterface 节点实例
  *
@@ -2874,7 +3018,7 @@ export function isAbstractInterface(node: unknown): node is Type.AbstractInterfa
  * 判断输入为 Param 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Param 节点没有继承类，此判断等价于`isStrictParam`
+ * @description 等价于`instanceof`运算
  * @example
  * ```ts
  * if (isParam(node)) {
@@ -2882,11 +3026,33 @@ export function isAbstractInterface(node: unknown): node is Type.AbstractInterfa
  * }
  * ```
  */
-export function isParam(node: unknown): node is Param {
+export function isParam(node: unknown): node is Type.ParamNode {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'Param'
+      node.concept === 'Param' ||
+      node.concept === 'ParamWithGroup'
+    )
+  );
+}
+
+/**
+ * 判断输入为 ParamWithGroup 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ParamWithGroup 节点没有继承类，此判断等价于`isStrictParamWithGroup`
+ * @example
+ * ```ts
+ * if (isParamWithGroup(node)) {
+ *   // 在这个花括号内，node 的类型是 ParamWithGroup 或者 ParamWithGroup 继承类型
+ * }
+ * ```
+ */
+export function isParamWithGroup(node: unknown): node is ParamWithGroup {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'ParamWithGroup'
     )
   );
 }
@@ -3027,6 +3193,7 @@ export function isLogicItem(node: unknown): node is Type.LogicItemNode {
       node.concept === 'BatchAssignment' ||
       node.concept === 'Comment' ||
       node.concept === 'CallLogic' ||
+      node.concept === 'CallEvent' ||
       node.concept === 'CallFunction' ||
       node.concept === 'CallInterface' ||
       node.concept === 'Destination' ||
@@ -3476,6 +3643,27 @@ export function isCallLogic(node: unknown): node is Type.CallLogicNode {
   );
 }
 
+/**
+ * 判断输入为 CallEvent 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，CallEvent 节点没有继承类，此判断等价于`isStrictCallEvent`
+ * @example
+ * ```ts
+ * if (isCallEvent(node)) {
+ *   // 在这个花括号内，node 的类型是 CallEvent 或者 CallEvent 继承类型
+ * }
+ * ```
+ */
+export function isCallEvent(node: unknown): node is CallEvent {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'CallEvent'
+    )
+  );
+}
+
 /**
  * 判断输入为 CallFunction 节点实例
  *
@@ -5006,6 +5194,23 @@ export function assertStrictNamespace(node: unknown): asserts node is Namespace
   }
 }
 
+/**
+ * 严格断言为 FrontendType 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictFrontendType(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FrontendType 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictFrontendType(node: unknown): asserts node is FrontendType {
+  if (!isStrictFrontendType(node)) {
+    throw new Error(`FrontendType 节点严格断言失败`);
+  }
+}
+
 /**
  * 严格断言为 Frontend 节点
  *
@@ -5397,6 +5602,23 @@ export function assertStrictViewComponent(node: unknown): asserts node is ViewCo
   }
 }
 
+/**
+ * 严格断言为 BusinessComponent 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictBusinessComponent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessComponent 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictBusinessComponent(node: unknown): asserts node is BusinessComponent {
+  if (!isStrictBusinessComponent(node)) {
+    throw new Error(`BusinessComponent 节点严格断言失败`);
+  }
+}
+
 /**
  * 严格断言为 Attribute 节点
  *
@@ -5516,6 +5738,23 @@ export function assertStrictAuthLogic(node: unknown): asserts node is AuthLogic
   }
 }
 
+/**
+ * 严格断言为 BusinessLogic 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictBusinessLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictBusinessLogic(node: unknown): asserts node is BusinessLogic {
+  if (!isStrictBusinessLogic(node)) {
+    throw new Error(`BusinessLogic 节点严格断言失败`);
+  }
+}
+
 /**
  * 严格断言为 AuthLogicForCallInterface 节点
  *
@@ -5567,6 +5806,23 @@ export function assertStrictParam(node: unknown): asserts node is Param {
   }
 }
 
+/**
+ * 严格断言为 ParamWithGroup 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictParamWithGroup(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ParamWithGroup 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictParamWithGroup(node: unknown): asserts node is ParamWithGroup {
+  if (!isStrictParamWithGroup(node)) {
+    throw new Error(`ParamWithGroup 节点严格断言失败`);
+  }
+}
+
 /**
  * 严格断言为 Return 节点
  *
@@ -5958,6 +6214,23 @@ export function assertStrictCallLogic(node: unknown): asserts node is CallLogic
   }
 }
 
+/**
+ * 严格断言为 CallEvent 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictCallEvent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallEvent 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictCallEvent(node: unknown): asserts node is CallEvent {
+  if (!isStrictCallEvent(node)) {
+    throw new Error(`CallEvent 节点严格断言失败`);
+  }
+}
+
 /**
  * 严格断言为 CallFunction 节点
  *
@@ -7206,6 +7479,24 @@ export function assertNamespace(node: unknown): asserts node is Namespace {
   }
 }
 
+/**
+ * 断言为 FrontendType 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictFrontendType`方法
+ * @example
+ * ```ts
+ * assertFrontendType(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FrontendType 或者 FrontendType 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertFrontendType(node: unknown): asserts node is FrontendType {
+  if (!isFrontendType(node)) {
+    throw new Error(`FrontendType 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 Frontend 节点
  *
@@ -7620,6 +7911,24 @@ export function assertViewComponent(node: unknown): asserts node is ViewComponen
   }
 }
 
+/**
+ * 断言为 BusinessComponent 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictBusinessComponent`方法
+ * @example
+ * ```ts
+ * assertBusinessComponent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessComponent 或者 BusinessComponent 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertBusinessComponent(node: unknown): asserts node is BusinessComponent {
+  if (!isBusinessComponent(node)) {
+    throw new Error(`BusinessComponent 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 Attribute 节点
  *
@@ -7746,6 +8055,24 @@ export function assertAuthLogic(node: unknown): asserts node is Type.AuthLogicNo
   }
 }
 
+/**
+ * 断言为 BusinessLogic 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictBusinessLogic`方法
+ * @example
+ * ```ts
+ * assertBusinessLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 或者 BusinessLogic 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertBusinessLogic(node: unknown): asserts node is BusinessLogic {
+  if (!isBusinessLogic(node)) {
+    throw new Error(`BusinessLogic 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 AuthLogicForCallInterface 节点
  *
@@ -7812,12 +8139,30 @@ export function assertAbstractInterface(node: unknown): asserts node is Type.Abs
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertParam(node: unknown): asserts node is Param {
+export function assertParam(node: unknown): asserts node is Type.ParamNode {
   if (!isParam(node)) {
     throw new Error(`Param 节点断言失败`);
   }
 }
 
+/**
+ * 断言为 ParamWithGroup 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictParamWithGroup`方法
+ * @example
+ * ```ts
+ * assertParamWithGroup(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ParamWithGroup 或者 ParamWithGroup 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertParamWithGroup(node: unknown): asserts node is ParamWithGroup {
+  if (!isParamWithGroup(node)) {
+    throw new Error(`ParamWithGroup 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 Return 节点
  *
@@ -8268,6 +8613,24 @@ export function assertCallLogic(node: unknown): asserts node is Type.CallLogicNo
   }
 }
 
+/**
+ * 断言为 CallEvent 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictCallEvent`方法
+ * @example
+ * ```ts
+ * assertCallEvent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallEvent 或者 CallEvent 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertCallEvent(node: unknown): asserts node is CallEvent {
+  if (!isCallEvent(node)) {
+    throw new Error(`CallEvent 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 CallFunction 节点
  *

package/src/concepts/utils/quick-info.ts

@@ -0,0 +1,64 @@
+import { Range } from '../../translator';
+
+export { Range } from '../../translator';
+
+/** 获取当前代码 */
+export type GetCode = () => string;
+
+export interface QuickInfoData {
+  /** 行 */
+  line: number;
+  /** 列 */
+  offset: number;
+}
+
+export type GetQuickInfoOffset = (range: Range, getCode: GetCode) => QuickInfoData;
+
+export function getCallExpressionQuickInfo(range: Range, getCode: GetCode) {
+  const code = getCode();
+  const data: QuickInfoData = {
+    line: range.start.line + 1,
+    offset: range.start.character + 1,
+  };
+
+  // 如果没有括号 ，括号就在外面，就 -1
+  // 有括号就找到括号的位置 然后 -1
+  let indexOf = 0;
+  if (!code.includes('(')) {
+    indexOf = -1;
+  }
+  // 如果有泛型先往前找一找
+  else {
+    if (code.includes('<')) {
+      indexOf = Math.min(code.indexOf('<'), code.indexOf('('));
+    } else {
+      indexOf = code.indexOf('(');
+    }
+    const subStr = code.substring(0, indexOf);
+    const codeArr = subStr?.split('.');
+    const lastLen = codeArr?.[codeArr.length - 1]?.length;
+    indexOf = subStr.length - lastLen;
+  }
+  data.offset += indexOf;
+  return data;
+}
+
+export function getNewCompositeQuickInfo(concept: 'NewComposite' | 'NewList' | 'NewMap', range: Range, getCode: GetCode): QuickInfoData {
+  const type = {
+    'NewComposite': '__newComposite',
+    'NewList': '__newList',
+    'NewMap': '__newMap',
+  }[concept];
+  const code = getCode();
+  const data: QuickInfoData = {
+    line: range.end.line,
+    offset: range.end.character,
+  };
+
+  const indexOf = code.lastIndexOf(`return ${type}`);
+  let newCode = code.substring(0, indexOf);
+  newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
+  data.offset = newCode.length + 'return '.length;
+
+  return data;
+}