@lcap/nasl 2.20.0-beta.3 → 2.20.0-beta.4

package/src/server/translator.ts

@@ -49,6 +49,7 @@ import {
     OqlQueryComponent,
     NewMap,
     NewList,
+    NewComposite,
 } from '../concepts';
 import { SourceMapItem } from '../translator';
 import { Diagnostic } from '../manager/diagnostic';
@@ -94,7 +95,7 @@ function transformType(tsType: string): string {
         return '拓展模块';
     else if (tsType === 'Promise<void>')
         return '未知类型';
-    else if (tsType.startsWith('{') && tsType.endsWith('}') || tsType.startsWith('{') && tsType.endsWith('...')) {
+    else if ((tsType.startsWith('{') && tsType.endsWith('}')) || (tsType.startsWith('{') && tsType.endsWith('...'))) {
         if (tsType.includes('__name: "AStructure_')) {
             return tsType.replace(/__name: "AStructure_\w{8}";/g, '');
         }
@@ -141,6 +142,7 @@ const NAMESPACE_CONCEPT_MAP: Record<string, string> = {
     extensions: '扩展模块',
     apis: '接口应用',
     components: '扩展组件',
+    properties: '配置参数',
 };
 
 function transformNamespace(tsNamespace: string): string {
@@ -276,6 +278,10 @@ const TS_RULES: Array<{
         re: /Cannot find name '__(?:OQL_GRAMMAR_ERROR)__'/,
         result: 'SQL查询：语句可能有异常。',
     },
+    {
+        re: /Cannot find name '__(?:OQL_ALIAS_WARNING)__'/,
+        result: 'SQL查询：别名不符合规范。',
+    },
     {
         re: /Cannot find name '__(?:OQL_EMPTY_ERROR)__'/,
         result: 'SQL查询：语句不能为空。',
@@ -375,9 +381,17 @@ const TS_RULES: Array<{
         re: /'__destinationEmpty__' is declared but its value is never read./,
         result: '任务未关联页面',
     },
+    {
+        re: /'__devConfigValueEmpty' is declared but its value is never read./,
+        result: '配置参数开发环境取值未设置',
+    },
+    {
+        re: /'__onlineConfigValueEmpty' is declared but its value is never read./,
+        result: '配置参数生产环境取值未设置',
+    },
     {
         re: /Variable '(.+?)' implicitly has an 'any' type./,
-        result: '$1推断不出类型！请连线或手动设置',
+        result: '$1推导不出类型！请连线或手动设置',
         transforms: [transformType],
     },
 ];
@@ -407,6 +421,14 @@ const POST_RULES: Array<{
         re: /Decimal|"Decimal"/g,
         result: '精确小数',
     },
+    {
+        re: /String|"String"/g,
+        result: '字符串',
+    },
+    {
+        re: /Boolean|"Boolean"/g,
+        result: '布尔值',
+    },
     {
         re: /never/g,
         result: '未知类型',
@@ -491,7 +513,7 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
             }
         }
 
-        if (node instanceof ProcessElement && (['ExclusiveGateway', 'ParallelGateway', 'InclusiveGateway'].includes(node.type))) {
+        if (node instanceof ProcessElement && ['ExclusiveGateway', 'ParallelGateway', 'InclusiveGateway'].includes(node.type)) {
             const reg = /Expected (.+?) arguments, but got (.+?)./.exec(text);
             let u = '排他网关';
             if (node.type === 'ParallelGateway') {
@@ -513,15 +535,27 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
         node = node.getAncestor('CallLogic');
     }
     // 赋值左右侧类型不一致, 把文字换一下
-    if (/Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/.exec(text) && node.parentNode instanceof Assignment) {
-        // OQL 的返回类型报错需要转换翻译，其内部 SQL 语句的参数类型报错不转换翻译
+    if (/Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/.exec(text)) {
         if (node instanceof OqlQueryComponent) {
-            if ((node.getCurrentSource().currentSource.range.start.line + 1) === tsErrorDetail.originalDiagnostic.start.line) {
+            tsErrorDetail.message = tsErrorDetail.message.replace('参数类型不一致！传入类型：', '类型不一致！传入类型：').replace('接收类型：', '期待类型：');
+        } else if (node.parentNode instanceof Assignment) {
+            // 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('接收类型：', '左边类型：');
             }
-        } else {
-            // node = node.getAncestor('CallLogic');
-            tsErrorDetail.message = tsErrorDetail.message.replace('参数类型不一致！传入类型：', '赋值：类型不一致！右边类型：').replace('接收类型：', '左边类型：');
+        } else if (node.parentNode instanceof NewMap) {
+            if (text.includes(`is not assignable to parameter of type 'None'`)) {
+                tsErrorDetail.message = tsErrorDetail.message = `'参数类型不一致！', 'map的key类型只能是String | Integer | Boolean | Long | Decimal'的其中一种`;
+            } else if (text.includes(`parameter of type 'never'`)) {
+                tsErrorDetail.message = '自动推导不出类型！newMap中有未知类型';
+            }
+        } else if (node.parentNode instanceof NewList && text.includes(`parameter of type 'never'`)) {
+            tsErrorDetail.message = '自动推导不出类型！newList中有未知类型';
         }
     }
     if (node instanceof Argument || node instanceof Anchor) {
@@ -552,10 +586,6 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
             tsErrorDetail.message = str;
         }
     }
-    if (node instanceof OqlQueryComponent) {
-        console.log(minRange, tsErrorDetail);
-    }
-
     // 类型报错的，需要放到上一级
     if (/'(.+?)' has no exported member(?: named)? '(.+?)'/.exec(text) || /Property '(.+?)' does not exist on type '(.+?)'./.exec(text)) {
         if (node instanceof TypeAnnotation) {
@@ -592,6 +622,10 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
             tsErrorDetail.message = '调用逻辑：参数不能为空！';
         } else if (node instanceof ProcessOutcome || node instanceof Function || node instanceof MatchCase) {
             tsErrorDetail.message = (node as any).constructor.nodeTitle + '：不能为空！';
+        } else if (node instanceof NewMap) {
+            tsErrorDetail.message = 'Map推导不出类型！请手动设置！';
+        } else if (node instanceof NewList) {
+            tsErrorDetail.message = 'List推导不出类型！请手动设置！';
         } else if (node instanceof Argument) {
             let str = tsErrorDetail.message;
             str = (node.parentNode as any).constructor.nodeTitle + '：' + str;
@@ -627,23 +661,35 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
     if (/'__UpdateNoProperty__' is declared but its value is never read./.exec(text)) {
         tsErrorDetail.message = '局部更新：未选择任何属性';
         const callLogic = node.parentNode.parentNode.parentNode as CallLogic;
-        const bodyArgument = callLogic.arguments.find(item => item.keyword === 'body');
+        const bodyArgument = callLogic.arguments.find((item) => item.keyword === 'body');
         node = bodyArgument.expression;
     }
 
     // 左右类型不一致的，把上级信息带上
     if (/^Type '(.+?)' is not assignable to type '(.+?)'\./.exec(text) || /^This condition will always return '(.+?)' since the types '(.+?)' and '(.+?)' have no overlap./.exec(text)) {
-        let str = tsErrorDetail.message;
-        str = (node.parentNode as any).constructor.nodeTitle + '：' + str;
-        tsErrorDetail.message = str;
-
-        if (node.parentNode instanceof AnonymousFunction) {
-            // 匿名函数：左右参数类型不一致！左边类型：布尔值，右边类型：整数。
-            tsErrorDetail.message = tsErrorDetail.message.replace('左右参数', '返回值')
-                .replace('左边类型', '接收类型')
-                .replace('右边类型', '传入类型');
-        } else if (text === `Type 'void' is not assignable to type 'never'.`) {
-            tsErrorDetail.message = `${node.name}推断不出类型！请连线或手动设置`;
+        if (node instanceof OqlQueryComponent) {
+            // SQL语句：查询字段重复：id
+            let cap = /^Type '(.+?)' is not assignable to type 'true'\./.exec(text);
+            if (cap) {
+                const errorMsg = 'SQL查询：查询字段重复：$1'.replace(/\$(\d+)/g, (m, index) => transformType(cap[index]));
+                tsErrorDetail.message = errorMsg;
+            } else {
+                cap = /^Type '(.+?)' is not assignable to type '(.+?)'\./.exec(text);
+                if (cap) {
+                    const errorMsg = 'SQL查询：返回类型不一致：选择类型：$2，返回类型：$1'.replace(/\$(\d+)/g, (m, index) => transformType(cap[index]));
+                    tsErrorDetail.message = errorMsg;
+                }
+            }
+        } else {
+            let str = tsErrorDetail.message;
+            str = (node.parentNode as any).constructor.nodeTitle + '：' + str;
+            tsErrorDetail.message = str;
+            if (node.parentNode instanceof AnonymousFunction) {
+                // 匿名函数：左右参数类型不一致！左边类型：布尔值，右边类型：整数。
+                tsErrorDetail.message = tsErrorDetail.message.replace('左右参数', '返回值').replace('左边类型', '接收类型').replace('右边类型', '传入类型');
+            } else if (text === `Type 'void' is not assignable to type 'never'.`) {
+                tsErrorDetail.message = `${node.name}推导不出类型！请连线或手动设置`;
+            }
         }
     }
     // 参数类型不一致！
@@ -673,18 +719,34 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
             node.isSmpty = true;
         }
     }
-    if (/Variable '(.+?)' implicitly has an 'any' type./.exec(text)) {
-        if (node.parentNode instanceof NewMap || node.parentNode instanceof NewList)
+    if (/Variable '(.+?)' implicitly has an 'any' type./.exec(text) || /Variable '(.+?)' implicitly has an 'any\[\]' type./.exec(text)) {
+        if (node.parentNode instanceof NewComposite) {
+            //
+        } else if (node.parentNode instanceof NewList) {
+            tsErrorDetail.message = tsErrorDetail.message.replace('！请连线或手动设置', '');
+        } else if (node.parentNode instanceof NewMap) {
+            tsErrorDetail.message = tsErrorDetail.message.replace('！请连线或手动设置', '');
+        } else {
             return;
-        // if (node.parentNode instanceof NewMap) {
-        //     tsErrorDetail.message = 'newMap未设置类型，右侧属性' + tsErrorDetail.message.split('请连线或手动设置')[0];
-        // } else if (node.parentNode instanceof NewList) {
-        //     tsErrorDetail.message = 'newList未设置类型，属性' + tsErrorDetail.message.split('请连线或手动设置')[0];
-        // }
+        }
     }
     for (const rule of POST_RULES) {
-        if (rule.re.test(tsErrorDetail.message))
-            tsErrorDetail.message = tsErrorDetail.message.replace(rule.re, rule.result);
+        if (rule.re.test(tsErrorDetail.message)) {
+            tsErrorDetail.message = tsErrorDetail.message.replace(rule.re, (value, index, oldStr) => {
+                // 处理匹配到的值的左右的内容，是不是还是字母，要是字母就原样输出，防止展示问题
+                try {
+                    const leftCode = index - 1 < 0 ? '' : oldStr[index - 1];
+                    const rightCode = oldStr[index + value.length] || '';
+                    if (/^[A-Za-z]+$/.test(leftCode) || /^[A-Za-z]+$/.test(rightCode)) {
+                        return value;
+                    } else {
+                        return rule.result;
+                    }
+                } catch (err) {
+                    return value;
+                }
+            });
+        }
     }
     node.tsErrorDetail = tsErrorDetail;
     // 如果logic中有报错就把标识置为true