@lcap/nasl 2.18.0 → 2.19.0-beta.2

package/src/server/formatTsUtils.ts

@@ -247,13 +247,9 @@ function findNode(typeKey: string, node: BaseNode) {
  * 获取下一级的节点进行递归
  * @param typeKey 当前节点的类型，主要为了取出内部的 T中的实际类型
  * @param item 当前节点的内容
- * @param parent 父级节点的内容
  * @param node 获取变量框的位置
  */
-export function nextFindTypeChild(typeKey: string, item: any, parent: any, node: BaseNode) {
-    // 有一个当前树分支的全部节点的node map，用作防止数据无限递归，只保留3层
-    const nodeMap = parent ? parent.nodeMap : new Map();
-    item.nodeMap = nodeMap;
+export function nextFindTypeChild(typeKey: string, item: any, node: BaseNode) {
     const newType = findNode(typeKey, node);
     if ((newType as Structure)?.properties && (newType as Structure).properties.length) {
         // 处理泛型的内容要取到值
@@ -274,16 +270,7 @@ export function nextFindTypeChild(typeKey: string, item: any, parent: any, node:
                 });
             }
         });
-        const index = nodeMap.get(newType) || 0;
-        if (index) {
-            nodeMap.set(newType, index + 1);
-        } else {
-            nodeMap.set(newType, 1);
-        }
-        // 最多保留3层
-        if (index < 3) {
-            item.children = formatVariableData(newStructure.properties, node, item);
-        }
+        item.children = formatVariableData(newStructure.properties, node, item);
     }
 }
 
@@ -359,7 +346,7 @@ function getAStructureScopeType(type: string, parent: any, node: BaseNode) {
                     newItem.concept = 'CompletionProperty';
                     // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
                     if (item.typeKey && !isNoChildType(item.typeKey)) {
-                        newItem.children = nextObjectTypeChild(item.typeKey, newItem, parentItem, node);
+                        newItem.children = nextObjectTypeChild(item.typeKey, newItem, node);
                     }
                     const completionProperty = new CompletionProperty(newItem);
                     completionProperty.icon = 'refProperty';
@@ -395,9 +382,6 @@ function getAStructureScopeType(type: string, parent: any, node: BaseNode) {
 function getAStructureObjectStringType(type: string, parent: any, node: BaseNode) {
     let newType = type.replaceAll(' ', '').replaceAll('\n', '').replace(/__name:"AStructure_\w{8}";/g, '');
     newType = newType.substring(1, newType.length - 1);
-    if (!parent.keyMap) {
-        parent.keyMap = new Map();
-    }
     if (/\{([^()]+)\}/.exec(newType)) {
         newType = newType.replace(/\{([^()]+)\}/, '');
     }
@@ -437,7 +421,7 @@ function getAStructureObjectStringType(type: string, parent: any, node: BaseNode
         newItem.concept = 'CompletionProperty';
         // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
         if (item.typeKey && !isNoChildType(item.typeKey)) {
-            newItem.children = nextObjectTypeChild(getPlatformType(item.typeKey), newItem, parentItem, node);
+            newItem.children = nextObjectTypeChild(getPlatformType(item.typeKey), newItem, node);
         }
         const completionProperty = new CompletionProperty(newItem);
 
@@ -451,13 +435,7 @@ function getAStructureObjectStringType(type: string, parent: any, node: BaseNode
     completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
     return completionProperty;
 }
-function nextObjectTypeChild(typeKey: string, item: any, parent: any, node: BaseNode) {
-    // 有一个当前树分支的全部节点的node map，用作防止数据无限递归，只保留3层
-    const nodeMap = parent.nodeMap || new Map();
-    item.nodeMap = nodeMap; // 有一个当前树分支的全部节点的node map，用作防止数据无限递归，只保留3层
-
-    const keyMap = parent.keyMap;
-    item.keyMap = keyMap;
+function nextObjectTypeChild(typeKey: string, item: any, node: BaseNode) {
     const newType = findNode(typeKey, node);
     if ((newType as Structure)?.properties && (newType as Structure).properties.length) {
         // 处理泛型的内容要取到值
@@ -478,16 +456,7 @@ function nextObjectTypeChild(typeKey: string, item: any, parent: any, node: Base
                 });
             }
         });
-        const index = nodeMap.get(newType) || 0;
-        if (index) {
-            nodeMap.set(newType, index + 1);
-        } else {
-            nodeMap.set(newType, 1);
-        }
-        // 最多保留3层
-        if (index < 3) {
-            return formatVariableData(newStructure.properties, node, item);
-        }
+        return formatVariableData(newStructure.properties, node, item);
     }
 }
 
@@ -533,21 +502,42 @@ export function formatVariableData(data: unknown | variableItem[], node: BaseNod
                 item.name = item.text;
                 const identifier = new Identifier({ name: item.name });
                 item.expression = identifier;
+                item.typeKey = typeKey;
             } else {
                 item.value = `${parent.value}.${item.name}`;
+                const object: any = BaseNode.from(parent.expression.toJSON());
                 const memberExpression = new MemberExpression({
-                    object: parent.expression,
+                    object,
                     property: new Identifier({ name: item.name }),
                 });
                 item.expression = memberExpression;
+                item.variableParent = parent;
+                item.typeKey = typeKey;
+                // 标记实体属性是否是符合类型
+                item.isComplexType = item.typeAnnotation?.isComplexType();
             }
             // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
             if (typeKey && !isNoChildType(typeKey)) {
-                nextFindTypeChild(typeKey, item, parent, node);
+                let currentParent = item;
+                let typeKeyIndex = 0;
+                while (currentParent.variableParent) {
+                    currentParent = currentParent.variableParent;
+                    if (currentParent.typeKey === typeKey) {
+                        typeKeyIndex++;
+                    }
+                }
+                // 向上找到3次一样的就结束
+                if (typeKeyIndex < 3) {
+                    nextFindTypeChild(typeKey, item, node);
+                }
             }
             // 如果是从实体或者数据结构取的属性，就需要重置一下类型
             item.concept = 'CompletionProperty';
             const completionProperty = new CompletionProperty(item);
+            // 标记实体属性是否是符合类型
+            if (typeof item.isComplexType === 'boolean') {
+                Object.assign(completionProperty, { isComplexType: item.isComplexType });
+            }
             if (!parent) {
                 // 变量 param return 在这里添加图标
                 completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
@@ -633,20 +623,20 @@ function sortFirstVariableData(result: CompletionProperty[], node: BaseNode) {
 }
 
 export function formatFrontEndVariables(frontEndVariables: Array<Variable>) {
-    const result = frontEndVariables.map((item) => {
-        const namespace = item.getNamespace();
+    const result = frontEndVariables.map((itemNode) => {
+        const namespace = itemNode.getNamespace();
         const newItem: any = {
-            name: item.name,
-            value: item.name,
+            name: itemNode.name,
+            value: itemNode.name,
             expression: new Identifier({
-                name: item.name,
+                name: itemNode.name,
                 namespace,
             }),
         };
-        const noChildType = isNoChildType(item.typeAnnotation.typeKey);
+        const noChildType = isNoChildType(itemNode.typeAnnotation.typeKey);
 
         if (!noChildType) {
-            nextFindTypeChild(item.typeAnnotation.typeKey, newItem, null, item);
+            nextFindTypeChild(itemNode.typeAnnotation.typeKey, newItem, itemNode);
         }
         const completionProperty = new CompletionProperty(newItem);
         completionProperty.icon = 'frontendVariable';

package/src/server/getLogics.ts

@@ -1,3 +1,4 @@
+import { Identifier } from './../concepts/Identifier__';
 import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process, ViewElement, stdlibNamespace, EnumItem } from '..';
 import { process2LogicNamespace } from './process2LogicNamespace';
 import { moduleToLogicNamesapce } from './getExtensionModules';
@@ -56,7 +57,7 @@ function iterator(tree: FakeNode | FakeProcessNode, searchContent: string, fakeN
 function toHump(name: string): string {
     return name.replace(/\-(\w)/g, (all, letter) => letter.toUpperCase());
 }
-export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boolean = true) {
+export async function getLogics(node: CallLogic | BindEvent| Identifier, needAllLogic: boolean = true) {
     const app = node.rootNode as App;
     if (node.concept === 'CallLogic' || node.concept === 'BindEvent') {
         const result = [];
@@ -264,6 +265,17 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
             result.push(systemTree);
         }
         return result;
+    } else if (node.concept === 'Identifier') {
+        const extensions = app.dependencies.map(moduleToLogicNamesapce).filter((item) => item.logics && item.logics.length);
+        const tree = new Namespace({
+            name: 'category`',
+            path: `${app.getNamespace()}.logics`,
+            title: '全局逻辑',
+            logics: app.logics,
+            children: [...extensions],
+        });
+
+        return [tree];
     }
 }
 

package/src/server/getMemberIdentifier.ts

@@ -191,7 +191,7 @@ export async function getMemberIdentifier(node: BaseNode) {
 
         // 这个可能需要自己算一下
         const result = [
-            { name: '字面量', children: literals, expanded: true, icon: 'category' },
+            { name: '常量', children: literals, expanded: true, icon: 'category' },
             { name: '枚举', children: newEnums, expanded: false, icon: 'category' },
             { name: '变量', children: completionData, expanded: true, icon: 'category' },
             { name: '公共变量', children: globalVariable, expanded: false, icon: 'category' },

package/src/server/getProcesses.ts

@@ -283,7 +283,7 @@ export function genCompletionProperty(prefix: string[] = []):(v: Variable | Para
         };
 
         if (!noChildType) {
-            nextFindTypeChild(v.typeAnnotation.typeKey, item, null, v);
+            nextFindTypeChild(v.typeAnnotation.typeKey, item, v);
         }
 
         const cp = new CompletionProperty(item);

package/src/server/naslServer.ts

@@ -202,7 +202,34 @@ export class NaslServer {
             // 收集到一个行为集合
             const eventValue = $event.value;
             eventValue.forEach(async (item: EventPayload) => {
-                this.changeStackList.push(item.originEvent);
+                /**
+                 * 多个行为进行合并
+                 * 合并规则是
+                 * 1.[a,b,c,c] 在cc的时候，在已有一个c，又来一个c的时候，如果他们不都是file级别的节点
+                 *   就可以前面的内容去掉，只保留最后一个
+                 * 2.[a,b,c,b,c] 在bc已存在，又来了bc 这就都要保留，因为可能顺序有相关性，不能去掉
+                 * 理论上只处理同时几个操作 合并，
+                 * 3.有field的也直接保留
+                 */
+                try {
+                    const changeEvent = item.originEvent;
+                    const changeNode = changeEvent.target;
+                    const { fileNode } = this.getCurrentSource(changeNode);
+                    if (changeNode !== fileNode || !changeEvent.field) {
+                        const findIndex = this.changeStackList.findIndex((changeStackItem: EventPayload) => {
+                            const target = changeStackItem.target;
+                            const { fileNode: targetFileNode } = this.getCurrentSource(target);
+                            return targetFileNode === fileNode;
+                        });
+                        if (findIndex === this.changeStackList.length - 1) {
+                            this.changeStackList.pop();
+                        }
+                    }
+                    this.changeStackList.push(item.originEvent);
+                } catch (err) {
+                    console.log(err);
+                    this.changeStackList.push(item.originEvent);
+                }
             });
 
             // 如果有长度开始执行状态机
@@ -615,7 +642,8 @@ export class NaslServer {
         return '';
     }
     async getDataSchemaStructureOrTypeAnnotation(node: ViewElement) {
-        if (!(node instanceof ViewElement)) return;
+        if (!(node instanceof ViewElement))
+            return;
 
         const { currentSource, fileNode } = this.getCurrentSource(node);
         const quickInfo = await this._getTypeQuickinfo({
@@ -626,16 +654,18 @@ export class NaslServer {
         if (quickInfo.responseRequired) {
             const displayString = quickInfo?.response?.displayString || '';
             const flag = displayString.includes('<') && displayString.includes('>');
-            if(!flag) return;
+            if (!flag)
+                return;
 
             const types = /\<([^()]+)\>/g.exec(displayString);
-            let typeStr = types && types[1];
+            const typeStr = types && types[1];
             const app = node.app;
             if (typeStr.includes('__name: "AStructure_')) {
                 const properties: StructureProperty[] = [];
                 typeStr
                     .replace(/([^:\s]+):\s+([^;]+);/g, ($1, name, typeKey) => {
-                        if(name === '__name') return;
+                        if (name === '__name')
+                            return;
 
                         typeKey = `app.${typeKey}`;
                         const keys = typeKey.split('.');
@@ -647,12 +677,12 @@ export class NaslServer {
                                 typeKind: 'reference',
                                 typeName,
                                 typeNamespace,
-                            })
-                        }))
+                            }),
+                        }));
                         return '';
                     });
                 return TypeAnnotation.createTypeAnonymousStructure(properties);
-            } else if(typeStr.startsWith('structures'))
+            } else if (typeStr.startsWith('structures'))
                 return app.findNodeByCompleteName(`app.${typeStr}`);
         }
     }
@@ -814,7 +844,8 @@ export class NaslServer {
             //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`implicitly has an 'any' type, but a better type may be inferred from usage.`));
             // }
             record.suggestionDiagnostics = record.suggestionDiagnostics
-                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`].includes(item.text))
+                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`
+                    , `'__UpdateNoProperty__' is declared but its value is never read.`].includes(item.text))
                 .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode, record))
                 .filter((diag) => !!diag);
 
@@ -847,7 +878,7 @@ export class NaslServer {
             }
             if (removed)
                 return diagnostics;
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof Match) {
                     const { cases, expression } = node || {};
                     const typeAnnotationMap: any = {};
@@ -857,7 +888,7 @@ export class NaslServer {
                         count: 0,
                     };
                     if (Array.isArray(cases)) {
-                        cases.forEach(async (caseItem, index) => {
+                        cases.forEach((caseItem, index) => {
                             let isDisabled = false;
                             // 是最后一项
                             if (index === cases.length - 1) {
@@ -997,7 +1028,7 @@ export class NaslServer {
             if (removed)
                 return diagnostics;
 
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof ViewElement && node.view === fileNode) {
                     if (node.tag) {
                         node.bindAttrs.forEach((bindAttr) => {
@@ -1035,6 +1066,9 @@ export class NaslServer {
                                 // 子页面内部逻辑过滤
                                 if (nodeIn.view !== fileNode)
                                     return;
+                                // 当局部变量、输出参数属于页面内逻辑时，需过滤同页面下不同逻辑下的同名变量
+                                if (node.logic && node.logic !== nodeIn.logic)
+                                    return;
                                 // 跟变量无关的赋值过滤
                                 const jsCode = nodeIn.toJS();
                                 if (!jsCode.includes(`${node.name} = `))
@@ -1108,6 +1142,40 @@ export class NaslServer {
                                 },
                             };
                             diagnostics.push(diagnostic);
+                        } else if (propertyValue.value) {
+                            const dataSource: any = fileNode;
+                            // 数据源有连接错误
+                            let envText;
+                            if (propertyValue.env === 'dev') {
+                                if (dataSource.__devConnectError) {
+                                    envText = '开发';
+                                } else if (dataSource.__devConnectError === false) {
+                                    return;
+                                }
+                            } else if (propertyValue.env === 'online') {
+                                if (dataSource.__onlineConnectError) {
+                                    envText = '生产';
+                                } else if (dataSource.__onlineConnectError === false) {
+                                    return;
+                                }
+                            }
+                            // 手动插入报错
+                            if (envText) {
+                                const diagnostic = {
+                                    node: fileNode,
+                                    severity: 'error',
+                                    message: `数据源配置：数据源 ${property.name} ${envText}环境数据源连接不通，请先检查${envText}环境数据源配置`,
+                                    // 保留原来的内容方便查询一些问题
+                                    originalDiagnostic: {
+                                        fileName: '',
+                                        start: <any>null,
+                                        end: <any>null,
+                                        category: 'error',
+                                        text: `DataSource connection error`,
+                                    },
+                                };
+                                return diagnostics.push(diagnostic);
+                            }
                         }
                     });
                 }
@@ -1118,17 +1186,18 @@ export class NaslServer {
             if (fileNode.parentNode instanceof App && !fileNode.parentNode.logics.includes(fileNode))
                 return diagnostics;
 
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
+                //OQL支持返回复合类型数据了
                 // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
-                if ((node instanceof OqlQueryComponent || node instanceof SqlQueryComponent) && (node as SqlQueryComponent).getTypeBanError()) {
-                    const diagnostic = {
-                        node,
-                        severity: 'error',
-                        message: 'SQL查询：返回类型内部,不支持复杂类型。',
-                    };
-                    node.tsErrorDetail = diagnostic;
-                    diagnostics.push(diagnostic);
-                }
+                // if ((node instanceof OqlQueryComponent || node instanceof SqlQueryComponent) && (node as SqlQueryComponent).getTypeBanError()) {
+                //     const diagnostic = {
+                //         node,
+                //         severity: 'error',
+                //         message: 'SQL查询：返回类型内部,不支持复杂类型。',
+                //     };
+                //     node.tsErrorDetail = diagnostic;
+                //     diagnostics.push(diagnostic);
+                // }
                 if (node instanceof Return || node instanceof Variable) {
                     if (!node.typeAnnotation && !node.__TypeAnnotation) {
                         const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
@@ -1164,6 +1233,11 @@ export class NaslServer {
                 this.checkNodeError(node, diagnostics);
             });
         }
+        if (fileNode instanceof Process) {
+            fileNode?.sourceMap.forEach((value, node) => {
+                this.checkNodeError(node, diagnostics);
+            });
+        }
         return diagnostics;
     }
 
@@ -1223,6 +1297,19 @@ export class NaslServer {
                 }
             });
         }
+        if (node instanceof MatchCase && (node.getAncestor('Match') as Match)?.isExpression && node.body.length === 0) {
+            // 如果不是其他就标红
+            if ((node?.getIndexOfParent() !== ((node.getAncestor('Match') as Match)?.cases?.length || 0) - 1)) {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配分支：表达式不能为空',
+                    titleTip: '表达式不能为空',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
+        }
         // 如果节点是match的patterns 里的
         if (node?.parentKey === 'patterns' && node.parentNode instanceof MatchCase) {
             const matchNode = node.getAncestor('Match');
@@ -1241,9 +1328,30 @@ export class NaslServer {
                     node.tsErrorDetail = diagnostic;
                     diagnostics.push(diagnostic);
                 }
+                // 如果TypeAnnotation 还存在，但是本身已经不是union类型，就是已经从union换别的类型了就都要报错
+            } else if (node instanceof TypeAnnotation && matchExpressionType?.typeKind !== 'union') {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配：选择类型不存在',
+                    titleTip: '该类型已被删除',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+                // 如果可枚举变量的 ，变量 还存在，但是本身已经是union类型，就是已经从别的类型 换了union就都要报错
+            } else if (!(node instanceof TypeAnnotation) && matchExpressionType?.typeKind === 'union') {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配：选择值不存在',
+                    titleTip: '该值无法匹配，请重新选择类型',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
             }
             if (node.tsErrorDetail) {
-                if (matchExpressionType?.typeNamespace?.includes('enums')) {
+                // 如果父级是枚举，而且子集选的是变量，就提示枚举值已被删除
+                if (matchExpressionType?.typeNamespace?.includes('enums') && (node instanceof MemberExpression)) {
                     node.tsErrorDetail.titleTip = '该枚举值已被删除';
                 } else if (!node.tsErrorDetail.titleTip) {
                     node.tsErrorDetail.titleTip = '该值已被删除';
@@ -1260,6 +1368,25 @@ export class NaslServer {
             node.tsErrorDetail = diagnostic;
             diagnostics.push(diagnostic);
         }
+        /**
+         * 如果节点是内置函数
+         * 穷举在线上的情况，不在线上就void报错， calllogic 和 callinterface 因为原来有报错，所以就忽略掉
+         * && 他在父级中，不在body
+         * && 也不再 if的线上
+         * && 也不再 switch的线上consequent
+         * && 也不再草稿区域
+         * && 不在 parentNode.parentNode（只用处理两层的，超过两层上就需要报错，只用直接是参数位第一层的需要） 是 callfunction 和 callInfterfase中，因为这两本身有强制类型，内置函数或者一些带T的声明那种，
+         * && 而且也没有类型，就说明在槽位里，就需要报错
+         */
+        if (node instanceof CallFunction && node.parentKey !== 'body' && node.parentKey !== 'alternate' && node.parentKey !== 'playground' && node.parentKey !== 'consequent' && node.parentNode?.parentNode?.concept !== 'CallLogic' && node.parentNode?.parentNode?.concept !== 'CallInterface' && !node.__TypeAnnotation) {
+            const diagnostic = {
+                node,
+                severity: 'error',
+                message: `类型不匹配，传入类型：void`,
+            };
+            node.tsErrorDetail = diagnostic;
+            diagnostics.push(diagnostic);
+        }
     }
 
     /* 接口导入查找 */
@@ -1983,12 +2110,8 @@ export class NaslServer {
             const minRange: MinRange = this._findMinRange(record, fileNode as FileNode);
             if (minRange) {
                 // 如果找到节点是callLogic就去更新
-                if (minRange.node instanceof CallLogic && node instanceof Param) {
-                    minRange.node.setCalleeArgName(parantNode as Logic);
-                }
-                // 如果节点参数增加页面也要更新
-                if (minRange.node instanceof Destination && node instanceof Param) {
-                    minRange.node.setViewArgument(parantNode as View);
+                if ((minRange.node instanceof CallLogic || minRange.node instanceof Destination) && node instanceof Param) {
+                    minRange.node.addCalleeArg(parantNode as any);
                 }
             }
         });
@@ -2290,7 +2413,7 @@ export class NaslServer {
      * @returns 不需要去查就可以返回类型的节点
      */
     getCurrentNodeKnownTypeAnnotation(node: BaseNode) {
-        if (node.concept === 'StringLiteral' || node.concept === 'BooleanLiteral' || node.concept === 'NullLiteral') {
+        if (node.concept === 'StringLiteral' || node.concept === 'StringInterpolation' || node.concept === 'BooleanLiteral' || node.concept === 'NullLiteral') {
             let type = 'String';
             switch (node.concept) {
                 case 'NullLiteral':
@@ -2307,7 +2430,7 @@ export class NaslServer {
             return TypeAnnotation.createPrimitive('Boolean');
         }
         // Convert和new都是自身携带类型的，就不进行修改
-        if (node instanceof CallFunction && node.calleeNamespace === 'nasl.util' && (node.calleeName === 'Convert' || node.calleeName === 'New')) {
+        if (node instanceof CallFunction && node.calleeNamespace === 'nasl.util' && (['Convert', 'New', 'FromString'].includes(node.calleeName))) {
             if (node.typeArguments.length) {
                 return node.typeArguments[0];
             }
@@ -2397,6 +2520,9 @@ export class NaslServer {
                 'Return',
                 'Variable',
                 'Match',
+                'NewComposite',
+                'NewList',
+                'NewMap',
             ].includes(node.concept))
                 return;
             // 要去ls那边获取的
@@ -2443,12 +2569,18 @@ export class NaslServer {
                 let newCode = item.code.substring(0, indexOf);
                 newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
                 fileDetail.offset = newCode.length + 'return '.length;
+            } else if (['NewComposite', 'NewList', 'NewMap'].includes(node.concept)) {
+                fileDetail.line = item.range.end.line;
+                const indexOf = item.code.indexOf('return __newComposite');
+                let newCode = item.code.substring(0, indexOf);
+                newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
+                fileDetail.offset = newCode.length + 'return '.length;
             }
             args.push(fileDetail);
         });
-        console.time('请求')
+        console.time('请求');
         const resultMap: any = (await this.getNaslNodeTypeFull(args)).response;
-        console.timeEnd('请求')
+        console.timeEnd('请求');
 
         // console.log(resultMap);
 
@@ -2489,14 +2621,24 @@ export class NaslServer {
             }
         });
 
-        // 重置类型状态
+        // 重置类型状态, 并且赋值
         types.forEach((value, node) => {
-            node.__isCorrectTypeAnnotation = true;
-            if (value) {
-                if (value instanceof TypeAnnotation) {
-                    node.__TypeAnnotation = (Object.freeze(value) as TypeAnnotation);
-                } else if (value.typeAnnotation) {
-                    node.__TypeAnnotation = (Object.freeze(value.typeAnnotation) as TypeAnnotation);
+            try {
+                // 因为node可能是经过处理的TypeAnnotation
+                node.__isCorrectTypeAnnotation = true;
+                if (value) {
+                    if (value instanceof TypeAnnotation) {
+                        node.__TypeAnnotation = (Object.freeze(value) as TypeAnnotation);
+                    } else if (value.typeAnnotation) {
+                        node.__TypeAnnotation = (Object.freeze(value.typeAnnotation) as TypeAnnotation);
+                    }
+                } else {
+                    // 清空原来已经赋值上去的类型，可能原来有现在没有了
+                    node.__TypeAnnotation = null;
+                }
+            } catch (err) {
+                if (globalThis.window) {
+                    console.log(err);
                 }
             }
         });
@@ -2767,7 +2909,7 @@ export class NaslServer {
         };
     }
 
-    async getCurrentTypeAnnotation(node: BaseNode) {
+    async getCurrentTypeAnnotation(node: BaseNode, outTime: number = 600) {
         if (node.__TypeAnnotation) {
             return node.__TypeAnnotation;
         }
@@ -2781,7 +2923,7 @@ export class NaslServer {
                 } else {
                     resolve(null);
                 }
-            }, 600);
+            }, outTime);
             const mySetInterval = setInterval(() => {
                 if (node.__isCorrectTypeAnnotation) {
                     resolve(node.__TypeAnnotation);

package/src/server/process2LogicNamespace.ts

@@ -89,6 +89,10 @@ export function processToTreeFragment(process: Process) {
                 k.getNamespace = function () {
                     return path;
                 };
+                const api = `/api/${process.name}/${e.name}/${k.name}`;
+                k.getPath = function () {
+                    return api;
+                };
             });
 
             fragment.elements.push({
@@ -107,6 +111,10 @@ export function processToTreeFragment(process: Process) {
     launchLogic.getNamespace = function () {
         return path;
     };
+    const api = `/api/${process.name}/${launchLogic.name}`;
+    launchLogic.getPath = function () {
+        return api;
+    };
 
     fragment.logics.push(launchLogic);
     launchLogic.parentKey = 'readonly';