feat: use non-nullable type converters for nullable->nullable convert

netglade · Oct 28, 2023 · d0f63ea · d0f63ea
1 parent 696de91
commit d0f63ea
Show file tree

Hide file tree

Showing 5 changed files with 90 additions and 11 deletions.
diff --git a/packages/auto_mappr/example/lib/mappr.auto_mappr.dart b/packages/auto_mappr/example/lib/mappr.auto_mappr.dart
diff --git a/packages/auto_mappr/lib/src/builder/assignments/type_converter_builder.dart b/packages/auto_mappr/lib/src/builder/assignments/type_converter_builder.dart
@@ -23,35 +23,66 @@ class TypeConverterBuilder extends AssignmentBuilderBase {
   @override
   bool canAssign() {
     return assignment.typeConverters.firstWhereOrNull(
-          (converter) => converter.canBeUsed(
-            mappingSource: source,
-            mappingTarget: target,
-          ),
+          (converter) =>
+              converter.canBeUsed(
+                mappingSource: source,
+                mappingTarget: target,
+              ) ||
+              converter.canBeUsedNullable(
+                mappingSource: source,
+                mappingTarget: target,
+              ),
         ) !=
         null;
   }
 
   @override
   Expression buildAssignment() {
-    final converter = assignment.typeConverters
-        // ignore: avoid-unsafe-collection-methods, checked by [canAssign]
-        .firstWhere((c) => c.canBeUsed(mappingSource: source, mappingTarget: target));
+    // ignore: avoid-unsafe-collection-methods, checked by [canAssign]
+    final converter = assignment.typeConverters.firstWhere(
+      (c) => c.canBeUsed(mappingSource: source, mappingTarget: target),
+      // ignore: avoid-unsafe-collection-methods, checked by [canAssign]
+      orElse: () => assignment.typeConverters.firstWhere(
+        (c) => c.canBeUsedNullable(
+          mappingSource: source,
+          mappingTarget: target,
+        ),
+      ),
+    );
 
     // Call.
     if (convertMethodArgument case final methodArgument?) {
       final targetRefer = EmitterHelper.current.typeRefer(type: target);
 
-      return EmitterHelper.current
-          .refer(converter.converter.referCallString, converter.converter.library.identifier)
-          .call([methodArgument]).asA(targetRefer);
+      if (converter.canBeUsed(mappingSource: source, mappingTarget: target)) {
+        return EmitterHelper.current
+            .refer(
+          converter.converter.referCallString,
+          converter.converter.library.identifier,
+        )
+            .call([methodArgument]).asA(targetRefer);
+      }
+
+      return methodArgument.equalTo(literalNull).conditional(
+            literalNull,
+            EmitterHelper.current
+                .refer(
+              converter.converter.referCallString,
+              converter.converter.library.identifier,
+            )
+                .call([methodArgument.nullChecked]).asA(targetRefer),
+          );
     }
 
     final sourceEmitted = EmitterHelper.current.typeReferEmitted(type: source);
     final targetEmitted = EmitterHelper.current.typeReferEmitted(type: target);
 
     // Tear-off.
     return EmitterHelper.current
-        .refer(converter.converter.referCallString, converter.converter.library.identifier)
+        .refer(
+          converter.converter.referCallString,
+          converter.converter.library.identifier,
+        )
         .asA(refer('$targetEmitted Function($sourceEmitted)'));
   }
 }
diff --git a/packages/auto_mappr/lib/src/models/type_converter.dart b/packages/auto_mappr/lib/src/models/type_converter.dart
@@ -33,6 +33,18 @@ class TypeConverter extends Equatable {
         _isConverterSubtype(target, mappingTarget, _ConversionRole.target);
   }
 
+  bool canBeUsedNullable({
+    required DartType mappingSource,
+    required DartType mappingTarget,
+  }) {
+    if(!(mappingSource.isNullable && mappingTarget.isNullable)) return false;
+
+    return canBeUsed(
+      mappingSource: mappingSource.element!.library!.typeSystem.promoteToNonNull(mappingSource),
+      mappingTarget: mappingTarget.element!.library!.typeSystem.promoteToNonNull(mappingTarget),
+    );
+  }
+
   bool _isConverterSubtype(DartType converterType, DartType fieldType, _ConversionRole role) {
     // Same type.
     if (converterType == fieldType) return true;

diff --git a/packages/auto_mappr/test/integration/fixture/type_converters.dart b/packages/auto_mappr/test/integration/fixture/type_converters.dart
@@ -11,6 +11,11 @@ import 'type_converters/module_alpha.dart';
     MapType<PrimitivesDto, Primitives>(
       converters: [TypeConverter<Object, String>(Mappr.objectToString)],
     ),
+    MapType<NullableDto, Nullable>(
+      converters: [
+        TypeConverter<int, Value<int>>(Mappr.intToValueInt),
+      ],
+    ),
     MapType<NormalFieldDto, NormalField>(
       converters: [TypeConverter<int, Value<int>>(Mappr.intToValueInt)],
     ),
@@ -57,6 +62,25 @@ class Mappr extends $Mappr {
   }
 }
 
+// Nullables.
+
+class NullableDto {
+  final int? alpha;
+  final int? beta;
+
+  const NullableDto({required this.alpha, required this.beta});
+}
+
+class Nullable with EquatableMixin {
+  final Value<int>? alpha;
+  final int? beta;
+
+  @override
+  List<Object?> get props => [alpha, beta];
+
+  const Nullable(this.alpha, this.beta);
+}
+
 // Primitives.
 
 class PrimitivesDto {

diff --git a/packages/auto_mappr/test/integration/type_converters_test.dart b/packages/auto_mappr/test/integration/type_converters_test.dart
@@ -13,6 +13,17 @@ void main() {
     mappr = const fixture.Mappr();
   });
 
+  test('nullable', () {
+    const dto = fixture.NullableDto(alpha: 123456, beta: 123);
+    final converted =
+        mappr.convert<fixture.NullableDto, fixture.Nullable>(dto);
+
+    expect(
+      converted,
+      equals(const fixture.Nullable(fixture.Value(123456), 123)),
+    );
+  });
+
   test('primitives', () {
     const dto = fixture.PrimitivesDto(alpha: 123456, beta: false);
     final converted = mappr.convert<fixture.PrimitivesDto, fixture.Primitives>(dto);