@lcap/nasl 2.16.1 → 2.17.1

package/src/concepts/TypeAnnotation__.ts

@@ -1,4 +1,8 @@
+import App from './App__';
+import Structure from './Structure__';
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
+import { genHash } from '../generator';
+import { firstUpperCase } from '../utils/string';
 
 export enum PRIMITIVE_TYPE {
     Boolean = 'Boolean',
@@ -12,7 +16,8 @@ export enum PRIMITIVE_TYPE {
     Date = 'Date',
     Time = 'Time',
     DateTime = 'DateTime',
-    Email = 'Email'
+    Email = 'Email',
+    Union = 'Union'
 }
 
 export const PRIMITIVE_TITLE: Record<string, string> = {
@@ -28,8 +33,21 @@ export const PRIMITIVE_TITLE: Record<string, string> = {
     Time: '时间',
     DateTime: '日期时间',
     Email: '电子邮箱',
+    Union: '联合类型',
 };
 
+/**
+ * 判断是否是联合类型
+ * @param typeAnnotation
+ * @returns
+ */
+export function isUnion(typeAnnotation: TypeAnnotation): boolean {
+    return typeAnnotation
+        && typeAnnotation.typeKind === 'union'
+        && typeAnnotation.typeNamespace === 'nasl.core'
+        && typeAnnotation.typeName === 'Union';
+}
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -41,7 +59,7 @@ import * as utils from '../utils';
 import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
-
+import StructureProperty from './StructureProperty__';
 
 /**
  * 类型标注
@@ -58,7 +76,7 @@ export class TypeAnnotation extends BaseNode {
      * 类型种类
      */
     @property()
-    typeKind: 'primitive' | 'reference' | 'generic' | 'typeParam' = undefined;
+    typeKind: 'primitive' | 'reference' | 'generic' | 'typeParam' | 'function' | 'union' | 'anonymousStructure' = undefined;
 
     /**
      * 类型命名空间
@@ -78,20 +96,30 @@ export class TypeAnnotation extends BaseNode {
     @property('TypeAnnotation')
     typeArguments?: Array<TypeAnnotation> = null;
 
+    /**
+     * 返回类型
+     */
+    @property('TypeAnnotation')
+    returnType?: Array<TypeAnnotation> = null;
+
     /**
      * 是否是推断出来的
      */
     @property()
     inferred?: boolean = undefined;
 
+    /**
+     * 匿名数据结构属性
+     */
+    @property('StructureProperty')
+    properties?: Array<StructureProperty> = null;
+
     /**
      * 规则对象
      */
     @property()
     ruleMap: Object = undefined;
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -128,25 +156,21 @@ export class TypeAnnotation extends BaseNode {
         });
     }
 
-    
-
-    
-
     /**
     * 插入类型标注
     * @internal
     * @param typeAnnotationOptions 类型标注参数
     */
-    _insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+    _insertTypeAnnotationInTypeArgumentsAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
 
     /**
     * 插入类型标注
     * @internal
     * @param typeAnnotation 已有的类型标注实例
     */
-    _insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+    _insertTypeAnnotationInTypeArgumentsAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
 
-    _insertTypeAnnotationAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
+    _insertTypeAnnotationInTypeArgumentsAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
         const typeAnnotationOptions: any = {};
         const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
         let typeAnnotation: TypeAnnotation;
@@ -164,22 +188,20 @@ export class TypeAnnotation extends BaseNode {
         return typeAnnotation;
     }
 
-    
-
     /**
      * 插入类型标注
      * @param typeAnnotationOptions 类型标注参数
      */
-    insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+    insertTypeAnnotationInTypeArgumentsAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
 
     /**
      * 插入类型标注
      * @param typeAnnotation 已有的类型标注实例
      */
-    insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+    insertTypeAnnotationInTypeArgumentsAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
 
-    insertTypeAnnotationAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
-        const node = this._insertTypeAnnotationAt(options as any, index);
+    insertTypeAnnotationInTypeArgumentsAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
+        const node = this._insertTypeAnnotationInTypeArgumentsAt(options as any, index);
         node.create({
             index,
             parentNode: this,
@@ -188,43 +210,39 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-    
-
     /**
      * 添加类型标注
      * @internal
      * @param typeAnnotationOptions 类型标注参数
      */
-    _addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+    _addTypeAnnotationInTypeArguments(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
 
     /**
      * 添加类型标注
      * @internal
      * @param typeAnnotation 已有的类型标注实例
      */
-    _addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
+    _addTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): TypeAnnotation;
 
-    _addTypeAnnotation(options?: Partial<TypeAnnotation> | TypeAnnotation) {
+    _addTypeAnnotationInTypeArguments(options?: Partial<TypeAnnotation> | TypeAnnotation) {
         const index = this.typeArguments.length;
-        return this._insertTypeAnnotationAt(options as any, index);
+        return this._insertTypeAnnotationInTypeArgumentsAt(options as any, index);
     }
 
-    
-
     /**
      * 添加类型标注
      * @param typeAnnotationOptions 类型标注参数
      */
-    addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+    addTypeAnnotationInTypeArguments(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
 
     /**
      * 添加类型标注
      * @param typeAnnotation 已有的类型标注实例
      */
-    addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
+    addTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): TypeAnnotation;
 
-    addTypeAnnotation(options?: Partial<TypeAnnotation> | TypeAnnotation) {
-        const node = this._addTypeAnnotation(options as any);
+    addTypeAnnotationInTypeArguments(options?: Partial<TypeAnnotation> | TypeAnnotation) {
+        const node = this._addTypeAnnotationInTypeArguments(options as any);
         const index = this.typeArguments.indexOf(node);
         node.create({
             index,
@@ -234,17 +252,217 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
+    /**
+    * 插入类型标注
+    * @internal
+    * @param typeAnnotationOptions 类型标注参数
+    */
+    _insertTypeAnnotationInReturnTypeAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+
+    /**
+    * 插入类型标注
+    * @internal
+    * @param typeAnnotation 已有的类型标注实例
+    */
+    _insertTypeAnnotationInReturnTypeAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+
+    _insertTypeAnnotationInReturnTypeAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
+        const typeAnnotationOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'returnType' };
+        let typeAnnotation: TypeAnnotation;
+        if (options instanceof TypeAnnotation) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            typeAnnotation = options;
+            Object.assign(typeAnnotation, relationOptions);
+        } else {
+            typeAnnotation = TypeAnnotation.from({
+                ...typeAnnotationOptions,
+                ...options,
+            }, this, 'returnType');
+        }
+        this.returnType.splice(index, 0, typeAnnotation);
+        return typeAnnotation;
+    }
+
+    /**
+     * 插入类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    insertTypeAnnotationInReturnTypeAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+
+    /**
+     * 插入类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    insertTypeAnnotationInReturnTypeAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+
+    insertTypeAnnotationInReturnTypeAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
+        const node = this._insertTypeAnnotationInReturnTypeAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'returnType',
+        });
+        return node;
+    }
+
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    _addTypeAnnotationInReturnType(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
 
-    
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    _addTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): TypeAnnotation;
+
+    _addTypeAnnotationInReturnType(options?: Partial<TypeAnnotation> | TypeAnnotation) {
+        const index = this.returnType.length;
+        return this._insertTypeAnnotationInReturnTypeAt(options as any, index);
+    }
+
+    /**
+     * 添加类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    addTypeAnnotationInReturnType(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+
+    /**
+     * 添加类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    addTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): TypeAnnotation;
+
+    addTypeAnnotationInReturnType(options?: Partial<TypeAnnotation> | TypeAnnotation) {
+        const node = this._addTypeAnnotationInReturnType(options as any);
+        const index = this.returnType.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'returnType',
+        });
+        return node;
+    }
+
+    /**
+    * 插入数据结构属性
+    * @internal
+    * @param structurePropertyOptions 数据结构属性参数
+    */
+    _insertStructurePropertyAt(structurePropertyOptions: Partial<StructureProperty>, index: number): StructureProperty;
+
+    /**
+    * 插入数据结构属性
+    * @internal
+    * @param structureProperty 已有的数据结构属性实例
+    */
+    _insertStructurePropertyAt(structureProperty: StructureProperty, index: number): StructureProperty;
+
+    _insertStructurePropertyAt(options: Partial<StructureProperty> | StructureProperty, index: number) {
+        const structurePropertyOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'properties' };
+        let structureProperty: StructureProperty;
+        if (options instanceof StructureProperty) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            structureProperty = options;
+            Object.assign(structureProperty, relationOptions);
+        } else {
+            structureProperty = StructureProperty.from({
+                ...structurePropertyOptions,
+                ...options,
+            }, this, 'properties');
+        }
+        this.properties.splice(index, 0, structureProperty);
+        return structureProperty;
+    }
+
+    /**
+     * 插入数据结构属性
+     * @param structurePropertyOptions 数据结构属性参数
+     */
+    insertStructurePropertyAt(structurePropertyOptions: Partial<StructureProperty>, index: number): StructureProperty;
+
+    /**
+     * 插入数据结构属性
+     * @param structureProperty 已有的数据结构属性实例
+     */
+    insertStructurePropertyAt(structureProperty: StructureProperty, index: number): StructureProperty;
+
+    insertStructurePropertyAt(options: Partial<StructureProperty> | StructureProperty, index: number) {
+        const node = this._insertStructurePropertyAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'properties',
+        });
+        return node;
+    }
+
+    /**
+     * 添加数据结构属性
+     * @internal
+     * @param structurePropertyOptions 数据结构属性参数
+     */
+    _addStructureProperty(structurePropertyOptions: Partial<StructureProperty>): StructureProperty;
+
+    /**
+     * 添加数据结构属性
+     * @internal
+     * @param structureProperty 已有的数据结构属性实例
+     */
+    _addStructureProperty(structureProperty: StructureProperty): StructureProperty;
+
+    _addStructureProperty(options?: Partial<StructureProperty> | StructureProperty) {
+        const index = this.properties.length;
+        return this._insertStructurePropertyAt(options as any, index);
+    }
+
+    /**
+     * 添加数据结构属性
+     * @param structurePropertyOptions 数据结构属性参数
+     */
+    addStructureProperty(structurePropertyOptions: Partial<StructureProperty>): StructureProperty;
+
+    /**
+     * 添加数据结构属性
+     * @param structureProperty 已有的数据结构属性实例
+     */
+    addStructureProperty(structureProperty: StructureProperty): StructureProperty;
+
+    addStructureProperty(options?: Partial<StructureProperty> | StructureProperty) {
+        const node = this._addStructureProperty(options as any);
+        const index = this.properties.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'properties',
+        });
+        return node;
+    }
 
     /**
      * 删除类型标注
      * @param typeAnnotation 已有的类型标注实例
      */
-    removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
+    removeTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): void;
 
-    removeTypeAnnotation(options: TypeAnnotation) {
-        let typeAnnotation: TypeAnnotation = options;
+    removeTypeAnnotationInTypeArguments(options: TypeAnnotation) {
+        const typeAnnotation: TypeAnnotation = options;
+        return typeAnnotation.delete();
+    }
+
+    /**
+     * 删除类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    removeTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): void;
+
+    removeTypeAnnotationInReturnType(options: TypeAnnotation) {
+        const typeAnnotation: TypeAnnotation = options;
         return typeAnnotation.delete();
     }
 
@@ -271,6 +489,40 @@ export class TypeAnnotation extends BaseNode {
         return params;
     }
 
+    /**
+     * 删除数据结构属性
+     * @param structureProperty 已有的数据结构属性实例
+     */
+    removeStructureProperty(structureProperty: StructureProperty): void;
+
+    removeStructureProperty(options: StructureProperty) {
+        const structureProperty: StructureProperty = options;
+        return structureProperty.delete();
+    }
+
+    __removeStructureProperty(structureProperty: StructureProperty) {
+        const parentKey = structureProperty.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: structureProperty,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(structureProperty);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === structureProperty) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
     //================================================================================
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
@@ -281,6 +533,11 @@ export class TypeAnnotation extends BaseNode {
             return `${this.typeNamespace}.${this.typeName}`;
         } else if (this.typeKind === 'generic') {
             return `${this.typeNamespace}.${this.typeName}<${(this.typeArguments || []).map((arg) => arg.typeKey)}>`;
+        } else if (this.typeKind === 'anonymousStructure') {
+            return `{ ${this.properties.map(({ name, typeAnnotation }) =>
+                (`${name}: ${typeAnnotation.typeKey}`)).join(', ')} }`;
+        } else if (this.typeKind === 'union') {
+            return `${this.typeArguments.map((arg) => arg.typeKey).join(' | ')}`;
         } else {
             return this.typeName;
         }
@@ -310,6 +567,8 @@ export class TypeAnnotation extends BaseNode {
                 return `${this.typeName}<${(this.typeArguments || []).map((arg) => arg.headTitle || arg.name || 'T').join(', ')}>`;
             else
                 return this.typeName;
+        } else if (this.typeKind === 'union') {
+            return `${this.typeArguments.map((arg) => arg.typeTitle || arg.name).join(' | ')}`;
         } else {
             return this.typeName;
         }
@@ -325,6 +584,11 @@ export class TypeAnnotation extends BaseNode {
             return this.typeName;
         } else if (this.typeKind === 'generic') {
             return `${this.typeName}<${this.typeArguments.map((arg) => arg.typeTitle || arg.name || 'T').join(', ')}>`;
+        } else if (this.typeKind === 'anonymousStructure') {
+            return `{ ${this.properties.map(({ name, typeAnnotation }) =>
+                (`${name}: ${typeAnnotation.typeTitle}`)).join(', ')} }`;
+        } else if (this.typeKind === 'union') {
+            return `${this.typeArguments.map((arg) => arg.typeTitle || arg.name).join(' | ')}`;
         } else {
             return this.typeName;
         }
@@ -333,7 +597,7 @@ export class TypeAnnotation extends BaseNode {
     static createPrimitive(typeName: string, source?: Partial<TypeAnnotation>) {
         if ((PRIMITIVE_TYPE as any)[typeName]) {
             return this.from(Object.assign({
-                typeKind: 'primitive',
+                typeKind: typeName === 'Union' ? 'union' : 'primitive',
                 typeName,
                 typeNamespace: 'nasl.core',
             }, source));
@@ -363,8 +627,14 @@ export class TypeAnnotation extends BaseNode {
         }, source));
     }
 
+    static createTypeAnonymousStructure(properties: Array<StructureProperty>, source?: Partial<TypeAnnotation>) {
+        return this.from(Object.assign({
+            typeKind: 'anonymousStructure',
+            properties,
+        }, source));
+    }
     /**
-     * 设置类型字段名称
+     * 设置类型属性名称
      */
     setTypeName(typeName: string) {
         const object = {
@@ -376,7 +646,7 @@ export class TypeAnnotation extends BaseNode {
     }
 
     /**
-     * 设置类型字段名称
+     * 设置类型属性名称
      */
     setTypeNamespace(typeNamespace: string) {
         const object = {
@@ -410,7 +680,29 @@ export class TypeAnnotation extends BaseNode {
             return `${this.tsCalleeNamespace}.${this.typeName}`;
         } else if (this.typeKind === 'generic') {
             let code = `${this.tsCalleeNamespace}.${this.typeName}<`;
-            return (code += `${(this.typeArguments || []).map((arg) => arg.toEmbeddedTS(shiftState(state, code, { inline: true })))}>`);
+            (this.typeArguments || []).forEach((arg, index) => {
+                code += arg.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                if (index !== this.typeArguments.length - 1)
+                    code += ', ';
+            });
+            code += '>';
+            return code;
+        } else if (this.typeKind === 'union') {
+            let code = '';
+            this.typeArguments.forEach((arg, index) => {
+                code += arg.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                if (index !== this.typeArguments.length - 1)
+                    code += ' | ';
+            });
+            return code;
+        } else if (this.typeKind === 'anonymousStructure') {
+            let code = `{ __name: "AStructure_${this.hash}", `;
+            (this.properties || []).forEach((property, i) => {
+                code += `${property.name}: `;
+                code += `${property.typeAnnotation.toEmbeddedTS(shiftState(state, code, { inline: true, tabSize: (state?.tabSize || 0) + 1 }))}`;
+                code += i < this.properties?.length - 1 ? ', ' : ' }';
+            });
+            return code;
         } else {
             if (this.tsCalleeNamespace && this.typeName) {
                 return `${this.tsCalleeNamespace}.${this.typeName}`;
@@ -422,6 +714,31 @@ export class TypeAnnotation extends BaseNode {
         }
     }
 
+    /**
+     * 用于标准化数据结构，便于计算 anonymousStructure 的 __name
+     */
+    get anonymousStructureTypeDesc(): string {
+        if (this.typeKind === 'generic') {
+            return `${this.typeName}<${this.typeArguments.map((arg) => arg.anonymousStructureTypeDesc || arg.name || 'T').join(', ')}>`;
+        } else if (this.typeKind === 'anonymousStructure') {
+            return `{ ${[...this.properties].sort(({ name: aName }, { name: bName }) => {
+                if (aName > bName)
+                    return 1;
+                return aName < bName ? -1 : 0;
+            }).map(({ name, typeAnnotation }) =>
+                (`${name}: ${typeAnnotation.anonymousStructureTypeDesc}`)).join(', ')} }`;
+        } else {
+            return this.typeName;
+        }
+    }
+
+    /**
+     * hash 用于比较 anonymousStructure 是否相同
+     */
+    get hash(): string {
+        return genHash(this.anonymousStructureTypeDesc);
+    }
+
     getDefaultValue(value: string) {
         let code = '';
         if (this.typeKind === 'primitive') {
@@ -482,6 +799,15 @@ export class TypeAnnotation extends BaseNode {
             return this.createPrimitive('Integer');
         }
     }
+    // 增加插入泛型子类型
+    typeArgumentsPush(typeItem: TypeAnnotation) {
+        if (typeItem instanceof TypeAnnotation) {
+            this.typeArguments.push(TypeAnnotation.from(typeItem, {
+                parentNode: this,
+                parentKey: 'typeArguments',
+            }));
+        }
+    }
 
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！

package/src/concepts/UnaryExpression__.ts

@@ -145,6 +145,7 @@ export class UnaryExpression extends LogicItem {
         if (this.operator === 'isNull') {
             return this.argument?.toJS(state);
         } else {
+            //return 'this.$global.isNot(' + this.argument?.toJS(state) + ')';
             return '!(' + this.argument?.toJS(state) + ')';
         }
     }

package/src/concepts/ValidationRule__.ts

@@ -320,6 +320,7 @@ export class ValidationRule extends LogicItem {
             calleeNamespace,
             calleeName,
             arguments: params,
+            folded: false,
         });
     }
     //================================================================================