feat: mark generated classes as final if freezed class is sealed

Author: Yegair

packages/freezed/lib/src/models.dart

@@ -504,6 +504,7 @@ class Class {
     required this.superCall,
     required this.properties,
     required this.copyWithTarget,
+    required this.isSealed,
   }) : assert(constructors.isNotEmpty);
 
   final String name;
@@ -516,6 +517,7 @@ class Class {
   final CopyWithTarget? copyWithTarget;
   final PropertyList properties;
   final List<Class> parents = [];
+  final bool isSealed;
 
   static Class _from(
     ClassDeclaration declaration,
@@ -597,6 +599,7 @@ class Class {
       genericsParameterTemplate: GenericsParameterTemplate.fromGenericElement(
         declaration.declaredElement!.typeParameters,
       ),
+      isSealed: declaration.declaredElement!.isSealed,
     );
   }
 

packages/freezed/lib/src/templates/concrete_template.dart

@@ -49,7 +49,7 @@ class Concrete {
 /// @nodoc
 $jsonSerializable
 ${constructor.decorators.join('\n')}
-class ${constructor.redirectedName}${data.genericsDefinitionTemplate} $_concreteSuper {
+${data.isSealed ? 'final ' : ''}class ${constructor.redirectedName}${data.genericsDefinitionTemplate} $_concreteSuper {
   $_concreteConstructor
   $_concreteFromJsonConstructor
 

packages/freezed/test/finalized_test.dart

@@ -0,0 +1,86 @@
+import 'package:analyzer/dart/analysis/results.dart';
+import 'package:analyzer/error/error.dart';
+import 'package:build_test/build_test.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('marks generated classes as final and sealed', () {
+    group('single constructor', () {
+      test(
+          'causes pattern_never_matches_value_type warning when trying to match on pattern that can never match',
+          () async {
+        final main = await resolveSources(
+          {
+            'freezed|test/integration/main.dart': r'''
+library main;
+import 'finalized.dart';
+
+void main() {
+  switch (FinalizedFoo()) {
+    case FinalizedBar():
+      break;
+
+    case FinalizedFoo():
+      break;
+  }
+}
+''',
+          },
+          (r) => r.findLibraryByName('main'),
+        );
+
+        final errorResult = await main!.session
+            .getErrors('/freezed/test/integration/main.dart') as ErrorsResult;
+
+        expect(errorResult.errors, hasLength(1));
+
+        final [error] = errorResult.errors;
+
+        expect(error.errorCode.errorSeverity, ErrorSeverity.WARNING);
+        expect(error.errorCode.name, 'PATTERN_NEVER_MATCHES_VALUE_TYPE');
+      });
+    });
+
+    group('multiple constructors', () {
+      test(
+          'causes pattern_never_matches_value_type warning when trying to match on pattern that can never match',
+          () async {
+        final main = await resolveSources(
+          {
+            'freezed|test/integration/main.dart': r'''
+library main;
+import 'finalized.dart';
+
+void main() {
+  switch (FinalizedMultiple.b()) {
+    case FinalizedBar():
+      break;
+
+    case FinalizedMultipleA():
+      break;
+
+    case FinalizedMultipleB():
+      break;
+
+    case FinalizedMultipleC():
+      break;
+  }
+}
+''',
+          },
+          (r) => r.findLibraryByName('main'),
+        );
+
+        final errorResult = await main!.session
+            .getErrors('/freezed/test/integration/main.dart') as ErrorsResult;
+
+        expect(errorResult.errors, hasLength(1));
+
+        final [error] = errorResult.errors;
+
+        expect(error.errorCode.errorSeverity, ErrorSeverity.WARNING);
+        expect(error.errorCode.name, 'PATTERN_NEVER_MATCHES_VALUE_TYPE');
+      });
+    });
+  });
+}

packages/freezed/test/integration/finalized.dart

@@ -0,0 +1,20 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'finalized.freezed.dart';
+
+@freezed
+sealed class FinalizedFoo with _$FinalizedFoo {
+  factory FinalizedFoo() = _FinalizedFoo;
+}
+
+@freezed
+sealed class FinalizedBar with _$FinalizedBar {
+  factory FinalizedBar() = _FinalizedBar;
+}
+
+@freezed
+sealed class FinalizedMultiple with _$FinalizedMultiple {
+  factory FinalizedMultiple.a() = FinalizedMultipleA;
+  factory FinalizedMultiple.b() = FinalizedMultipleB;
+  factory FinalizedMultiple.c() = FinalizedMultipleC;
+}