diff --git a/packages/freezed/lib/src/models.dart b/packages/freezed/lib/src/models.dart index 8adeca3e..3aacb379 100644 --- a/packages/freezed/lib/src/models.dart +++ b/packages/freezed/lib/src/models.dart @@ -1109,6 +1109,9 @@ To fix, either: return '$escapedElementName$generics'; } + + bool get shouldBeFinal => + options.annotation.makeGeneratedClassesFinal ?? false; } class PropertyList { @@ -1299,6 +1302,11 @@ class ClassConfig { }, orElse: () => globalConfigs.map, ), + makeGeneratedClassesFinal: annotation.decodeField( + 'makeGeneratedClassesFinal', + decode: (obj) => obj.toBoolValue(), + orElse: () => globalConfigs.makeGeneratedClassesFinal, + ), ); } diff --git a/packages/freezed/lib/src/templates/concrete_template.dart b/packages/freezed/lib/src/templates/concrete_template.dart index 19271f4a..140d170d 100644 --- a/packages/freezed/lib/src/templates/concrete_template.dart +++ b/packages/freezed/lib/src/templates/concrete_template.dart @@ -43,7 +43,7 @@ class Concrete { /// @nodoc $jsonSerializable ${constructor.decorators.join('\n')} -class ${constructor.redirectedName}${data.genericsDefinitionTemplate} $_concreteSuper { +${data.shouldBeFinal ? 'final ' : ''}class ${constructor.redirectedName}${data.genericsDefinitionTemplate} $_concreteSuper { $_concreteConstructor $_concreteFromJsonConstructor diff --git a/packages/freezed/test/finalized_test.dart b/packages/freezed/test/finalized_test.dart new file mode 100644 index 00000000..a688e277 --- /dev/null +++ b/packages/freezed/test/finalized_test.dart @@ -0,0 +1,223 @@ +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', () { + group('sealed with 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 (SealedWithFinalFoo()) { + case SealedWithFinalBar(): + break; + + case SealedWithFinalFoo(): + break; + } +} +''', + }, + (r) => r.findLibraryByName('main'), + readAllSourcesFromFilesystem: true, + ); + + 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('sealed with single constructor and superclass', () { + 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() { + final SuperFoo foo = CustomFoo(); + + switch (foo) { + case SealedWithFinalSuperFoo(): + break; + + case AbstractWithFinalSuperFoo(): + break; + + case CustomFoo(): + break; + + case SealedWithFinalBar(): + break; + } +} +''', + }, + (r) => r.findLibraryByName('main'), + readAllSourcesFromFilesystem: true, + ); + + 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('sealed with 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 (SealedWithFinalAbc.b()) { + case SealedWithFinalBar(): + break; + + case SealedWithFinalAbcA(): + break; + + case SealedWithFinalAbcB(): + break; + + case SealedWithFinalAbcC(): + break; + } +} +''', + }, + (r) => r.findLibraryByName('main'), + readAllSourcesFromFilesystem: true, + ); + + 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('abstract with single constructor', () { + test( + 'doesnt cause 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 (AbstractWithFinalFoo()) { + case AbstractWithFinalBar(): + break; + + case AbstractWithFinalFoo(): + break; + } +} +''', + }, + (r) => r.findLibraryByName('main'), + readAllSourcesFromFilesystem: true, + ); + + final errorResult = + await main!.session.getErrors( + '/freezed/test/integration/main.dart', + ) + as ErrorsResult; + + expect(errorResult.errors, isEmpty); + }, + ); + }); + + group('abstract with multiple constructors', () { + test( + 'does not cause 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 (AbstractWithFinalAbc.b()) { + case AbstractWithFinalBar(): + break; + + case AbstractWithFinalAbcA(): + break; + + case AbstractWithFinalAbcB(): + break; + + case AbstractWithFinalAbcC(): + break; + } +} +''', + }, + (r) => r.findLibraryByName('main'), + readAllSourcesFromFilesystem: true, + ); + + final errorResult = + await main!.session.getErrors( + '/freezed/test/integration/main.dart', + ) + as ErrorsResult; + + expect(errorResult.errors, isEmpty); + }, + ); + }); + }); +} diff --git a/packages/freezed/test/integration/finalized.dart b/packages/freezed/test/integration/finalized.dart new file mode 100644 index 00000000..7d8860a3 --- /dev/null +++ b/packages/freezed/test/integration/finalized.dart @@ -0,0 +1,63 @@ +import 'package:freezed_annotation/freezed_annotation.dart'; + +part 'finalized.freezed.dart'; + +@Freezed(makeGeneratedClassesFinal: true) +sealed class SealedWithFinalFoo with _$SealedWithFinalFoo { + factory SealedWithFinalFoo() = _SealedWithFinalFoo; +} + +@Freezed(makeGeneratedClassesFinal: true) +sealed class SealedWithFinalBar with _$SealedWithFinalBar { + factory SealedWithFinalBar() = _SealedWithFinalBar; +} + +@Freezed(makeGeneratedClassesFinal: true) +sealed class SealedWithFinalAbc with _$SealedWithFinalAbc { + factory SealedWithFinalAbc.a() = SealedWithFinalAbcA; + factory SealedWithFinalAbc.b() = SealedWithFinalAbcB; + factory SealedWithFinalAbc.c() = SealedWithFinalAbcC; +} + +@Freezed(makeGeneratedClassesFinal: true) +abstract class AbstractWithFinalFoo with _$AbstractWithFinalFoo { + factory AbstractWithFinalFoo() = _AbstractWithFinalFoo; +} + +@Freezed(makeGeneratedClassesFinal: true) +abstract class AbstractWithFinalBar with _$AbstractWithFinalBar { + factory AbstractWithFinalBar() = _AbstractWithFinalBar; +} + +@Freezed(makeGeneratedClassesFinal: true) +abstract class AbstractWithFinalAbc with _$AbstractWithFinalAbc { + factory AbstractWithFinalAbc.a() = AbstractWithFinalAbcA; + factory AbstractWithFinalAbc.b() = AbstractWithFinalAbcB; + factory AbstractWithFinalAbc.c() = AbstractWithFinalAbcC; +} + +sealed class SuperFoo { + const SuperFoo(); +} + +final class CustomFoo extends SuperFoo {} + +@Freezed(makeGeneratedClassesFinal: true) +sealed class SealedWithFinalSuperFoo extends SuperFoo + with _$SealedWithFinalSuperFoo { + const SealedWithFinalSuperFoo._() : super(); + + factory SealedWithFinalSuperFoo() = _SealedWithFinalSuperFoo; +} + +@Freezed(makeGeneratedClassesFinal: true) +abstract class AbstractWithFinalSuperFoo extends SuperFoo + with _$AbstractWithFinalSuperFoo { + const AbstractWithFinalSuperFoo._() : super(); + + factory AbstractWithFinalSuperFoo() = _AbstractWithFinalSuperFoo; +} + +class SubFoo extends AbstractWithFinalSuperFoo { + SubFoo() : super._(); +} diff --git a/packages/freezed_annotation/lib/freezed_annotation.dart b/packages/freezed_annotation/lib/freezed_annotation.dart index 9a5f4631..6db333f2 100644 --- a/packages/freezed_annotation/lib/freezed_annotation.dart +++ b/packages/freezed_annotation/lib/freezed_annotation.dart @@ -219,6 +219,7 @@ class Freezed { this.makeCollectionsUnmodifiable, this.addImplicitFinal = true, this.genericArgumentFactories = false, + this.makeGeneratedClassesFinal, }); /// Decode the options from a build.yaml @@ -489,6 +490,43 @@ class Freezed { /// If that value is null too, defaults to [FreezedWhenOptions.all]. @_FreezedWhenOptionsConverter() final FreezedWhenOptions? when; + + /// Whether to add `final` modifiers to the generated classes. + /// + /// Defaults to false. + /// + /// This makes the generated classes `final` by default, + /// so when using them in a switch statement, the analzyer will warn you + /// if you try to match against a pattern that will never match the type. + /// + /// ```dart + /// @Freezed(makeGeneratedClassesFinal: true) + /// sealed class Foo with _$Foo { + /// const Foo._(); + /// const factory Foo() = _Foo; + /// } + /// + /// @Freezed(makeGeneratedClassesFinal: true) + /// sealed class Bar with _$Bar { + /// const Bar._(); + /// const factory Bar() = _Bar; + /// } + /// + /// void main() { + /// switch (Foo()) { + /// // The analyzer will yield a warning that this case can never match, + /// // because all subclasses of Foo are sealed/final, so it is guaranteed + /// // that instances of type Bar can never also be of type Foo. + /// case Bar(): + /// // ... + /// break; + /// + /// case Foo(): + /// // ... + /// break; + /// } + /// ``` + final bool? makeGeneratedClassesFinal; } /// Defines an immutable data-class. diff --git a/packages/freezed_annotation/lib/freezed_annotation.g.dart b/packages/freezed_annotation/lib/freezed_annotation.g.dart index d937ed04..ae5b4008 100644 --- a/packages/freezed_annotation/lib/freezed_annotation.g.dart +++ b/packages/freezed_annotation/lib/freezed_annotation.g.dart @@ -37,6 +37,7 @@ Freezed _$FreezedFromJson(Map json) => Freezed( addImplicitFinal: json['add_implicit_final'] as bool? ?? true, genericArgumentFactories: json['generic_argument_factories'] as bool? ?? false, + makeGeneratedClassesFinal: json['make_generated_classes_final'] as bool?, ); const _$FreezedUnionCaseEnumMap = { diff --git a/packages/freezed_annotation/test/freezed_test.dart b/packages/freezed_annotation/test/freezed_test.dart index f2232705..358c3336 100644 --- a/packages/freezed_annotation/test/freezed_test.dart +++ b/packages/freezed_annotation/test/freezed_test.dart @@ -151,6 +151,39 @@ void main() { expect(defaultValue.unionValueCase, isNull); expect(defaultValue.when, isNull); expect(defaultValue.makeCollectionsUnmodifiable, isTrue); + expect(defaultValue.addImplicitFinal, isTrue); + expect(defaultValue.genericArgumentFactories, isFalse); + expect(defaultValue.makeGeneratedClassesFinal, isNull); + }); + + test('.fromJson (explicit values)', () { + final overrides = Freezed.fromJson({ + 'copy_with': false, + 'equal': false, + 'fallback_union': 'test', + 'from_json': true, + 'to_json': true, + 'to_string_override': true, + 'union_key': 'foo', + 'union_value_case': 'screaming_snake', + 'make_collections_unmodifiable': false, + 'add_implicit_final': false, + 'generic_argument_factories': true, + 'make_generated_classes_final': true, + }); + + expect(overrides.copyWith, isFalse); + expect(overrides.equal, isFalse); + expect(overrides.fallbackUnion, 'test'); + expect(overrides.fromJson, isTrue); + expect(overrides.toJson, isTrue); + expect(overrides.toStringOverride, isTrue); + expect(overrides.unionKey, 'foo'); + expect(overrides.unionValueCase, FreezedUnionCase.screamingSnake); + expect(overrides.makeCollectionsUnmodifiable, isFalse); + expect(overrides.addImplicitFinal, isFalse); + expect(overrides.genericArgumentFactories, isTrue); + expect(overrides.makeGeneratedClassesFinal, isTrue); }); test('.fromJson({map: x})', () { @@ -226,9 +259,14 @@ void main() { }); }); + test('freezed', () { + expect(freezed.makeGeneratedClassesFinal, isNull); + }); + test('unfreezed', () { expect(unfreezed.makeCollectionsUnmodifiable, false); expect(unfreezed.equal, false); expect(unfreezed.addImplicitFinal, false); + expect(unfreezed.makeGeneratedClassesFinal, isNull); }); }