@lcap/nasl 2.18.0-beta.3 → 2.18.0

package/out/server/naslServer.js

@@ -538,6 +538,49 @@ class NaslServer {
         }
         return '';
     }
+    async getDataSchemaStructureOrTypeAnnotation(node) {
+        if (!(node instanceof concepts_1.ViewElement))
+            return;
+        const { currentSource, fileNode } = this.getCurrentSource(node);
+        const quickInfo = await this._getTypeQuickinfo({
+            file: fileNode.getEmbeddedFilePath(),
+            line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+            offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character) + `new nasl.ui.`.length,
+        });
+        if (quickInfo.responseRequired) {
+            const displayString = quickInfo?.response?.displayString || '';
+            const flag = displayString.includes('<') && displayString.includes('>');
+            if (!flag)
+                return;
+            const types = /\<([^()]+)\>/g.exec(displayString);
+            let typeStr = types && types[1];
+            const app = node.app;
+            if (typeStr.includes('__name: "AStructure_')) {
+                const properties = [];
+                typeStr
+                    .replace(/([^:\s]+):\s+([^;]+);/g, ($1, name, typeKey) => {
+                    if (name === '__name')
+                        return;
+                    typeKey = `app.${typeKey}`;
+                    const keys = typeKey.split('.');
+                    const typeName = keys.pop();
+                    const typeNamespace = keys.join('.');
+                    properties.push(concepts_1.StructureProperty.from({
+                        name,
+                        typeAnnotation: concepts_1.TypeAnnotation.from({
+                            typeKind: 'reference',
+                            typeName,
+                            typeNamespace,
+                        })
+                    }));
+                    return '';
+                });
+                return concepts_1.TypeAnnotation.createTypeAnonymousStructure(properties);
+            }
+            else if (typeStr.startsWith('structures'))
+                return app.findNodeByCompleteName(`app.${typeStr}`);
+        }
+    }
     /**
      * ts的 quickInfo方法，查询指定位置的详情
      * @param args 文件信息数组
@@ -904,41 +947,37 @@ class NaslServer {
                                 const jsCode = nodeIn.toJS();
                                 if (!jsCode.includes(`${node.name} = `))
                                     return;
-                                // 逻辑内局部变量、输出参数、输入参数过滤
-                                if (nodeIn.logic?.variables.find((lVar) => jsCode.includes(`${lVar.name} = `))
-                                    || nodeIn.logic?.returns.find((lRet) => jsCode.includes(`${lRet.name} = `))
-                                    || nodeIn.logic?.params.find((lPar) => jsCode.includes(`${lPar.name} = `))
-                                    || nodeIn.logic?.virtualParams.find((vParam) => jsCode.includes(`${vParam.name} = `)))
-                                    return;
-                                if (node instanceof concepts_1.Variable
-                                    && node.parentNode instanceof concepts_1.View
-                                    && (nodeIn.logic?.params.find((param) => jsCode.includes(param.name))
-                                        || nodeIn.logic?.virtualParams.find((vParam) => jsCode.includes(vParam.name))
-                                        || nodeIn.logic?.variables.find((variable) => jsCode.includes(variable.name)))) {
+                                // 页面局部变量
+                                if (node instanceof concepts_1.Variable && node.parentNode instanceof concepts_1.View) {
+                                    // 跟页面局部变量无关的赋值过滤
+                                    if (!jsCode.includes(`this.${node.name} = `))
+                                        return;
                                     // 直接赋值 logic 内局部变量、输入参数直接提示系统无法推断类型
-                                    if (!nodeIn.tsErrorDetail) {
-                                        const diagnostic = {
-                                            node: nodeIn,
-                                            severity: 'error',
-                                            message: `页面${nodeTypeName} ${node.name} 赋值页面逻辑内局部变量或输入参数时，系统无法推导类型。`,
-                                        };
-                                        nodeIn.tsErrorDetail = diagnostic;
-                                        diagnostics.push(diagnostic);
+                                    if (nodeIn.logic?.params.find((param) => jsCode.includes(param.name))
+                                        || nodeIn.logic?.virtualParams.find((vParam) => jsCode.includes(vParam.name))
+                                        || nodeIn.logic?.variables.find((variable) => jsCode.includes(variable.name))) {
+                                        if (!nodeIn.tsErrorDetail) {
+                                            const diagnostic = {
+                                                node: nodeIn,
+                                                severity: 'error',
+                                                message: `页面${nodeTypeName} ${node.name} 赋值页面逻辑内局部变量或输入参数时，系统无法推导类型。`,
+                                            };
+                                            nodeIn.tsErrorDetail = diagnostic;
+                                            diagnostics.push(diagnostic);
+                                        }
+                                        msg = '系统无法推断类型。';
                                     }
-                                    msg = '系统无法推断类型。';
                                 }
-                                else {
-                                    if (!nodeIn.tsErrorDetail) {
-                                        const diagnostic = {
-                                            node: nodeIn,
-                                            severity: 'error',
-                                            message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
-                                        };
-                                        nodeIn.tsErrorDetail = diagnostic;
-                                        diagnostics.push(diagnostic);
-                                    }
-                                    msg = '必须赋值有返回值的内容。';
+                                if (!nodeIn.tsErrorDetail) {
+                                    const diagnostic = {
+                                        node: nodeIn,
+                                        severity: 'error',
+                                        message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                                    };
+                                    nodeIn.tsErrorDetail = diagnostic;
+                                    diagnostics.push(diagnostic);
                                 }
+                                msg = '必须赋值有返回值的内容。';
                             }
                         });
                         if (!msg)
@@ -2218,7 +2257,6 @@ class NaslServer {
             const nodeTypeAnnotation = this.getCurrentNodeKnownTypeAnnotation(node);
             if (nodeTypeAnnotation) {
                 types.set(node, nodeTypeAnnotation);
-                node.__TypeAnnotation = nodeTypeAnnotation;
                 return;
             }
             // 要通过自己或者依赖关系拿的，二次遍历
@@ -2233,7 +2271,7 @@ class NaslServer {
                 'Return',
                 'Variable',
             ].includes(node.concept) && node.typeAnnotation) {
-                node.__TypeAnnotation = node.typeAnnotation;
+                types.set(node, node.typeAnnotation);
                 return;
             }
             if (![
@@ -2300,7 +2338,9 @@ class NaslServer {
             }
             args.push(fileDetail);
         });
+        console.time('请求');
         const resultMap = (await this.getNaslNodeTypeFull(args)).response;
+        console.timeEnd('请求');
         // console.log(resultMap);
         // const result = (await this.getNaslNodeQuickInfoFull(args)).response;
         // console.log(result);
@@ -2314,22 +2354,19 @@ class NaslServer {
             const nodeTypeAnnotation = (0, formatTsUtils_1.type2TypeAnnotation)(item?.[0]?.nodeType);
             // console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, nodeTypeAnnotation?.typeKey);
             types.set(newQuickInfoNodes[index].node, nodeTypeAnnotation);
-            newQuickInfoNodes[index].node.__TypeAnnotation = nodeTypeAnnotation;
-            newQuickInfoNodes[index].node.__nodeType = item?.[0]?.nodeType;
+            newQuickInfoNodes[index].node.__nodeType = Object.freeze(item?.[0]?.nodeType);
             // console.log('方案1：', displayString1);
         });
         getFromOthers.forEach((type, node) => {
             if (node instanceof concepts_1.Assignment) {
                 if (!types.get(node.left)) {
                     types.set(node.left, types.get(node.right));
-                    node.left.__TypeAnnotation = types.get(node.right);
                 }
             }
             else if (node instanceof concepts_1.Argument) {
                 // 如果Argument，但是没可以用的类型，就用原来logic的参数类型
                 const argType = this.getArgumentTypeAnnotation(node, newQuickInfoNodes, types);
                 types.set(node, argType);
-                node.__TypeAnnotation = argType.typeAnnotation;
             }
             else if (node instanceof concepts_1.MatchCase) {
                 // matchCase的类型
@@ -2338,7 +2375,6 @@ class NaslServer {
                     const last = node.body[node.body.length - 1];
                     if (last.__TypeAnnotation) {
                         types.set(node, last.__TypeAnnotation);
-                        node.__TypeAnnotation = last.__TypeAnnotation;
                     }
                 }
             }
@@ -2346,6 +2382,14 @@ class NaslServer {
         // 重置类型状态
         types.forEach((value, node) => {
             node.__isCorrectTypeAnnotation = true;
+            if (value) {
+                if (value instanceof concepts_1.TypeAnnotation) {
+                    node.__TypeAnnotation = Object.freeze(value);
+                }
+                else if (value.typeAnnotation) {
+                    node.__TypeAnnotation = Object.freeze(value.typeAnnotation);
+                }
+            }
         });
         // newQuickInfoNodes.forEach((itemDetail, index) => {
         //     const { node, filePath } = itemDetail;
@@ -2443,6 +2487,7 @@ class NaslServer {
     }
     // 增量标注
     async IncrementalAnnotationJSON(records) {
+        console.time('增量标注');
         const nodes = [];
         records.forEach((record) => {
             const fileNode = this.file2NodeMap.get(record.filePath);
@@ -2461,6 +2506,7 @@ class NaslServer {
             }
         });
         await this.getQuickInfoNodesTypeMap(nodes);
+        console.timeEnd('增量标注');
     }
     annotationToJson(typesMap, json) {
         typesMap.forEach((value, node) => {