@lcap/nasl 3.1.0-beta.2 → 3.1.0-beta.4

package/src/concepts/CallInterface__.ts

@@ -8,6 +8,7 @@ import InterfaceParam from './InterfaceParam__';
 import Structure from './Structure__';
 import Module from './Module__';
 import AuthInterface from './AuthInterface__';
+import Frontend from './Frontend__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -234,7 +235,7 @@ export class CallInterface extends LogicItem {
 
     /**
      * 标识当前删除是否为鉴权方式更新导致的删除。
-     * 针对此种删除，删除逻辑已经处理，需要再此走 deleteCallNode 逻辑
+     * 针对此种删除，删除逻辑已经处理，无需再走 deleteCallNode 逻辑
      */
     @property('Boolean')
     __authDelete: Boolean = false;
@@ -248,7 +249,14 @@ export class CallInterface extends LogicItem {
                 const oldItf: Interface = this.getCallNode();
                 if (oldItf) {
                     let refCount = 0;
-                    const refs = await oldItf.findUsage();
+                    const refs = await oldItf.findUsage() as Map<any, any>;
+
+                    const isOnlyUsedByFronted = refs.size === 1 && Array.from(refs.keys()).filter(key => key instanceof Frontend).length > 0;
+                    const isAuthInterface = oldItf instanceof AuthInterface;
+                    // 当仅仅只有前端使用，且该接口是鉴权接口时需要将接口还原为普通接口
+                    if (isOnlyUsedByFronted && isAuthInterface) {
+                        this.replaceToInterface(oldItf);
+                    }
                     refs.forEach((val: any) => {
                         const loopFindNode = (item: any) => {
                             if (item.children) {
@@ -274,6 +282,23 @@ export class CallInterface extends LogicItem {
         }
     }
 
+    replaceToInterface(oldItf: AuthInterface) {
+        this.app.emit('collect:start', { actionMsg: '调用接口恢复为非鉴权' });
+        const {
+            name, originLogicName, path, method, description, params, returns,
+            protocol, protocolParams,
+        } = oldItf;
+        const newInterface =  new Interface({
+            name, originLogicName, path, method, description, params, returns,
+            protocol, protocolParams,
+        });
+        const m = oldItf.parentNode as Module;
+        const interfaceIndex = m?.interfaces?.findIndex?.((item) => item.name === oldItf.name);
+        oldItf.delete();
+        m.insertInterfaceAt(newInterface, interfaceIndex);
+        this.app.emit('collect:end');
+    }
+
     get tsCalleeNamespace() {
         if (this.calleeNamespace) {
             let tsCalleeNamespace = this.calleeNamespace;
@@ -309,10 +334,9 @@ export class CallInterface extends LogicItem {
     }
 
     toJS(state?: TranslatorState): string {
-        const _arr = this.calleewholeKey.split('.');
-        const _name = _arr[1];
-        const _interfaceName = _arr[3];
-        const _module = this.app?.interfaceDependencies?.find?.((item) => item.name === _name);
+        const { calleewholeKey, app, completeArguments } = this;
+        const [, _name, , _interfaceName] = calleewholeKey.split('.');
+        const _module = app?.interfaceDependencies?.find?.((item) => item.name === _name);
         const _interface = _module?.interfaces?.find?.((item) => item.name === _interfaceName);
         if (!_interface) {
             if (!this.calleeNamespace || !this.calleeName)
@@ -332,55 +356,51 @@ export class CallInterface extends LogicItem {
                 return item.name;
             });
         const _paths = _params.filter((item) => item.in === 'path').map((item) => item.name);
-        const completeArguments = this.completeArguments;
-        let code = `await this.$services['_custom']['${this.calleeNamespace}.${this.calleeName}']`;
-        code += `({
-            config: {
-                download: false,
-            },
-            query: {`;
-        completeArguments
-            .filter((arg) => _queries.includes(arg?.keyword))
-            .forEach((arg, index) => {
-                code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
-                if (index !== completeArguments.length - 1)
-                    code += ', ';
-            });
-        code += `},
-            path: {`;
-        completeArguments
-            .filter((arg) => _paths.includes(arg?.keyword))
-            .forEach((arg, index) => {
-                code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
-                if (index !== completeArguments.length - 1)
-                    code += ', ';
-            });
-        code += `},
-            headers: {`;
-        completeArguments
-            .filter((arg) => _headers.includes(arg?.keyword))
-            .forEach((arg, index) => {
-                code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
-                if (index !== completeArguments.length - 1)
+
+        /** 填充参数信息 */
+        const setArgumentCode = (args: Argument[], keys: string[], code: string, useKeyWord: boolean, useRest: boolean) => {
+            const filledArgs = args
+                // 维持原样，暂时不过滤没有填入值的参数
+                // .filter((arg) => Boolean(arg?.expression))
+                .filter((arg) => keys.includes(arg.keyword));
+
+            filledArgs.forEach((arg, index) => {
+                if (useRest) {
+                    code += ` ...${arg?.toJS(shiftState(state, code))}`;
+                } else if (useKeyWord) {
+                    code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
+                } else {
+                    code += ` ${arg?.toJS(shiftState(state, code))}`;
+                }
+
+                if (index !== args.length - 1) {
                     code += ', ';
+                }
             });
+
+            if (filledArgs.length === 0 && !useKeyWord && !useRest) {
+                code += 'undefined';
+            }
+
+            return code;
+        };
+
+        let code = `await this.$services['_custom']['${this.calleeNamespace}.${this.calleeName}']`;
+
+        code += `({ config: {\ndownload: false,\n },\nquery: {`;
+        code = setArgumentCode(completeArguments, _queries, code, true, false);
+        code += `}, path: {`;
+        code = setArgumentCode(completeArguments, _paths, code, true, false);
+        code += `}, headers: {`;
+        code = setArgumentCode(completeArguments, _headers, code, true, false);
         code += `},\n`;
+
         if (isSimpleBody) {
             code += `body: `;
-            completeArguments
-                .filter((arg) => _body.includes(arg?.keyword))
-                .forEach((arg, index) => {
-                    code += ` ${arg?.toJS(shiftState(state, code))}`;
-                });
+            code = setArgumentCode(completeArguments, _body, code, false, false);
         } else {
             code += `body: {`;
-            completeArguments
-                .filter((arg) => _body.includes(arg?.keyword))
-                .forEach((arg, index) => {
-                    code += ` ...${arg?.toJS(shiftState(state, code))}`;
-                    if (index !== completeArguments.length - 1)
-                        code += ', ';
-                });
+            code = setArgumentCode(completeArguments, _body, code, false, true);
             code += '}';
         }
 
@@ -395,9 +415,10 @@ export class CallInterface extends LogicItem {
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = this.tsCalleeKey;
-        const completeArguments = this.completeArguments;
-        code += '(';
+        const { completeArguments, parentNode, parentKey, tsCalleeKey } = this;
+
+        let code = `${tsCalleeKey}(`;
+
         if (completeArguments?.length) {
             code += '{';
             completeArguments?.forEach((arg, index) => {
@@ -408,18 +429,18 @@ export class CallInterface extends LogicItem {
             code += '}';
         }
         code += ')';
-        if (this.parentNode.concept !== 'Argument'
-            && this.parentKey !== 'test'
-            && this.parentKey !== 'patterns'
-            && this.parentNode.concept !== 'Assignment'
-            && this.parentNode.concept !== 'ForEachStatement'
-            && this.parentNode.concept !== 'SelectMembers'
-            && this.parentNode.concept !== 'UnaryExpression'
-            && this.parentNode.concept !== 'BinaryExpression'
-            && this.parentNode.concept !== 'MemberExpression'
-            && this.parentNode.concept !== 'StringInterpolation'
-            && !['NewMap', 'NewList'].includes(this.parentNode.concept)
-            && this.parentKey !== 'returnExpression') {
+        if (parentNode.concept !== 'Argument'
+            && parentKey !== 'test'
+            && parentKey !== 'patterns'
+            && parentKey !== 'returnExpression'
+            && parentNode.concept !== 'Assignment'
+            && parentNode.concept !== 'ForEachStatement'
+            && parentNode.concept !== 'SelectMembers'
+            && parentNode.concept !== 'UnaryExpression'
+            && parentNode.concept !== 'BinaryExpression'
+            && parentNode.concept !== 'MemberExpression'
+            && parentNode.concept !== 'StringInterpolation'
+            && !['NewMap', 'NewList'].includes(parentNode.concept)) {
             code += ';';
         }
         code += '\n';

package/src/concepts/CallLogic__.ts

@@ -8,6 +8,7 @@ import { findConceptKeyWordIndexFromNamespace } from '../utils';
 import * as JSON5 from 'json5';
 import { config } from '../config';
 import Identifier from './Identifier__';
+import type { TSPPosition } from '../translator/tsp';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -765,41 +766,34 @@ export class CallLogic extends LogicItem {
         code += 'await (';
         let refName = '';
         let extensionName = '';
-        const calleeNamespace = this.calleeNamespace;
-        const keywordProcessIndex = findConceptKeyWordIndexFromNamespace(this.calleeNamespace, 'processes');
+
+        const {
+            calleeName,
+            calleeNamespace,
+            isComponentLogic,
+            completeArguments,
+            isViewLogic,
+            typeArguments,
+        } = this;
+
+        const keywordProcessIndex = findConceptKeyWordIndexFromNamespace(calleeNamespace, 'processes');
         const isProcessLogic = keywordProcessIndex !== -1;
         const isFrontendLibrary = calleeNamespace.startsWith('extensions') && calleeNamespace.indexOf('frontends');
         // calleeNamespace不存在，一定是页面逻辑
         if (calleeNamespace) {
             const namespaceArr = calleeNamespace.split('.');
-            if (this.isComponentLogic) {
+            if (isComponentLogic) {
                 const componentName = namespaceArr[1];
                 const viewElement = this.view?.findElementByName(componentName);
                 refName = viewElement?.refName ?? componentName;
-                console.log(componentName);
-                console.log(refName);
             }
             if (isFrontendLibrary) {
                 extensionName = namespaceArr[1];
             }
         }
-        const completeArguments = this.completeArguments;
-        // 服务端逻辑
-        if (!this.isViewLogic) {
-            const logic = getNodeByNodeCallee(this.app, this.calleewholeKey, (key: string, tempPoint: any) => {
-                // 处理 NASL 中未定义的假的节点
-                if (key === tempPoint.name) {
-                    return {
-                        tempPoint,
-                        state: 1,
-                    };
-                }
-                const t = tempPoint[key];
-                return {
-                    tempPoint: t,
-                    state: Array.isArray(t) ? 2 : 1,
-                };
-            });
+        // 全局逻辑
+        if (!isViewLogic) {
+            const logic = this.getCallNode();
             const args = logic?.params || [];
             const keywordEntitiesIndex = findConceptKeyWordIndexFromNamespace(this.calleeNamespace, 'entities');
             code += `this.$logics['${this.calleeNamespace ? `${this.calleeNamespace}.${this.calleeName}` : this.calleeName}']`;
@@ -810,13 +804,14 @@ export class CallLogic extends LogicItem {
                 query: {`;
             if (isProcessLogic) {
                 const argsStr = args
-                    .map((arg: any, index: number) => {
+                    .map((arg, index) => {
                         const actualArg = completeArguments[index];
                         return {
                             keyword: arg?.name,
                             arg: actualArg,
                         };
                     })
+                    .filter((item) => Boolean(item.arg.expression))
                     .map((obj: any) => `\n${obj?.keyword}: ${obj?.arg?.toJS(shiftState(state, code))}`)
                     .join(', ');
                 code += argsStr;
@@ -830,13 +825,13 @@ export class CallLogic extends LogicItem {
             if (keywordEntitiesIndex !== -1) {
                 let logicArgs = this.arguments;
                 let breakBody = false;
-                switch (this.calleeName) {
+                switch (calleeName) {
                     case 'get':
                     case 'delete': {
                         logicArgs = [];
                         code += `query: {`;
                         const argsStr = args
-                            .map((arg: any, index: number) => {
+                            .map((arg, index) => {
                                 const actualArg = this.arguments?.[index];
                                 return {
                                     keyword: arg?.name,
@@ -854,8 +849,8 @@ export class CallLogic extends LogicItem {
                     case 'batchUpdate': {
                         code += `body: {\n`;
                         const argsStr = logicArgs
-                            .filter((arg: any) => arg.expression)
-                            .map((arg: any) => {
+                            .filter((arg) => arg.expression)
+                            .map((arg) => {
                                 const name = arg.keyword === 'body' ? (this.calleeName === 'batchUpdate' ? 'entities' : 'entity') : arg.keyword;
                                 return `${name}: ${arg.expression.toJS(shiftState(state, code))}`;
                             })
@@ -869,7 +864,7 @@ export class CallLogic extends LogicItem {
                     case 'updateBy': {
                         code += `body: {`;
                         const argsStr = logicArgs
-                            .filter((arg: any) => arg.expression)
+                            .filter((arg) => arg.expression)
                             .map((arg: any) => {
                                 const name = arg.keyword === 'body' ? 'entity' : arg.keyword;
                                 // filter回调函数
@@ -918,17 +913,18 @@ export class CallLogic extends LogicItem {
                 body: {`;
                 if (!isProcessLogic) {
                     const argsStr = args
-                        .map((arg: any, index: number) => {
+                        .map((arg, index) => {
                             const actualArg = completeArguments[index];
                             return {
                                 keyword: arg?.name,
                                 arg: actualArg,
                             };
                         })
-                        .map((obj: any) => `\n${obj?.keyword}: ${obj?.arg?.toJS(shiftState(state, code))}`)
+                        .filter((item) => Boolean(item.arg.expression))
+                        .map((obj) => `\n${obj?.keyword}: ${obj?.arg?.toJS(shiftState(state, code))}`)
                         .join(', ');
                     code += argsStr;
-                    if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
+                    if (Array.isArray(typeArguments) && typeArguments.length) {
                         code += `,\n__typeArguments: ${JSON5.stringify(this.typeArguments)}`;
                     }
                 }
@@ -936,7 +932,7 @@ export class CallLogic extends LogicItem {
             }
             code += '\n})';
         } else {
-            if (this.isComponentLogic) {
+            if (isComponentLogic) {
                 // 组件ref元素的对象没有qu dao的容错
                 code += `this.$refs && this.$refs[\`${refName}\`] && this.$refs[\`${refName}\`].${this.calleeName} && this.$refs[\`${refName}\`].${this.calleeName}`;
             } else if (calleeNamespace === 'nasl.ui' || calleeNamespace === 'nasl.util') {
@@ -1069,6 +1065,22 @@ export class CallLogic extends LogicItem {
         return this.arguments.map((a) => a.toBrief()).join('<br />');
     }
 
+    get useValidation() {
+        const {
+            validation,
+            rootNode,
+        } = this;
+
+        return (
+            rootNode?.preferenceMap.serverValidationRules === 'custom' &&
+            Boolean(validation)
+        );
+    }
+
+    get useIife() {
+        return Boolean(this.handleError || this.useValidation);
+    }
+
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = '';
@@ -1083,14 +1095,11 @@ export class CallLogic extends LogicItem {
             completeArguments,
             parentNode,
             validation,
-            rootNode,
+            useIife,
+            useValidation,
             arguments: logicArgs,
         } = this;
 
-        const useValidation = (
-            rootNode.preferenceMap.serverValidationRules === 'custom' &&
-            Boolean(validation)
-        );
         /** 设置函数范型参数 */
         const setTypeArguments = () => {
             if (Array.isArray(typeArguments) && typeArguments.length) {
@@ -1135,7 +1144,7 @@ export class CallLogic extends LogicItem {
 
         /** 设置表达式末尾分号 */
         const setEndSemi = () => {
-            const { concept: parentConcept } = parentNode;
+            const { concept: parentConcept } = parentNode ?? {};
             if (
                 !['test', 'patterns','returnExpression'].includes(parentKey) &&
                 ![
@@ -1155,9 +1164,6 @@ export class CallLogic extends LogicItem {
             }
         };
 
-        /** 使用立即执行函数包裹 */
-        const useIife = Boolean(handleError || useValidation);
-
         if (useIife) {
             code += '(() =>{\nconst wrapper = ';
 
@@ -1199,7 +1205,7 @@ export class CallLogic extends LogicItem {
     }
 
     // 通过内容过去节点
-    getCallNode() {
+    getCallNode(): Logic | undefined {
         let node;
         // 如果是页面局部逻辑
         if (!this.calleeNamespace && this.calleeName && this.view) {
@@ -1229,6 +1235,23 @@ export class CallLogic extends LogicItem {
         return node;
     }
 
+    /** 获取类型标注时的偏移量 */
+    getQuickInfoOffset(detail: TSPPosition, code: string): TSPPosition {
+        if (!this.useIife) {
+            return { ...detail };
+        }
+
+        const characterOffset = 8;
+        const lines = code.split('\n');
+        // @ts-ignore
+        const lineOffset = lines.findLastIndex((item) => item.startsWith('return wrapper'));
+
+        return {
+            line: detail.line + lineOffset,
+            offset: characterOffset,
+        };
+    }
+
     /**
      * 是否允许验证规则
      *  - 当前元素在前端，但是调用的函数在后端
@@ -1241,34 +1264,33 @@ export class CallLogic extends LogicItem {
     // 可以设置默认值的节点
     // 目前只开放了app下的，所以这些节点，查找引用吧默认值塞回来
     get completeArguments() {
-        const node = this.getCallNode();
-        let logicParam: Param[] = [];
-        const Arguments: Argument[] = [];
-        if (node?.params) {
-            logicParam = node.params;
-        }
-        if (this.arguments?.length) {
-            this.arguments.forEach((arg, index) => {
-                const param = logicParam[index] || ({} as any);
-                // 打开了必填，
-                // 或者遗留问题，没有required = undefined 而且没有defaultValue，就是之前的必填项
-                arg.paramRequired = Boolean(param.required || (param.required === undefined && !param.defaultValue));
-                arg.paramTypeAnnotation = undefined;
-                arg.paramDefaultValue = undefined;
-                arg.keyword = param.name ?? arg.keyword;
-                // 取到是不是必填放入参数中
-                if (param && !arg.expression) {
-                    // 非必填时 才会有默认值
-                    arg.paramTypeAnnotation = param.typeAnnotation;
-                    arg.paramDefaultValue = param.defaultValue;
-                }
-                Arguments.push(arg);
-            });
-        }
-        return Arguments;
+        const callArguments = (this.arguments ?? []).slice();
+        // 没有参数时可以跳过查询原逻辑标签
+        const node = callArguments.length > 0 ? this.getCallNode() : undefined;
+        const logicParams = node?.params ?? [];
+
+        callArguments.forEach((arg, index) => {
+            const param = logicParams[index] || ({} as Param);
+            // 打开了必填，
+            // 或者遗留问题，没有required = undefined 而且没有defaultValue，就是之前的必填项
+            arg.paramRequired = Boolean(param.required || (param.required === undefined && !param.defaultValue));
+            arg.paramTypeAnnotation = undefined;
+            arg.paramDefaultValue = undefined;
+            // 强制更新当前的 keyword
+            arg.keyword = (param?.name && param.name.length > 0) ? param.name : arg.keyword;
+            // 取到是不是必填放入参数中
+            if (param && !arg.expression) {
+                // 非必填时 才会有默认值
+                arg.paramTypeAnnotation = param.typeAnnotation;
+                arg.paramDefaultValue = param.defaultValue;
+            }
+        });
+
+        return callArguments;
     }
 
     static isSystem(node: CallLogic) {
+        // 如此处需要更新，则需同时更新 menu-poppup 组件下的 includesSystemLogic 校验逻辑
         return ['nasl.process', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.io'].includes(node?.calleeNamespace);
     }
 

package/src/concepts/CompletionProperty__.ts

@@ -234,8 +234,13 @@ export class CompletionProperty extends BaseNode {
         const completeNameArr = this.completeName.split('.');
         let name = completeNameArr[0];
         // 公共变量， 全局变量情况下
-        if (completeNameArr[0] === 'app' || completeNameArr[0] === 'nasl')
+        if (completeNameArr[0] === 'app' && completeNameArr[1] === 'backend') {
+            name = `${completeNameArr[0]}.${completeNameArr[1]}.${completeNameArr[2]}.${completeNameArr[3]}`;
+        } else if (completeNameArr[0] === 'app' && completeNameArr[1] === 'frontends') {
+            name = `${completeNameArr[0]}.${completeNameArr[1]}.${completeNameArr[2]}.${completeNameArr[3]}.${completeNameArr[4]}`;
+        } else if (completeNameArr[0] === 'nasl') {
             name = `${completeNameArr[0]}.${completeNameArr[1]}.${completeNameArr[2]}`;
+        }
         if (that.concept === 'EnumItem')
             name = name.split('[')[0];
         return name;

package/src/concepts/ConfigPropertyValue__.ts

@@ -92,9 +92,9 @@ export class ConfigPropertyValue extends BaseNode {
         });
     }
 
-    
 
-    
+
+
 
     //================================================================================
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/Function__.ts

@@ -981,8 +981,8 @@ export class Function extends BaseNode {
         }
         code += ')';
         let resultCode = '';
-        // 代优化，只有需要转换的函数才加async
-        if (grandParent?.view && asyncFuncMap[grandParent?.calleeName] && code.indexOf('await') != -1) {
+        const ancestorLogic = this.getAncestor('Logic');
+        if (grandParent?.view && ancestorLogic && asyncFuncMap[grandParent?.calleeName] && code.indexOf('await') != -1) {
             resultCode += 'async (' + code;
         } else {
            resultCode = '(' + code;

package/src/concepts/QueryJoinExpression__.ts

@@ -1,4 +1,5 @@
 import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
+import CallQueryComponent from './CallQueryComponent__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -409,6 +410,18 @@ export class QueryJoinExpression extends LogicItem {
         return `${this.entityNamespace}.${this.entityName}`;
     }
 
+    setEntityNameAndEffect(entityName: string) {
+        this.setEntityName(entityName);
+        this.effect();
+    }
+    effect() {
+        // 处理选中的此实体的 CallQueryComponent（只限 CallQueryComponent.ideVersion 2.11 版本）
+        const callQueryComponent = this.getAncestor('CallQueryComponent') as CallQueryComponent;
+        if (callQueryComponent?.ideVersion === '2.11') {
+            callQueryComponent.saveStructure();
+        }
+    }
+
     /**
      * 设置实体namespace属性
      */

package/src/concepts/TypeAnnotation__.ts

@@ -1072,6 +1072,37 @@ export class TypeAnnotation extends BaseNode {
         return JSON.stringify(typeAnnotation1) === JSON.stringify(typeAnnotation2);
     }
 
+    // 是否包含平台类型
+    hasSystemType() {
+        const disableTypeNamespaces = ['nasl.ui', 'nasl.auth', 'nasl.http', 'nasl.process']
+        const traverseChild = (item: TypeAnnotation, cb: (arg: TypeAnnotation) => (boolean | void)): boolean => {
+            const res = cb(item);
+            if (res === false) return true
+            if (item && item.concept === 'TypeAnnotation') {
+                if (item.typeKind === 'anonymousStructure') {
+                    return item.properties.some(prop => traverseChild(prop.typeAnnotation, cb))
+                } else if (item.typeArguments && ['generic', 'union'].includes(item.typeKind)) {
+                    return item.typeArguments.some((arg) => traverseChild(arg, cb));
+                }
+            }
+        }
+        let result = false
+        traverseChild(this, (node: TypeAnnotation) => {
+            if (node.typeNamespace?.endsWith('.structures')) {
+                const structure = this.rootNode.findNodeByCompleteName(node.typeNamespace + '.' + node.typeName)
+                const res = !structure.properties.some((prop: StructureProperty) => prop.typeAnnotation.hasSystemType())
+                if (res === false) {
+                    result = true
+                }
+                return res
+            } else if (disableTypeNamespaces.includes(node.typeNamespace)) {
+                result = true
+                return false
+            }
+        })
+        return result
+    }
+
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓