@lcap/nasl 2.18.0-beta.5 → 2.18.0-beta.7

package/src/server/extendBaseNode.ts

@@ -161,19 +161,6 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
         refsList = refsList.filter((item) =>
             // 因为ui组件本身会多渲染一次,就先过滤一个
             !(item.lineText.includes(': nasl.ui.')));
-        // 删除参数单独处理
-        if (node instanceof Param) {
-            const methodRefs: tsProtocol.ReferencesResponseItem[] = [];
-            refsList.forEach((item) => {
-                // 入参查找引用,查到logic 和自己,内容完全一样,就保留一个
-                const find = methodRefs.find((findItem) => item.lineText === findItem.lineText);
-                if (!find) {
-                    methodRefs.push(item);
-                }
-            });
-            refsList = methodRefs;
-        }
-
         // delete的弹框展示
         const confirmParms = {
             actionType: 'delete',
@@ -182,7 +169,7 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
             icon: 'warning',
         };
         let callback = null;
-        if (refsList.length <= 1) {
+        if (refsList.length <= 1 || (node instanceof Param && node.parentNode instanceof Logic && refsList.length <= 2)) {
             // 页面组件直接删除然后return
             if (node instanceof ViewElement) {
                 this.delete();
@@ -235,6 +222,7 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                     App.emit('collect:start', {
                         actionMsg: '删除参数',
                     });
+                    const Index = node.getIndexOfParent();
                     this.delete();
                     refsList.forEach((record) => {
                         const fileNode = naslServer.file2NodeMap.get(record.file);
@@ -242,11 +230,8 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                             return null;
                         const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
                         if (minRange) {
-                            if (minRange.node instanceof CallLogic) {
-                                minRange.node.setCalleeArgName(parentNode as Logic);
-                            }
-                            if (minRange.node instanceof Destination) {
-                                minRange.node.setViewArgument(parentNode as View);
+                            if (minRange.node instanceof CallLogic || minRange.node instanceof Destination) {
+                                minRange.node.deleteCalleeArg(Index);
                             }
                         }
                     });

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,17 +502,32 @@ 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;
             }
             // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
             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';
@@ -633,20 +617,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/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

@@ -1035,6 +1035,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} = `))
@@ -1983,12 +1986,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);
                 }
             }
         });
@@ -2502,7 +2501,9 @@ export class NaslServer {
                     }
                 }
             } catch (err) {
-                console.log(err);
+                if (globalThis.window) {
+                    console.log(err);
+                }
             }
         });
         // newQuickInfoNodes.forEach((itemDetail, index) => {

package/src/server/translator.ts

@@ -86,6 +86,8 @@ function transformType(tsType: string): string {
         return '无返回值';
     else if (tsType === '__elements')
         return '页面元素';
+    else if (tsType === '__unknown__')
+        return '无效';
     else if (tsType === 'extensions')
         return '拓展模块';
     else if (tsType === 'Promise<void>')
@@ -173,8 +175,13 @@ const TS_RULES: Array<{
 }> = [
     {
         re: /Object literal may only specify known properties, and '(.+?)' does not exist in type/,
-        result: '当前参数$1，不可用',
-        transforms: [outOriginalvalue],
+        result: '当前参数$1，不可用。',
+        transforms: [transformType],
+    },
+    {
+        re: /Object literal may only specify known properties, but '(.+?)' does not exist in type/,
+        result: '当前参数$1，不可用。',
+        transforms: [transformType],
     },
     {
         re: /Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/,
@@ -494,8 +501,15 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
     }
     // 赋值左右侧类型不一致, 把文字换一下
     if (/Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/.exec(text) && node.parentNode instanceof Assignment) {
-        // node = node.getAncestor('CallLogic');
-        tsErrorDetail.message = tsErrorDetail.message.replace('参数类型不一致！传入类型：', '赋值：类型不一致！右边类型：').replace('接收类型：', '左边类型：');
+        // OQL 的返回类型报错需要转换翻译，其内部 SQL 语句的参数类型报错不转换翻译
+        if (node instanceof OqlQueryComponent) {
+            if ((node.getCurrentSource().currentSource.range.start.line + 1) === tsErrorDetail.originalDiagnostic.start.line) {
+                tsErrorDetail.message = tsErrorDetail.message.replace('参数类型不一致！传入类型：', '赋值：类型不一致！右边类型：').replace('接收类型：', '左边类型：');
+            }
+        } else {
+            // node = node.getAncestor('CallLogic');
+            tsErrorDetail.message = tsErrorDetail.message.replace('参数类型不一致！传入类型：', '赋值：类型不一致！右边类型：').replace('接收类型：', '左边类型：');
+        }
     }
     if (node instanceof Argument || node instanceof Anchor) {
         // if (/Type '(.+?)' is not assignable to type '(.+?)'./.exec(text)) {