@lcap/nasl 2.21.0-beta.2 → 2.21.0-beta.3

package/out/server/naslServer.js

@@ -33,6 +33,7 @@ const path = __importStar(require("path"));
 const worker_threads_1 = require("worker_threads");
 /// #endif
 const config_1 = require("../config");
+const sentry_1 = require("../sentry");
 const Messager_1 = __importDefault(require("../common/Messager"));
 const getMemberIdentifier_1 = require("../server/getMemberIdentifier");
 const concepts_1 = require("../concepts");
@@ -56,6 +57,7 @@ const EmbeddedTSFileOffsetMap = {
     Variable: 12,
     ConfigProperty: 12,
 };
+const Messager = (0, sentry_1.sentryMonitorTSWorkerMessager)(Messager_1.default);
 let isChangeInterface = false; //判断是否导入接口
 let actionArr = []; //用于导入接口收集更改的节点
 let timer = null; //超时器用于收集导入接口相关
@@ -123,7 +125,7 @@ class NaslServer {
         // 单个文件正在change，不允许同时两个文件一起change
         this.singleFileChangeIng = false;
         this.diagnosticManager = new diagnostic_1.DiagnosticManager();
-        this.messager = new Messager_1.default({
+        this.messager = new Messager({
             protocol: 'ts-worker',
             sender: 'ide',
             context: this,
@@ -800,24 +802,6 @@ 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));
@@ -828,7 +812,7 @@ class NaslServer {
                 if (diagnostic?.node) {
                     let currentNode = diagnostic.node;
                     // 数据源警告类型降级
-                    if (currentNode.concept === 'DataSource') {
+                    if (currentNode.concept === 'DataSource' && diagnostic.originalDiagnostic?.text === 'DataSource connection error') {
                         diagnostic.severity = 'warning';
                         record.suggestionDiagnostics.push(diagnostic);
                         return null;
@@ -1290,24 +1274,38 @@ class NaslServer {
                             if ((bindAttr.model || bindAttr.sync) && bindAttr.expression) {
                                 const bindExpression = bindAttr.expression;
                                 let diagnostic;
-                                if (bindExpression.concept !== 'Identifier' && bindExpression.concept !== 'MemberExpression') {
-                                    diagnostic = {
-                                        node: bindAttr,
-                                        severity: 'error',
-                                        message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
-                                    };
-                                }
-                                else {
+                                if (bindExpression.concept === 'MemberExpression') {
+                                    let current = bindExpression;
                                     if (bindExpression.isEnum()) {
                                         diagnostic = {
-                                            node: bindAttr,
+                                            node: bindExpression,
                                             severity: 'error',
                                             message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
                                         };
                                     }
+                                    else {
+                                        while (current.object) {
+                                            if (current.object.concept !== 'MemberExpression' && current.object.concept !== 'Identifier') {
+                                                diagnostic = {
+                                                    node: bindExpression,
+                                                    severity: 'error',
+                                                    message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
+                                                };
+                                                break;
+                                            }
+                                            current = current.object;
+                                        }
+                                    }
+                                }
+                                else if (bindExpression.concept !== 'Identifier') {
+                                    diagnostic = {
+                                        node: bindExpression,
+                                        severity: 'error',
+                                        message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
+                                    };
                                 }
                                 if (diagnostic) {
-                                    bindAttr.tsErrorDetail = diagnostic;
+                                    bindExpression.tsErrorDetail = diagnostic;
                                     diagnostics.push(diagnostic);
                                 }
                             }
@@ -1600,21 +1598,30 @@ class NaslServer {
                         }
                     });
                 }
+                Object.keys(typeMap).forEach((item) => {
+                    if (typeMap[item].length > 1) {
+                        typeMap[item].forEach((nodeItem) => {
+                            const diagnostic = {
+                                node: nodeItem,
+                                severity: 'error',
+                                message: '匹配：重复添加类型',
+                                titleTip: '重复添加此项',
+                            };
+                            nodeItem.tsErrorDetail = diagnostic;
+                            diagnostics.push(diagnostic);
+                        });
+                    }
+                });
+            }
+            else if (node.expression) {
+                const diagnostic = {
+                    node: node.expression,
+                    severity: 'error',
+                    message: '类型不匹配，传入类型：void',
+                };
+                node.expression.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
             }
-            Object.keys(typeMap).forEach((item) => {
-                if (typeMap[item].length > 1) {
-                    typeMap[item].forEach((nodeItem) => {
-                        const diagnostic = {
-                            node: nodeItem,
-                            severity: 'error',
-                            message: '匹配：重复添加类型',
-                            titleTip: '重复添加此项',
-                        };
-                        nodeItem.tsErrorDetail = diagnostic;
-                        diagnostics.push(diagnostic);
-                    });
-                }
-            });
         }
         if (node instanceof concepts_1.MatchCase && node.getAncestor('Match')?.isExpression && node.body.length === 0) {
             // 如果不是其他就标红
@@ -1749,8 +1756,10 @@ 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 = [
@@ -2085,6 +2094,31 @@ class NaslServer {
                 });
             }
         }
+        if ((node instanceof concepts_1.Param || node instanceof concepts_1.Return) && node.parentNode instanceof concepts_1.Process) {
+            const { currentSource } = this.getCurrentSource(node.parentNode);
+            if (currentSource) {
+                const code = currentSource.code;
+                const prefix = '__ProcessIdentification__';
+                const positions = [];
+                let pos = code.indexOf(prefix);
+                while (pos !== -1) {
+                    pos = code.indexOf(node.name, pos + prefix.length);
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                }
+                positions.shift();
+                // 拿到标识下定义的参数名字
+                const promises = positions.map((item) => this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
         if (node instanceof concepts_1.ProcessElement) {
             if (currentSource) {
                 const code = currentSource.code;
@@ -2108,6 +2142,34 @@ class NaslServer {
                 });
             }
         }
+        if (node instanceof concepts_1.Return && node.parentNode instanceof concepts_1.ProcessElement) {
+            const { currentSource } = this.getCurrentSource(node.parentNode);
+            if (currentSource) {
+                const code = currentSource.code;
+                const prefix = '__ProcessIdentification__';
+                const positions = [];
+                let pos = code.indexOf(prefix);
+                // 需要再次定位到processelement对象上，避免process上存在同名参数
+                pos = code.indexOf(node.parentNode.name, pos + prefix.length);
+                while (pos !== -1) {
+                    pos = code.indexOf(node.name, pos + prefix.length);
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                    // 需要再次定位到processelement对象上，避免process上存在同名参数
+                    pos = code.indexOf(node.parentNode.name, pos + node.parentNode.name.length);
+                }
+                // 拿到标识下定义的参数名字
+                const promises = positions.map((item) => this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
         // console.log(refsList, 'refsList');
         return refsList;
     }
@@ -2910,7 +2972,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('Long');
+                return concepts_1.TypeAnnotation.createPrimitive('Integer');
             }
         }
         if (node instanceof concepts_1.CallQueryComponent || node instanceof concepts_1.SqlQueryComponent || node instanceof concepts_1.OqlQueryComponent) {
@@ -2964,6 +3026,11 @@ class NaslServer {
                 types.set(node, node.typeAnnotation);
                 return;
             }
+            // 如果 入参不是虚拟节点的，就不去请求类型
+            // 只有虚拟节点的入参，才没有类型
+            if (node.concept === 'Param' && node.parentKey !== 'virtualParams') {
+                return;
+            }
             if (![
                 'Identifier',
                 'UnaryExpression',
@@ -2981,6 +3048,7 @@ class NaslServer {
                 'OqlQueryComponent',
                 'QueryFieldExpression',
                 'QueryGroupByExpression',
+                'Param',
             ].includes(node.concept))
                 return;
             // 要去ls那边获取的
@@ -2990,6 +3058,7 @@ class NaslServer {
                 line: (0, translator_1.lsp2tspNumber)(item.range.start.line),
                 offset: (0, translator_1.lsp2tspNumber)(item.range.start.character),
             };
+            // 位置计算偏移
             if (node.concept === 'BinaryExpression'
                 || node.concept === 'CallLogic'
                 || node.concept === 'CallFunction'
@@ -3063,8 +3132,8 @@ 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);
-            types.set(newQuickInfoNodes[index].node, nodeTypeAnnotation);
+            // console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, nodeTypeAnnotation?.typeKey);
+            types.set(newQuickInfoNodes[index].node, Object.freeze(nodeTypeAnnotation));
             newQuickInfoNodes[index].node.__nodeType = Object.freeze(item?.[0]?.nodeType);
             // console.log('方案1：', displayString1);
         });
@@ -3110,10 +3179,10 @@ class NaslServer {
                         }
                     }
                     if (value instanceof concepts_1.TypeAnnotation) {
-                        node.__TypeAnnotation = Object.freeze(value);
+                        node.__TypeAnnotation = value;
                     }
                     else if (value.typeAnnotation) {
-                        node.__TypeAnnotation = Object.freeze(value.typeAnnotation);
+                        node.__TypeAnnotation = value.typeAnnotation;
                     }
                 }
                 else {
@@ -3280,7 +3349,7 @@ class NaslServer {
                                 concept: 'TypeAnnotation',
                                 typeKind: 'primitive',
                                 typeNamespace: 'nasl.core',
-                                typeName: 'Long',
+                                typeName: 'Integer',
                                 typeArguments: null,
                                 inferred: null,
                             },
@@ -3294,7 +3363,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('Long').toJSON();
+                    jsonNode.typeAnnotation = concepts_1.TypeAnnotation.createPrimitive('Integer').toJSON();
                 }
             }
             if (node instanceof concepts_1.Match) {