@hadss/turbo-trans-json-plugin 1.0.0-rc.0

package/src/core/analyzers/CustomTypeAnalyzer.ts

@@ -0,0 +1,337 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  ClassDeclaration,
+  EnumDeclaration,
+  InterfaceDeclaration,
+  Project,
+  SourceFile,
+  TypeAliasDeclaration
+} from 'ts-morph';
+import {
+  ClassDetails,
+  EnumDetails,
+  EnumMemberInfo,
+  InterfaceDetails,
+  TypeAliasDetails,
+  TypeDependency,
+  TypeDetails,
+  TypeKind
+} from '..';
+import SerializationPathUtil from '../utils/SerializationPathUtil';
+import { TsMorphUtil } from '../utils/TsMorphUtil';
+
+export class CustomTypeAnalyzer {
+  private static readonly INSTANCE: CustomTypeAnalyzer = new CustomTypeAnalyzer();
+  /** 类型查找缓存 <名称+路径，依赖地址> */
+  private searchCache = new Map<string, TypeDependency | null>();
+
+  private constructor() { }
+
+  public static getInstance(): CustomTypeAnalyzer {
+    return this.INSTANCE;
+  }
+
+  /**
+   * 类型查找方法-实现本文件-->本模块-->跨模块三步走查找逻辑
+   *
+   * @param targetName 目标类型名称
+   * @param sourceFile 起始源文件
+   * @returns 查找结果，未找到时返回 null
+   */
+  public findDefinition(targetName: string, sourceFile: SourceFile): TypeDependency | null {
+    const cacheKey = `${sourceFile.getFilePath()}:${targetName}`;
+
+    // 检查缓存
+    if (cacheKey && this.searchCache.has(cacheKey)) {
+      const cached = this.searchCache.get(cacheKey);
+      return cached !== undefined ? cached : null;
+    }
+
+    let result: TypeDependency | null;
+
+    // 步骤1：在当前文件中查找
+    result = this.findInCurrentFile(targetName, sourceFile);
+    if (result) {
+      if (cacheKey) {
+        this.searchCache.set(cacheKey, result);
+      }
+      return result;
+    }
+
+    // 步骤2：根据导入语句查找本模块内的类型定义
+    result = this.findInImports(targetName, sourceFile);
+    if (result) {
+      if (cacheKey) {
+        this.searchCache.set(cacheKey, result);
+      }
+      return result;
+    }
+
+    // 步骤3：查找oh_modules中的跨模块类型定义
+    result = this.findInCrossModule(targetName, sourceFile);
+    if (result) {
+      if (cacheKey) {
+        this.searchCache.set(cacheKey, result);
+      }
+      return result;
+    }
+
+    // 缓存未找到的结果
+    if (cacheKey) {
+      this.searchCache.set(cacheKey, null);
+    }
+    return null;
+  }
+
+  public findClassDeclFromClassName(className: string, sourceFile: SourceFile): ClassDeclaration | InterfaceDeclaration | null {
+    const res = this.findDefinition(className, sourceFile);
+    if (res && res.typeKind === TypeKind.CLASS) {
+      return (res.details as ClassDetails).classDecl;
+    }
+    if (res && res.typeKind === TypeKind.INTERFACE) {
+      return (res.details as InterfaceDetails).interfaceDecl;
+    }
+    return null;
+  }
+
+  public clearCache(): void {
+    this.searchCache.clear();
+  }
+
+  private findInCurrentFile(targetName: string, sourceFile: SourceFile): TypeDependency | null {
+    const typeDetail = this.searchInSourceFile(targetName, sourceFile);
+    if (typeDetail) {
+      return {
+        typeName: targetName,
+        typeKind: typeDetail.kind,
+        importPath: '',
+        source: {
+          type: 'local',
+          sourceFilePath: sourceFile.getFilePath()
+        },
+        details: typeDetail
+      };
+    }
+    return null;
+  }
+
+  private findInImports(targetName: string, sourceFile: SourceFile): TypeDependency | null {
+    const imports = sourceFile.getImportDeclarations();
+
+    for (const importDecl of imports) {
+      // TODO:当前实现只处理命名导入，default导入和命名空间导入暂未支持
+      const namedImports = importDecl.getNamedImports();
+      const specifierValue = importDecl.getModuleSpecifierValue();
+
+      // 检查是否在命名导入中找到了目标类型
+      for (const namedImport of namedImports) {
+        const importName = namedImport.getName();
+        if (importName === targetName) {
+          // 找到了导入的类型，现在需要解析文件路径
+          const moduleSpecifier = importDecl.getModuleSpecifierValue();
+          const resolvedPath = this.resolveImportPath(moduleSpecifier, sourceFile);
+
+          if (resolvedPath && SerializationPathUtil.exist(resolvedPath)) {
+            // 加载外部文件并查找类型定义
+            const externalSourceFile = this.getOrLoadSourceFile(resolvedPath);
+            if (externalSourceFile) {
+              const typeDetail = this.searchInSourceFile(targetName, externalSourceFile);
+              if (typeDetail) {
+                return {
+                  typeName: targetName,
+                  typeKind: typeDetail.kind,
+                  importPath: specifierValue,
+                  source: {
+                    type: 'imported',
+                    sourceFilePath: externalSourceFile.getFilePath(),
+                    originalImport: specifierValue
+                  },
+                  details: typeDetail
+                };
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
+  private findInCrossModule(targetName: string, sourceFile: SourceFile): TypeDependency | null {
+    // TODO: 跨模块暂未实现
+    return null;
+  }
+
+  private searchInSourceFile(targetName: string, sourceFile: SourceFile): TypeDetails | null {
+    // 查找类定义
+    const classes = sourceFile.getClasses();
+    for (const classDecl of classes) {
+      if (classDecl.getName() === targetName) {
+        return this.parseClassDetails(classDecl);
+      }
+    }
+
+    // 查找接口定义
+    const interfaces = sourceFile.getInterfaces();
+    for (const interfaceDecl of interfaces) {
+      if (interfaceDecl.getName() === targetName) {
+        return this.parseInterfaceDetails(interfaceDecl);
+      }
+    }
+
+    // 查找枚举定义
+    const enums = sourceFile.getEnums();
+    for (const enumDecl of enums) {
+      if (enumDecl.getName() === targetName) {
+        return this.parseEnumDetails(enumDecl);
+      }
+    }
+
+    // 查找类型定义
+    const types = sourceFile.getTypeAliases();
+    for (const typeAliasDecl of types) {
+      if (typeAliasDecl.getName() === targetName) {
+        return this.parseTypeAliasDetails(typeAliasDecl);
+      }
+    }
+
+    return null;
+  }
+
+  private parseEnumDetails(enumDecl: EnumDeclaration): EnumDetails {
+    const members: EnumMemberInfo[] = [];
+    let valueType: 'string' | 'number' = 'number'; // 默认为数值类型
+    let numericValue = 0; // 用于自动递增的数值
+
+    const enumMembers = enumDecl.getMembers();
+    for (const member of enumMembers) {
+      const memberName = member.getName();
+      let memberValue: string | number;
+      let literalValue: string;
+
+      const initializer = member.getInitializer();
+      if (initializer) {
+        // 有显式初始值
+        const initText = initializer.getText().trim();
+
+        // 判断是字符串还是数值
+        if (initText.startsWith('"') && initText.endsWith('"')) {
+          // 字符串枚举
+          memberValue = initText.slice(1, -1); // 去掉引号
+          literalValue = initText; // 保留引号
+          valueType = 'string';
+        } else if (initText.startsWith("'") && initText.endsWith("'")) {
+          // 字符串枚举（单引号）
+          memberValue = initText.slice(1, -1); // 去掉引号
+          literalValue = `"${memberValue}"`; // 统一使用双引号
+          valueType = 'string';
+        } else {
+          // 数值枚举
+          const numValue = parseInt(initText, 10);
+          if (!isNaN(numValue)) {
+            memberValue = numValue;
+            literalValue = numValue.toString();
+            numericValue = numValue + 1; // 更新下一个自动值
+          } else {
+            // 复杂表达式，暂时当作字符串处理
+            memberValue = initText;
+            literalValue = `"${initText}"`;
+            valueType = 'string';
+          }
+        }
+      } else {
+        // 没有显式初始值，使用自动递增的数值
+        memberValue = numericValue;
+        literalValue = numericValue.toString();
+        numericValue++;
+      }
+      members.push({
+        name: memberName,
+        value: memberValue,
+        literalValue
+      });
+    }
+    return { kind: TypeKind.ENUM, valueType, members };
+  }
+
+  private parseClassDetails(classDecl: ClassDeclaration): ClassDetails {
+    return {
+      kind: TypeKind.CLASS,
+      classDecl,
+      isGeneric: classDecl.getTypeParameters().length > 0
+    };
+  }
+
+  private parseInterfaceDetails(interfaceDecl: InterfaceDeclaration): InterfaceDetails {
+    return {
+      kind: TypeKind.INTERFACE,
+      interfaceDecl,
+      isGeneric: interfaceDecl.getTypeParameters().length > 0
+    };
+  }
+
+  private parseTypeAliasDetails(typeAliasDecl: TypeAliasDeclaration): TypeAliasDetails {
+    const aliasedType = typeAliasDecl.getTypeNodeOrThrow().getText();
+
+    // 解析实际类型节点，填充 resolvedType
+    const actualTypeNode = typeAliasDecl.getTypeNodeOrThrow();
+    const { TypeHandlerRegistry } = require('../handlers/TypeHandlerRegistry');
+
+    // 递归解析实际类型结构
+    const resolvedType = TypeHandlerRegistry.getInstance().parseType(actualTypeNode, {
+      depth: 0,
+      genericParams: []
+    });
+
+    return { kind: TypeKind.TYPE, aliasedType, resolvedType };
+  }
+
+  private resolveImportPath(moduleSpecifier: string, sourceFile: SourceFile): string | null {
+    const currentFilePath = sourceFile.getFilePath();
+    const currentDir = SerializationPathUtil.dirname(currentFilePath);
+
+    // 处理相对路径导入
+    if (moduleSpecifier.startsWith('./') || moduleSpecifier.startsWith('../')) {
+      const resolvedPath = SerializationPathUtil.pathResolve(currentDir, moduleSpecifier);
+
+      // 尝试不同的文件扩展名
+      const extensions = ['.ets', '.d.ets'];
+      for (const ext of extensions) {
+        const fullPath = resolvedPath + ext;
+        if (SerializationPathUtil.exist(fullPath)) {
+          return fullPath;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  private getOrLoadSourceFile(filePath: string): SourceFile | null {
+    const existingFile = TsMorphUtil.getProject().getSourceFile(filePath);
+    if (existingFile) {
+      return existingFile;
+    }
+
+    if (SerializationPathUtil.exist(filePath)) {
+      return TsMorphUtil.getProject().addSourceFileAtPath(filePath);
+    }
+
+    return null;
+  }
+}

package/src/core/analyzers/SendableMergeChecker.ts

@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Decorator } from 'ts-morph';
+import { ClassAnalysis, PropertyKind, TypeStructure } from '../Types';
+import { DecoratorConstants } from '../constants';
+import { Logger } from '../logger/Logger';
+import { SendableMergeabilityRegistry } from './SendableMergeabilityRegistry';
+
+/**
+ * Sendable类合并性检查器
+ *
+ * 检查是否可以将原始类和Sendable类合并为单一Sendable类。
+ *
+ * 合并条件：
+ * 1. 类层级无非TurboTrans装饰器
+ * 2. 类无泛型参数
+ * 3. 每个属性无非TurboTrans装饰器
+ * 4. 每个属性是Sendable允许类型或可合并的@Serializable类
+ * 5. 父类也必须可合并
+ *
+ * 合并后的类：
+ * - 移除所有TurboTrans装饰器
+ * - 添加 @Sendable 装饰器
+ * - 类名保持不变
+ */
+export class SendableMergeChecker {
+  // TurboTrans装饰器集合（用于快速查找）
+  private static readonly TURBO_TRANS_DECORATORS = new Set(DecoratorConstants.SERIAL_DECORATORS);
+
+  // Sendable允许的基础类型（根据官方文档）
+  private static readonly SENDABLE_PRIMITIVE_KINDS = new Set<PropertyKind>([
+    PropertyKind.STRING,
+    PropertyKind.NUMBER,
+    PropertyKind.BOOLEAN,
+    PropertyKind.BIGINT,
+    PropertyKind.NULL,
+    PropertyKind.UNDEFINED,
+  ]);
+
+  // TODO: 这里的白名单暂时还没写全
+  // Sendable允许的Collections容器类型
+  private static readonly SENDABLE_COLLECTION_KINDS = new Set<PropertyKind>([
+    PropertyKind.COLLECTIONS_ARRAY,
+    PropertyKind.COLLECTIONS_SET,
+    PropertyKind.COLLECTIONS_MAP,
+  ]);
+
+  /**
+   * 检查类的Sendable合并性
+   * @param classAnalysis 类分析结果
+   * @returns 合并性分析结果
+   */
+  public static check(classAnalysis: ClassAnalysis): boolean {
+    // 条件1: 检查类级别装饰器
+    const classDecorators = classAnalysis.originalClass?.getDecorators() || [];
+    const nonTurboTransDecorators = this.getNonTurboTransDecorators(classDecorators);
+    if (nonTurboTransDecorators.length > 0) {
+      // TODO: 完善debug日志
+      Logger.debug(`${classAnalysis.className}类有其他装饰器`);
+      return false;
+    }
+
+    // 条件2: 检查泛型参数
+    if (classAnalysis.generics.isGeneric) {
+      // TODO: 完善debug日志
+      Logger.debug(`${classAnalysis.className}类有泛型参数`);
+      return false;
+    }
+
+    // 条件3 & 4: 检查属性装饰器和类型
+    const invalidProperties: string[] = [];
+    for (const property of classAnalysis.properties) {
+      // 条件3: 检查属性装饰器
+      const propertyNode = classAnalysis.originalClass?.getProperty(property.name);
+      if (propertyNode) {
+        const propDecorators = propertyNode.getDecorators();
+        const nonTurboPropDecorators = this.getNonTurboTransDecorators(propDecorators);
+        if (nonTurboPropDecorators.length > 0) {
+          // TODO: 完善debug日志
+          invalidProperties.push(`${property.name} (装饰器: ${nonTurboPropDecorators.join(', ')})`);
+          continue;
+        }
+      }
+
+      // 条件4: 检查属性类型是否为Sendable允许类型
+      if (!this.isSendableType(property.type, classAnalysis)) {
+        // TODO: 完善debug日志
+        invalidProperties.push(`${property.name} (类型: ${property.type.sourceText})`);
+      }
+    }
+
+    if (classAnalysis.originalClass) {
+      for (const method of classAnalysis.originalClass.getMethods()) {
+        // 条件3: 检查方法装饰器
+        const methodDecorators = method.getDecorators();
+        const nonTurboPropDecorators = this.getNonTurboTransDecorators(methodDecorators);
+        if (nonTurboPropDecorators.length > 0) {
+          invalidProperties.push(`${method.getName()} (装饰器: ${nonTurboPropDecorators.join(', ')})`);
+        }
+      }
+    }
+
+    if (invalidProperties.length > 0) {
+      // TODO: 完善debug日志
+      Logger.debug(invalidProperties.join('\n'));
+      return false;
+    }
+
+    // 条件5: 递归检查父类
+    if (classAnalysis.inheritance.isInherited && classAnalysis.inheritance.baseClassAnalysis) {
+      // TODO: 完善debug日志
+      Logger.debug(`${classAnalysis.className}的父类不可合并`);
+      return this.check(classAnalysis.inheritance.baseClassAnalysis as ClassAnalysis);
+    }
+
+    // 所有条件满足，可以合并
+    return true;
+  }
+
+  /**
+   * 获取非TurboTrans装饰器列表
+   * @param decorators 装饰器数组
+   * @returns 非TurboTrans装饰器名称列表
+   */
+  private static getNonTurboTransDecorators(decorators: Decorator[]): string[] {
+    return decorators
+      .map(d => d.getName())
+      .filter(name => !this.TURBO_TRANS_DECORATORS.has(name));
+  }
+
+  /**
+   * 检查类型是否为Sendable允许类型
+   * @param typeStructure 类型结构
+   * @param contextClass 当前类分析上下文（用于查找自定义类型）
+   * @returns 是否为Sendable允许类型
+   */
+  private static isSendableType(typeStructure: TypeStructure, contextClass: ClassAnalysis): boolean {
+    const { kind } = typeStructure;
+
+    // 基础类型
+    if (this.SENDABLE_PRIMITIVE_KINDS.has(kind)) {
+      return true;
+    }
+
+    // Collections容器类型
+    if (this.SENDABLE_COLLECTION_KINDS.has(kind)) {
+      // 递归检查泛型参数类型
+      return typeStructure.args.every(arg => this.isSendableType(arg, contextClass));
+    }
+
+    // 自定义类类型（OBJECT类型）
+    if (kind === PropertyKind.OBJECT && typeStructure.classDetails) {
+      // 检查是否为可合并的@Serializable类
+      const classDetails = typeStructure.classDetails;
+      if (classDetails.classDecl.getDecorator('Sendable')) {
+        return true;
+      }
+
+      const className = classDetails.classDecl.getNameOrThrow();
+      // 从全局注册表查询合并性
+      const canMerge = SendableMergeabilityRegistry.canMerge(className);
+
+      if (canMerge === undefined) {
+        // 类还未分析（可能在其他文件中，或循环引用）
+        // 保守处理：假设不可合并
+        // 注意：在双阶段分析架构下，这种情况应该很少发生
+        return false;
+      }
+
+      return canMerge;
+    }
+
+    // Optional/Nullable/Union类型：所有成员都必须是Sendable类型
+    if ((kind === PropertyKind.UNION || kind === PropertyKind.OPTIONAL || kind === PropertyKind.NULLABLE) &&
+      typeStructure.unionDetails) {
+      return typeStructure.unionDetails.every(member => this.isSendableType(member, contextClass));
+    }
+
+    // 其他类型（Array, Set, Map, Record等）不是Sendable类型
+    return false;
+  }
+}

package/src/core/analyzers/SendableMergeabilityRegistry.ts

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Logger } from '..';
+
+/**
+ * Sendable合并性全局注册表
+ *
+ * 用于存储所有类的合并性分析结果，避免循环依赖和重复分析。
+ *
+ * 使用场景：
+ * 1. 在 ClassAnalyzer 分析完所有类后，注册每个类的合并性
+ * 2. 在 SendableMergeChecker.isSendableType() 中查询依赖类的合并性
+ *
+ * 生命周期：
+ * - 每次代码生成开始前清空
+ * - 分析阶段填充
+ * - 生成阶段查询
+ */
+export class SendableMergeabilityRegistry {
+  // 合并性映射：类名 -> 是否可合并
+  private static mergeabilityMap = new Map<string, boolean>();
+
+  /**
+   * 注册类的合并性
+   * @param className 类名
+   * @param canMerge 是否可以合并
+   */
+  static register(className: string, canMerge: boolean): void {
+    this.mergeabilityMap.set(className, canMerge);
+    Logger.debug(`[SendableMergeabilityRegistry] 注册类合并性: ${className} -> ${canMerge}`);
+  }
+
+  /**
+   * 查询类的合并性
+   * @param className 类名
+   * @returns 是否可合并，undefined 表示类还未分析
+   */
+  static canMerge(className: string): boolean | undefined {
+    return this.mergeabilityMap.get(className);
+  }
+
+  /**
+   * 检查类是否已注册
+   * @param className 类名
+   * @returns 是否已注册
+   */
+  static hasClass(className: string): boolean {
+    return this.mergeabilityMap.has(className);
+  }
+
+  /**
+   * 清空所有注册信息（每次代码生成前调用）
+   */
+  static clear(): void {
+    const count = this.mergeabilityMap.size;
+    this.mergeabilityMap.clear();
+    Logger.debug(`[SendableMergeabilityRegistry] 清空注册表，已移除 ${count} 个类的合并性信息`);
+  }
+}

package/src/core/constants/DecoratorConstants.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * 装饰器常量定义
+ */
+export class DecoratorConstants {
+  // TSerialization装饰器
+  static readonly SERIALIZABLE = 'Serializable'
+  static readonly SERIAL_NAME = 'SerialName'
+  static readonly REQUIRED = 'Required'
+  static readonly TRANSIENT = 'Transient'
+
+  static readonly SERIAL_DECORATORS = [this.SERIALIZABLE, this.SERIAL_NAME, this.REQUIRED, this.TRANSIENT];
+}

package/src/core/constants/PathConstants.ts

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * 路径相关常量定义
+ */
+export class PathConstants {
+  /** 默认源代码根目录 */
+  static readonly DEFAULT_SOURCE_ROOT = './src/main'
+  
+  /** 生成代码根目录 */
+  static readonly GENERATED_ROOT = './src/generated'
+  
+  /** 支持的文件扩展名 */
+  static readonly ETS_EXTENSIONS = '.ets'
+  
+  /** 默认扫描目录 */
+  static readonly DEFAULT_SCAN_DIRS = ['src/main/ets']
+}