@lcap/nasl 2.18.0-beta.3 → 2.18.0

package/src/server/naslServer.ts

@@ -614,6 +614,48 @@ export class NaslServer {
         }
         return '';
     }
+    async getDataSchemaStructureOrTypeAnnotation(node: ViewElement) {
+        if (!(node instanceof ViewElement)) return;
+
+        const { currentSource, fileNode } = this.getCurrentSource(node);
+        const quickInfo = await this._getTypeQuickinfo({
+            file: (fileNode as FileNode).getEmbeddedFilePath(),
+            line: lsp2tspNumber(currentSource.range.start.line),
+            offset: 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: StructureProperty[] = [];
+                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(StructureProperty.from({
+                            name,
+                            typeAnnotation: TypeAnnotation.from({
+                                typeKind: 'reference',
+                                typeName,
+                                typeNamespace,
+                            })
+                        }))
+                        return '';
+                    });
+                return TypeAnnotation.createTypeAnonymousStructure(properties);
+            } else if(typeStr.startsWith('structures'))
+                return app.findNodeByCompleteName(`app.${typeStr}`);
+        }
+    }
 
     /**
      * ts的 quickInfo方法，查询指定位置的详情
@@ -997,40 +1039,37 @@ export 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 Variable
-                                    && node.parentNode instanceof 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 Variable && node.parentNode instanceof 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);
-                                    }
-                                    msg = '系统无法推断类型。';
-                                } else {
-                                    if (!nodeIn.tsErrorDetail) {
-                                        const diagnostic = {
-                                            node: nodeIn,
-                                            severity: 'error',
-                                            message: `${nodeIn.label}左边 ${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 = '必须赋值有返回值的内容。';
                                 }
+                                if (!nodeIn.tsErrorDetail) {
+                                    const diagnostic = {
+                                        node: nodeIn,
+                                        severity: 'error',
+                                        message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                                    };
+                                    nodeIn.tsErrorDetail = diagnostic;
+                                    diagnostics.push(diagnostic);
+                                }
+                                msg = '必须赋值有返回值的内容。';
                             }
                         });
                         if (!msg)
@@ -2330,7 +2369,6 @@ export class NaslServer {
             const nodeTypeAnnotation = this.getCurrentNodeKnownTypeAnnotation(node);
             if (nodeTypeAnnotation) {
                 types.set(node, nodeTypeAnnotation);
-                node.__TypeAnnotation = nodeTypeAnnotation;
                 return;
             }
             // 要通过自己或者依赖关系拿的，二次遍历
@@ -2344,8 +2382,8 @@ export class NaslServer {
             if ([
                 'Return',
                 'Variable',
-            ].includes(node.concept) && (node as Return | Variable).typeAnnotation) {
-                node.__TypeAnnotation = (node as Return | Variable).typeAnnotation;
+            ].includes(node.concept) && (node as Variable).typeAnnotation) {
+                types.set(node, (node as Variable).typeAnnotation);
                 return;
             }
             if (![
@@ -2408,7 +2446,9 @@ export class NaslServer {
             }
             args.push(fileDetail);
         });
+        console.time('请求')
         const resultMap: any = (await this.getNaslNodeTypeFull(args)).response;
+        console.timeEnd('请求')
 
         // console.log(resultMap);
 
@@ -2424,8 +2464,7 @@ export class NaslServer {
             const nodeTypeAnnotation = 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 as any).__nodeType = item?.[0]?.nodeType;
+            (newQuickInfoNodes[index].node as any).__nodeType = Object.freeze(item?.[0]?.nodeType);
 
             // console.log('方案1：', displayString1);
         });
@@ -2433,13 +2472,11 @@ export class NaslServer {
             if (node instanceof Assignment) {
                 if (!types.get(node.left)) {
                     types.set(node.left, types.get(node.right));
-                    node.left.__TypeAnnotation = (types.get(node.right) as TypeAnnotation);
                 }
             } else if (node instanceof Argument) {
                 // 如果Argument，但是没可以用的类型，就用原来logic的参数类型
                 const argType = this.getArgumentTypeAnnotation(node, newQuickInfoNodes, (types as any));
                 types.set(node, argType);
-                node.__TypeAnnotation = argType.typeAnnotation;
             } else if (node instanceof MatchCase) {
                 // matchCase的类型
                 // 直接从最后一项的返回值取，有就有没有就没有
@@ -2447,7 +2484,6 @@ export class NaslServer {
                     const last = node.body[node.body.length - 1];
                     if (last.__TypeAnnotation) {
                         types.set(node, last.__TypeAnnotation);
-                        node.__TypeAnnotation = last.__TypeAnnotation;
                     }
                 }
             }
@@ -2456,6 +2492,13 @@ 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);
+                }
+            }
         });
         // newQuickInfoNodes.forEach((itemDetail, index) => {
         //     const { node, filePath } = itemDetail;
@@ -2561,6 +2604,7 @@ export class NaslServer {
 
     // 增量标注
     async IncrementalAnnotationJSON(records: DiagnosticRecord[]) {
+        console.time('增量标注');
         const nodes: QuickInfoNodes = [];
         records.forEach((record) => {
             const fileNode = this.file2NodeMap.get(record.filePath);
@@ -2580,6 +2624,7 @@ export class NaslServer {
         });
 
         await this.getQuickInfoNodesTypeMap(nodes);
+        console.timeEnd('增量标注');
     }
 
     annotationToJson(typesMap: Map<BaseNode, TypeAnnotation | {