feat: throw on invalid config and add support for complex sealed classes

Author: O-Hannonen

example/lib/complex_sealed_class_examples.dart

@@ -0,0 +1,79 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'complex_sealed_class_examples.g.dart';
+
+@JsonSerializable(
+  unionDiscriminator: 'base_base_base_type',
+)
+sealed class BaseBaseBaseType {
+  BaseBaseBaseType();
+
+  factory BaseBaseBaseType.fromJson(Map<String, dynamic> json) =>
+      _$BaseBaseBaseTypeFromJson(json);
+
+  Map<String, dynamic> toJson() => _$BaseBaseBaseTypeToJson(this);
+}
+
+@JsonSerializable(
+  unionDiscriminator: 'base_base_type',
+)
+sealed class BaseBase extends BaseBaseBaseType {
+  BaseBase();
+}
+
+@JsonSerializable(
+  unionDiscriminator: 'base_type',
+)
+sealed class Base extends BaseBase {
+  Base();
+}
+
+@JsonSerializable()
+class FirstBaseImpl extends Base {
+  FirstBaseImpl(this.value);
+
+  String value;
+}
+
+@JsonSerializable()
+class SecondBaseImpl extends Base {
+  SecondBaseImpl(this.value);
+
+  String value;
+}
+
+@JsonSerializable()
+class BaseBaseImpl extends BaseBase {
+  BaseBaseImpl(this.value);
+
+  String value;
+}
+
+@JsonSerializable(
+  createToJson: false,
+)
+sealed class SecondBase {
+  SecondBase();
+
+  factory SecondBase.fromJson(Map<String, dynamic> json) =>
+      _$SecondBaseFromJson(json);
+}
+
+@JsonSerializable(
+  createToJson: false,
+)
+sealed class ThirdBase {
+  ThirdBase();
+
+  factory ThirdBase.fromJson(Map<String, dynamic> json) =>
+      _$ThirdBaseFromJson(json);
+}
+
+@JsonSerializable(
+  createToJson: false,
+)
+class ImplAll implements SecondBase, ThirdBase {
+  ImplAll(this.value);
+
+  String value;
+}

example/lib/complex_sealed_class_examples.g.dart

@@ -48,6 +48,57 @@ class GeneratorHelper extends HelperCore with EncodeHelper, DecodeHelper {
       );
     }
 
+    final sealedSuperClassesOrEmpty = sealedSuperClasses(element);
+
+    final sealedDiscriminators = sealedSuperClassesOrEmpty
+        .map((sealedClass) => jsonSerializableConfig(sealedClass, _generator))
+        .map((config) => config?.unionDiscriminator);
+
+    if ((sealedSuperClassesOrEmpty.isNotEmpty || element.isSealed) &&
+        config.genericArgumentFactories) {
+      throw InvalidGenerationSourceError(
+        'The class `${element.displayName}` is annotated '
+        'with `JsonSerializable` field `genericArgumentFactories: true`. '
+        '`genericArgumentFactories: true` is not supported for classes '
+        'that are sealed or have sealed superclasses.',
+        todo:
+            'Remove the `genericArgumentFactories` option or '
+            'remove the `sealed` keyword from the class.',
+        element: element,
+      );
+    }
+
+    if (element.isSealed) {
+      if (sealedDiscriminators.contains(config.unionDiscriminator)) {
+        throw InvalidGenerationSource(
+          'Nested sealed classes cannot have the same discriminator.',
+          todo:
+              'Rename one of the discriminators with `unionDiscriminator` '
+              'field in `@JsonSerializable`.',
+        );
+      }
+      sealedClassImplementations(element).forEach((impl) {
+        final annotationConfig = jsonSerializableConfig(impl, _generator);
+
+        if (annotationConfig == null) {
+          throw InvalidGenerationSourceError(
+            'The class `${element.displayName}` is sealed but its '
+            'implementation `${impl.displayName}` is not annotated with '
+            '`JsonSerializable`.',
+            todo: 'Add `@JsonSerializable` annotation to ${impl.displayName}.',
+          );
+        }
+
+        if (annotationConfig.createToJson != config.createToJson) {
+          throw InvalidGenerationSourceError(
+            'The class `${element.displayName}` is sealed but its '
+            'implementation `${impl.displayName}` has a different '
+            '`createToJson` option than the base class.',
+          );
+        }
+      });
+    }
+
     final sortedFields = createSortedFieldSet(element);
 
     // Used to keep track of why a field is ignored. Useful for providing
@@ -113,6 +164,16 @@ class GeneratorHelper extends HelperCore with EncodeHelper, DecodeHelper {
       // by `_writeCtor`.
       ..fold(<String>{}, (Set<String> set, fe) {
         final jsonKey = nameAccess(fe);
+
+        if (sealedDiscriminators.contains(jsonKey)) {
+          throw InvalidGenerationSourceError(
+            'The JSON key "$jsonKey" is conflicting with the discriminator '
+            'of sealed superclass ',
+            todo: 'Rename the field or the discriminator.',
+            element: fe,
+          );
+        }
+
         if (!set.add(jsonKey)) {
           throw InvalidGenerationSourceError(
             'More than one field has the JSON key for name "$jsonKey".',

json_serializable/lib/src/generator_helper.dart

@@ -9,10 +9,12 @@ import 'package:json_annotation/json_annotation.dart';
 import 'package:source_gen/source_gen.dart';
 import 'package:source_helper/source_helper.dart';
 
+import 'settings.dart';
 import 'shared_checkers.dart';
 import 'type_helpers/config_types.dart';
 
 const _jsonKeyChecker = TypeChecker.fromRuntime(JsonKey);
+const _jsonSerializableChecker = TypeChecker.fromRuntime(JsonSerializable);
 
 DartObject? _jsonKeyAnnotation(FieldElement element) =>
     _jsonKeyChecker.firstAnnotationOf(element) ??
@@ -167,20 +169,63 @@ ConstructorElement constructorByName(ClassElement classElement, String name) {
   return ctor;
 }
 
+/// Given a [ClassElement] that is a sealed class, returns all the
+/// direct subclasses of the given sealed class, excluding any
+/// indirect subclasses (ie. subclasses of subclasses).
+///
+/// Otherwise, returns an empty iterable.
 Iterable<ClassElement> sealedClassImplementations(
-  ClassElement maybeSealedClass,
+  ClassElement maybeSealedSuperClass,
 ) {
-  if (maybeSealedClass case final sc when sc.isSealed) {
-    return LibraryReader(sc.library)
-        .annotatedWith(const TypeChecker.fromRuntime(JsonSerializable))
-        .map((e) => e.element)
-        .whereType<ClassElement>()
-        .where((e) => e.allSupertypes.contains(sc.thisType));
+  if (maybeSealedSuperClass case final sc when sc.isSealed) {
+    return LibraryReader(
+      sc.library,
+    ).allElements.whereType<ClassElement>().where(
+      (e) => e.interfaces.contains(sc.thisType) || e.supertype?.element == sc,
+    );
   }
 
   return const Iterable<ClassElement>.empty();
 }
 
+/// Given a [ClassElement] that is a subclass of sealed classes, returns
+/// all of the sealed superclasses, including all indirect superclasses
+/// (ie. superclasses of superclasses)
+///
+/// Otherwise, returns an empty iterable.
+Iterable<ClassElement> sealedSuperClasses(
+  ClassElement maybeSealedImplementation,
+) => maybeSealedImplementation.allSupertypes
+    .map((type) => type.element)
+    .whereType<ClassElement>()
+    .where((element) => element.isSealed);
+
+/// Given a [ClassElement] that is annotated with `@JsonSerializable`, returns
+/// the annotation config merged with build runner config and defaults.
+///
+/// Otherwise, returns `null`.
+ClassConfig? jsonSerializableConfig(
+  ClassElement maybeAnnotatedElement,
+  Settings generator,
+) {
+  final maybeSuperAnnotation = _jsonSerializableChecker.firstAnnotationOfExact(
+    maybeAnnotatedElement,
+    throwOnUnresolved: false,
+  );
+
+  if (maybeSuperAnnotation case final superAnnotation?) {
+    final annotationReader = ConstantReader(superAnnotation);
+
+    return mergeConfig(
+      generator.config,
+      annotationReader,
+      classElement: maybeAnnotatedElement,
+    );
+  }
+
+  return null;
+}
+
 /// If [targetType] is an enum, returns the [FieldElement] instances associated
 /// with its values.
 ///