fix initialization of record mappers

Author: schultek

packages/dart_mappable/test/initializer/init_package_test.init.dart

@@ -10,6 +10,9 @@ typedef Point =
 @MappableRecord()
 typedef Offset<T> = ({double x, T y});
 
+@MappableRecord()
+typedef Rect = ({Point topLeft, Point bottomRight});
+
 class RoundingHook extends MappingHook {
   const RoundingHook();
 
@@ -66,5 +69,25 @@ void main() {
       expect(p, equals((x: 1, y: 2)));
       expect(encode(p), equals({'a': 1, 'y': 2}));
     });
+
+    test('can decode and encode nested record', () {
+      var decode = MapperContainer.globals.fromMap;
+      var encode = MapperContainer.globals.toMap;
+
+      RectMapper.ensureInitialized();
+
+      var r = decode<Rect>({
+        'topLeft': {'a': 1.3, 'y': 2},
+        'bottomRight': {'a': 3.7, 'y': 4},
+      });
+      expect(r, equals((topLeft: (x: 1, y: 2), bottomRight: (x: 4, y: 4))));
+      expect(
+        encode(r),
+        equals({
+          'topLeft': {'a': 1, 'y': 2},
+          'bottomRight': {'a': 4, 'y': 4},
+        }),
+      );
+    });
   });
 }

packages/dart_mappable/test/records/mappable_record_test.dart

@@ -1,5 +1,3 @@
-
-
 import 'package:analyzer/dart/element/element.dart';
 import 'package:dart_mappable/dart_mappable.dart';
 

packages/dart_mappable/test/records/mappable_record_test.mapper.dart

@@ -1,5 +1,7 @@
+import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 
+import '../../../mapper_group.dart';
 import '../../record/target_record_mapper_element.dart';
 import '../class_mapper_element.dart';
 
@@ -12,57 +14,75 @@ mixin LinkedElementsMixin on ClassMapperElement {
       linked.add('$prefix${target.mapperName}');
     }
 
-    void checkType(DartType t) {
-      var e = t.element;
-      var m = parent.getMapperForElement(e);
-      if (m != null) {
-        linked.add(
-          '${parent.prefixOfElement(m.annotation.element)}${m.mapperName}',
-        );
-      }
+    linked.addAll(
+      findLinkedElements(
+        params.map((p) => p.parameter.type),
+        element.typeParameters,
+        parent,
+      ),
+    );
 
-      if (t is ParameterizedType) {
-        for (var arg in t.typeArguments) {
-          checkType(arg);
-        }
-      }
+    return linked.toList();
+  }();
+}
 
-      r:
-      if (t is RecordType) {
-        if (t.alias != null) {
-          var m = parent.getMapperForElement(t.alias!.element);
-          if (m != null && m is TargetRecordMapperElement) {
-            linked.add(
-              '${parent.prefixOfElement(m.annotation.element)}${m.mapperName}',
-            );
-            break r;
-          }
-        }
-        var e = parent.records.get(t);
-        if (e != null) {
-          linked.add(e.mapperName);
-        }
-        for (var f in [...t.positionalFields, ...t.namedFields]) {
-          checkType(f.type);
-        }
-      }
+List<String> findLinkedElements(
+  Iterable<DartType> types,
+  List<TypeParameterElement> typeParams,
+  MapperElementGroup parent,
+) {
+  var linked = <String>{};
+
+  void checkType(DartType t) {
+    var e = t.element;
+    var m = parent.getMapperForElement(e);
+    if (m != null) {
+      linked.add(
+        '${parent.prefixOfElement(m.annotation.element)}${m.mapperName}',
+      );
     }
 
-    for (var param in params) {
-      checkType(param.parameter.type);
+    if (t is ParameterizedType) {
+      for (var arg in t.typeArguments) {
+        checkType(arg);
+      }
     }
 
-    for (var param in element.typeParameters) {
-      if (param.bound != null) {
-        var m = parent.getMapperForElement(param.bound!.element);
-        if (m is ClassMapperElement) {
+    r:
+    if (t is RecordType) {
+      if (t.alias != null) {
+        var m = parent.getMapperForElement(t.alias!.element);
+        if (m != null && m is TargetRecordMapperElement) {
           linked.add(
             '${parent.prefixOfElement(m.annotation.element)}${m.mapperName}',
           );
+          break r;
         }
       }
+      var e = parent.records.get(t);
+      if (e != null) {
+        linked.add(e.mapperName);
+      }
+      for (var f in [...t.positionalFields, ...t.namedFields]) {
+        checkType(f.type);
+      }
     }
+  }
 
-    return linked.toList();
-  }();
+  for (var type in types) {
+    checkType(type);
+  }
+
+  for (var param in typeParams) {
+    if (param.bound != null) {
+      var m = parent.getMapperForElement(param.bound!.element);
+      if (m is ClassMapperElement) {
+        linked.add(
+          '${parent.prefixOfElement(m.annotation.element)}${m.mapperName}',
+        );
+      }
+    }
+  }
+
+  return linked.toList();
 }

packages/dart_mappable_builder/lib/src/elements/class/alias_class_mapper_element.dart

@@ -2,6 +2,8 @@ import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:collection/collection.dart';
 
+import '../class/mixins/linked_elements_mixin.dart';
+import '../field/record_mapper_field_element.dart';
 import '../mapper_element.dart';
 
 abstract class RecordMapperElement<T extends Element>
@@ -21,6 +23,19 @@ abstract class RecordMapperElement<T extends Element>
 
   List<String>? get inheritedTypeArgs => null;
 
+  @override
+  List<RecordMapperFieldElement> get fields;
+
+  late final List<String> linkedElements = () {
+    return findLinkedElements(
+      fields.map((f) => f.param.type),
+      element is TypeParameterizedElement
+          ? (element as TypeParameterizedElement).typeParameters
+          : [],
+      parent,
+    );
+  }();
+
   late String genericRecordDeclaration = () {
     var t = type.positionalFields
         .mapIndexed((i, f) => genericArgAt(i))

packages/dart_mappable_builder/lib/src/elements/class/mixins/linked_elements_mixin.dart

@@ -23,6 +23,16 @@ class RecordMapperGenerator extends MapperGenerator<RecordMapperElement> {
           if (_instance == null) {
             MapperContainer.globals.use(_instance = ${element.mapperName}._());
             MapperBase.addType(${element.genericTypeParamsDeclaration}(f) => f<${element.genericRecordDeclaration}>());
+    ''');
+
+    var linked = element.linkedElements;
+    if (linked.isNotEmpty) {
+      for (var l in linked) {
+        output.write('      $l.ensureInitialized();\n');
+      }
+    }
+
+    output.write('''
           }
           return _instance!;
         }

packages/dart_mappable_builder/lib/src/elements/record/record_mapper_element.dart

@@ -405,7 +405,12 @@ class MapperElementGroup {
 
     bool isMapper(Element e) {
       return (e is ClassElement && classChecker.hasAnnotationOf(e)) ||
-          (e is EnumElement && enumChecker.hasAnnotationOf(e));
+          (e is EnumElement && enumChecker.hasAnnotationOf(e) ||
+              (e is TypeAliasElement &&
+                  ((e.aliasedType.element is ClassElement &&
+                          classChecker.hasAnnotationOf(e)) ||
+                      (e.aliasedType is RecordType &&
+                          recordChecker.hasAnnotationOf(e)))));
     }
 
     if (scope == InitializerScope.package ||
@@ -424,16 +429,29 @@ class MapperElementGroup {
           })
           .where((l) => l != null)
           .map(
-            (lib) =>
-                MapEntry(lib!, [...lib.classes, ...lib.enums].where(isMapper)),
+            (lib) => MapEntry(
+              lib!,
+              <Element>[
+                ...lib.classes,
+                ...lib.enums,
+                ...lib.typeAliases,
+              ].where(isMapper),
+            ),
           )
           .where((e) => e.value.isNotEmpty)
           .toList();
     } else if (scope == InitializerScope.library) {
       var lib = await buildStep.inputLibrary;
 
       return [
-        MapEntry(lib, [...lib.classes, ...lib.enums].where(isMapper)),
+        MapEntry(
+          lib,
+          <Element>[
+            ...lib.classes,
+            ...lib.enums,
+            ...lib.typeAliases,
+          ].where(isMapper),
+        ),
       ];
     }