freezed

• Fix ==/copyWith when immutable collections are enabled yet non-factory constructors are used.
• Fix (int,) records incorrectly generated
• Support analyzer 13.0
• Support primary constructors
• Breaking: No-longer support final keyword inside constructor parameter. This is due to Dart 3.13 no-longer allowing this syntax. This prevents @unfreezed from defining immutable fields.

fix: correct immutable collection handling in == and copyWith for non…

• Fix (int,) records incorrectly generated

• Support analyzer 13.0
• Support primary constructors
• Breaking: No-longer support final keyword inside constructor parameter. This is due to Dart 3.13 no-longer allowing this syntax. This prevents @unfreezed from defining immutable fields.

freezed : 3.2.5 -> 3.2.6-dev.1

freezed : 3.2.4 -> 3.2.5

Support analyzer 9.0.0

freezed : 3.2.2 -> 3.2.3
freezed_lint : 0.0.11 -> 0.0.12

freezed : 3.2.1 -> 3.2.2

Support latest analyzer/source_gen

• Use build 3.0.0-dev.
• Use source_gen 3.0.0-dev.
• Support Dart 3.8.0 and analyzer 7.5.9 as a minumum.

• Added when/map back
• Stop writing // dart format width=80 to the generated freezed files.

Remove logs

• Fix ==/hashCode when using inheritance. The generated ==/hashCode now call super == other when necessary.
• Fix an issue with Diagnosticable and toString
• Fix ejecting union cases when more than one class is defined in a file
• Fix a copyWith bug when a constructor parameter has no matching property
• Fix null exception in some cases when using generic classes and copyWith

• Update docs (thanks to @lishaduck)
• Support Dart 3.6.0 and analyzer 6.9.0 as a minimum.

Update readme (thanks to @snapsl)

• Fix various deep-copy bugs
• Throw when using extends/with but not specifying a MyClass._() constructor
• Throw when a Freezed class forgot to include with _$MyClass
• "Normal" classes shouldn't require MyClass._() when they define getters/methods/...

Fix a bug with diagnosticable objects.

New: Mixed mode

Freezed 3.0 is about supporting a "mixed mode".
From now on, Freezed supports both the usual syntax:

@freezed
sealed class Usual with _$Usual {
  factory Usual({int a}) = _Usual;
}

But also:

@freezed
class Usual with _$Usual {
  Usual({this.a});
  final int a;
}

This has multiple benefits:

• Simple classes don't need Freezed's "weird" syntax and can stay simple
• Unions can keep using the usual factory syntax

This also offers a way to use all constructor features, such as initializers or super():

class Base {
  Base(String value);
}

@freezed
class Usual extends Base with _$Usual {
  Usual({int? a}) a = a ?? 0, super('value');
  final int a;
}

New: Inheritance and non-constant default values.

When using Freezed, a common problem has always been the lack of extends support and non-constant default values.

Besides through "Mixed mode" mentioned above, Freezed now offers a way for factory constructors to specify non-constant defaults and a super(), by relying on the MyClass._() constructor:

It also has another benefit:
Complex Unions now have a way to use Inheritance and non-constant default values, by relying on a non-factory MyClass._() constructor.

For context:
Before, when a Freezed class specified a property or method, it was required to specify a MyClass._() constructor:

@freezed
class Example with _$Example {
  // Necessary for helloWorld() to work
  Example._();
  factory Example(String name) = _Example

  void helloWorld() => print('Hello $name');
}

However, that Example._() constructor was required to have no parameter.

Starting Freezed 3.0, this constructor can accept any parameter. Freezed will then pass its values from other factory constructors, based on name.

In short, this enables extending any class:

class Subclass {
  Subclass.name(this.value);
  final int value;
}

@freezed
class MyFreezedClass extends Subclass with _$MyFreezedClass {
  // We can receive parameters in this constructor, which we can use with `super.field`
  MyFreezedClass._(super.value): super.name();

  factory MyFreezedClass(int value, /* other fields */) = _MyFreezedClass;
}

It also enables non-constant default values:

@freezed
sealed class Response<T> with _$Response<T> {
  // We give "time" parameters a non-constant default
  Response._({DateTime? time}) : time = time ?? DateTime.now();
  // Constructors may enable passing parameters to ._();
  factory Response.data(T value, {DateTime? time}) = ResponseData;
  // If ._ parameters are named and optional, factory constructors are not required to specify it
  factory Response.error(Object error) = ResponseError;

  @override
  final DateTime time;
}

New: "Eject" union cases

Along with the mixed mode, it is also possible to eject a "union" case, by having it point to a custom class.

Concretely, you can do:

@freezed
sealed class Result<T> with _$Result {
  Result._();
  // Data does not exist, so Freezed will generate it as usual
  factory Result.data(T data) = ResultData;
  // We wrote a ResultError class in the same library, so Freezed won't do anything
  factory Result.error(Object error) = ResultError;
}

// We manually wrote `ResultError`
class ResultError<T> extends Result<T> {
  ResultError(this.error): super._();
  final Object error;
}

This combines nicely with "Mixed mode" mentioned previously, as extracted union cases can also be Freezed classes:

// Using freezed with a simple class:
@freezed
class ResultError<T> extends Result<T> {
  ResultError(this.error): super._();
  final Object error;
}

// Or using a factory:
@freezed
class ResultError<T> extends Result<T> {
  ResultError._(): super._();
  factory ResultError(Object error) = _ResultError;
}

This feature offers fine-grained control over every parts of your models.

Note: Unfortunately, it is kind of required to "extend" the parent class (so here extends Result<T>). This is because Dart doesn't support sealed mixin class, so you can't do with Result<T> instead.

Other changes:

• Breaking: Removed map/when and variants. These have been discouraged since Dart got pattern matching.
• Breaking: Freezed classes should now either be abstract, sealed, or manually implements _$MyClass.
• When formatting is disabled (default), Freezed now generates // dart format off. This prevents having to exclude generated file from formatting check in the CI.
• It is now possible to have a private constructor for unions:

  @freezed
  sealed class Result<T> with _$Result {
    // It wasn't possible to write _data before, but now is.
    factory Result._data(T data) = ResultData;
    factory Result.error(Object error) = ResultError;
  }
  

Support analyzer 7.0.0

• freezed_annotation upgraded to 2.4.4

• Generate documentation for copyWith (thanks to @rekire)

• Stop using JsonKey(ignore: true) in favour of JsonKey(includeFromJson: false, includeToJson: false) (thanks to @lrsvmb)
• Require json_annotation ^6.8.0

• Require Dart >=3.0.0
• Support latest collection

• Support analyzer 6.5.0

• Fixed copyWith(value: null) when using nullable generics

• Fixed @freezed no-longer working inside part of files.

• Added format: false flag in the build.yaml, to disable formatting in generated files. This can significantly improve performance, but may require updating your CI to not check that generated files are formatted.
• Fixed an InconsistentAnalysisException

• Fixed a performance problem

• Fixed broken link in docs (thanks to @iDevOrz)

• Have the == implementation use Object as parameter instead of dynamic

Loosened analyzer version to support both ^5.13.0 and ^6.0.0 (thanks to @SunlightBro)

Do not throw on unresolved annotations.

• Fix lowercase warning on generated objects.

• Support analyzer 6.0.0

• freezed_annotation upgraded to 2.3.0

• Allow enabling/disabling all when/map variants at once (thanks to @gaetschwartz)

• Fix regression in analyzer 5.13.0 (thanks to @SunlightBro)

• Fix allow dollar ($) in recursive class names (thanks to @andreasgangso)
• Fix deprecated warning with analyzer 5.12.0 (thanks to @SunlightBro)
• Remove warning when marking a class as abstract

• Fixed an issue with the generated code when classes contains a $ in their property/constructor/class name (thanks to @medz)

Fix more issues with copyWith

Fix various issues with copyWith

• Union types now expose properties with the same name but different type on the shared interface. (Thanks to @DevNico)

  This allows doing:

  @freezed
  class Union with _$Union {
    factory Union.first(int value) = _UnionFirst;
    factory Union.second(double value) = _UnionSecond;
  }
  
  void main() {
    Union union;
  
    num value = union.value;
    // No need for casting as "num" is the shared interface between int/double
  }
  

• Fixes copyWith not working with null on some scenarios.

• Fixes a stackoverflow error when continuously passing unmodifiable collections as parameter to freezed classes

• fix: Deep copy now correctly handles cases where a property is a Freezed class with disabled copyWith

Upgrade analyzer

• The generated copyWith is now annotated by @useResult (thanks to @miDeb)
• Improved performance of copyWith (thanks to @miDeb)
• Improved type inference when using mapOrNull/whenOrNull (thanks to @DevNico)
• Re-introduced @With.fromString and @Implements.fromString to allow unions to implement generic types. (thanks to @rorystephenson)
• fixes @Default for Strings containing (, [ or { (thanks to @hugobrancowb)
• fix Freezed incorrectly comparing primitives using DeepCollectionEquality (thanks to @knaeckeKami)
• fix image links (thanks to @SunlightBro)

• Bump Analyzer to 5.0.0
• Fix an issuee where Freezed fails to detect that the Diagnosticable API is available

Improve pub score

• Add support for de/serializing generic Freezed classes (Thanks to @TimWhiting)
• Fixed a StackOverflow error when defining circular exports (Thanks to @TimWhiting)

Increase minimum analyzer version.

Fixes a bug where using @unfreezed on unions somehow still generated immutable properties.

Update warning message when using abstract freezed classes

• fix: performance regression with ==/hashCode/copyWith due to immutable collections (#653)
• fix: build.yaml decoding crash
• fix: remove annotations on internal properties related to immutable collections (#659)

Fixed invalid generated code when defining nullable collections.

• Fixed a bug where the generated when/map methods were potentially invalid when using default values
• Fixed a bug where when/map methods were generated even when not necessary

• Breaking: freezed_annotation no-longer exports the entire package:collection

• Breaking: Freezed no-longer generates $MyClassTearOff. This feature is now available in Dart

• Breaking Removed @Freezed(maybeMap: ) & @Freezed(maybeWhen: ) in favor of a separate:

  @Freezed(map: FreezedMap(...), when: FreezedWhenOptions(...))
  

• Breaking: Freezed now converts Lists/Maps/Sets into UnmodifiableListView/UnmodifiableMapView/UnmodifiableSetView. This can be disabled for one class by specifying @Freezed(makeCollectionsUnmodifiable: false). Alternatively, this can be configured inside the build.yaml file

• Added parameters of @Freezed to customize the generated code. This includes: fromJson, toJson, map, when, equal, toStringOverride, copyWith.

  These parameters allow disabling code that would otherwise be generated. It also allows forcing the generation even if it would otherwise not be generated.

• Feat: Add screaming snake union case type (#617) (thanks to @zbarbuto)

• Fix null exceptions in some cases when using typedefs (thanks to @smiLLe)

• Support analyzer 4.0.0

• Fix an issue with generic Freezed classes failing to compile when using @With<Mixin<T>>() #614

• Added @unfreezed as a variant to @freezed, for mutable classes

• Lints are now disabled inside generated files (requires Dart 2.15)
• Upgraded the analyzer version to 3.0.0

Added support for disabling the generation of maybeMap/maybeWhen (thanks to @Lyokone)