@lcap/nasl 2.20.1-beta.2 → 2.21.0-beta.1

package/out/server/naslServer.js

@@ -133,6 +133,12 @@ class NaslServer {
                 if (data && data.event === 'publishDiagnostics') {
                     const records = await this._resolveDiagnosticRecords(data.records);
                     this.diagnosticManager.pushAll(records);
+                    try {
+                        (0, common_1.invokeCommand)('naslServer:nodeChange');
+                    }
+                    catch (e) {
+                        console.log('no "naslServer:nodeChange" event received');
+                    }
                 }
             },
         });
@@ -411,8 +417,7 @@ class NaslServer {
         await this.openApp(app);
         // 重新check一遍所有内容
         await this.getDiagnosticRecordsAndPushAll();
-        // 重新补一遍标注
-        await this.createdNaslAnnotatedJSON(app);
+        // check内容后，会自动走增量类型标注完善全部类型
     }
     /**
      * 初始化之前添加文件
@@ -795,6 +800,24 @@ class NaslServer {
                 });
             }
             record.semanticDiagnostics = record.semanticDiagnostics
+                /**
+                 * reduce 为去除重复的 'Duplicate identifier xxxx' 报错
+                 * 原属于 TS@4.x 的 bug，在 TS@5.0-dev 后修复，详见：https://github.com/microsoft/TypeScript/issues/51437
+                 * 触发场景：
+                 *   OQL查询中写入SQL语句：'select * from Entity1 ee, Entity1 ee, Entity1 ee, Entity1 ee'
+                 *   翻译出的TS代码中，ee 被成功检查为重复变量，但 ee 报错的数量超过 ee 实际的出现数量，需对同一 token 的报错进行去重
+                 */
+                .reduce((res, item) => {
+                const hit = item.text.startsWith('Duplicate identifier') && res.some((r) => (r.text === item.text
+                    && r.start.line === item.start.line
+                    && r.start.offset === item.start.offset
+                    && r.end.line === item.end.line
+                    && r.end.offset === item.end.offset));
+                if (!hit) {
+                    res.push(item);
+                }
+                return res;
+            }, [])
                 .map((diag) => this._resolveDiagnostic(diag, node, record))
                 .filter((diag) => !!diag);
             record.semanticDiagnostics.push(...this._attachDiagnostics(node));
@@ -804,6 +827,25 @@ class NaslServer {
                 // 错误降级如果属于草稿态的就降级
                 if (diagnostic?.node) {
                     let currentNode = diagnostic.node;
+                    // 数据源警告类型降级
+                    if (currentNode.concept === 'DataSource') {
+                        diagnostic.severity = 'warning';
+                        record.suggestionDiagnostics.push(diagnostic);
+                        return null;
+                    }
+                    else if (currentNode.concept === 'OqlQueryComponent') {
+                        // OQL别名错误降级为警告
+                        if (diagnostic.originalDiagnostic && diagnostic.originalDiagnostic?.text.includes('__OQL_ALIAS_WARNING__')) {
+                            // 重置 图标和错误等级
+                            diagnostic.severity = 'warning';
+                            if (diagnostic.node?.tsErrorDetail) {
+                                // 重置组件节点上的错误信息
+                                diagnostic.node.tsErrorDetail.severity = 'warning';
+                            }
+                            record.suggestionDiagnostics.push(diagnostic);
+                            return null;
+                        }
+                    }
                     while (currentNode?.parentNode?.concept !== 'App') {
                         if (currentNode.parentKey?.toLowerCase()?.includes('playground')) {
                             // 草稿区降级
@@ -816,19 +858,6 @@ class NaslServer {
                             record.suggestionDiagnostics.push(diagnostic);
                             return null;
                         }
-                        else if (currentNode.concept === 'OqlQueryComponent') {
-                            // OQL别名错误降级为警告
-                            if (diagnostic.originalDiagnostic && diagnostic.originalDiagnostic?.text.includes('__OQL_ALIAS_WARNING__')) {
-                                // 重置 图标和错误等级
-                                diagnostic.severity = 'warning';
-                                if (diagnostic.node?.tsErrorDetail) {
-                                    // 重置组件节点上的错误信息
-                                    diagnostic.node.tsErrorDetail.severity = 'warning';
-                                }
-                                record.suggestionDiagnostics.push(diagnostic);
-                                return null;
-                            }
-                        }
                         currentNode = currentNode.parentNode;
                     }
                 }
@@ -1390,14 +1419,14 @@ class NaslServer {
                         if (!propertyValue.value && fileNode.name !== 'defaultDS') {
                             const diagnostic = {
                                 node: fileNode,
-                                severity: 'error',
+                                severity: 'warning',
                                 message: `数据源配置：数据源${property.name}${propertyValue.env === 'dev' ? '开发环境' : '生产环境'}未配置数据信息`,
                                 // 保留原来的内容方便查询一些问题
                                 originalDiagnostic: {
                                     fileName: '',
                                     start: null,
                                     end: null,
-                                    category: 'error',
+                                    category: 'warning',
                                     text: `Data Source is not config`,
                                 },
                             };
@@ -1427,14 +1456,14 @@ class NaslServer {
                             if (envText) {
                                 const diagnostic = {
                                     node: fileNode,
-                                    severity: 'error',
+                                    severity: 'warning',
                                     message: `数据源配置：数据源 ${property.name} ${envText}环境数据源连接不通，请先检查${envText}环境数据源配置`,
                                     // 保留原来的内容方便查询一些问题
                                     originalDiagnostic: {
                                         fileName: '',
                                         start: null,
                                         end: null,
-                                        category: 'error',
+                                        category: 'warning',
                                         text: `DataSource connection error`,
                                     },
                                 };
@@ -1663,22 +1692,38 @@ class NaslServer {
         }
         /**
          * 如果节点是内置函数
-         * 穷举在线上的情况，不在线上就void报错， calllogic 和 callinterface 因为原来有报错，所以就忽略掉
+         * 穷举在线上的情况，不在线上就void报错， callinterface 因为原来有报错，所以就忽略掉
          * && 他在父级中，不在body
          * && 也不再 if的线上
          * && 也不再 switch的线上consequent
          * && 也不再草稿区域
          * && 不在 parentNode.parentNode（只用处理两层的，超过两层上就需要报错，只用直接是参数位第一层的需要） 是 callfunction 和 callInfterfase中，因为这两本身有强制类型，内置函数或者一些带T的声明那种，
          * && 而且也没有类型，就说明在槽位里，就需要报错
+         *
+         * 如果是内置函数而且也不在线上
+         * 只有下面自己实现的函数才会报错
          */
-        if (node instanceof concepts_1.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);
+        if (node instanceof concepts_1.CallFunction && node.parentKey !== 'body' && node.parentKey !== 'alternate' && node.parentKey !== 'playground' && node.parentKey !== 'consequent' && node.parentNode?.parentNode?.concept !== 'CallInterface' && !node.__TypeAnnotation) {
+            let showErr = false;
+            if (node.parentNode?.parentNode?.concept === 'CallLogic') {
+                // calllogic 中别的类型会强校验，但是内置函数，不会强制校验，下面这几个其实是走的内置函数的实现，所以需要手动增加一下校验
+                const { calleeNamespace, calleeName } = node.parentNode.parentNode;
+                if ((calleeNamespace === 'nasl.ui' || calleeNamespace === 'nasl.util') && (calleeName === 'showMessage' || calleeName === 'consoleLog' || calleeName === 'jsonSerialize' || calleeName === 'jsonDeserialize')) {
+                    showErr = true;
+                }
+            }
+            else {
+                showErr = true;
+            }
+            if (showErr) {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: `类型不匹配，传入类型：void`,
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
         }
         // newMap key或者value没填都要有报错
         if (node instanceof concepts_1.NewMap) {
@@ -1704,17 +1749,19 @@ class NaslServer {
                 if (!(node.right.tsErrorDetail) && leftType.sortedTypeKey !== rightType.sortedTypeKey) {
                     const excludeList = [
                         'nasl.collection.List<nasl.core.String>',
-                        'nasl.collection.List<nasl.core.Text>',
                         'nasl.collection.List<nasl.core.Email>',
                         'nasl.collection.Map<nasl.core.String, nasl.core.String>',
-                        'nasl.collection.Map<nasl.core.String, nasl.core.Text>',
                         'nasl.collection.Map<nasl.core.String, nasl.core.Email>',
                     ];
+                    const excludeList2 = [
+                        'nasl.collection.List<>',
+                        'nasl.collection.List<T>',
+                    ];
                     // 先特殊处理等 类型合并后就可以去掉了
                     if (excludeList.includes(leftType.sortedTypeKey) && excludeList.includes(rightType.sortedTypeKey)) {
                         return null;
                     }
-                    else if (['nasl.collection.List<>'].includes(leftType.sortedTypeKey) || ['nasl.collection.List<>'].includes(rightType.sortedTypeKey)) {
+                    else if (excludeList2.includes(leftType.sortedTypeKey) || excludeList2.includes(rightType.sortedTypeKey)) {
                         return null;
                     }
                     const diagnostic = {
@@ -2576,6 +2623,31 @@ class NaslServer {
         }
         return result;
     }
+    // 通过当前节点，查找被引用的节点
+    async nodeFindRefNodes(node) {
+        let refsList = await this._isHaveRef(node);
+        // 如果查找引用查到自己里面的引用不展示
+        refsList = refsList.filter((item) => 
+        // 自己引用自己的过滤掉
+        // 删除的时候过滤一把组件删除提示
+        // 展示组件自己屏蔽掉
+        !item.isDefinition && !item.lineText.includes(' = new nasl.ui.'));
+        // 最后返回的结果
+        const result = new Set();
+        try {
+            refsList.forEach((record) => {
+                const fileNode = this.file2NodeMap.get(record.file);
+                if (!fileNode)
+                    return;
+                const minRange = this._findMinRange(record, fileNode);
+                result.add(minRange.node);
+            });
+        }
+        catch (err) {
+            console.log(err);
+        }
+        return [...result];
+    }
     // 获取节点的上层渲染
     _getTreeMap(minRange, fileNode, resMap, nodeMap) {
         const minRangeNode = minRange.node;
@@ -2838,7 +2910,7 @@ class NaslServer {
         if (node instanceof concepts_1.Param) {
             // index在nasl foreach上有脏数据
             if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
-                return concepts_1.TypeAnnotation.createPrimitive('Integer');
+                return concepts_1.TypeAnnotation.createPrimitive('Long');
             }
         }
         if (node instanceof concepts_1.CallQueryComponent || node instanceof concepts_1.SqlQueryComponent || node instanceof concepts_1.OqlQueryComponent) {
@@ -2991,7 +3063,7 @@ class NaslServer {
             // console.log('原始：', displayString);
             // console.log('方案2：', item?.[0]?.nodeType);
             const nodeTypeAnnotation = (0, formatTsUtils_1.type2TypeAnnotation)(item?.[0]?.nodeType);
-            // console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, nodeTypeAnnotation?.typeKey);
+            console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, nodeTypeAnnotation?.typeKey);
             types.set(newQuickInfoNodes[index].node, nodeTypeAnnotation);
             newQuickInfoNodes[index].node.__nodeType = Object.freeze(item?.[0]?.nodeType);
             // console.log('方案1：', displayString1);
@@ -3051,7 +3123,7 @@ class NaslServer {
             }
             catch (err) {
                 if (globalThis.window) {
-                    console.log(err);
+                    // console.log(err);
                 }
             }
         });
@@ -3106,7 +3178,9 @@ class NaslServer {
     }
     // 全量标注并且返回json
     async getNaslAnnotatedJSON(app, releaseFlag) {
-        console.time('全量标注');
+        if (this.changeStackList?.length) {
+            throw new Error(`当前还有${this.changeStackList.length}个文件还在执行更新操作，请稍后再试！或刷新后重试！`);
+        }
         const nodes = [];
         this.file2NodeMap.forEach((fileNode, filePath) => {
             // 先不排除view，传递给后端的时候，去除views下的标注
@@ -3131,24 +3205,6 @@ class NaslServer {
         }
         return json;
     }
-    // 加载全量nasl节点标注
-    async createdNaslAnnotatedJSON(app) {
-        // 全量标注
-        const nodes = [];
-        this.file2NodeMap.forEach((fileNode, filePath) => {
-            // 先不排除view，传递给后端的时候，去除views下的标注
-            if (!['Structure', 'DataSource', 'Entity', 'Enum', 'Role'].includes(fileNode.concept)) {
-                fileNode.sourceMap.forEach((item, node) => {
-                    nodes.push({
-                        filePath,
-                        node,
-                        item,
-                    });
-                });
-            }
-        });
-        await this.getQuickInfoNodesTypeMap(nodes, true);
-    }
     // 增量标注
     async IncrementalAnnotationJSON(records) {
         console.time('增量标注');
@@ -3224,7 +3280,7 @@ class NaslServer {
                                 concept: 'TypeAnnotation',
                                 typeKind: 'primitive',
                                 typeNamespace: 'nasl.core',
-                                typeName: 'Integer',
+                                typeName: 'Long',
                                 typeArguments: null,
                                 inferred: null,
                             },
@@ -3238,7 +3294,7 @@ class NaslServer {
                 // index在nasl foreach上有脏数据
                 if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
                     const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
-                    jsonNode.typeAnnotation = concepts_1.TypeAnnotation.createPrimitive('Integer').toJSON();
+                    jsonNode.typeAnnotation = concepts_1.TypeAnnotation.createPrimitive('Long').toJSON();
                 }
             }
             if (node instanceof concepts_1.Match) {