fix: include type parameters in switch cases and copyWith factories for sealed classes

Sealed classes with type parameters require explicit type parameters in
pattern matching switch cases and copyWith factory method assignments.
Without this, Dart's analyzer flags the generated code as non-exhaustive
or incorrectly typed.

Changes:
- Add genericsParameterTemplate to switch case patterns in _mapImpl and _whenImpl
- Add type parameters to copyWith factory method implementation class reference

This fixes compilation errors for sealed classes with type parameters and
eliminates the need for post-generation patching.

Author: Julien Zarka

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

@@ -64,7 +64,7 @@ class CopyWith {
       leading = 'abstract mixin ';
       body =
           '''
-  factory $_abstractClassName($clonedClassName$genericsParameter value, \$Res Function($clonedClassName$genericsParameter) _then) = $_implClassName;
+  factory $_abstractClassName($clonedClassName$genericsParameter value, \$Res Function($clonedClassName$genericsParameter) _then) = $_implClassName${genericsParameter.append('\$Res')};
 ${_copyWithPrototype('call')}
 
 ${_abstractDeepCopyMethods().join()}

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

@@ -216,7 +216,7 @@ String _mapImpl(
     ..writeln('final _that = this;')
     ..writeln('switch (_that) {');
   for (final constructor in data.constructors) {
-    buffer.write('case ${constructor.redirectedName}()');
+    buffer.write('case ${constructor.redirectedName}${data.genericsParameterTemplate}()');
     if (!areCallbacksRequired) {
       buffer.write(' when ${constructor.callbackName} != null');
     }
@@ -288,7 +288,7 @@ String _whenImpl(
     ..writeln('switch (_that) {');
 
   for (final constructor in data.constructors) {
-    buffer.write('case ${constructor.redirectedName}()');
+    buffer.write('case ${constructor.redirectedName}${data.genericsParameterTemplate}()');
     if (!areCallbacksRequired) {
       buffer.write(' when ${constructor.callbackName} != null');
     }

packages/freezed/test/integration/sealed_generic_switch/sealed_generic.dart

@@ -0,0 +1,9 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'sealed_generic.freezed.dart';
+
+@freezed
+sealed class SealedGeneric<T> with _$SealedGeneric<T> {
+  const factory SealedGeneric.first(T data) = SealedGenericFirst<T>;
+  const factory SealedGeneric.second(T data) = SealedGenericSecond<T>;
+}

packages/freezed/test/sealed_generic_switch_test.dart

@@ -0,0 +1,62 @@
+// ignore_for_file: prefer_const_constructors, omit_local_variable_types, deprecated_member_use_from_same_package
+import 'package:analyzer/dart/analysis/results.dart';
+import 'package:build_test/build_test.dart';
+import 'package:test/test.dart';
+
+Future<void> main() async {
+  test('sealed class with type parameters generates correct switch cases', () async {
+    final library = await resolveSources(
+      {'freezed|test/integration/sealed_generic_switch/sealed_generic.dart': useAssetReader},
+      (r) => r.libraries.firstWhere(
+        (element) =>
+            element.firstFragment.source.toString().contains('sealed_generic'),
+      ),
+    );
+
+    const generatedPath =
+        '/freezed/test/integration/sealed_generic_switch/sealed_generic.freezed.dart';
+    final result = await library.session.getErrors(generatedPath);
+    expect(result, isA<ErrorsResult>(), reason: 'Expected ErrorsResult for $generatedPath');
+    final errorResult = result as ErrorsResult;
+
+    // The key test: verify that the generated code has no errors
+    // This confirms that switch cases with type parameters are correctly generated
+    expect(errorResult.errors, isEmpty);
+  });
+  
+  test('sealed class with type parameters - verify generated switch cases include type params', () async {
+    final library = await resolveSources(
+      {'freezed|test/integration/sealed_generic_switch/sealed_generic.dart': useAssetReader},
+      (r) => r.libraries.firstWhere(
+        (element) =>
+            element.firstFragment.source.toString().contains('sealed_generic'),
+      ),
+    );
+
+    const generatedPath =
+        '/freezed/test/integration/sealed_generic_switch/sealed_generic.freezed.dart';
+    
+    // Access the generated file through the session
+    // The file should be available as it's a part of the library
+    final fileResult = await library.session.getFile(generatedPath);
+    expect(fileResult, isA<FileResult>(), reason: 'Expected FileResult for $generatedPath');
+    
+    // Try to get content - if empty, the file might be generated in memory
+    // In that case, we rely on the error check in the first test to verify correctness
+    if (fileResult is FileResult) {
+      final content = fileResult.content;
+      if (content.isNotEmpty) {
+        // Verify that switch cases include type parameters
+        expect(content, contains('case SealedGenericFirst<T>():'));
+        expect(content, contains('case SealedGenericSecond<T>():'));
+        
+        // Verify that copyWith factory includes type parameters
+        expect(content, contains('= _\$SealedGenericCopyWithImpl<T, \$Res>;'));
+        expect(content, contains('= _\$SealedGenericFirstCopyWithImpl<T, \$Res>;'));
+        expect(content, contains('= _\$SealedGenericSecondCopyWithImpl<T, \$Res>;'));
+      }
+      // If content is empty, the first test's error check is sufficient
+      // as it confirms the generated code compiles without errors
+    }
+  });
+}