@lcap/nasl 3.2.0-beta.4 → 3.3.0-alpha

package/src/server/translator.ts

@@ -1,482 +1,460 @@
 import { getDisplayString2Type } from './naslServer';
 import {
-    Module,
-    BaseNode,
-    App,
-    Structure,
-    Logic,
-    Entity,
-    TypeAnnotation,
-    MemberExpression,
-    EntityProperty,
-    EntityIndex,
-    View,
-    Destination,
-    Enum,
-    BindEvent,
-    QueryFromExpression,
-    QueryJoinExpression,
-    QueryFieldExpression,
-    Identifier,
-    CallLogic,
-    EnumItem,
-    Param,
-    Process,
-    Interface,
-    Argument,
-    ViewElement,
-    BindAttribute,
-    Assignment,
-    CallQueryComponent,
-    Role,
-    Configuration,
-    CallInterface,
-    Return,
-    ProcessElement,
-    NullLiteral,
-    SwitchCase,
-    WhileStatement,
-    IfStatement,
-    UnaryExpression,
-    ForEachStatement,
-    CallFunction,
-    ProcessOutcome,
-    Function,
-    Anchor,
-    BatchAssignment,
-    AnonymousFunction,
-    MatchCase,
-    OqlQueryComponent,
-    NewMap,
-    NewList,
-    NewComposite,
-    ValidationRule,
+  Module,
+  BaseNode,
+  App,
+  Structure,
+  Logic,
+  Entity,
+  TypeAnnotation,
+  MemberExpression,
+  EntityProperty,
+  EntityIndex,
+  View,
+  Destination,
+  Enum,
+  BindEvent,
+  QueryFromExpression,
+  QueryJoinExpression,
+  QueryFieldExpression,
+  Identifier,
+  CallLogic,
+  EnumItem,
+  Param,
+  Process,
+  Interface,
+  Argument,
+  ViewElement,
+  BindAttribute,
+  Assignment,
+  CallQueryComponent,
+  Role,
+  Configuration,
+  CallInterface,
+  Return,
+  ProcessElement,
+  NullLiteral,
+  SwitchCase,
+  WhileStatement,
+  IfStatement,
+  UnaryExpression,
+  ForEachStatement,
+  CallFunction,
+  ProcessOutcome,
+  Function,
+  Anchor,
+  BatchAssignment,
+  AnonymousFunction,
+  MatchCase,
+  OqlQueryComponent,
+  NewMap,
+  NewList,
+  NewComposite,
+  ValidationRule,
 } from '../concepts';
 import { SourceMapItem } from '../translator';
 import { Diagnostic } from '../manager/diagnostic';
 import { sortTsString } from '../utils/sortTsString';
 import { getNodeByNodeCallee } from '../automate/engine/utils.js';
+
 export interface MinRange {
-    node: BaseNode;
-    item: SourceMapItem;
+  node: BaseNode;
+  item: SourceMapItem;
 }
 
 const mapAstString = new Map();
 
 function transformType(tsType: string): string {
-    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 = 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;
+  if (tsType === 'string' || tsType === 'String') return '字符串';
+  if (tsType === 'number') return '数字';
+  if (tsType === 'Integer') return '整数';
+  if (tsType === 'Double') return '小数';
+  if (tsType === 'Decimal') return '小数';
+  if (tsType === 'Long') return '整数';
+  if (tsType === 'DateTime') return '日期时间';
+  if (tsType === 'Date') return '日期';
+  if (tsType === 'Time') return '时间';
+  if (tsType === 'boolean' || tsType === 'Boolean') return '布尔值';
+  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 = 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: Record<string, string> = {
-    entities: '实体',
-    structures: '数据结构',
-    enums: '枚举',
-    logics: '逻辑',
-    interfaces: '接口',
-    views: '页面',
-    elements: '元素',
-    processes: '流程',
-    roles: '角色',
-    extensions: '扩展模块',
-    apis: '接口应用',
-    components: '扩展组件',
-    properties: '配置参数',
+  entities: '实体',
+  structures: '数据结构',
+  enums: '枚举',
+  logics: '逻辑',
+  interfaces: '接口',
+  views: '页面',
+  elements: '元素',
+  processes: '流程',
+  roles: '角色',
+  extensions: '扩展模块',
+  apis: '接口应用',
+  components: '扩展组件',
+  properties: '配置参数',
 };
 
 function transformNamespace(tsNamespace: string): string {
-    for (const key in NAMESPACE_CONCEPT_MAP) {
-        const value = NAMESPACE_CONCEPT_MAP[key];
-        if (tsNamespace.endsWith(key))
-            return value;
-    }
-    return 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: string): string {
-    if (tsMethod === 'forEach')
-        return 'ForEach';
-    else
-        return tsMethod;
+  if (tsMethod === 'forEach') return 'ForEach';
+  return tsMethod;
 }
 
 function transformIdentifier(identifier: string): string {
-    if (NAMESPACE_CONCEPT_MAP[identifier])
-        return NAMESPACE_CONCEPT_MAP[identifier];
-    else
-        return ` ${transformType(identifier)} 上的`;
+  if (NAMESPACE_CONCEPT_MAP[identifier]) return NAMESPACE_CONCEPT_MAP[identifier];
+  return ` ${transformType(identifier)} 上的`;
 }
 
 export function outOriginalvalue(value: string) {
-    return value;
+  return value;
 }
 const TS_RULES_TYPE_INCONSISTENCY: Array<RegExp> = [
-    /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 '(.+?)'/,
+  /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: Array<{
-    re: RegExp;
-    result: string;
-    transforms?: Array<(str: string) => string>;
+  re: RegExp;
+  result: string;
+  transforms?: Array<(str: string) => string>;
 }> = [
-    {
-        re: /Property '(FrontEnd|BackEnd)(.+?)' is private and only accessible within/,
-        result: '找不到配置参数$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: /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],
-    },
+  {
+    re: /Property '(FrontEnd|BackEnd)(.+?)' is private and only accessible within/,
+    result: '找不到配置参数$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: /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: Array<{
-    re: RegExp;
-    result: string;
-    transforms?: Array<(str: string) => string>;
+  re: RegExp;
+  result: string;
+  transforms?: Array<(str: string) => string>;
 }> = [
-    {
-        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: '',
-    },
+  {
+    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],
-    });
+  POST_RULES.push({
+    re: new RegExp(key, 'g'),
+    result: NAMESPACE_CONCEPT_MAP[key],
+  });
 });
 
 export function translateDiagnosticMessage(message: string) {
-    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]));
-        }
+  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;
+  }
+  return message;
 }
 /**
  * 节点和ts 报错结合，转成更精准的ts报错
@@ -485,350 +463,366 @@ export function translateDiagnosticMessage(message: string) {
  * @returns
  */
 export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diagnostic) {
-    const text = tsErrorDetail?.originalDiagnostic?.text;
-    let node = minRange?.node;
-    const logicAncestor = node.getAncestor('Logic') || {} as any;
-    const { parentNode = { concept: '' } } = logicAncestor;
-    const isFELogic = ['BindEvent', 'View'].includes(parentNode.concept);
+  const text = tsErrorDetail?.originalDiagnostic?.text;
+  let node = minRange?.node;
+  const logicAncestor = node.getAncestor('Logic') || ({} as any);
+  const { parentNode = { concept: '' } } = logicAncestor;
+  const isFELogic = ['BindEvent', 'View'].includes(parentNode.concept);
 
-    // 有一些节点报错信息不向外暴露,缺失一些原生标签等等的展示
-    if (node instanceof View || node instanceof 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;
-        }
+  // 有一些节点报错信息不向外暴露,缺失一些原生标签等等的展示
+  if (node instanceof View || node instanceof ViewElement) {
+    if (text.startsWith(`'nasl.ui' has no exported member named `)) {
+      return null;
+    }
+    if (text.startsWith(`Property '`) && text.includes(`does not exist on type 'typeof ui'.`)) {
+      return null;
+    }
+    if (text.startsWith(`Namespace 'nasl.ui' has no exported member `)) {
+      return null;
+    }
+    if (text.startsWith(`Function expression, which lacks return-type annotation, implicitly has an 'any[]' return type.`)) {
+      return null;
+    }
+  }
+  // 处理bindevent参数没传递的报错
+  if (/Expected (.+?) arguments, but got (.+?)./.exec(text)) {
+    // bindevent本身现在就不传参数
+    if (node instanceof BindEvent) {
+      return null;
     }
-    // 处理bindevent参数没传递的报错
-    if (/Expected (.+?) arguments, but got (.+?)./.exec(text)) {
-        // bindevent本身现在就不传参数
-        if (node instanceof BindEvent) {
-            return null;
-        }
-
-        if (node instanceof 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 '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 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 'InitiateTask':
+          u = '发起任务';
+          break;
+        default:
+          u = '任务';
+      }
+      if (reg[2] === '0') {
+        tsErrorDetail.message = `${u}出口顺序流个数不能是0`;
+      } else {
+        tsErrorDetail.message = `${u}出口顺序流个数不能大于1`;
+      }
 
-        if (node instanceof 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}没有意义`;
-            }
-        }
+      if (node.type === 'StartNoneEvent') {
+        tsErrorDetail.message = `开始节点只能有一个出口顺序流`;
+      }
     }
 
-    // 因为缺少参数时候有可能有特殊情况,因为原本少的多了就会找到 callLogic上,
-    // 但是只少一个的时候就会找到准确的Argument上 需要特殊处理, ui层就可以统一处理
-    if (/Expected (.+?) arguments, but got (.+?)./.exec(text) && node.getAncestor('CallLogic')) {
-        node = node.getAncestor('CallLogic');
+    if (node instanceof 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}没有意义`;
+      }
     }
-    // 赋值左右侧类型不一致, 把文字换一下
-    if (/Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/.exec(text)) {
-        if (node instanceof OqlQueryComponent) {
-            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 if (node.parentNode instanceof 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 NewList && text.includes(`parameter of type 'never'`)) {
-            tsErrorDetail.message = '自动推导不出类型！newList中有未知类型';
+  }
+
+  // 因为缺少参数时候有可能有特殊情况,因为原本少的多了就会找到 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 OqlQueryComponent) {
+      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 if (node.parentNode instanceof 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 NewList && text.includes(`parameter of type 'never'`)) {
+      tsErrorDetail.message = '自动推导不出类型！newList中有未知类型';
     }
-    if (node instanceof Argument || node instanceof Anchor) {
-        // if (/Type '(.+?)' is not assignable to type '(.+?)'./.exec(text)) {
-        // }
-        // Argument在callInterface上的报错放到内部
-        if (node.expression) {
-            node = node.expression;
-        }
+  }
+  if (node instanceof Argument || node instanceof Anchor) {
+    // if (/Type '(.+?)' is not assignable to type '(.+?)'./.exec(text)) {
+    // }
+    // Argument在callInterface上的报错放到内部
+    if (node.expression) {
+      node = node.expression;
     }
+  }
 
-    if (node instanceof AnonymousFunction) {
-        if (node.body)
-            node = node.body;
-    } else if (node instanceof Function) {
-        if (node.returnExpression) 
-            node = node.returnExpression;
-    }
+  if (node instanceof AnonymousFunction) {
+    if (node.body) node = node.body;
+  } else if (node instanceof Function) {
+    if (node.returnExpression) node = node.returnExpression;
+  }
 
-    // 处理一些复制过来的内容 Identifier或者MemberExpression内容缺失，错误要像上冒
-    if (node instanceof Identifier || node instanceof MemberExpression) {
-        if (node.parentNode instanceof MemberExpression) {
-            let parentNode: BaseNode = node;
-            while (parentNode && parentNode.parentNode instanceof MemberExpression) {
-                parentNode = parentNode.parentNode;
-            }
-            node = parentNode || node;
+  // 处理一些复制过来的内容 Identifier或者MemberExpression内容缺失，错误要像上冒
+  if (node instanceof Identifier || node instanceof MemberExpression) {
+    if (node.parentNode instanceof MemberExpression) {
+      let parentNode: BaseNode = node;
+      while (parentNode && parentNode.parentNode instanceof MemberExpression) {
+        parentNode = parentNode.parentNode;
+      }
+      node = parentNode || node;
 
-            let str = tsErrorDetail.message;
-            str = (node as any).constructor.nodeTitle + '：' + str;
-            tsErrorDetail.message = str;
-        }
+      let str = tsErrorDetail.message;
+      str = `${(node as any).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 TypeAnnotation) {
-            // 变量type的报错放到type本身上
-            // node = node.parentNode;
-            let str = tsErrorDetail.message;
-            if (node) {
-                str = (node as any).parentNode.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 TypeAnnotation) {
+      // 变量type的报错放到type本身上
+      // node = node.parentNode;
+      let str = tsErrorDetail.message;
+      if (node) {
+        str = `${(node as any).parentNode.constructor.nodeTitle}：${str}`;
+      }
+      tsErrorDetail.message = str;
     }
+  }
 
-    /**
-     * 所有问题的报错处理具体信息
-     * 转成一个最合理的文案
-     */
-    if (/^Cannot find name '__(?:IDENTIFIER|LEFT|RIGHT)__'\.$/.exec(text)) {
-        if (node instanceof IfStatement || node instanceof SwitchCase || node instanceof WhileStatement) {
-            tsErrorDetail.message = (node as any).constructor.nodeTitle + '：参数不能为空！所需类型：基础类型>布尔值';
-        } else if (node instanceof ForEachStatement) {
-            tsErrorDetail.message = 'ForEach：结束值：不能为空！所需类型：基础类型>整数';
-        } else if (node instanceof UnaryExpression) {
-            tsErrorDetail.message = '!：参数不能为空！';
-        } else if (node instanceof Assignment) {
-            tsErrorDetail.message = '赋值：参数不能为空！';
-        } else if (node instanceof BatchAssignment) {
-            tsErrorDetail.message = '批量赋值：参数不能为空';
-        } else if ((node instanceof Argument && node.parentNode instanceof CallInterface) || node instanceof CallInterface) {
-            tsErrorDetail.message = '调用接口：参数不能为空！';
-        } else if ((node instanceof Argument && node.parentNode instanceof CallFunction) || node instanceof CallFunction) {
-            tsErrorDetail.message = '调用函数：参数不能为空！';
-        } else if ((node instanceof Argument && node.parentNode instanceof CallLogic) || node instanceof CallLogic) {
-            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;
-            tsErrorDetail.message = str;
-        } else if (node instanceof TypeAnnotation) {
-            // 如果是TypeAnnotation 嵌套TypeAnnotation，就往上冒，多是那种T嵌套的
-            let str = tsErrorDetail.message;
-            // TypeAnnotation要冒泡到最上面
-            while (node.parentNode && node.parentNode instanceof TypeAnnotation) {
-                node = node.parentNode;
-            }
-            str = (node.parentNode as any).constructor.nodeTitle + '：' + str;
+  /**
+   * 所有问题的报错处理具体信息
+   * 转成一个最合理的文案
+   */
+  if (/^Cannot find name '__(?:IDENTIFIER|LEFT|RIGHT)__'\.$/.exec(text)) {
+    if (node instanceof IfStatement || node instanceof SwitchCase || node instanceof WhileStatement) {
+      tsErrorDetail.message = `${(node as any).constructor.nodeTitle}：参数不能为空！所需类型：基础类型>布尔值`;
+    } else if (node instanceof ForEachStatement) {
+      tsErrorDetail.message = 'ForEach：结束值：不能为空！所需类型：基础类型>整数';
+    } else if (node instanceof UnaryExpression) {
+      tsErrorDetail.message = '!：参数不能为空！';
+    } else if (node instanceof Assignment) {
+      tsErrorDetail.message = '赋值：参数不能为空！';
+    } else if (node instanceof BatchAssignment) {
+      tsErrorDetail.message = '批量赋值：参数不能为空';
+    } else if ((node instanceof Argument && node.parentNode instanceof CallInterface) || node instanceof CallInterface) {
+      tsErrorDetail.message = '调用接口：参数不能为空！';
+    } else if ((node instanceof Argument && node.parentNode instanceof CallFunction) || node instanceof CallFunction) {
+      tsErrorDetail.message = '调用函数：参数不能为空！';
+    } else if ((node instanceof Argument && node.parentNode instanceof CallLogic) || node instanceof CallLogic) {
+      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}`;
+      tsErrorDetail.message = str;
+    } else if (node instanceof TypeAnnotation) {
+      // 如果是TypeAnnotation 嵌套TypeAnnotation，就往上冒，多是那种T嵌套的
+      let str = tsErrorDetail.message;
+      // TypeAnnotation要冒泡到最上面
+      while (node.parentNode && node.parentNode instanceof TypeAnnotation) {
+        node = node.parentNode;
+      }
+      str = `${(node.parentNode as any).constructor.nodeTitle}：${str}`;
 
-            tsErrorDetail.message = str;
-        } else if (node instanceof Identifier) {
-            // 根据父级内容推断当前缺少啥
-            const identifierToString = (node: Identifier) => {
-                let str = tsErrorDetail.message;
-                if (node.parentNode instanceof Assignment) {
-                    str = '赋值：参数不能为空！';
-                } else if (node.parentNode instanceof Argument && node.parentNode.parentNode instanceof CallLogic) {
-                    str = '调用逻辑：参数不能为空！';
-                } else if (node.parentNode instanceof ValidationRule) {
-                    str = '验证逻辑：验证对象不能为空！';
-                } else {
-                    str = (node.parentNode as any).constructor.nodeTitle + '：' + str;
-                    tsErrorDetail.message = str;
-                }
-                return str;
-            };
-            tsErrorDetail.message = identifierToString(node);
+      tsErrorDetail.message = str;
+    } else if (node instanceof Identifier) {
+      // 根据父级内容推断当前缺少啥
+      const identifierToString = (node: Identifier) => {
+        let str = tsErrorDetail.message;
+        if (node.parentNode instanceof Assignment) {
+          str = '赋值：参数不能为空！';
+        } else if (node.parentNode instanceof Argument && node.parentNode.parentNode instanceof CallLogic) {
+          str = '调用逻辑：参数不能为空！';
+        } else if (node.parentNode instanceof ValidationRule) {
+          str = '验证逻辑：验证对象不能为空！';
+        } else {
+          str = `${(node.parentNode as any).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 as CallLogic;
-        const bodyArgument = callLogic?.arguments?.find((item) => item.keyword === 'body');
-        node = bodyArgument?.expression;
-    }
+  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');
+    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 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}推导不出类型！请连线或手动设置`;
-            }
+  // 左右类型不一致的，把上级信息带上
+  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 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}推导不出类型！请连线或手动设置`;
+      }
     }
-    if (/Property '(.+?)' is missing in type '(.+?)' but required in type '(.+?)'/.exec(text)) {
-        if (node.parentNode instanceof NewComposite) {
-            tsErrorDetail.message = tsErrorDetail.message.replace('类型不一致', '接收与传入类型不一致').replace('左边类型', '左边接收类型').replace('右边类型', '右边传入类型');
-            tsErrorDetail.message = node.name + tsErrorDetail.message;
-        }
+  }
+  if (/Property '(.+?)' is missing in type '(.+?)' but required in type '(.+?)'/.exec(text)) {
+    if (node.parentNode instanceof 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 TypeAnnotation && node.parentNode instanceof MatchCase) || node instanceof 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 (/^Type '(.+?)' does not satisfy the constraint '(.+?)'\./.exec(text)) {
+    // match
+    if ((node instanceof TypeAnnotation && node.parentNode instanceof MatchCase) || node instanceof 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 Param)
-            return null;
+  // 左右类型不一致的，把上级信息带上
+  if (/^A type literal property cannot have an initializer./.exec(text)) {
+    if (node instanceof Param) return null;
+  }
+  if (/'__LogicEmpty' is declared but its value is never read./.exec(text)) {
+    if (node instanceof Logic) {
+      node.isSmpty = true;
     }
-    if (/'__LogicEmpty' is declared but its value is never read./.exec(text)) {
-        if (node instanceof 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 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 (checkAStructure_(text)) {
-        return null;
+  }
+  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;
     }
-    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 (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;
+          }
+          return rule.result;
+        } catch (err) {
+          return value;
         }
+      });
     }
-    if (node && tsErrorDetail) {
-        node.tsErrorDetail = tsErrorDetail;
-    }
+  }
+  if (node && tsErrorDetail) {
+    node.tsErrorDetail = tsErrorDetail;
+  }
 
-    return {
-        node,
-        ...tsErrorDetail,
-    };
+  return {
+    node,
+    ...tsErrorDetail,
+  };
 }
 
-export function checkAStructure_(errorText: string): any {
-    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].startsWith('{') && cap[1].endsWith('}')) || (cap[1].startsWith('{') && cap[1].endsWith('...')))
-            && ((cap[2].startsWith('{') && cap[2].endsWith('}')) || (cap[2].startsWith('{') && cap[2].endsWith('...')))
-            && (cap[1].includes('__name: "AStructure_') && cap[2].includes('__name: "AStructure_'))) {
-            const x = sortTsString(transformType(cap[1]));
-            const y = sortTsString(transformType(cap[2]));
-            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;
-                }
-            }
-        }
+export function checkAStructure_(errorText: string) {
+  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].startsWith('{') && cap[1].endsWith('}')) || (cap[1].startsWith('{') && cap[1].endsWith('...'))) &&
+      ((cap[2].startsWith('{') && cap[2].endsWith('}')) || (cap[2].startsWith('{') && cap[2].endsWith('...'))) &&
+      cap[1].includes('__name: "AStructure_') &&
+      cap[2].includes('__name: "AStructure_')
+    ) {
+      const x = sortTsString(transformType(cap[1]));
+      const y = sortTsString(transformType(cap[2]));
+      if (x === y) {
+        return true;
+      }
+      if (mapAstString.get(x) === y || mapAstString.get(y) === x) {
+        return true;
+      }
+      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;
+  }
+  return false;
 }