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

package/src/core/services/CodeGenerationService/generators/SendableClassGenerator.ts

@@ -13,8 +13,13 @@
  * limitations under the License.
  */
 
-import { ClassDeclaration, SourceFile } from 'ts-morph';
-import { ClassAnalysis, ClassDetails, Logger, PropertyAnalysis, PropertyKind, TypeKind, TypeStructure } from '../../..';
+import {
+  ClassDeclaration, ConstructorDeclaration, Decorator, Identifier, ImportDeclaration, ParameterDeclaration,
+  PropertyDeclaration, SourceFile
+} from 'ts-morph';
+import {
+  ClassAnalysis, ClassDetails, Logger, PropertyAnalysis, PropertyKind, TypeDependency, TypeKind, TypeStructure
+} from '../../..';
 import { ImportManager } from '../shared/ImportManager';
 import { ClassAnalyzer } from '../../../analyzers/ClassAnalyzer';
 import { TypeHandlerRegistry } from '../../../handlers';
@@ -64,7 +69,8 @@ export class SendableClassGenerator {
 
   private getOriginClassDeclaration(result: ClassAnalysis): ClassDeclaration {
     const originalContent = result.originalClass?.getFullText();
-    const copiedSourceFile = TsMorphUtil.getProject().createSourceFile('copied-file.ts', originalContent, { overwrite: true });
+    const copiedSourceFile = TsMorphUtil.getProject()
+      .createSourceFile('copied-file.ts', originalContent, { overwrite: true });
     return copiedSourceFile.getClassOrThrow(result.className);
   }
 
@@ -90,77 +96,93 @@ export class SendableClassGenerator {
   }
 
   private removeAllDecorators(classDecl: ClassDeclaration): void {
-    // 剔除类级别装饰器
+    this.removeClassDecorators(classDecl);
+    this.removePropertyDecorators(classDecl);
+    this.removeMethodDecorators(classDecl);
+  }
+
+  private removeClassDecorators(classDecl: ClassDeclaration): void {
     classDecl.getDecorators().forEach((decorator) => {
-      Logger.warn(
-        `Remove the decorator ${decorator.getName()}, because @Sendable cannot coexist with other decorators`
-      );
-      decorator.remove();
+      this.logAndRemoveDecorator(decorator);
     });
+  }
 
-    // 剔除属性装饰器，@Sendable无法与其他装饰器共存
+  private removePropertyDecorators(classDecl: ClassDeclaration): void {
     classDecl.getProperties().forEach((property) => {
-      property.getDecorators().forEach((decorator) => {
-        Logger.warn(
-          `Remove the decorator ${decorator.getName()}, because @Sendable cannot coexist with other decorators`
-        );
-        decorator.remove();
-      });
+      property.getDecorators().forEach((decorator) => this.logAndRemoveDecorator(decorator));
     });
+  }
 
-    // 剔除方法装饰器，@Sendable无法与其他装饰器共存
+  private removeMethodDecorators(classDecl: ClassDeclaration): void {
     classDecl.getMethods().forEach((method) => {
-      method.getDecorators().forEach((decorator) => {
-        Logger.warn(
-          `Remove the decorator ${decorator.getName()}, because @Sendable cannot coexist with other decorators`
-        );
-        decorator.remove();
-      });
+      method.getDecorators().forEach((decorator) => this.logAndRemoveDecorator(decorator));
     });
   }
 
+  private logAndRemoveDecorator(decorator: Decorator): void {
+    Logger.warn(
+      `Remove the decorator ${decorator.getName()}, because @Sendable cannot coexist with other decorators`
+    );
+    decorator.remove();
+  }
+
   private convertPropertyTypesToSendable(classDecl: ClassDeclaration, result: ClassAnalysis): void {
     const properties = classDecl.getProperties();
-
     properties.forEach((property) => {
-      const propertyName = property.getName();
-
-      Logger.debug(`Converting property ${propertyName} to sendable`);
-
-      // 从分析结果中找到对应的属性信息
-      const propertyAnalysis = result.properties.find((p) => p.name === propertyName);
-      if (!propertyAnalysis) {
-        Logger.warn(`未找到属性 ${propertyName} 的分析信息`);
-        return;
-      }
-
-      Logger.debug(
-        `Found property ${propertyName} analysis info: ${propertyAnalysis.name} ${propertyAnalysis.type.sourceText}`
-      );
-
-      // 转换类型为Sendable兼容类型
-      const sendableType = this.convertToSendableType(propertyAnalysis.type);
-
-      Logger.debug(`Converted type ${propertyAnalysis.type.sourceText} to ${sendableType}`);
-
-      if (sendableType !== propertyAnalysis.type.sourceText) {
-        property.setType(sendableType);
-        Logger.debug(`属性 ${propertyName} 类型从 ${propertyAnalysis.type.sourceText} 转换为 ${sendableType}`);
-      }
-
-      // 处理默认值中的构造函数调用
-      const initializer = property.getInitializer();
-      if (initializer) {
-        const initializerText = initializer.getText();
-        const convertedInitializer = this.convertInitializerToSendable(initializerText);
-        if (convertedInitializer !== initializerText) {
-          property.setInitializer(convertedInitializer);
-          Logger.debug(`属性 ${propertyName} 默认值从 ${initializerText} 转换为 ${convertedInitializer}`);
-        }
-      }
+      this.convertSinglePropertyToSendable(property, result);
     });
   }
 
+  private convertSinglePropertyToSendable(
+    property: PropertyDeclaration,
+    result: ClassAnalysis
+  ): void {
+    const propertyName = property.getName();
+    Logger.debug(`Converting property ${propertyName} to sendable`);
+
+    const propertyAnalysis = result.properties.find((p) => p.name === propertyName);
+    if (!propertyAnalysis) {
+      Logger.warn(`未找到属性 ${propertyName} 的分析信息`);
+      return;
+    }
+
+    Logger.debug(
+      `Found property ${propertyName} analysis info: ${propertyAnalysis.name} ${propertyAnalysis.type.sourceText}`
+    );
+
+    this.updatePropertyType(property, propertyAnalysis);
+    this.updatePropertyInitializer(property, propertyAnalysis.name);
+  }
+
+  private updatePropertyType(
+    property: PropertyDeclaration,
+    propertyAnalysis: PropertyAnalysis
+  ): void {
+    const sendableType = this.convertToSendableType(propertyAnalysis.type);
+    Logger.debug(`Converted type ${propertyAnalysis.type.sourceText} to ${sendableType}`);
+
+    if (sendableType !== propertyAnalysis.type.sourceText) {
+      property.setType(sendableType);
+      Logger.debug(`属性 ${propertyAnalysis.name} 类型从 ${propertyAnalysis.type.sourceText} 转换为 ${sendableType}`);
+    }
+  }
+
+  private updatePropertyInitializer(
+    property: PropertyDeclaration,
+    propertyName: string
+  ): void {
+    const initializer = property.getInitializer();
+    if (!initializer) {
+      return;
+    }
+    const initializerText = initializer.getText();
+    const convertedInitializer = this.convertInitializerToSendable(initializerText);
+    if (convertedInitializer !== initializerText) {
+      property.setInitializer(convertedInitializer);
+      Logger.debug(`属性 ${propertyName} 默认值从 ${initializerText} 转换为 ${convertedInitializer}`);
+    }
+  }
+
   private addSendableConstraints(classDecl: ClassDeclaration): void {
     // 添加@Sendable装饰器
     classDecl.addDecorator({ name: 'Sendable' });
@@ -187,7 +209,29 @@ export class SendableClassGenerator {
 
   private generatedToOriginMethodBody(result: ClassAnalysis, returnType: string): string {
     const statements: string[] = [];
-    let constructorCall;
+    const constructorCall = this.getConstructorCall(result, returnType);
+    statements.push(`const origin = ${constructorCall};`);
+
+    const assignmentProps = result.properties.filter((p) => {
+      return result.constructorParams.every((cp) => cp.name !== p.name);
+    });
+    // 生成属性赋值语句
+    if (assignmentProps.length > 0) {
+      statements.push('');
+      statements.push('// 非构造函数属性赋值');
+      assignmentProps.forEach((prop) => {
+        const assignment = this.generatePropertyConversion(prop, 'this.');
+        statements.push(`origin.${prop.name} = ${assignment};`);
+      });
+    }
+
+    statements.push('');
+    statements.push('return origin;');
+
+    return statements.join('\n');
+  }
+
+  private getConstructorCall(result: ClassAnalysis, returnType: string): string {
     if (result.constructorParams.length > 0) {
       const constructorProps: PropertyAnalysis[] = [];
       result.properties.forEach((p) => {
@@ -209,29 +253,10 @@ export class SendableClassGenerator {
         })
         .join(', ');
 
-      constructorCall = `new ${returnType}(${args})`;
+      return `new ${returnType}(${args})`;
     } else {
-      constructorCall = `new ${returnType}()`;
+      return `new ${returnType}()`;
     }
-    statements.push(`const origin = ${constructorCall};`);
-
-    const assignmentProps = result.properties.filter((p) => {
-      return result.constructorParams.every((cp) => cp.name !== p.name);
-    });
-    // 生成属性赋值语句
-    if (assignmentProps.length > 0) {
-      statements.push('');
-      statements.push('// 非构造函数属性赋值');
-      assignmentProps.forEach((prop) => {
-        const assignment = this.generatePropertyConversion(prop, 'this.');
-        statements.push(`origin.${prop.name} = ${assignment};`);
-      });
-    }
-
-    statements.push('');
-    statements.push('return origin;');
-
-    return statements.join('\n');
   }
 
   private generatePropertyConversion(prop: PropertyAnalysis, prefix: string): string {
@@ -257,84 +282,141 @@ export class SendableClassGenerator {
   }
 
   private addNecessaryImports(result: ClassAnalysis, importManager: ImportManager): void {
-    // 1. 处理类导入
+    this.processPropertyDependencyImports(result, importManager);
+    this.processBaseClassImport(result, importManager);
+    this.processCollectionsImport(result, importManager);
+    this.copySourceFileImports(result, importManager);
+  }
+
+  private processPropertyDependencyImports(result: ClassAnalysis, importManager: ImportManager): void {
     result.properties.forEach((property) => {
       property.type.dependencies.forEach((dependency) => {
-        if (dependency.typeKind === TypeKind.CLASS) {
-          const classAnalysis = ClassAnalyzer.analyzeClass((dependency.details as ClassDetails).classDecl);
-          if (classAnalysis.decorators.serializable?.generateSendable) {
-            importManager.registerCustomImport('./Sendable' + dependency.typeName, 'Sendable' + dependency.typeName);
-          } else {
-            importManager.registerCustomTypeImport(dependency.source.sourceFilePath!, dependency.typeName);
-          }
-        } else {
-          importManager.registerCustomTypeImport(dependency.source.sourceFilePath!, dependency.typeName);
-        }
+        this.registerDependencyImport(dependency, importManager);
       });
     });
+  }
+
+  private registerDependencyImport(
+    dependency: TypeDependency,
+    importManager: ImportManager
+  ): void {
+    if (dependency.typeKind !== TypeKind.CLASS) {
+      importManager.registerCustomTypeImport(dependency.source.sourceFilePath!, dependency.typeName);
+      return;
+    }
+    const classAnalysis = ClassAnalyzer.analyzeClass((dependency.details as ClassDetails).classDecl);
+    if (classAnalysis.decorators.serializable?.generateSendable) {
+      importManager.registerCustomImport('./Sendable' + dependency.typeName, 'Sendable' + dependency.typeName);
+    } else {
+      importManager.registerCustomTypeImport(dependency.source.sourceFilePath!, dependency.typeName);
+    }
+  }
 
+  private processBaseClassImport(result: ClassAnalysis, importManager: ImportManager): void {
     const baseClass = result.inheritance.baseClassAnalysis;
-    if (baseClass) {
-      importManager.registerCustomImport('./Sendable' + baseClass.className, 'Sendable' + baseClass.className);
+    if (!baseClass) {
+      return;
     }
-    // 2. 检查是否需要collections导入
+    importManager.registerCustomImport('./Sendable' + baseClass.className, 'Sendable' + baseClass.className);
+  }
+
+  private processCollectionsImport(result: ClassAnalysis, importManager: ImportManager): void {
     const needsCollections = this.needsCollectionsImport(result);
-    if (needsCollections) {
-      importManager.registerArkTSImports(['collections']);
+    if (!needsCollections) {
+      return;
     }
-    // 3. 拷贝源文件导入
-    result.originalClass?.getSourceFile().getImportDeclarations().forEach(importDecl => {
-      const specifier = importDecl.getModuleSpecifierValue();
-      const names = importDecl.getNamedImports().map((names) => names.getName());
-      const defaultImport = importDecl.getDefaultImport();
-      const originalDir = SerializationPathUtil.dirname(result.sourceFilePath);
-
-      const importOriginAbs = SerializationPathUtil.pathResolve(originalDir, specifier);
-      if (SerializationPathUtil.exist(importOriginAbs + '.ets')) {
-        // 路径存在，使用模块化路径计算
-        const importOriginAbsWithExt = importOriginAbs + '.ets';
-        names.forEach((name) => {
-          importManager.registerCustomTypeImport(importOriginAbsWithExt, name);
-        });
-        if (defaultImport) {
-          importManager.registerDefaultImport(importOriginAbsWithExt, defaultImport.getText());
-        }
-      } else {
-        // 不存在该路径，说明可能为包名，暂时不动
-        names.forEach((name) => {
-          importManager.registerCustomImport(specifier, name);
-        });
-        if (defaultImport) {
-          importManager.registerDefaultImport(specifier, defaultImport.getText());
-        }
-      }
+    importManager.registerArkTSImports(['collections']);
+  }
+
+  private copySourceFileImports(result: ClassAnalysis, importManager: ImportManager): void {
+    const importDeclarations = result.originalClass?.getSourceFile().getImportDeclarations();
+    if (!importDeclarations) {
+      return;
+    }
+    importDeclarations.forEach((importDecl) => {
+      this.processSingleImportDeclaration(importDecl, result, importManager);
+    });
+  }
+
+  private processSingleImportDeclaration(
+    importDecl: ImportDeclaration,
+    result: ClassAnalysis,
+    importManager: ImportManager
+  ): void {
+    const specifier = importDecl.getModuleSpecifierValue();
+    const names = importDecl.getNamedImports().map((n) => n.getName());
+    const defaultImport = importDecl.getDefaultImport();
+    const originalDir = SerializationPathUtil.dirname(result.sourceFilePath);
+    const importOriginAbs = SerializationPathUtil.pathResolve(originalDir, specifier);
+
+    if (SerializationPathUtil.exist(importOriginAbs + '.ets')) {
+      this.registerModuleImports(importOriginAbs + '.ets', names, defaultImport, importManager);
+    } else {
+      this.registerPackageImports(specifier, names, defaultImport, importManager);
+    }
+  }
+
+  private registerModuleImports(
+    absPath: string,
+    names: string[],
+    defaultImport: Identifier | undefined,
+    importManager: ImportManager
+  ): void {
+    names.forEach((name) => {
+      importManager.registerCustomTypeImport(absPath, name);
+    });
+    if (defaultImport) {
+      importManager.registerDefaultImport(absPath, defaultImport.getText());
+    }
+  }
+
+  private registerPackageImports(
+    specifier: string,
+    names: string[],
+    defaultImport: Identifier | undefined,
+    importManager: ImportManager
+  ): void {
+    names.forEach((name) => {
+      importManager.registerCustomImport(specifier, name);
     });
+    if (defaultImport) {
+      importManager.registerDefaultImport(specifier, defaultImport.getText());
+    }
   }
 
   private convertConstructorParameterTypes(classDecl: ClassDeclaration, result: ClassAnalysis): void {
     const constructors = classDecl.getConstructors();
-
     constructors.forEach((constructor) => {
-      const parameters = constructor.getParameters();
+      this.convertSingleConstructorParameters(constructor, result);
+    });
+  }
 
-      parameters.forEach((parameter) => {
-        const paramName = parameter.getName();
+  private convertSingleConstructorParameters(
+    constructor: ConstructorDeclaration,
+    result: ClassAnalysis
+  ): void {
+    const parameters = constructor.getParameters();
+    parameters.forEach((parameter) => {
+      this.convertSingleParameter(parameter, result);
+    });
+  }
 
-        // 从分析结果中找到对应的属性信息
-        const propertyAnalysis = result.properties.find((p) => p.name === paramName);
-        if (!propertyAnalysis) {
-          Logger.warn(`未找到构造函数参数 ${paramName} 的分析信息`);
-          return;
-        }
+  private convertSingleParameter(
+    parameter: ParameterDeclaration,
+    result: ClassAnalysis
+  ): void {
+    const paramName = parameter.getName();
+    const propertyAnalysis = result.properties.find((p) => p.name === paramName);
+    if (!propertyAnalysis) {
+      Logger.warn(`未找到构造函数参数 ${paramName} 的分析信息`);
+      return;
+    }
 
-        // 转换参数类型为Sendable兼容类型
-        const sendableType = this.convertToSendableType(propertyAnalysis.type);
-        if (sendableType !== propertyAnalysis.type.sourceText) {
-          parameter.setType(sendableType);
-          Logger.debug(`构造函数参数 ${paramName} 类型从 ${propertyAnalysis.type.sourceText} 转换为 ${sendableType}`);
-        }
-      });
-    });
+    const sendableType = this.convertToSendableType(propertyAnalysis.type);
+    if (sendableType !== propertyAnalysis.type.sourceText) {
+      parameter.setType(sendableType);
+      Logger.debug(`构造函数参数 ${paramName} 类型从 ${propertyAnalysis.type.sourceText} 转换为 ${sendableType}`);
+    }
   }
 
   private isObjectType(typeName: string): boolean {
@@ -371,41 +453,50 @@ export class SendableClassGenerator {
   }
 
   private convertInitializerToSendable(initializerText: string): string {
-    let convertedText = initializerText;
-
-    // 1. 处理数组字面量（最优先）
-    if (convertedText === '[]') {
-      convertedText = 'new collections.Array()';
-    } else if (convertedText.startsWith('[') && convertedText.endsWith(']')) {
-      // 处理 [1, 2, 3] 这种情况
-      const arrayContent = convertedText.slice(1, -1);
-      if (arrayContent.trim()) {
-        convertedText = `new collections.Array(${arrayContent})`;
-      } else {
-        convertedText = 'new collections.Array()';
-      }
-    }
+    let convertedText = this.convertArrayLiteralToSendable(initializerText);
+    convertedText = this.replaceCollectionTypes(convertedText);
+    convertedText = this.replaceObjectConstructors(convertedText);
 
-    // 2. 处理集合类型构造函数（优先于对象类型）
-    convertedText = convertedText.replace(/new\s+Set\s*\(/g, 'new collections.Set(');
-    convertedText = convertedText.replace(/new\s+Map\s*\(/g, 'new collections.Map(');
-    convertedText = convertedText.replace(/new\s+Array\s*\(/g, 'new collections.Array(');
+    Logger.debug(`初始化器转换: ${initializerText} -> ${convertedText}`);
+    return convertedText;
+  }
 
-    // 3. 处理对象构造函数：new Person(...) -> new SendablePerson(...)
+  private convertArrayLiteralToSendable(text: string): string {
+    if (text === '[]') {
+      return 'new collections.Array()';
+    }
+    if (!text.startsWith('[') || !text.endsWith(']')) {
+      return text;
+    }
+    const arrayContent = text.slice(1, -1);
+    if (arrayContent.trim()) {
+      return `new collections.Array(${arrayContent})`;
+    }
+    return 'new collections.Array()';
+  }
+
+  private replaceObjectConstructors(text: string): string {
     const objectConstructorPattern = /new\s+(\w+)\s*\(/g;
-    convertedText = convertedText.replace(objectConstructorPattern, (match, className) => {
-      // 跳过已经转换的集合类型
-      if (className === 'collections' || match.includes('collections.')) {
-        return match;
-      }
-
-      if (this.isObjectType(className)) {
-        return match.replace(className, `Sendable${className}`);
-      }
-      return match;
+    return text.replace(objectConstructorPattern, (match, className) => {
+      return this.replaceObjectConstructorMatch(match, className);
     });
+  }
 
-    Logger.debug(`初始化器转换: ${initializerText} -> ${convertedText}`);
+  private replaceObjectConstructorMatch(match: string, className: string): string {
+    if (className === 'collections' || match.includes('collections.')) {
+      return match;
+    }
+    if (this.isObjectType(className)) {
+      return match.replace(className, `Sendable${className}`);
+    }
+    return match;
+  }
+
+  private replaceCollectionTypes(text: string): string {
+    let convertedText = text;
+    convertedText = convertedText.replace(/new\s+Set\s*\(/g, 'new collections.Set(');
+    convertedText = convertedText.replace(/new\s+Map\s*\(/g, 'new collections.Map(');
+    convertedText = convertedText.replace(/new\s+Array\s*\(/g, 'new collections.Array(');
     return convertedText;
   }
 

package/src/core/services/CodeGenerationService/generators/SerializerGenerator.ts

@@ -50,12 +50,14 @@ export class SerializerGenerator {
     this.templateEngine = new HandlebarsTemplateEngine();
   }
 
-  generate(sourceFile: SourceFile, result: ClassAnalysis | InterfaceAnalysis, context: ITaskContext): GenerationContext | string {
+  generate(sourceFile: SourceFile, result: ClassAnalysis | InterfaceAnalysis,
+    context: ITaskContext): GenerationContext | string {
     // 检查是否使用自定义序列化器
     if (result.decorators?.serializable?.with) {
-      sourceFile.addStatements(this.generateBuiltinSerializerRegistrationForSupplementary(context, result as ClassAnalysis));
+      sourceFile.addStatements(
+        this.generateBuiltinSerializerRegistrationForSupplementary(context, result as ClassAnalysis));
       // 使用自定义序列化器，仅生成注册语句
-      return this.generateCustomSerializerRegistration(sourceFile, result as ClassAnalysis);
+      return this.generateCustomSerializerRegistration(result as ClassAnalysis);
     }
 
     // 1. 注册必要的导入
@@ -103,7 +105,8 @@ export class SerializerGenerator {
     // 基础导入 + 动态内置序列化器导入
     this.importManager.registerCoreImports([
       'Serializer', 'SerialDescriptor', 'buildClassSerialDescriptor',
-      'Encoder', 'Decoder', 'registerAutoGeneratedSerializerEntry', 'registerAutoGeneratedSerializerEntryProviderForSupplementary',
+      'Encoder', 'Decoder', 'registerAutoGeneratedSerializerEntry', 'ObjectUtils',
+      'registerAutoGeneratedSerializerEntryProviderForSupplementary', 'lazy',
       ...requiredBuiltinSerializers
     ]);
 
@@ -201,17 +204,17 @@ export class SerializerGenerator {
       }
 
       // 注册属性相关的序列化器导入
-      this.execPropertyImports(property.type.dependencies);
+      this.execPropertyImports(property.type.dependencies, !!property.decorators?.with);
     }
   }
 
-  private execPropertyImports(dependencies: TypeDependency[]): void {
+  private execPropertyImports(dependencies: TypeDependency[], hasWithParam: boolean): void {
     dependencies.forEach((dependency: TypeDependency) => {
-      this.processDependency(dependency);
+      this.processDependency(dependency, hasWithParam);
     });
   }
 
-  private processDependency(dependency: TypeDependency): void {
+  private processDependency(dependency: TypeDependency, hasWithParam: boolean): void {
     const source = dependency.source;
 
     // 提前返回，减少嵌套
@@ -226,16 +229,16 @@ export class SerializerGenerator {
     // 根据类型种类分别处理
     switch (dependency.typeKind) {
       case TypeKind.CLASS:
-        this.processClassDependency(dependency, source);
+        this.processClassDependency(dependency, source, hasWithParam);
         break;
 
       case TypeKind.INTERFACE:
-        this.processInterfaceDependency(dependency);
+        this.processInterfaceDependency(dependency, hasWithParam);
         break;
     }
   }
 
-  private processClassDependency(dependency: TypeDependency, source: DependencySource): void {
+  private processClassDependency(dependency: TypeDependency, source: DependencySource, hasWithParam: boolean): void {
     const classDetails = dependency.details as ClassDetails;
     const tempClassAnalysis = ClassAnalyzer.analyzeClass(classDetails.classDecl);
 
@@ -249,6 +252,10 @@ export class SerializerGenerator {
     if (tempClassAnalysis.decorators.serializable) {
       this.handleSerializableClass(dependency, source, serializerName);
     } else {
+      if (hasWithParam) {
+        // 有自定义序列化器，无需关注这个导入了
+        return;
+      }
       // 从 tempSerializer 目录（index.ets）导入
       this.importManager.registerTempSerializerImport(`${dependency.typeName}${serializerName}`);
     }
@@ -263,7 +270,11 @@ export class SerializerGenerator {
     }
   }
 
-  private processInterfaceDependency(dependency: TypeDependency): void {
+  private processInterfaceDependency(dependency: TypeDependency, hasWithParam: boolean): void {
+    if (hasWithParam) {
+      // 有自定义序列化器，无需关注这个导入了
+      return;
+    }
     const interfaceDetails = dependency.details as InterfaceDetails;
     const tempClassAnalysis = ClassAnalyzer.analyzeInterface(interfaceDetails.interfaceDecl);
     TempSerializerGenerator.getInstance().generateSerializer(tempClassAnalysis);
@@ -275,13 +286,11 @@ export class SerializerGenerator {
     this.importManager.registerTempSerializerImport(`${dependency.typeName}${serializerName}`);
   }
 
-  private generateCustomSerializerRegistration(sourceFile: SourceFile, result: ClassAnalysis): string {
+  private generateCustomSerializerRegistration(result: ClassAnalysis): string {
     this.importManager.registerCoreImports(['registerAutoGeneratedSerializerEntry']);
 
     const customSerializer = result.decorators.serializable!.with;
-    const registrationCode = `registerAutoGeneratedSerializerEntry(${result.className}, ${customSerializer});`;
-
-    return registrationCode;
+    return `registerAutoGeneratedSerializerEntry(${result.className}, ${customSerializer});`;
   }
 
   private generateBuiltinSerializerRegistrationForSupplementary(context: ITaskContext, result: ClassAnalysis): string {
@@ -289,10 +298,8 @@ export class SerializerGenerator {
     const serialNameConstant = this.generateSerialNameConstant(result, context);
 
     const customSerializer = result.decorators.serializable!.with;
-    const registrationCode = `const ${result.className}_SERIAL_NAME = '${serialNameConstant}';\n
+    return `const ${result.className}_SERIAL_NAME = '${serialNameConstant}';\n
     registerAutoGeneratedSerializerEntryProviderForSupplementary(${result.className}_SERIAL_NAME, () => [${result.className}, ${customSerializer}]);`;
-
-    return registrationCode;
   }
 
   private getAllRequiredSerializers(properties: PropertyAnalysis[]): string[] {

package/src/core/services/CodeGenerationService/generators/TempSerializerGenerator.ts

@@ -38,7 +38,8 @@ export class TempSerializerGenerator {
   private context: ITaskContext | null = null;
   private serializerFiles: Map<string, SerializerFileInfo> = new Map();
 
-  private constructor() { }
+  private constructor() {
+  }
 
   static getInstance(): TempSerializerGenerator {
     return this.INSTANCE;
@@ -102,7 +103,7 @@ export class TempSerializerGenerator {
     });
   }
 
-  private registerImports(classAnalysis: ClassAnalysis | InterfaceAnalysis, importManager: ImportManager) {
+  private registerImports(classAnalysis: ClassAnalysis | InterfaceAnalysis, importManager: ImportManager): void {
     // 注册源文件导入
     importManager.registerCustomTypeImport(classAnalysis.sourceFilePath, classAnalysis.className);
     // 拷贝源文件导入
@@ -174,7 +175,8 @@ export class TempSerializerGenerator {
     // 检测类名冲突
     const classNameMap = new Map<string, SerializerFileInfo[]>();
     for (const [_, fileInfo] of this.serializerFiles) {
-      const serializerName = `${fileInfo.className}${fileInfo.isGeneric ? StringConstants.SERIALIZER_FACTORY : StringConstants.SERIALIZER}`;
+      const serializerName = `${fileInfo.className}${fileInfo.isGeneric ? StringConstants.SERIALIZER_FACTORY :
+        StringConstants.SERIALIZER}`;
       if (!classNameMap.has(serializerName)) {
         classNameMap.set(serializerName, []);
       }