Notable bug fixes:

• Multiple levels of export * will now be correctly indexed so that they won't be missing in autoimport results.

Library Definitions

• Add Float16Array type

Likely to cause new Flow errors:

• When component syntax support is enabled, upper case functions with component-like name but doesn't return React.Node will no longer be treated like components. Thus, all the hooks call in such functions will have react-rule-hook-definitely-not-in-component-or-hook errors.
• Usage of Object.assign will now trigger unsafe-object-assign lint error that's on by default. The type checking behavior for Object.assign will otherwise stay the same for now.
• When Flow decides that the hook call definitely doesn't happen within component or hook body, it will emit errors with code react-rule-hook-definitely-not-in-component-or-hook.

Parser:

• Parse the TS nonnull assertion operator.

It should have the same behavior as 0.269.0.

Breaking:

• The Linux x86 build is now built from ubuntu-22.04. It might make Flow not runnable on older linux distributions.

Likely to cause new Flow errors:

• Code like the (example) will have [react-rule-hook-conditional] instead of [react-rule-hook-naming-convention] errors.
• $Diff support is removed. If you have trouble migrating, you can try to polyfill it by this. However, $Diff has surprising behavior with regard to optional props in the second type parameter, which cannot be easily polyfilled (example).

New Features:

• We now allow you to configure certain error code to be unsuppressable. For example, to make react-rule-hook-naming-convention and react-rule-hook-conditional errors unsuppressable, you can add the following to the [options] section in flowconfig:

unsuppressable_error_codes=react-rule-hook-naming-convention
unsuppressable_error_codes=react-rule-hook-conditional

Likely to cause new Flow errors:

• We have updated the way type parameters are instantiated in generic calls, specifically when using upper bounds:

  • We will no longer infer synthetic intersection types.
  • If multiple upper bounds are available, we pick the smallest type based on subtyping (example).

• Support for $Rest is removed. Omit should be used instead. If you still have many instances of $Rest, you can replace them with $Diff as a temporary measure, but note that we intend to eventually remove $Diff as well.

• React-rule hook errors related to conditional hook calls will now have react-rule-hook-conditional error code.

• React-rule hook errors related to naming convention issues will now have react-rule-hook-naming-convention error code.

Notable bug fixes:

• We are rolling out the initial phase of a fix to a fundamental soundness issue related to primitive literal type inference. This unsoundness has allowed invalid code like: const x = 'a'; 'b' as typeof x as 'a'; (try-Flow) to type check without errors. With this fix, Flow will infer singleton literal types for primitive literals in contexts where such precision is required. Examples of this are: const-declarations (e.g. in const x = 42 will infer the type 42 for x), annotation positions (e.g. typeof x is equivalent to the type 42), conditionals (e.g. in if (x.tag === 42) {} Flow will infer the type 42 for the value 42, instead of number). In this part of the rollout, whenever this precision is not required Flow will infer the unsound type it used to infer before (a hybrid between the singleton and general type). Eliminating this unsound type completely will be done soon.
• flow-remove-types now handles the removal of empty imports after removing type/typeof imports (thanks @jbroma)

• Fix a bug that causes fixed libdef-override error to stick around after an incremental recheck.

Likely to cause new Flow errors:

• Support for $PropertyType and $ElementType has been removed. Now referencing these types will just resolve to a global type if you have your own definition for them, and result in a cannot-resolve-name error otherwise. These types have been replaced by index access types for a long time. You can migrate to index access types by enabling use-indexed-access-type from https://www.npmjs.com/package/eslint-plugin-fb-flow and running the quickfixes. If you are unable to migrate, you can add the following to your global libdefs:

type $PropertyType<T, K> = T[K];
type $ElementType<T, K> = T[K];

• Now given the subtyping check component()<: component(ref?: ref_prop), Flow will ensure that ref_prop is a subtype of void instead of a subtype of React.RefSetter<void>.
• React$ComponentType, which was previously given [internal-type] error on every usage, is now removed.
• React.ComponentType<Props> is now only an alias of component(...Props), instead of some special cased types. This comes with stricter checks and conversions, such as making Props readonly, erroring on the presence the ref prop instead of silently ignoring them, and ensures that Props is a subtype of {...}. In addition, the React$AbstractComponent type is removed.

Notable bug fixes:

• fixed a subtle unsoundness in the inference of computed-property dictionary object creation (e.g. try-Flow)

Library Definitions:

• React.lazy and React.memo is now generic over the presence or absence of ref prop.

• Make @flowtyped resolution support work on Windows.

Notable bug fixes:

• We fixed a bug that caused suppressions to not apply for libdef-override errors.
• We fixed a bug that caused libdef-override errors not being raised even if it's turned on.

Notable bug fixes:

• Make libdef-override=off in [lints] section actually turn off all libdef-override errors.