Allow nulls if a generic type parameter allows nulls.

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 # 8.10.0
 
+- Allow `null` values in generic types when the type argument is nullable. For
+  example, if a class `Value<T>` has a field of type `T`, a `Value<int?>` can
+  now hold a `null` value.
 - Stop generating unnecessary `new` keywords.
 - Stop generating explicit null checks in constructors: these are not needed
   with sound null safety.

built_value_generator/lib/src/serializer_source_class.dart

@@ -475,7 +475,7 @@ class $serializerImplName implements PrimitiveSerializer<$genericName> {
 
   String _generateRequiredFieldSerializers() {
     return fields
-        .where((field) => !field.isNullable)
+        .where((field) => !field.isNullable && !field.hasGenericType)
         .map((field) => "'${escapeString(field.wireName)}', "
             'serializers.serialize(object.${field.name}, '
             'specifiedType: '
@@ -484,7 +484,7 @@ class $serializerImplName implements PrimitiveSerializer<$genericName> {
   }
 
   String _generateNullableFieldSerializers() {
-    var nullableFields = fields.where((field) => field.isNullable).toList();
+    var nullableFields = fields.where((field) => field.isNullable || field.hasGenericType).toList();
     if (nullableFields.isEmpty) return '';
 
     return 'Object? value;' +

built_value_generator/lib/src/serializer_source_field.dart

@@ -86,6 +86,10 @@ abstract class SerializerSourceField
       element.getter?.returnType.nullabilitySuffix ==
       NullabilitySuffix.question;
 
+  @memoized
+  bool get hasGenericType =>
+      element.getter?.returnType is TypeParameterType;
+
   @memoized
   bool get isNullable => hasNullableAnnotation || hasNullableType;
 

built_value_generator/lib/src/value_source_class.dart

@@ -1048,7 +1048,7 @@ abstract class ValueSourceClass
         if (!field.isNullable) {
           needsNullCheck.add(name);
         }
-        if (field.hasNullableGenericType) {
+        if (field.hasGenericType) {
           genericFields[name] =
               field.element.getter!.returnType.element!.displayName;
         }

built_value_generator/lib/src/value_source_field.dart

@@ -109,12 +109,8 @@ abstract class ValueSourceField
       NullabilitySuffix.question;
 
   @memoized
-  bool get hasNullableGenericType =>
-      element.getter?.returnType is TypeParameterType &&
-      (element.getter!.returnType as TypeParameterType)
-              .bound
-              .nullabilitySuffix ==
-          NullabilitySuffix.question;
+  bool get hasGenericType =>
+      element.getter?.returnType is TypeParameterType;
 
   @memoized
   bool get isNullable => hasNullableAnnotation || hasNullableType;

end_to_end_test/test/generics_serializer_test.dart

@@ -67,6 +67,37 @@ void main() {
     });
   });
 
+  group('GenericValue with known specifiedType, correct builder and null', () {
+    var data = GenericValue<int?>();
+    var specifiedType = const FullType(GenericValue, [FullType.nullable(int)]);
+    var serializersWithBuilder = (serializers.toBuilder()
+          ..addBuilderFactory(specifiedType, () => GenericValueBuilder<int?>()))
+        .build();
+    var serialized = json.decode(json.encode([])) as Object;
+
+    test('can be serialized', () {
+      expect(
+          serializersWithBuilder.serialize(data, specifiedType: specifiedType),
+          serialized);
+    });
+
+    test('can be deserialized', () {
+      expect(
+          serializersWithBuilder.deserialize(serialized,
+              specifiedType: specifiedType),
+          data);
+    });
+
+    test('keeps generic type on deserialization', () {
+      expect(
+          serializersWithBuilder
+              .deserialize(serialized, specifiedType: specifiedType)
+              .runtimeType
+              .toString(),
+          r'_$GenericValue<int?>');
+    });
+  });
+
   group('GenericValue with unknown specifiedType', () {
     var data = GenericValue<int>((b) => b..value = 1);
     var serialized = json.decode(json.encode([
@@ -89,6 +120,26 @@ void main() {
     });
   });
 
+  group('GenericValue with unknown specifiedType null value', () {
+    var data = GenericValue<int?>();
+    var serialized = json.decode(json.encode([
+      'GenericValue',
+    ])) as Object;
+
+    test('can be serialized', () {
+      expect(serializers.serialize(data), serialized);
+    });
+
+    test('can be deserialized', () {
+      expect(serializers.deserialize(serialized), data);
+    });
+
+    test('loses generic type on deserialization', () {
+      expect(serializers.deserialize(serialized).runtimeType.toString(),
+          r'_$GenericValue<Object?>');
+    });
+  });
+
   group('BoundGenericValue with known specifiedType but missing builder', () {
     var data = BoundGenericValue<int>((b) => b..value = 1);
     var specifiedType = const FullType(BoundGenericValue, [FullType(int)]);

end_to_end_test/test/generics_test.dart

@@ -18,6 +18,10 @@ void main() {
           throwsA(const TypeMatcher<BuiltValueNullFieldError>()));
     });
 
+    test('does not throw on null for nullable fields on build', () {
+      GenericValue<int?>();
+    });
+
     test('fields can be set via build constructor', () {
       final value = GenericValue<int>((b) => b..value = 1);
       expect(value.value, 1);