@lcap/nasl 3.6.0-alpha.6 → 3.6.0-alpha.7

package/out/server/translator.js

@@ -1,847 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkAStructure_ = exports.naslNodeTranslateMessage = exports.translateDiagnosticMessage = exports.outOriginalvalue = void 0;
-const naslServer_1 = require("./naslServer");
-const concepts_1 = require("../concepts");
-const sortTsString_1 = require("../utils/sortTsString");
-const mapAstString = new Map();
-function transformType(tsType) {
-    if (tsType === 'string' || tsType === 'String')
-        return '字符串';
-    else if (tsType === 'number')
-        return '数字';
-    else if (tsType === 'Integer')
-        return '整数';
-    else if (tsType === 'Double')
-        return '小数';
-    else if (tsType === 'Decimal')
-        return '小数';
-    else if (tsType === 'Long')
-        return '整数';
-    else if (tsType === 'DateTime')
-        return '日期时间';
-    else if (tsType === 'Date')
-        return '日期';
-    else if (tsType === 'Time')
-        return '时间';
-    else if (tsType === 'boolean' || tsType === 'Boolean')
-        return '布尔值';
-    else if (tsType === 'unknown')
-        return '未知类型';
-    else if (tsType === 'Enums')
-        return '枚举';
-    else if (tsType === 'views')
-        return '页面';
-    else if (tsType === 'void')
-        return '无返回值';
-    else if (tsType === '__elements')
-        return '页面元素';
-    else if (tsType === '__unknown__')
-        return '无效';
-    else if (tsType === 'extensions')
-        return '拓展模块';
-    else if (tsType === 'Promise<void>')
-        return '未知类型';
-    else if ((tsType.startsWith('{') && tsType.endsWith('}')) || (tsType.startsWith('{') && tsType.endsWith('...'))) {
-        if (tsType.includes('__name: "AStructure_')) {
-            return tsType.replace(/__name: "AStructure_\w{8}";/g, '');
-        }
-        return '当前节点';
-    }
-    else if (tsType.endsWith('[]')) {
-        return `List<${transformType(tsType.slice(0, -2))}>`;
-    }
-    else if (tsType.startsWith('<T extends ') && tsType.endsWith('>() => T')) {
-        const types = (0, naslServer_1.getDisplayString2Type)(tsType);
-        let tsStr = '';
-        types.forEach((item, index) => {
-            tsStr += index === 0 ? transformType(item) : ' | ' + transformType(item);
-        });
-        return tsStr;
-    }
-    else if (tsType.includes(' & ')) {
-        const types = tsType.split(' & ');
-        let tsStr = '';
-        types.forEach((item, index) => {
-            tsStr += index === 0 ? transformType(item) : ' | ' + transformType(item);
-        });
-        return tsStr;
-    }
-    else if (tsType.includes(' | ')) {
-        const types = tsType.split(' | ');
-        let tsStr = '';
-        types.forEach((item, index) => {
-            const newItem = item.replace(/[a-zA-Z_]+/g, (text) => transformType(text));
-            tsStr += index === 0 ? newItem : ' 或 ' + newItem;
-        });
-        return tsStr;
-    }
-    else {
-        return tsType;
-    }
-}
-const NAMESPACE_CONCEPT_MAP = {
-    entities: '实体',
-    structures: '数据结构',
-    enums: '枚举',
-    logics: '逻辑',
-    interfaces: '接口',
-    views: '页面',
-    elements: '元素',
-    processes: '流程',
-    roles: '角色',
-    extensions: '扩展模块',
-    apis: '接口应用',
-    components: '扩展组件',
-    properties: '配置参数',
-};
-function transformNamespace(tsNamespace) {
-    for (const key in NAMESPACE_CONCEPT_MAP) {
-        const value = NAMESPACE_CONCEPT_MAP[key];
-        if (tsNamespace.endsWith(key))
-            return value;
-    }
-    return tsNamespace;
-}
-function transformMethod(tsMethod) {
-    if (tsMethod === 'forEach')
-        return 'ForEach';
-    else
-        return tsMethod;
-}
-function transformIdentifier(identifier) {
-    if (NAMESPACE_CONCEPT_MAP[identifier])
-        return NAMESPACE_CONCEPT_MAP[identifier];
-    else
-        return ` ${transformType(identifier)} 上的`;
-}
-function outOriginalvalue(value) {
-    return value;
-}
-exports.outOriginalvalue = outOriginalvalue;
-const TS_RULES_TYPE_INCONSISTENCY = [
-    /This condition will always return '(.+?)' since the types '(.+?)' and '(.+?)' have no overlap/,
-    /Property '(.+?)' is missing in type '(.+?)' but required in type '(.+?)'/,
-    /Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/,
-    /Type '(.+?)' is not assignable to type '(.+?)'/,
-    /Type '(.+?)' does not satisfy the constraint '(.+?)'/,
-    /Type '(.+?)' is missing the following properties from type '(.+?)'/,
-];
-const TS_RULES = [
-    {
-        re: /Property '(FrontEnd|BackEnd)(.+?)' is private and only accessible within/,
-        result: '找不到配置参数$2',
-        transforms: [transformType, transformType],
-    },
-    {
-        re: /Property '(.+?)' is private and only accessible within class '(.+?)'./,
-        result: '“$1”是私有的，只能在“$2”中访问。',
-        transforms: [transformType, transformType],
-    },
-    {
-        re: /Object literal may only specify known properties, and '(.+?)' does not exist in type/,
-        result: '当前参数$1，不可用。',
-        transforms: [transformType],
-    },
-    {
-        re: /Object literal may only specify known properties, but '(.+?)' does not exist in type/,
-        result: '当前参数$1，不可用。',
-        transforms: [transformType],
-    },
-    {
-        re: /Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/,
-        result: '参数类型不一致！传入类型：$1，接收类型：$2。',
-        transforms: [transformType, transformType],
-    },
-    {
-        re: /Type '(.+?)' is not assignable to type '(.+?)'/,
-        result: '左右参数类型不一致！左边类型：$2，右边类型：$1。',
-        transforms: [transformType, transformType],
-    },
-    {
-        re: /Type '(.+?)' does not satisfy the constraint '(.+?)'/,
-        result: '参数类型不一致！传入类型：$1，接收类型：$2。',
-        transforms: [transformType, transformType],
-    },
-    {
-        re: /This condition will always return '(.+?)' since the types '(.+?)' and '(.+?)' have no overlap/,
-        result: '左右参数类型不一致！左边类型：$2，右边类型：$3。',
-        transforms: [transformType, transformType, transformType],
-    },
-    {
-        re: /Type '(.+?)' is missing the following properties from type '(.+?)'/,
-        result: '类型不一致！左边类型：$2，右边类型：$1。',
-        transforms: [transformType, transformType],
-    },
-    {
-        re: /Property '(.+?)' is missing in type '(.+?)' but required in type '(.+?)'/,
-        result: '类型不一致！左边类型：$3，右边类型：$2。',
-        transforms: [outOriginalvalue, transformType, transformType],
-    },
-    {
-        re: /object literal cannot have multiple properties with the same name/,
-        result: '不能具有多个名称相同的属性。',
-    },
-    {
-        re: /Invalid character/,
-        result: '无效的字符',
-    },
-    {
-        // This expression is not callable.\n  Type 'Entity1' has no call signatures.
-        re: /This expression is not callable.\s*Type '(.+?)' has no call signatures/,
-        result: '此表达式不可用。',
-    },
-    {
-        re: /Expression expected/,
-        result: '表达式不能为空！',
-    },
-    {
-        re: /Cannot find name '__(?:IDENTIFIER|LEFT|RIGHT)__'/,
-        result: '表达式不能为空！',
-    },
-    {
-        re: /Cannot find name '__(?:FRONTENDVARIABLES)__'/,
-        result: '前端全局变量：不可在非页面下使用。',
-    },
-    {
-        re: /Cannot find name '__(?:QueryFieldExpression)__'/,
-        result: '数据查询：实体属性不能为空。',
-    },
-    {
-        re: /Cannot find name '__(?:WHERE_MULTIPLE_CONDITION)__'/,
-        result: '数据查询：筛选条件不能有多个表达式。',
-    },
-    {
-        re: /Cannot find name '__(?:HAVING_MULTIPLE_CONDITION)__'/,
-        result: '数据查询：聚合属性过滤不能有多个表达式。',
-    },
-    {
-        re: /Cannot find name '__(?:EMPTY_AGGREGATE_NAME)__'/,
-        result: '数据查询：聚合函数名称不能为空。',
-    },
-    {
-        re: /Cannot find name '__(?:EMPTY_AGGREGATE_ALIAS)__'/,
-        result: '数据查询：聚合函数别名不能为空。',
-    },
-    {
-        re: /Cannot find name '__(?:EMPTY_GROUP_BY_NAME)__'/,
-        result: '数据查询：分组属性不能为空。',
-    },
-    {
-        re: /Cannot find name '__(?:EMPTY_GROUP_BY_ALIAS)__'/,
-        result: '分组属性别名不能为空。',
-    },
-    {
-        re: /Cannot find name '__(?:SQL_GRAMMAR_ERROR)__'/,
-        result: 'SQL查询：语句可能有异常。',
-    },
-    {
-        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查询：语句不能为空。',
-    },
-    {
-        re: /Cannot find name '__(?:NO_SELECT_TYPE)__'/,
-        result: '未选择返回数据类型',
-    },
-    {
-        re: /'_unsupported_syntax_lcap'/,
-        result: 'SQL查询：不支持的使用方式',
-    },
-    {
-        re: /Cannot find name '__UsersEmpty__'./,
-        result: '任务完成人为空',
-    },
-    {
-        re: /Cannot find name '__assignmentLineEmpty__'./,
-        result: '批量赋值没有连线',
-    },
-    {
-        re: /Cannot find name '__ValidationRule__'./,
-        result: '校验规则不能为空',
-    },
-    {
-        re: /No value exists in scope for the shorthand property '__(?:IDENTIFIER|LEFT|RIGHT)__'. Either declare one or provide an initializer./,
-        result: '用户任务未关联页面',
-    },
-    {
-        re: /No value exists in scope for the shorthand property '__(?:outOfProcess)__'. Either declare one or provide an initializer./,
-        result: '节点未关联到流程图',
-    },
-    {
-        re: /'(.+?)' has no exported member(?: named)? '(.+?)'/,
-        result: '找不到接口$1 $2。',
-        transforms: [transformNamespace, transformType],
-    },
-    {
-        re: /Unreachable code detected\./,
-        result: '逻辑中有未使用的。',
-    },
-    // {
-    //   re: /Property '__slice' does not exist on type '(.+?)'/,
-    //   result: 'ForEach：循环列表：参数类型不匹配！所需类型：数组、集合等，提供类型：$1',
-    //   transforms: [transformType],
-    // },
-    {
-        re: /Property '(.+?)' does not exist on type 'typeof (.+?)'/,
-        result: '找不到$2 $1。',
-        transforms: [transformMethod, transformIdentifier],
-    },
-    {
-        re: /Property '(.+?)' does not exist on type '(.+?)'/,
-        result: '找不到$2 $1。',
-        transforms: [transformMethod, transformIdentifier],
-    },
-    {
-        re: /Cannot find name '(.+?)'. Did you mean '(.+?)'\?/,
-        result: '找不到 $1。',
-        transforms: [outOriginalvalue, outOriginalvalue],
-    },
-    {
-        re: /Expected (.+?) type arguments, but got (.+?)/,
-        result: '预期 $1 个类型参数，但传入了 $2 个。',
-        transforms: [outOriginalvalue, outOriginalvalue],
-    },
-    {
-        re: /Expected (.+?) arguments, but got (.+?)./,
-        result: '预期 $1 个参数，但传入了 $2 个。',
-        transforms: [outOriginalvalue, outOriginalvalue],
-    },
-    {
-        re: /The (.+?)-hand side of an arithmetic operation must be of type (.+?). type./,
-        result: '表达式错误！',
-        transforms: [outOriginalvalue, outOriginalvalue],
-    },
-    {
-        re: /Operator '(.+?)' cannot be applied to types '(.+?)' and '(.+?)'./,
-        result: '符号：$1 参数类型不匹配！所需类型：基础类型>$2，提供类型：$3。',
-        transforms: [outOriginalvalue, transformType, transformType],
-    },
-    {
-        re: /Object is possibly 'undefined'./,
-        result: '所选择的内容未定义。',
-    },
-    {
-        re: /Cannot find name '(.+?)'./,
-        result: '所选择的内容 $1 未定义。',
-        transforms: [outOriginalvalue],
-    },
-    {
-        re: /Duplicate identifier '(.+?)'./,
-        result: '当前内容中有重复的 $1，可能会影响使用。',
-        transforms: [outOriginalvalue],
-    },
-    {
-        re: /'__LogicEmpty' is declared but its value is never read./,
-        result: '逻辑为空，请编辑内容',
-    },
-    {
-        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推导不出类型！请连线或手动设置',
-        transforms: [transformType],
-    },
-    {
-        re: /'(.+?)' refers to a value, but is being used as a type here. Did you mean 'typeof (.+?)'?/,
-        result: '$1未初始化！请连线',
-        transforms: [transformType],
-    },
-];
-const POST_RULES = [
-    {
-        re: /__IDENTIFIER__/g,
-        result: 'undefined',
-    },
-    {
-        re: /Integer|"Integer"/g,
-        result: '整数',
-    },
-    {
-        re: /Long|"Long"/g,
-        result: '整数',
-    },
-    {
-        re: /Double|"Double"/g,
-        result: '小数',
-    },
-    {
-        re: /Decimal|"Decimal"/g,
-        result: '小数',
-    },
-    {
-        re: /String|"String"/g,
-        result: '字符串',
-    },
-    {
-        re: /Boolean|"Boolean"/g,
-        result: '布尔值',
-    },
-    {
-        re: /never/g,
-        result: '未知类型',
-    },
-    // 匿名数据结构去掉冗余展示 __name: "AStructure_\w{8}"
-    {
-        re: /__name: "AStructure_\w{8}";/g,
-        result: '',
-    },
-];
-Object.keys(NAMESPACE_CONCEPT_MAP).forEach((key) => {
-    POST_RULES.push({
-        re: new RegExp(key, 'g'),
-        result: NAMESPACE_CONCEPT_MAP[key],
-    });
-});
-function translateDiagnosticMessage(message) {
-    // 业务组件先处理
-    const businessComponent = /Namespace 'app.frontendTypes.(.+?).businessComponents' has no exported member '(.+?)'./.exec(message);
-    if (businessComponent?.[1] && businessComponent?.[2]) {
-        return `找不到${businessComponent?.[1]}端下的业务组件${businessComponent?.[2]}`;
-    }
-    for (const rule of TS_RULES) {
-        const cap = rule.re.exec(message);
-        if (cap) {
-            return rule.result.replace(/\$(\d+)/g, (m, index) => rule.transforms[index - 1](cap[index]));
-        }
-    }
-    return message;
-}
-exports.translateDiagnosticMessage = translateDiagnosticMessage;
-/**
- * 节点和ts 报错结合，转成更精准的ts报错
- * @param minRange
- * @param tsErrorDetail 报错具体信息
- * @returns
- */
-function naslNodeTranslateMessage(minRange, tsErrorDetail) {
-    const text = tsErrorDetail?.originalDiagnostic?.text;
-    let node = minRange?.node;
-    const logicAncestor = node.getAncestor('Logic') || {};
-    const { parentNode = { concept: '' } } = logicAncestor;
-    // const isFELogic = ['BindEvent', 'View'].includes(parentNode.concept);
-    // 有一些节点报错信息不向外暴露,缺失一些原生标签等等的展示
-    if (node instanceof concepts_1.View || node instanceof concepts_1.BusinessComponent || node instanceof concepts_1.ViewElement) {
-        if (text.startsWith(`'nasl.ui' has no exported member named `)) {
-            return null;
-        }
-        else if (text.startsWith(`Property '`) && text.includes(`does not exist on type 'typeof ui'.`)) {
-            return null;
-        }
-        else if (text.startsWith(`Namespace 'nasl.ui' has no exported member `)) {
-            return null;
-        }
-        else if (text.startsWith(`Function expression, which lacks return-type annotation, implicitly has an 'any[]' return type.`)) {
-            return null;
-        }
-        else if (/Property 'businessComponents' does not exist on type 'typeof (pc|h5)'./.exec(text)) {
-            return null;
-        }
-    }
-    // 处理bindevent参数没传递的报错
-    if (/Expected (.+?) arguments, but got (.+?)./.exec(text)) {
-        // bindevent本身现在就不传参数
-        if (node instanceof concepts_1.BindEvent) {
-            return null;
-        }
-        if (node instanceof concepts_1.ProcessElement && (node.isUserTask || node.type === 'AutoTask' || node.type === 'StartNoneEvent')) {
-            const reg = /Expected (.+?) arguments, but got (.+?)./.exec(text);
-            let u;
-            switch (node.type) {
-                case 'UserTask':
-                    u = '用户任务';
-                    break;
-                case 'AutoTask':
-                    u = '自动任务';
-                    break;
-                case 'ApprovalTask':
-                    u = '审批任务';
-                    break;
-                case 'MultiApprovalTask':
-                    u = '多人审批任务';
-                    break;
-                case 'InitiateTask':
-                    u = '发起任务';
-                    break;
-                default:
-                    u = '任务';
-            }
-            if (reg[2] === '0') {
-                tsErrorDetail.message = `${u}出口顺序流个数不能是0`;
-            }
-            else {
-                tsErrorDetail.message = `${u}出口顺序流个数不能大于1`;
-            }
-            if (node.type === 'StartNoneEvent') {
-                tsErrorDetail.message = `开始节点只能有一个出口顺序流`;
-            }
-        }
-        if (node instanceof concepts_1.ProcessElement && ['ExclusiveGateway', 'ParallelGateway', 'InclusiveGateway'].includes(node.type)) {
-            const reg = /Expected (.+?) arguments, but got (.+?)./.exec(text);
-            let u = '排他网关';
-            if (node.type === 'ParallelGateway') {
-                u = '并行网关';
-            }
-            else if (node.type === 'InclusiveGateway') {
-                u = '包容网关';
-            }
-            if (reg[2] === '0') {
-                tsErrorDetail.message = `${u}出口顺序流和入口顺序流个数不能等于0`;
-            }
-            else {
-                tsErrorDetail.message = `${u}出口顺序流和入口顺序流个数同时等于1，该${u}没有意义`;
-            }
-        }
-    }
-    // 因为缺少参数时候有可能有特殊情况,因为原本少的多了就会找到 callLogic上,
-    // 但是只少一个的时候就会找到准确的Argument上 需要特殊处理, ui层就可以统一处理
-    if (/Expected (.+?) arguments, but got (.+?)./.exec(text) && node.getAncestor('CallLogic')) {
-        node = node.getAncestor('CallLogic');
-    }
-    // 赋值左右侧类型不一致, 把文字换一下
-    if (/Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/.exec(text)) {
-        if (node instanceof concepts_1.OqlQueryComponent) {
-            tsErrorDetail.message = tsErrorDetail.message
-                .replace('参数类型不一致！传入类型：', '类型不一致！传入类型：')
-                .replace('接收类型：', '期望类型：');
-        }
-        else if (node.parentNode instanceof concepts_1.Assignment) {
-            // OQL 的返回类型报错需要转换翻译，其内部 SQL 语句的参数类型报错不转换翻译
-            if (node instanceof concepts_1.OqlQueryComponent) {
-                if (node.getCurrentSource().currentSource.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 if (node.parentNode instanceof concepts_1.NewMap) {
-            if (text.includes(`is not assignable to parameter of type 'None'`)) {
-                const cap = /Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/.exec(text);
-                tsErrorDetail.message = tsErrorDetail.message = `参数类型不一致！传入类型：${transformType(cap[1])}，接收类型：字符串  或 布尔值 或 整数 或 小数`;
-            }
-            else if (text.includes(`parameter of type 'never'`)) {
-                tsErrorDetail.message = '自动推导不出类型！newMap中有未知类型';
-            }
-        }
-        else if (node.parentNode instanceof concepts_1.NewList && text.includes(`parameter of type 'never'`)) {
-            tsErrorDetail.message = '自动推导不出类型！newList中有未知类型';
-        }
-        else if (node instanceof concepts_1.ProcessOutcome || node instanceof concepts_1.ProcessOutcomes) {
-            const cap = /Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/.exec(text);
-            const selectComes = cap[1].split(' | ');
-            const currentComes = cap[2].split(' | ');
-            if (node instanceof concepts_1.ProcessOutcome) {
-                tsErrorDetail.message = `流向出口不存在，${selectComes.map((item) => item).join(',')}出口流不属于[${currentComes.map((item) => item).join(',')}]当中的某个流`;
-            }
-            else {
-                tsErrorDetail.message = `流向出口不存在，${selectComes.map((item) => item).join(',')}有错误的出口流`;
-            }
-        }
-    }
-    if (/Property '__slice' does not exist on type '(.+?)'/.exec(text)) {
-        const cap = /Property '__slice' does not exist on type '(.+?)'/.exec(text);
-        if (cap) {
-            if (node instanceof concepts_1.ForEachStatement) {
-                tsErrorDetail.message = `ForEach：循环列表：参数类型不匹配！所需类型：数组、集合等，提供类型：$1`.replace(/\$(\d+)/g, (m, index) => transformType(cap[index]));
-            }
-            else if (node instanceof concepts_1.Paginate) {
-                tsErrorDetail.message = `分页：分页对象类型不匹配！所需类型：数组、集合等，提供类型：$1`.replace(/\$(\d+)/g, (m, index) => transformType(cap[index]));
-            }
-        }
-    }
-    if (node instanceof concepts_1.Argument || node instanceof concepts_1.Anchor) {
-        // if (/Type '(.+?)' is not assignable to type '(.+?)'./.exec(text)) {
-        // }
-        // Argument在callInterface上的报错放到内部
-        if (node.expression) {
-            node = node.expression;
-        }
-    }
-    if (node instanceof concepts_1.AnonymousFunction) {
-        if (node.body)
-            node = node.body;
-    }
-    else if (node instanceof concepts_1.Function) {
-        if (node.returnExpression)
-            node = node.returnExpression;
-    }
-    // 处理一些复制过来的内容 Identifier或者MemberExpression内容缺失，错误要像上冒
-    if (node instanceof concepts_1.Identifier || node instanceof concepts_1.MemberExpression) {
-        if (node.parentNode instanceof concepts_1.MemberExpression) {
-            let parentNode = node;
-            while (parentNode && parentNode.parentNode instanceof concepts_1.MemberExpression) {
-                parentNode = parentNode.parentNode;
-            }
-            node = parentNode || node;
-            let str = tsErrorDetail.message;
-            str = node.constructor.nodeTitle + '：' + str;
-            tsErrorDetail.message = str;
-        }
-    }
-    // 类型报错的，需要放到上一级
-    if (/'(.+?)' has no exported member(?: named)? '(.+?)'/.exec(text) || /Property '(.+?)' does not exist on type '(.+?)'./.exec(text)) {
-        if (node instanceof concepts_1.TypeAnnotation) {
-            // 变量type的报错放到type本身上
-            // node = node.parentNode;
-            let str = tsErrorDetail.message;
-            if (node) {
-                str = node.parentNode.constructor.nodeTitle + '：' + str;
-            }
-            tsErrorDetail.message = str;
-        }
-    }
-    /**
-     * 所有问题的报错处理具体信息
-     * 转成一个最合理的文案
-     */
-    if (/^Cannot find name '__(?:IDENTIFIER|LEFT|RIGHT)__'\.$/.exec(text)) {
-        if (node instanceof concepts_1.IfStatement || node instanceof concepts_1.SwitchCase || node instanceof concepts_1.WhileStatement) {
-            tsErrorDetail.message = node.constructor.nodeTitle + '：参数不能为空！所需类型：基础类型>布尔值';
-        }
-        else if (node instanceof concepts_1.ForEachStatement) {
-            tsErrorDetail.message = 'ForEach：结束值：不能为空！所需类型：基础类型>整数';
-        }
-        else if (node instanceof concepts_1.UnaryExpression) {
-            tsErrorDetail.message = '!：参数不能为空！';
-        }
-        else if (node instanceof concepts_1.Assignment) {
-            tsErrorDetail.message = '赋值：参数不能为空！';
-        }
-        else if (node instanceof concepts_1.BatchAssignment) {
-            tsErrorDetail.message = '批量赋值：参数不能为空';
-        }
-        else if ((node instanceof concepts_1.Argument && node.parentNode instanceof concepts_1.CallInterface) || node instanceof concepts_1.CallInterface) {
-            tsErrorDetail.message = '调用接口：参数不能为空！';
-        }
-        else if ((node instanceof concepts_1.Argument && node.parentNode instanceof concepts_1.CallFunction) || node instanceof concepts_1.CallFunction) {
-            tsErrorDetail.message = '调用函数：参数不能为空！';
-        }
-        else if ((node instanceof concepts_1.Argument && node.parentNode instanceof concepts_1.CallLogic) || node instanceof concepts_1.CallLogic) {
-            tsErrorDetail.message = '调用逻辑：参数不能为空！';
-        }
-        else if (node instanceof concepts_1.ProcessOutcome || node instanceof concepts_1.Function || node instanceof concepts_1.MatchCase) {
-            tsErrorDetail.message = node.constructor.nodeTitle + '：不能为空！';
-        }
-        else if (node instanceof concepts_1.NewMap) {
-            tsErrorDetail.message = 'Map推导不出类型！请手动设置！';
-        }
-        else if (node instanceof concepts_1.NewList) {
-            tsErrorDetail.message = 'List推导不出类型！请手动设置！';
-        }
-        else if (node instanceof concepts_1.Argument) {
-            let str = tsErrorDetail.message;
-            str = node.parentNode.constructor.nodeTitle + '：' + str;
-            tsErrorDetail.message = str;
-        }
-        else if (node instanceof concepts_1.TypeAnnotation) {
-            // 如果是TypeAnnotation 嵌套TypeAnnotation，就往上冒，多是那种T嵌套的
-            let str = tsErrorDetail.message;
-            // TypeAnnotation要冒泡到最上面
-            while (node.parentNode && node.parentNode instanceof concepts_1.TypeAnnotation) {
-                node = node.parentNode;
-            }
-            str = node.parentNode.constructor.nodeTitle + '：' + str;
-            tsErrorDetail.message = str;
-        }
-        else if (node instanceof concepts_1.Identifier) {
-            // 根据父级内容推断当前缺少啥
-            const identifierToString = (node) => {
-                let str = tsErrorDetail.message;
-                if (node.parentNode instanceof concepts_1.Assignment) {
-                    str = '赋值：参数不能为空！';
-                }
-                else if (node.parentNode instanceof concepts_1.Argument && node.parentNode.parentNode instanceof concepts_1.CallLogic) {
-                    str = '调用逻辑：参数不能为空！';
-                }
-                else if (node.parentNode instanceof concepts_1.ValidationRule) {
-                    str = '验证逻辑：验证对象不能为空！';
-                }
-                else {
-                    str = node.parentNode.constructor.nodeTitle + '：' + str;
-                    tsErrorDetail.message = str;
-                }
-                return str;
-            };
-            tsErrorDetail.message = identifierToString(node);
-        }
-    }
-    if (/'__UpdateNoProperty__' is declared but its value is never read./.exec(text)) {
-        tsErrorDetail.message = '局部更新：未选择任何属性';
-        const callLogic = node?.parentNode?.parentNode?.parentNode;
-        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)) {
-        if (node instanceof concepts_1.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.constructor.nodeTitle + '：' + str;
-            tsErrorDetail.message = str;
-            if (node.parentNode instanceof concepts_1.AnonymousFunction) {
-                // 匿名函数：左右参数类型不一致！左边类型：布尔值，右边类型：整数。
-                tsErrorDetail.message = tsErrorDetail.message.replace('左右参数', '返回值').replace('左边类型', '接收类型').replace('右边类型', '传入类型');
-            }
-            else if (text === `Type 'void' is not assignable to type 'never'.`) {
-                tsErrorDetail.message = `${node.name}推导不出类型！请连线或手动设置`;
-            }
-        }
-    }
-    if (/Property '(.+?)' is missing in type '(.+?)' but required in type '(.+?)'/.exec(text)) {
-        if (node.parentNode instanceof concepts_1.NewComposite) {
-            tsErrorDetail.message = tsErrorDetail.message
-                .replace('类型不一致', '接收与传入类型不一致')
-                .replace('左边类型', '左边接收类型')
-                .replace('右边类型', '右边传入类型');
-            tsErrorDetail.message = node.name + tsErrorDetail.message;
-        }
-    }
-    // 参数类型不一致！
-    if (/^Type '(.+?)' does not satisfy the constraint '(.+?)'\./.exec(text)) {
-        // match
-        if ((node instanceof concepts_1.TypeAnnotation && node.parentNode instanceof concepts_1.MatchCase) || node instanceof concepts_1.MatchCase) {
-            return null;
-            // ide进行计算
-            // const reg = /^Type '(.+?)' does not satisfy the constraint '(.+?)'\./.exec(text);
-            // if (reg[1] && reg[2]) {
-            //     tsErrorDetail.message = '匹配：类型不一致! 传入类型：' + transformType(reg[1]) + '，接收类型：' + transformType(reg[2]);
-            //     if (reg[2] === 'never') {
-            //         tsErrorDetail.message = '匹配：类型不一致! 传入类型：' + transformType(reg[1]) + '，接收类型：无可以接收的类型';
-            //     }
-            // }
-            // tsErrorDetail.titleTip = '该类型无法满足条件';
-        }
-    }
-    // 左右类型不一致的，把上级信息带上
-    if (/^A type literal property cannot have an initializer./.exec(text)) {
-        if (node instanceof concepts_1.Param)
-            return null;
-    }
-    if (/'__LogicEmpty' is declared but its value is never read./.exec(text)) {
-        if (node instanceof concepts_1.Logic) {
-            node.isSmpty = true;
-        }
-    }
-    if (/Variable '(.+?)' implicitly has an 'any' type./.exec(text) || /Variable '(.+?)' implicitly has an 'any\[\]' type./.exec(text)) {
-        if (node.parentNode instanceof concepts_1.NewComposite) {
-            //
-        }
-        else if (node.parentNode instanceof concepts_1.NewList) {
-            tsErrorDetail.message = tsErrorDetail.message.replace('！请连线或手动设置', '');
-        }
-        else if (node.parentNode instanceof concepts_1.NewMap) {
-            tsErrorDetail.message = tsErrorDetail.message.replace('！请连线或手动设置', '');
-        }
-        else {
-            return;
-        }
-    }
-    if (checkAStructure_(text)) {
-        return null;
-    }
-    for (const rule of POST_RULES) {
-        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;
-                }
-            });
-        }
-    }
-    if (node && tsErrorDetail) {
-        node.tsErrorDetail = tsErrorDetail;
-    }
-    return {
-        node,
-        ...tsErrorDetail,
-    };
-}
-exports.naslNodeTranslateMessage = naslNodeTranslateMessage;
-function checkAStructure_(errorText) {
-    const index = TS_RULES_TYPE_INCONSISTENCY.findIndex((item) => item.exec(errorText));
-    if (index !== -1) {
-        const rule = TS_RULES_TYPE_INCONSISTENCY[index];
-        const cap = rule.exec(errorText);
-        if (rule === TS_RULES_TYPE_INCONSISTENCY[0] || rule === TS_RULES_TYPE_INCONSISTENCY[1]) {
-            cap.splice(1, 1);
-        }
-        if (cap[1].includes('__name: "AStructure_') &&
-            cap[2].includes('__name: "AStructure_')) {
-            const x = (0, sortTsString_1.sortTsString)(transformType(cap[1]));
-            const y = (0, sortTsString_1.sortTsString)(transformType(cap[2]));
-            if (x === null || y === null) {
-                return;
-            }
-            if (x === y) {
-                return true;
-            }
-            else if (mapAstString.get(x) === y || mapAstString.get(y) === x) {
-                return true;
-            }
-            else {
-                const regex = /Type '"AStructure_(.*)' is not assignable to type '"AStructure_(.*)'/;
-                const nameError = regex.exec(errorText);
-                const length1 = x.match(/:/g) ? x.match(/:/g).length : -1;
-                const length2 = y.match(/:/g) ? y.match(/:/g).length : -2;
-                if (nameError && length1 === length2) {
-                    mapAstString.set(x, y);
-                    mapAstString.set(y, x);
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-exports.checkAStructure_ = checkAStructure_;
-//# sourceMappingURL=translator.js.map