flow-parser

Likely to cause new Flow errors:

• For all object literals in positions that cannot be contextually typed, we will infer a stricter type for them. It will cause new errors in code like

const foo = {baz: new Dog()};
type Foo = {bar?: string, baz: Animal};
declare function acceptFoo(foo: Foo): void;
acceptFoo(foo); // error

To fix the error, you can either annotate the object

const foo: Foo = {baz: new Dog()};

type Foo = {bar?: string, baz: Animal};
declare function acceptFoo(foo: Foo): void;

acceptFoo(foo);

or make the call site accepts readonly objects:

const foo = {baz: new Dog()};

type Foo = $ReadOnly<{bar?: string, baz: Animal}>;
declare function acceptFoo(foo: Foo): void;

acceptFoo(foo);

We provide a codemod to automate the annotation process. flow codemod annotate-literal-declaration --write --max-type-size 5. (You can adjust the max type size based on your needs).

IDE:

• Support rename on private properties and methods.

Library Definitions:

• React$MixedElement is removed from builtin libdef. It will cause internal-type error since v0.258.0. You should use React.MixedElement instead.

• Bug fixes for match

New Features:

• Support for experimental match feature using option experimental.pattern_matching=true

Likely to cause new Flow errors:

• Unannotated object literals reachable from exports will now be inferred to have all mutable fields when being imported. Previously, it has unsound types, so new errors might appear.
• When comparing two object types whose properties have variance incompatibilities, Flow will raise a single error that will summarize the properties with incompatible variances, instead of a single error for each property. (e.g. try-Flow)
• When an object with extra properties is passed to a place that expect an exact object, we will now generate a single error with all extra properties. The error message will list the extra properties, and state that "Exact objects do not accept extra props". In rare cases, the error locations might be moved.
• Flow will error more consistently with sketchy-bool on nullable boolean types (e.g. try-Flow)

Library Definitions:

• All properties in the builtin PropertyDescriptor type are marked as readonly. If you need a mutable version, you can introduce something like type MutablePropertyDescriptor<T> = {...$Exact<PropertyDescriptor<T>>, ...}

Notable bug fixes:

• Fixed windows builds.
• Fixed crash when loading saved state.

Likely to cause new Flow errors:

• We are announcing Natural Inference for Flow, an improved way to infer types for primitive values, that resolves a long-standing correctness gap and source of confusion. See more in this post.
• Added nested-hook and nested-component lint errors which detect nested hook or component syntax within component or hook syntax. This is on by default.

Notable bug fixes:

• For default imports, the autoimport ranking will now consider the names of the importing side. (e.g. Previously we completely ignored the name of foo in import foo from './bar', but now we will count foo. If the pattern of import foo from './bar' happens a lot, then the autoimport algorithm will be more likely to suggest import foo from './bar' rather than import bar from './bar').
• Flow will infer a correct type when viewing the type of an object literal as a dictionary type. For example, the error in this try-Flow will be raised.
• Previously, we undercounted some imports during indexing, which causes autoimport ranking to behave incorrectly. The issue is now fixed.
• Flow will no longer emit react-rule-hook-conditional error for hooks called in a conditionally defined nested component.

Notable bug fixes:

• Prevent non-termination when computing code actions.

Notable bug fixes:

• Fixed https://flow.org/try. It was broken from v0.270.0 to v0.272.0.
• Documentation in hover now preserves indentations. Therefore, code blocks in jsdoc will no longer lose indentation.

Likely to cause new Flow errors:

• When component syntax is enabled, hook calls happen inside an upper case function that doesn't have a props param that's a subtype of interface {} will get react-rule-hook-definitely-not-in-component-or-hook error.
• Calling a function that's a union of hook and non-hook will now get react-rule-hook-mixed-with-non-hook error instead of react-rule-hook error. Calling functions named like hook but not in hook syntax will now get react-rule-hook-non-hook-syntax instead of react-rule-hook error.

Notable bug fixes:

• Go-to-definition on default import of module.exports will correctly jump to the exporting file

Parser:

• Fix crash on ''#!/usr/bin/env node\n'' when generating token list

Library Definitions:

• React.forwardRef is marked as deprecated. We might remove it from our builtin libdef in the future.

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.

Likely to cause new Flow errors:

• Overriding already defined names and modules in library definitions will now error with code [libdef-override]. The error cannot be suppressed without specific error code like $FlowFixMe[libdef-override]. It can be turned off by turning off the libdef-override lint.

New Features:

• The Number static methods Number.isFinite, Number.isInteger, Number.isNaN, and Number.isSafeInteger now apply a refinement that their input is a number. Note that the top level isNaN and isFinite functions (not off of Number) do not apply the same refinement as they first coerce their input to number.

Notable bug fixes:

• Fix a potential crash in libdef files with illegal import export. Thanks @techieshark for the repro.

Likely to cause new Flow errors:

• Signature verification errors will now show up for libdef files

New Features:

• Declaration merging for declare namespace is now supported in toplevel library definitions.

Notable bug fixes:

• In component type annotation, the ref prop can now have any type.

Library Definitions:

• Since the last version, most of the bundled libdefs will no longer be maintained and shipped with Flow. Going forward, they should be downloaded from flow-typed. Starting from this version, we will also no longer ship a set of precise typing definition for jsx intrinsics. To maintain the same behavior as before, you should have a flow-typed.config.json in the root of your project with the following content:

{
  "env": ["node", "dom", "bom", "intl", "cssom", "indexeddb", "serviceworkers", "webassembly", "jsx"]
}

Likely to cause new Flow errors:

• Signature verification errors will now show up for libdef files

New Features:

• Declaration merging for declare namespace is now supported in toplevel library definitions.

Notable bug fixes:

• In component type annotation, the ref prop can now have any type.

Library Definitions:

• Since the last version, most of the bundled libdefs will no longer be maintained and shipped with Flow. Going forward, they should be downloaded from flow-typed. Starting from this version, we will also no longer ship a set of precise typing definition for jsx intrinsics. To maintain the same behavior as before, you should have a flow-typed.config.json in the root of your project with the following content:

{
  "env": ["node", "dom", "bom", "intl", "cssom", "indexeddb", "serviceworkers", "webassembly", "jsx"]
}

Likely to cause new Flow errors:

• Referencing React$Component directly will now be an error.
• Use of React$ComponentType, React$Context and React$RefSetter will now trigger internal-type errors.

New Features:

• Added types for JSX intrinsics, which will cause new errors and show autocomplete for DOM intrinsics like div

Notable bug fixes:

• Replace incorrect definition for ClientRect and ClientRectList with aliases to DOMRect and DOMRectList This fixes the type definitions for the DOM APIs in Flow, but replacing an nonexistent globals ClientRect and ClientRectList types with just an alias to DOMRect and DOMRectList.
• fixed a bug that caused spurious errors on rest array assignments (e.g. try-Flow).
• When a library definition file has changed, Flow will no longer just stop the server. Instead, Flow will properly recheck everything, even under lazy mode.
• We now allow something of type React.ComponentType<{}> to be a subtype of component()

IDE:

• Component syntax components will now show up in document symbols

Library Definitions:

• Most of the bundled libdefs will no longer be maintained and shipped with Flow. Going forward, they should be downloaded from flow-typed. To maintain the same behavior as before, you should have a flow-typed.config.json in the root of your project with the following content:

{
  "env": ["node", "dom", "bom", "intl", "cssom", "indexeddb", "serviceworkers", "webassembly"]
}

Notable bug fixes:

• Fixed a bug that causes incorrect updates to our index that tracks usage of exports, which leads to incorrect autoimport-ranked-by-usage results.

Notable bug fixes:

• Fixed a crash after initialization with saved state if the typing for react module is provided as a userland module.

New Features:

• Bigint values inside of template literals now coerce to strings, e.g. `${1n}`. Addition with string (e.g. 1n + 'blah') is still banned.
• Add ability to resolve node package entrypoints/exports
• Flow now allows inference of type guards for simple expression arrow functions with one parameter. For example, in ["a", null].filter(s => s != null) it will automatically infer that the arrow function encodes a x is string type guard and will apply it on the input array resulting in aArray<string>. (try-Flow)
• module.system.node.root_relative_dirname will allow conditional mapping like module.system.node.root_relative_dirname='<PROJECT_ROOT>/foo' -> 'bar'. Under such config, import 'a' will only be resolved to <PROJECT_ROOT>/bar/a if import 'a' is in a file in the <PROJECT_ROOT>/foo directory. This feature will be helpful if you want to combine two flow roots with different module.system.node.root_relative_dirname config.

Likely to cause new Flow errors:

• When an opaque type is refined to be not null/undefined, we now refine the opaque type's upper bound rather than returning the opaque type unmodified.

Notable bug fixes:

• Flow will error more consistently on incompatible uses of refined string, number and boolean literal types (e.g. try-Flow)
• Fixed some cases of type filtering during type guard refinement (e.g. try-Flow)
• Fixed a bug of missing errors when certain functions were checked against interfaces (e.g. try-Flow)
• Fixed negation of refinement of type-guard functions with multiple parameters (e.g. try-Flow)
• Relaxed type-guard consistency checks when the function returns with true or false. (e.g. try-Flow)

Parser:

• We now provide parsing support for declare global {...} (using it will still result in an error). The AST will have the shape of

{
    "type":"DeclareNamespace",
    "loc": ...,
    "range": ...,
    "global":true,
    "id":{
        "type":"Identifier",
        "loc": ...,
        "range":...,
        "name":"global",
        "typeAnnotation":null,
        "optional":false
    },
    "body":{
        "type":"BlockStatement",
        ...
    },
}

Library Definitions:

• The global React$PureComponent is removed. If you want to refer to it, it needs to be imported from react.

New Features:

• You may now write object literals with Flow Enum values as computed keys. This will result in a dictionary type, keyed by the Flow Enum type. Note that all possible Flow Enum representation types are valid object keys, so we just support all of them.
• You can use number typed keys (rather than just number literals) to create objects, these will be treated as dictionaries {[number]: T}

Notable bug fixes:

• Fixed soundness hole in subtyping of type guard functions (e.g. try-Flow)
• Fixed a bug that caused spurious errors when type guards were used in private methods (e.g. try-Flow)
• Flow will no longer invalidate refinements made before the loop for const-like variables within a loop (example)

IDE:

• For identifiers of array patterns bind to a require call, go-to-definition will jump to itself.

Library Definitions:

• The internal type React$FragmentType is removed from Flow's builtin global type definitions.

Notable bug fixes:

• Fixed a bug that causes experimental auto-import-on-paste to miss imports for component names used in jsx.

Likely to cause new Flow errors:

• When a function without statics is passed to a place that expects inexact objects, the error will just say "function without statics is incompatible with object", instead of listing all the missing props in statics in errors. Error code might change.
• When a non-callable object is passed to a place expecting functions, we will have a clearer message saying "non-callable object is incompatible with function" instead of the current error talking about the callable property. Some error code might change, which requires new suppressions.

Notable bug fixes:

• For errors involving unions and intersections, we will now show a list of possible causes in a sorted order: the ones that are mostly likely to be the cause will be shown first.

IDE:

• We slightly changed the go-to-definition behavior for export from statements:
  • For bar in export {foo as bar} from '...', we will always jump to itself
  • For foo in export {foo} from '...' or export {foo as bar} from '...', we will always jump to the name at the export, if this statement is well typed.
  • For foo in export {foo} from '...' or export {foo as bar} from '...', we will jump to itself if the statement is not well-typed.
• Go-to-definition on intrinsic jsx elements will jump to nowhere instead of jump to itself.
• Go-to-definition for require('...') expression will now jump to the default export of an ESM module if available, or the first export of an ESM module.

Library Definitions:

• Type for React.Context has been updated to support React 19's context as provider model. Given this change, you might need additional annotations on exports. e.g.

IDE:

• Fixed go-to-definition for Meta-specific module references.

Likely to cause new Flow errors:

• method-unbinding errors will not affect choice over intersection members. (e.g. try-Flow)
• We now disallow coercions between functions and class statics.
• The ability to configure react.ref_as_prop=disabled is removed.
• Use of React$Node and React$MixedElement outside of libdefs will now trigger internal-type errors.

Library Definitions:

• Improved definition of Array.concat().

Misc:

• Flow language server will stop advertising that we can handle all code actions kinds prefixed with "source". It can help to prevent VSCode sending flow irrelevant code actions to handle during save.

Likely to cause new Flow errors:

• We have improved inference for exported primitive literal values.
  • Before this change the inferred type for export const obj = {f: "foo"}; was {f: str<"foo">}, where str<"foo"> was a type that opportunistically and unsoundly behaved either as string or as the singleton type "foo".
  • Flow will now infer the type {f: string} for obj.
  • For const like exports, e.g. export const x = "foo"; Flow will export the type "foo".
  • To fix errors that arise due to this change, you can provide annotations around exported literals or use the as const modifier.
• We fixed a major unsoundness with regards to dictionary object creation. Previously, the computed property will just be ignored for string or any keys. Now, if the computed property is added to some existing objects (e.g. {foo: string, [stringTypedKey]: v}), then we will error on the property. Otherwise, the {[key]: value} will be {[typeof key}: typeof value}
• We fixed a bug that causes opaque type's underlying representation to leak beyond the file it's defined. You might see more errors as a result.
• Flow will now perform a complete function call check even when [react-rule-unsafe-mutation] errors are raised.
• Previously we incorrectly distribute-over-union for maybe or optional input types of conditional type. (e.g. (?string) extends string ? true : false is evaluated to true | false instead of false). This is now fixed, and code that depends on the bug might have new errors.
• If you have refiend a value based on typeof x === 'function', and then do typeof x === 'object', the result is now empty as that is impossible.
• Singleton types are now also considered in conditional equality checks on member expressions. (e.g. try-Flow)
• React.Config type, deprecated in v0.254, is now removed.

New Features:

• 'key' in x now refines the type of x to objects which have the property key.
  • in checks for both own and non-own properties.
  • If we find that a key does not exist in an inexact object or instance/interface, then the negation is not refined since the property may or may not exist.
  • An optional property is also considered as if it may or may not exist.
  • If a proto/super is a union, every member of the union must have it
  • If the input to the refinement is an intersection, one member of that intersection must have it
  • We don't refine arrays since it's not useful (check for .length instead), and also because Flow doesn't handle array holes.
• Flow now supports no_unchecked_indexed_access=true in flowconfig, which is equivalent to noUncheckedIndexedAccess from TS. It will add | void to every indexed access with general string key on dictionary objects or number key on arrays.
• Support for React 19's ref-as-prop model is now available via react.ref_as_prop=partial_support, and this is now the default. (To disable it, use react.ref_as_prop=disabled.) Under this mode, ref prop in jsx will be treated as a regular prop for function components, but utility types like React.ElementConfig<...> still won't include the regular ref prop yet.
• Flow now allows using union of strings as the type of computed property keys.
• You can now destructure object properties using number literal keys (which are int-like).

Notable bug fixes:

• Refining type guards with opaque types will now refine the general type (example of code that used to fail before, but now passes: try-Flow)
• Allow more flexibility in checks involving super type of opaque type (e.g. try-Flow)
• Fixed a bug when using opaque types in type guards in files other than the one where the type guard function was defined.
• We now allow a union of generic or opaque string typed values to be used as a key of computed property, if it's bounded by a string type.

Library Definitions:

• Add libdef types for getNotifications and showNotification API for ServiceWorkerRegistration

Notable bug fixes:

• Fixed a limitation when checking intersections of polymorphic types (e.g. tryFlow)
• Fixed an internal error raised when using super in an object method. Such cases are now user-facing errors.

Likely to cause new Flow errors:

• Referencing a react-component typed value in type position will now create a React$RendersExactly<typeof Component> type instead of React$Element<typeof Component> type. All existing usages intended to create an exact react element will now error as a result. Using it as type passed to render type, React.PropsOf, React.PropOf and React.RefOf is unaffected and will not be affected in the future. If you want exact react elements, the only way that doesn't trigger Flow error is by ExactReactElement_DEPRECATED<typeof Component>.

Library Definitions:

• React.Config type is marked as deprecated and will be removed soon. You can create your own equivalent type with

type ReactConfigShim<Props, DefaultProps> = $ReadOnly<{
  ...Omit<Props, $Keys<DefaultProps>>, ...Partial<DefaultProps>
}>;

Misc:

• Add option to disable experimental configuration

Notable bug fixes:

• Fixed a potential crash when experimental multiplatform support is enabled.

Likely to cause new Flow errors:

• Previously we incorrectly applied truthy refinement on optional chaining where it shouldn't be applied. The issue is now fixed, and you might see change in behavior similar to these examples

Library Definitions:

• Improve Array toSpliced method type (thanks @aph!)

Likely to cause new Flow errors:

• React$ElementRef is now implemented with a conditional type instead of a builtin Flow utility type. You might see new errors with generic React$ElementRef. Most of the times, you should replace React.ElementRef<T> with just T if there are no other uses of generic T.
• We've increased safety in checks involving recursive types.

New Features:

• You can now set multiple @flowtyped like directories via module.declaration_dirnames config. e.g.

module.declaration_dirnames=<PROJECT_ROOT>/decl1
module.declaration_dirnames=<PROJECT_ROOT>/decl2

Please note that when you set this, @flowtyped at the root will no longer be considered special, and you will need to explicitly add it like

module.declaration_dirnames=<PROJECT_ROOT>/@flowtyped

Notable bug fixes:

• A generic type as input to conditional type will have type parameters pinned with their default or upper bound, instead of being empty.
• We fixed a cache collision issue that might cause instantiation of a value-imported generic component type to interfere with a typeof-imported generic component type.

IDE:

• Flow now respects includeDeclaration from LSP request for find-references command. In practice, this means that "find all references" in vscode will continue to return both declaration and all uses, while "go to references" will exclude the declaration.

Likely to cause new Flow errors:

• Flow will no longer apply type transformation to function components' props when you extract props through the utility types. For example, function components' props won't automatically get $ReadOnly applied, which might cause new errors.

New Features:

• We have removed the restriction of not allowing generics with ref prop in component syntax

Notable bug fixes:

• Files in [declarations] section will have all lint errors silenced.
• Fixed an issue that caused errors in hover type on unions of evaluated types (example)
• Flow allows unions of strings to be used as the key in creation of objects with computed properties.

Misc:

• Performance fix

Likely to cause new Flow errors:

• Remove the deprecated React.AbstractComponent type. We recommend replacing them with component types. Since v0.249.0, we have provided a codemod via the flow-upgrade package to aid larger codebases with this conversion: yarn run flow-codemod eliminateAbstractComponent path/to/src.
• In addition to the removal of React.AbstractComponent type, we also removed support for the internal React$AbstractComponent when more than 1 type argument has been passed. Similarly, you should migrate to use component types if you want to specify ref props and renders.

New Features:

• We now support a new way to easily specify library definitions for npm modules. For all files in @flowtyped directory at the root, they can be resolved by the relative path without leading ./ relative to @flowtyped. e.g. <PROJECT_ROOT>/@flowtyped/react.js.flow can be used to type the react package, and <PROJECT_ROOT>/@flowtyped/react/jsx-runtime.js.flow can be used to type react/jsx-runtime module. We now recommend using this approach instead of using declare module in global libdef.

Notable bug fixes:

• any will now correctly propagate to inferred render type. example.
• Fixed a bug with regard to jsx type inference with generic callable objects. example
• Fixed a soundness hole that allowed frozen objects to be incompatible with non-readonly objects. This example will now produce an error.

Library Definitions:

• We have updated some core React type definitions to use the new component type instead of React.AbstractComponent. Most of the code won't be affected, but you might have to sometimes make the Props readonly.

Likely to cause new Flow errors:

• Fix a bug where scope analysis of exported component type is done incorrectly, which causes generics mentioned within component type to be incorrectly typed as any.

Notable bug fixes:

• We will now remove previous props in generic component types in type argument inference. example
• When all option is specified in the config of flow-remove-types, we now respect it and will correctly handle Flow-typed files without @flow pragma.

Likely to cause new Flow errors:

• Uses of React$AbstractComponent outside library definitions will now trigger internal-type lint error, which is on by default. React.AbstractComponent is also marked as deprecated. We recommend replacing them with component types. We have provided a codemod via the flow-upgrade package to aid larger codebases with this conversion: yarn run flow-codemod eliminateAbstractComponent path/to/src.

Notable bug fixes:

• Fixed issue with StringPrefix and StringSuffix when used as a component syntax prop.
• Fixed an issue that causes type argument inference on component type to be incorrectly under-constrained. (example)
• Fixed as cast support in flow-remove-types.

Library Definitions:

• React string refs are no longer supported in React.cloneElement. e.g. React.cloneElement(e, {ref: 'foo'}) will be an error.
• The deprecated React$Ref type and various aliases of it are removed.

IDE:

• React.Component annotated exported will now also show up in auto-imports in a type position.

Breaking changes:

• Support for long deprecated predicate function (%checks) is removed. It will still parse, but all of them will error with unsupported-syntax, and %checks will be completely ignored for type checking purpose as if it doesn't exist.
• $TupleMap support is now removed. $TupleMap will now resolve to the global definition is there is one, or it will fail and the type becomes any.

Likely to cause new Flow errors:

• Support for the unsound $TEMPORARY$* types is dropped. If your codebase happens to have any of these types, you can replace them with there sound and well-documented equivalents:
  • Replace $TEMPORARY$object<{props}> with $ReadOnly<{props}> or {props}
  • Replace $TEMPORARY$array<T> with $ReadOnlyArray<T> or Array<T>
  • Replace $TEMPORARY$number<42> with number or '42'
  • Replace $TEMPORARY$string<"foo"> with string or "foo"
  • We have provided a flow-runner codemod via the flow-upgrade package to aid larger codebases with this conversion: yarn run flow-codemod replaceTemporaryTypes path/to/src.
• The inferred type for Object.freeze({ A: 'a', B: 'b' }) is now {+A:'a',+B:'b'} both locally within a file and when the object is being exported. This replaces an earlier unsound behavior where the type of A would opportunistically behaved either as string or 'a' depending on the context where it appeared.
• React string refs are now banned.
• contextTypes and childContextTypes in react class components are now empty typed, so declaring legacy context in React will be an error.
• Component syntax component and component types' ref prop now must have React.RefSetter<...> type.

Parser:

• Component type in parentheses can now be correctly parsed. e.g. type Foo = (component(x: number) renders Bar);
• Trailing comma is now allowed after rest parameter in component syntax components and component types.
• The v regex flag is now supported.

IDE:

• We now provide a code action to stub out a react component, at the location of an unbound JSX identifier.
• Component declaration/type without renders clause will no longer show renders React.Node on hover.
• Hovering on components will now consistently show its props and renders information. Previously, the information is omitted for component declarations.
• If we see : renders <annot> at the position that expects a render declaration, the quickfix will suggest removing : instead of replacing : with renders.

Library Definitions:

• Added type for util.stripVTControlCharacters for NodeJS.

Misc:

• Performance optimization for unions

Breaking changes:

• Support for the deprecated $Call type is removed. $Call will now resolve to whatever $Call points to in the global libdef. If you need more time to migrate, you can create a shim like $Call<F, T> = $TupleMap<[T], F>[0], but please note that we intend to remove support for $TupleMap eventually.
• deprecated-type-dollar-call lint is removed, since the support for $Call is removed.
• react.disable_function_components_default_props config option is removed. It is on by default since v0.238.

Likely to cause new Flow errors:

• $TupleMap is deprecated and will be soon removed, now that mapped type works on array inputs. Existing $TupleMap will still work in this release, but every use will trigger a deprecated-type lint that is on by default.
• Flow now performs literal subtyping checks for strict equality conditions in non-refinement contexts. example
• Fixed destructuring with invalid literal defaults. The following now errors properly: example
• Using string ref on components that are definitely not a class component is now an error. example
• React utility types will no longer incorrectly accept hook types when they expect component types. e.g. type A = React$ElementConfig<hook (props: {foo: string}) => void>; will now error.

New Features:

• Refinements against negated bigint literals should now work.

Notable bug fixes:

• Mapped type on generic arrays is now supported. Previously it will fail with array is not an object error.
• flow-remove-types now correctly handles as cast with generics.

IDE:

• On hover, values that have React.AbstractComponent type will be shown in the component type syntax
• Flow now offers a code action to insert inferred render type when you hover on the name of the component.
• Flow now provides keyword completion for component type, hook types and render types.

Library Definitions:

• Overly restrictive typing of queueMicrotask is now fixed.

Likely to cause new Flow errors:

• Support for $ObjMap has been completely removed. This change means that:
  • $ObjMap will resolve to a user-defined $ObjMap global if it's available in your libdef. You can use type $ObjMap<O, F> = {[K in keyof O]: $Call<F, O[K]>} to get most of the same behavior, except that in the mapped type version O[K] will include void for optional props. Please note that this should be considered as a permanent shim, because we intend to eventually remove $Call.
  • flow codemod key-mirror command was removed, since this codemod tries to convert $ObjMap to $KeyMirror
  • deprecated-type-objmap lint was removed.
• Component syntax components without ref prop will have void as the instance, so React.ElementRef<component> of such component will return void.

New Features:

• Mapped types now support array and tuple types in the form of {[K in keyof <array or tuple type>: <mapped type>}.
  • With this support, we intend to deprecate $TupleMap in the next release and remove the support for $TupleMap eventually
• You can now refine against variables and member expressions with a literal type, not just literal themselves.

Notable bug fixes:

• Flow now only reports one error when two disjoint large enum-like unions are compared (example).

IDE:

• Code actions on component syntax components will produce smaller targeted edits, rather than reprint the entire component.
• Deprecated utility type like $Call are no longer suggested in autocomplete.
• Flow will now provide a quick fix when the spread prop of a component with component syntax redefines some already defined props.

Library Definitions:

• React.Ref is marked as deprecated. Use React.RefSetter instead for ref props, and React.RefObject for returns of useRef.
• React.RefSetter now includes null and void.
• Promise.all and Promise.allSettled have been updated to use mapped type instead of $TupleMap. The requirement on the type arguments are slightly changed.

Misc:

• The language for invalidated refinement is slightly tweaked. Instead of saying refactoring to a constant, we now say refactoring to a const variable.

Website:

• Refined expressions are now highlighted in try-flow playground. Hovering on refined expressions will show where it's refined, and hovering on some invalidated property refinements will show the location and reason of the invalidation.

IDE:

• Flow now responds to textDocument/prepareName LSP request. This ensures that Flow's rename support can be surfaced when multiple VSCode extension adds rename support for JS files.

Likely to cause new Flow errors:

• React.Element type, deprecated in 0.243.0, is now removed.
• Fixed a bug where refinements are incorrectly not invalidated. example
• Under custom jsx pragma, children is no longer incorrectly added to props. Some spurious errors will be gone. example

New Features:

• Added LSP signature help support for JSX attributes. The feature is triggered with the opening { of a JSX attribute value.
• Flow now allows to configure the typing of jsx creation under the new option react.custom_jsx_typing=true. Under this flag, Flow will type check jsx by through your self-defined global type React$CustomJSXFactory type, which should be a function type that accepts arguments according to jsx spec. e.g. You can write a loose one like type React$CustomJSXFactory = (component: any, props: any, ...children: any) => React.MixedElement

Notable bug fixes:

• Fixed jsdoc attachment to signature help results for overloaded functions. (example)
• Signature help on overloaded functions will show information in the correct order of signatures
• Labels of autocomplete on members will indicate if the property is optional with a "?"
• Fixed a bug where a type-only namespace within a namespace is accidentally dropped. This bug used to make globalThis.React.Node being incorrectly unavailable.
• Fixed poor interaction of "Add missing attributes" quickfix when Linked Editing Range is enabled.
• Clicking on related symbol location on hover will jump to the right location in VSCode. Previously it incorrectly jumped to the position 1 character left of the right location.

IDE:

• Elements of component syntax components (e.g. typeof <A /> where A is in component syntax) will no longer be shown in hover with shorthand syntax like A. Instead, it will be shown as React$Element<typeof A>

Likely to cause new Flow errors:

• The inexact_tuple_types_syntax option (which was on by default) is now deleted. Make sure you are using hermes-parser and related packages at version >= 0.23.0
• Render types will no longer allow specific renders wrapping more general renders like renders React.Element<React.AbstractComponent<{}, mixed, renders* A>>. Invalid render types will behave like any.
• Some previously allowed generic render types are no longer allowed (example). This ensures that generic render types are only used to model transparent components like React.Fragment.
• renders* T where T is generic is now banned.

Notable bug fixes:

• Render type with union type arguments will be correctly wrapped with parentheses.

Likely to cause new Flow errors:

• All deprecated-type and untyped-type-import lint are on and at error level by default.
• Use of some internal types of Flow that have other identical public-facing variants (e.g. React$ElementConfig vs React.ElementConfig) are now a lint error that's enabled by default. To disable it, set internal-type=off in the lints section of the flowconfig. For now, these types are still allowed in libdef files, but we plan to also disallow it in the future. To codemod existing code, get the latest flow-upgrade package and run yarn run flow-codemod replaceReactDollarUtilityTypes
• Direct use of React$Element type is banned via the internal-type lint. The React.Element alias still exists for now, but it is marked with @deprecated in the jsdoc. Please read the jsdoc for better alternatives. A global alias ExactReactElement_DEPRECATED is added to help you clearly mark the use of exact React element types, and you should use it to replace React.Element that you cannot replace without compromising runtime type safety.
• Flow now consistently errors on bad comparison with enums example

New Features:

• Allow generic bound by inexact tuple as function rest args. This example now works.
• Support for declare component statement and component type is enabled by default.
• Flow now provide the "insert inferred type as type cast" code action. You only need to select the expression in the editor to trigger the code action.

Notable bug fixes:

• Fixed a bug that causes an internal error. example

Misc:

• experimental.namespaces config option is removed. Namespaces support is enabled by default in the previous release.

Library Definitions:

• Add .replaceChildren method type definition for dom nodes.
• Object.getPrototypeof is still special cased, but the special-casing is only available for a syntactic Object.getPrototypeof(...) call. If you try to use Object.getPrototypeof in some other ways (e.g. const f = Object.getPrototypeof; f(...)), you will get a a less precise and accurate typing for it. The Object$GetPrototypeOf type, which was used to back the special case behavior, is removed.

New Features:

• For Pick utility type with string literals in the second type argument, go-to-definition on the string literal will jump to corresponding prop's location

Notable bug fixes:

• Re-exported types will show in autoimports from files without any import statement.

Likely to cause new Flow errors:

• Support for special function type $Flow$DebugPrint was removed. To see the internal representation of type, use the flow type-at-pos command with flag --debug-print-internal-repr. Note that this is for debugging purpose only, and you should never depend on the output of --debug-print-internal-repr
• More invalid compare errors will be consistently caught when using == and !=.
• invalid-render errors can no longer be suppressed without specific error code.
• Flow can now detect more bad cyclic types, including across module boundaries. example
• You may see some errors moved around when $Exact<...> is involved. Some invalid $Exact<...> type will now have not-an-object error code.
• Fixed a bug that makes some exported types accidentally any. Previously hidden errors might be exposed.

New Features:

• declare namespace support is enabled by default.
• Added "Add Missing Attributes" quickfix for JSX. This is available when the cursor is over the name of a JSX element that is missing a required attribute.
• Added a StringSuffix type, which goes along with the recently added StringPrefix type. StringSuffix can be used to type strings with a specified suffix. E.g. StringSuffix<'!'> allows for 'yay!' and 'woo!'. The type argument for the suffix must be a string literal. The second, optional, type argument can be used for the type of the remainder of the string after the suffix is removed.

Notable bug fixes:

• Fix a bug that caused Flow to infer incorrect render types for elements of polymorphic components under niche circumstances

IDE:

• Flow now supports symlinked node_modules in autoimports better. If allowed by the node resolution algorithm, autoimport will insert import specifier like my-package or my-package/foo instead of a relative path import.

Library Definitions:

• CredMgmtCredentialRequestOptions properties are now optional
• Reflect.setPrototypeof are no longer special-cased, and the backing special type Object$SetPrototypeOf is removed. The new typing is intentionally loose. Similar to Object.setPrototypeof, this is inherently unsafe since Flow won't track prototype mutations.
• Object.assign is still special cased, but the special-casing is only available for a syntactic Object.assign(...) call. If you try to use Object.assign in some other ways (e.g. const f = Object.assign; f(...)), you will get a a less precise and accurate typing for it. If you don't like the default fallback type, you can override the Object$Assign type. While the special-casing behavior will stay for the syntactic call, you should migrate your code to use the spread syntax instead.

No changes from 0.240.0

Likely to cause new Flow errors:

• We fixed a bug that causes Flow to incorrectly believe that the LHS of logical operators are not nullable. example
• Flow can now detect more kinds of bad cyclic types. (example)
• Flow will now consistently catch some invalid comparison of the kind obj.type === 'foo'. example
• Fixed a bug in the type guard refinement that involves sentinel properties (e.g. try-Flow)
• Function.prototype.apply and Function.prototype.call are now typed using userland types instead of hardcoded builtin support. You might see slight inference differences, error message and code changing as a result.
• Flow now enforces that only function types are assigned to the .constructor property of object types. (D58538540 pvekris)
• Fix subtyping checks of unions of bigint types against other unions of bigints.
• Make array holes be typed as void, not empty.

New Features:

• You can now pass in an (optional) second type argument to the StringPrefix utility type. This is the type of the remainder of the string after the prefix is removed. For example, "$1", "$2" are subtypes of StringPrefix<'$', '1' | '2'>, but "$999" is not. StringPrefix<X> is equivalent to StringPrefix<X, string>
• You can use the $Values utility type to get the type of the elements of an array type or tuple type.
• You can now do sentinel refinements on tuples, like you can already do for objects. This is especially useful for function arguments (you can type the ...args as a union of tuples). [example]
• Sentinel refinements now work when using number keys on objects [example]
• Flow now keep original type after invalid object prop-exists refinement on write-only property.

Notable bug fixes:

• Some operations can now be performed on an opaque type with appropriate bounds. example
• Fixed a bug that occurs when you have a tuple type spread after two or more non-spread arguments. Those will now be resolved in the correct order.

Library Definitions:

• String.codePointAt now returns number | void

Notable bug fixes:

• Fixed a bug where IDE services doesn't respect files.implicitly_include_root=false config.