flow-parser

Notable bug fixes:

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

Likely to cause new Flow errors:

• We now detect errors when props of React components using component syntax, or hook argument/return values of React hooks using hook syntax, contain arrays, sets, or maps that are mutated using their methods (Array.push, Set.add, Map.set, etc). These values are expected to be read-only, and we previously errored on directly setting their props; this release extends this enforcement to method calls as well.
• We are adding more strict checking for type guard functions to account for the refinement happening in the else branch of conditionals that use them (see docs for more information). You might see new errors appear in the declaration of type guards. One way to address these is by turning the type guard definition to one-sided, by adding implies before the type guard (example try-Flow)

New Features:

• The StringPrefix type represents strings which being with the specified prefix. E.g. StringPrefix<'data-'> allows for 'data-floo' and 'data-bar'. The type argument for this type must be a string literal. [example]
• Flow now supports globalThis.

Notable bug fixes:

• Fixed an issue since 0.232.0 that will cause failure to connect to Flow server if libdef has parse errors.
• Made the "extract to function" refactoring more robust to errors during code synthesis.
• Fixed a bug that can cause hover to hang forever for recursive namespaces. example
• Go-to-definition on new C() will jump to definition of C instead of the constructor definition. Hovering on C will still show the jsdoc on the constructor.
• Strip as const casts and as casts in flow-remove-types

IDE:

• Hover will show a list of all the symbols found in the inferred type and the locations where they are defined. VSCode LSP and CLI are supported. The LSP version includes a link to the definition. The CLI version only shows the name of the file (no path)

Library Definitions:

• Calling shift() and pop() on an Array<T> will now return T | undefined.
• Add cause property on Error instance; Support error cause in error constructor options
• Add type definition for FinalizationRegistry
• Add type definition for CSSSupportsRule
• Add closeAllConnections, closeIdleConnections to https$Server

Misc:

• In v0.238.1 and v0.238.2, we have bumped the required GLIBC version to v2.35 on Linux. We have now reduced the requirement to v2.31 for x86_64 build of Linux.

Notable bug fixes:

• Fixed a bug where a recheck triggered by flow force-recheck doesn't respect files.implicitly_include_root=false config.
• Fixed a bug that causes missing results in find-ref and rename.

This release is used to test the release automation powered by GitHub Actions. No changes are expected.

Likely to cause new Flow errors:

• In v0.237.2, we shipped the flag react.disable_function_components_default_props that will make Flow ignore defaultProps on function components for React component typing purposes. This flag is now on by default. If this is too disruptive for your codebase, you can turn this off for now. Note that we do not intend to keep this flag forever, so you should try to turn this flag on as soon as possible.
• We made React.createElement have an opaque type, which means calling this function directly will be an error. This will be helpful to prepare for React 19 changes. Note that JSX typing is unaffected. If you are not ready for this change, you can override your library definition like this to approximate the previous behavior as much as possible.
• When there is an invalid-component-prop error, Flow will no longer make the entire props to be any type. Instead, Flow will create a Props type as if these invalid props do not exist. example
• We are making the typing of the exported object of a module more strict. If you see errors when casting the exported type of a module to a writable object, try either casting it to a readonly version instead, or casting the exported object to the writable object type.
• We now infer the type for Object.freeze({ A: "a", B: "b" }) as {+A: "a", +B: "b"}, ie we use readonly properties and singleton types for literal initializers. Casts like this example will now be an error.
• We now error more consistently when a property is missing from an intersection of objects (e.g. try-Flow)
• untyped-import errors are now on the import source rather than imported names.

New Features:

• Under files.implictly_include_root=false (default is true, which is the current behavior), Flow will no longer include everything under the directory where the flowconfig is in by default.

Notable bug fixes:

• Fixed a category of spurious errors when using Array.reduce and returning a union type (e.g. try-Flow)
• Explicit type arguments in JSX are now considered for contextual typing. example
• Fixed spread of empty array when calculating tuple elements, e.g. [...[]] as [] now works.
• nested-component errors can now be suppressed.

IDE:

• Flow now suggests properties of objects that are contextually typed with optional types. For example, in ({ foo: { | } } as ?{ foo: { x: number }}) it will populate x, when calling autocomplete at the point of the cursor |. (try-Flow)
• We now provide autocomplete for types in the global React type-only namespace.
• We now support go-to-definition for JSX member expression like <Foo.Bar />.
• Re-exported values from export {Foo} from 'bar' statements will now appear in autoimport results.
• autoimports_ranked_by_usage is now enabled by default.
• Flow will now show the type of the constructor of a class (instantiated if it is generic) when hovering over the "new" keyword in new C(e)
• Hover types will now show the specialized version of a polymorphic component used at a JSX expression
• Hover types won't add unnecessary parentheses around union types.

Library Definitions:

• Add React 19 useOptimistic and useActionState API definitions
• Add libdef for TextDecoderStream

New Features:

• We added a flag to help prepare your codebase for React 19's defaultProps change. defaultProps on function components will no longer work in React 19. Under react.disable_function_components_default_props=true, Flow will ignore defaultProps on function components for React typing purposes. Note that we do not intend to keep this flag forever, so you should try to turn this flag on as soon as possible.

Notable bug fixes:

• Fixed an issue that might cause connecting to flow server to fail with out of retries.

Likely to cause new Flow errors:

• Flow will no longer break up a union argument when calling an overloaded function. The code in this try-Flow will now be an error.

New Features:

• Under jest_integration=true, Flow will now error on some jest mocking APIs (e.g. jest.mock('./my-module')) if the module doesn't exist.

Notable bug fixes:

• Fixed spread of empty array when calculating tuple elements, e.g. [...[]] as [] now works.
• Fixed inferred type of React.ElementConfig/Props when passed in a component syntax component (e.g. try-Flow)

Likely to cause new Flow errors:

• Ensure React class component constructors call super with a props object. example
• Modified typing of React.cloneElement. You might see errors being shifted around, and some advanced patterns no longer supported. The API is not encouraged by React, so migrating away from it is recommended.
• For JSX elements under react.runtime=classic, we now type check the JSX unconditionally using the right React.createElement typing, and check whether the locally defined React has the right React.createElement definition. If you have some JSX that's already invalid, you might see different errors. example
• React$CreateClass type, aliased to any since v0.176, is removed.
• Fix typing of isValid Flow Enums method, reverting back to behavior from before v0.232.
• Support for $CharSet, an undocumented feature, has been removed. RegExp$flags, which depends on $CharSet, is also removed. In most cases, you should replace these types with string.
• Support for --traces and the corresponding flowconfig option has been removed.
• React.createFactory libdef is removed. This API is already deprecated and will be removed in React 19.

Notable bug fixes:

• Fixed interactions of various types with specialized versions of mixed (such as $NonMaybeType<mixed>). (try-Flow examples)

Misc:

• Support removing export type * (ExportAllDeclaration) nodes with flow-remove-types (thanks @jbroma!)

Parser:

• Updated bigint literal AST output for bigint property to match ESTree spec. Numeric separators are removed (_), and should contain only decimal digits.

IDE:

• Under component_syntax=true, autocomplete will provide component and hook keyword in appropriate places.

Library Definitions:

• $asyncIterator, which is never a real global, is removed from global libdef.
• We removed $await in the libdef. If you are depending on it like typeof $await, you can replace it with <T>(Promise<T> | T) => T.

Likely to cause new Flow errors (copied from 0.235.0 release notes):

• Flow's react-rule enforcement now detects reads from ref.current within nested functions of hooks and components that are called during rendering.
• obj[key] where obj is not a dictionary object and key is a string used to not error and just silently return any. We now error on this pattern.

Misc:

• By default, flow ast will now parse component syntax rather than reject it. You can pass --no-component-syntax to get the old behavior (D56501290 samzhou19815)

Likely to cause new Flow errors:

• Flow might catch more inexact incompatible with exact errors. example
• Fixed a bug that leads to Flow sometimes ignoring differences in call props of an object. New errors might be exposed. example
• We rewrite the way we generate types for annotations. We will now detect and error on trivially recursive types like type T = T or type Foo = typeof foo; const foo: Foo = .... In addition to this, you might see some errors being moved around.
• Fixed Flow Enums exhaustive checking logic when input is a generic.
• Invalid indexed access types with string index, like {foo: string}[string], will now error instead of silently making it any.

New Features:

• You can have a tuple spread of a generic in the parameter of a function and not have to supply the relevant type argument if that spread is the only spread in that tuple, and it is the last element of that tuple.
• Negative numbers are now allowed in Flow Enum values.
• Allow Flow Enums to be cast to their representation type when the cast expression is typed as a generic type.
• Added a new global type EnumValue<>, which represents all Flow Enum values. You can constrain the enum values to those with a particular representation type by supplying the type argument, e.g. EnumValue<string>.
• Added a new global type Enum<>, which represents all Flow Enums (this is a complement to the new EnumValue type). You can constrain the enums to ones which have a particular enum value, e.g. Enum<> is the same as Enum<EnumValue<>>, and the type of all enums with string representation types is Enum<EnumValue<string>>. These "abstract enums" have no know members, so you can't access members or exhaustively check them, but you can use methods such as .members(), .cast(), etc.
• Allow === comparison of abstract Flow Enums as well as Enums themselves with the same ID.
• You can now cast Flow Enum values to their representation type using .valueOf(), e.g. enum E {A, B}; const s: string = E.A.valueOf().

Notable bug fixes:

• We now error more reliably in the matching property tests, for example when the object part is a complex expression. example
• Fixed spurious errors in propagating type hints. example
• Infer type in a conditional type is now allowed to be underconstrained. When the true branch is taken, this underconstrained infer type will be pinned to the upper bound. example
• Add Enum and EnumValue to $NotNullOrVoid - previously there was no supertype for all enum values or enums.

IDE:

• We now show jsdoc information on component props with component syntax.

Likely to cause new Flow errors:

• Flow will now error on invalid type applications at the declaration site, if the type application does not use another generic type from an outer scope. example
• We fixed a bug where we incorrectly unwrapped the opaque type to the underlying representation in refinements
• Predicate functions (%checks) can no longer be recursive
• Fixed subtyping of indexers in instances/interfaces

Notable bug fixes:

• We fixed some spurious errors regarding opaque type refinements. example
• We made a change to method-unbinding errors so that it no longer errors when in an any/mixed context. This allows us to better support jest
• We fixed an issue where explicitly supplied JSX type arguments were ignored
• We fixed bigint Flow Enums that do not explicitly speicy of bigint during parsing. We were previously not correctly inferring that this was a bigint enum.
• flow.org/try now supports go-to-definition, autocomplete, and signature help

Parser:

• Previously Flow outputs ReadOnlyTypeAnnotation in parser output for annotations like readonly string[]. Now we output it as TypeOperator with "operator": "readonly"

IDE:

• Fix printer output of casting syntax when LHS of as or as const has low precedence

Library Definitions:

• We migrated the built-in React library definitions to use component and hook syntax for various React-provided APIs. Look out for a blog post on our medium account for more details and see the React section in our docs

Likely to cause new Flow errors:

• Support for $Compose and $ComposeReverse types are removed. We recommend to use overloads to approximate their behavior instead. e.g.

declare export function compose(): <T>(a: T) => T;
declare export function compose<F: (...$ReadOnlyArray<empty>) => mixed>(
  f: F,
): F;
declare export function compose<A, T: $ReadOnlyArray<any>, R>(
  f1: (a: A) => R,
  f2: (...T) => A,
): (...T) => R;
declare export function compose<A, B, T: $ReadOnlyArray<any>, R>(
  f1: (b: B) => R,
  f2: (a: A) => B,
  f3: (...T) => A,
): (...T) => R;
declare export function compose<A, B, C, T: $ReadOnlyArray<any>, R>(
  f1: (c: C) => R,
  f2: (b: B) => C,
  f3: (a: A) => B,
  f4: (...T) => A,
): (...T) => R;
declare export function compose<R>(
  f1: (b: any) => R,
  ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
): (...$ReadOnlyArray<any>) => R;
declare export function compose<R>(
  ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
): (...$ReadOnlyArray<any>) => R;

• You might see more errors around type application. example
• Fix subtyping of indexers in instances/interfaces. example

New Features:

• Updated the isValid Flow Enums method to use a type guard, allowing it to refine its input to the enum type in a conditional context. E.g.

enum Status {Active, Off}
const s = "Active";
if (Status.isValid(s)) {
  s as Status; // Should work
}

• export type Foo = ... and export interface Bar {...} statements are now allowed in declare module and declare namespace bodies.
• We added a new codemod flow codemod remove-unnecessary-react-import which can help remove unnecessary react imports under react.runtime=automatic

Notable bug fixes:

• Fixed issue when explicitly supplied JSX type arguments are ignored
• Fixed code action output of casting syntax when LHS of as or as const has low precedence

Library Definitions:

• Added definitions for the following APIs:
  • window.showOpenFilePicker(): MDN, WICG
  • window.showSaveFilePicker(): MDN, WICG
  • window.showDirectoryPicker(): MDN, WICG
  • DataTransferItem.getAsFileSystemHandle(): MDN, WICG
  • StorageManager.getDirectory(): MDN, WHATWG

Likely to cause new Flow errors:

• Fixed subtyping of inline interfaces, e.g. try-flow.

New Features:

• No longer trigger method-unbinding errors with indexed access types.
• Add relay_integration.esmodules option. When this option, along with relay_integration, is enabled, Flow will treat graphql fragments/queries/etc. as import default rather than require. Use this when you ouput ESM from Relay's codegen (e.g. eagerEsModules).

Notable bug fixes:

• Don't error when returning an array, map, etc when an AsyncGenerator<T, void, void> type is expected (e.g. try-Flow)

IDE:

• Fixed a bug where AUTO332 appeared in the result of string literal type completion.

Library Definitions:

• Added definitions for FileSystem APIs (thanks @ZelJin).
• Added constructor to the StorageManager class (thanks @ZelJin).
• Removed checkPropTypes, DOM, createClass, ConcurrentMode from react module.
• Types in react module can now also be used when React is default imported like import React from 'react', they can also be used without imports, e.g. type N = React.Node.

Likely to cause new Flow errors:

• We now put value exports and type exports into two different namespaces. It means that we will now consistently error on places where you try to import, re-export, or use a imported type as a value. This change also makes certain patterns that happen to work in the past no longer work, e.g.

// a.js
export type Foo = string;
// b.js
const A = require('./a');
module.exports = {...A};
// c.js
// previously allowed, no longer allowed
import type {Foo} from './b';

• We have allowed function parameters to refer to each other for a while now. However, we didn't implement the analysis correctly for exported functions, which causes inconsistent behaviors. This is now fixed e.g.

// a.js
// we incorrectly resolve x to refer to
// be external to the function params,
// which is a global in this case
export function foo(x: string, y: typeof x) {}
// b.js
import {foo} from './a';
foo("", 3); // no error before, errors now

• Previously, we allowed assignment to any globals, regardless of whether it's a type or value. Therefore, both were allowed in Array = 3; $ReadOnlyArray = 2; Now the latter is banned.
• Flow now consistently bans referring a type-only global as value
• Some bad annotations that cause value-as-type or recursive-definition errors will no longer affect which branch to take in overload resolution.

New Features:

• Flow now supports typeof with type arguments type T = typeof foo<string>. This syntax is supported in prettier since v3.1. If you previously enabled the flag typeof_with_type_arguments=true, you need to remove it.
• Flow now supports explicit type arguments on JSX. e.g. <Foo<string, _, number >propA='d' />. Note that some type arguments can be inferred using the _ syntax.
• Flow now supports the same NoInfer intrinsic that will be available in TypeScript 5.4.
• Under experimental.ts_syntax=true, Flow will
  • Automatically translate TypeScript's readonly on tuple and array types into Flow equivalent $ReadOnly<[...]> and $ReadOnlyArray<...> without error.
  • Automatically translate TypeScript's keyof into Flow equivalent $Keys without error. Note that there are behavior differences between $Keys<> and keyof right now (flow, TS), so use it with caution.
  • Automatically translate TypeScript's unknown never and undefined into Flow equivalent mixed empty and void without error.
  • Support TypeScript's variance annotation readonly in out, in out without error.

Misc:

• experimental.ts_syntax is now always on in https://flow.org/try.

Misc:

• Fixed a potential crash under the experimental flag experimental.blocking_worker_communication=false.

Likely to cause new Flow errors:

• invalid-recursive-exported-annotation will now have error code of recursive-definition.
• Previously we would emit confusing errors when you try to use a value that has union types as a type. Now it will consistently emit value-as-type errors. (example).
• Unsupported statements like loops within declare module will no longer cause parse errors. Instead, they will be errored on during type checking.
• declare export type and declare export interface statements in toplevel are no longer parser errors. Instead, they will now be errored during type checking.
• Previous toplevel-library-import errors and unsupported-statement-in-lib errors will all have unsupported-syntax error code now.

New Features:

• We introduced experimental.ts_syntax flag that you can set to true. When this flag is on, Flow will no longer complain about certain TypeScript syntax, and will automatically turn them into the closest Flow equivalent types. Initially, we support the following: Readonly, ReadonlyArray, ReadonlyMap, ReadonlySet, NonNullable, and using extends to specify type parameter bounds. In the future, more kinds of types that we currently parse but error on might be added. (e.g. keyof). Please note that the support here is best effort. We make no guarantee that these types have the same semantics as those in TypeScript 100% of the time, but for common cases, it might be good enough for you.

Notable bug fixes:

• We now allow the use of saved state for glean indexer, if saved state is enabled in flowoconfig or CLI arguments.
• Improved the way we compute contextual hints for spread arguments of calls (e.g. try-Flow).
• In declare module, all the values will be auto-exported if we cannot decide whether the module is in CJS or ESM. However, support for declare const and declare let was missing. This has now been fixed.

Misc:

• Make both the default value for the .flowconfig casting_syntax option, if not supplied.

Likely to cause new Flow errors:

• Some new errors might be raised when using React.cloneElement with polymorphic components. Eg. try-Flow. Note that React.cloneElement is deprecated
• Nested declare module is no longer a parser error, but a type checking error
• declare module is now explicitly banned in nested scope and outside of library definition files. It already does nothing under those contexts.

New Features:

• All kinds of imports are now supported in library definition files
• We will no longer require annotations on class properties, if the class properties are already initialized with "annotation-like" expressions. e.g. We can now infer the type directly for properties like prop = (foo: string): number => 3.

Notable bug fixes:

• Fixed a bug that causes the first run of flow check to always return 0 errors, when some parts of temporary directory is a symlink.
• Hover type on react elements now show the type of the component and props, instead of just React$Element. (e.g. try-Flow)
• For missing annotation on exports, we now correctly say some annotation is missing on an identifier instead of array pattern. e.g. for export function f(a) {}, we now say "Missing type annotation at identifier" instead of "Missing type annotation at array pattern".

Parser:

• Flow can now parse declare namespace Foo {...} statements. The body of the declare namespace statement shares the same restrictions of declare module.
• Invalid exports in declare module are no longer parse errors. They are now type checker errors.

Likely to cause new Flow errors:

• Some errors related to empty arrays might have their error locations or codes changed.
• Flow will now interpret trivially recursive types, such as type T = T as empty, instead of any. (e.g. try-Flow).
• We now error when calling .call() on polymorphic functions where the return type is under-constrained (e.g. try-Flow). To fix add an annotation to the return result.

Parser:

• DeclareModule AST will no longer have a kind field

Library Definitions:

• Removed redundant cases in Array.from overloads. It might cause some error locations and codes to change.
• Add types for the Storage API, available via window.navigator.storage (thanks @ZelJin).

Likely to cause new Flow errors:

• $ObjMap and $TupleMap become stricter. The following code now errors: example

IDE:

• Linked JSX editing will now only trigger if you edit the opening tag, instead of both the opening and the closing tag.
• We now provide IDE services in user-defined library definitions.

Notable bug fixes:

• Fixed a bug where recursive types defined across multiple files caused spurious errors and led to unsound types
• Add .databases() to IDBFactory (thanks @bobrovnikov)
• Mark DOMStringList as iterable, so that it works with Array.from(...) (thanks @bobrovnikov)

Notable bug fixes:

• [fix] disable aggressive behavior of linkedEditingRange requests when there are parse errors
• [fix] Only print "evaluated" hover type results if the type is of a reasonable size (less than 100 nodes)
• [perf] faster LSP commands through skipping redundant parsing
• [fix][ide] Find-all-references and rename will no longer return stale results on the file that triggers the request. Instead, we will compute the most up-to-date result at the time of the request for the triggering file.

Notable bug fixes:

• We improved the inference support for function rest parameters in a generic function. This example can now type check. You can also extract the parameters of a function excluding the first parameters now: (example)
• In hover type, when a name is defined in another file but is imported with a different name, Flow will use the locally aliased name.
• fixed a crash happening when a class was defined in a scope where a binding with the same name already existed (try-Flow example)

Likely to cause new Flow errors:

• %checks is now deprecated. It will still work as before (for now), but if you enable the deprecated-type Flow lint, you will see additional errors. Instead, use type guards.
• $Call, $ObjMap, $ObjMapi, $ObjMapConst are now deprecated. They will still work as before (for now), but if you enable the deprecated-type Flow lint, you will see additional errors. Since Flow 0.209, you can now use builtin types like Parameters, ReturnType, Pick, Omit to easily extract and transform types. For more advanced use cases, you can read the docs of conditional type and mapped type to understand how to write it in equivalent ways.
• Ban creation of object literal computed properties with non-literal number keys
• Ban accessing objects with non-literal number keys
• You can now create and access object keys with int-like number literals, these act as their string equivalents.
• Union of exact objects allow computed access as long as one of the members of the union have the property

New Features:

• Add support for number literals as keys in object literals, e.g. const obj = {1: true, 2: false}
• Support numeric keys in object type annotations. They are equivalent to the string version.

Notable bug fixes:

• Removed spurious underconstrained error with mapped type, if the relevant type parameter already has a default. (example)
• Support calling Array.from with string input and also mapping function, e.g. Array.from('str', x => x.length)

IDE:

• [ide] Go-to-definition for a barrel-exported type name will now jump to the original definition location, instead of incorrectly jumping to itself.

Library Definitions:

• Add type stubs for global crypto object, crypto.getRandomValues, and crypto.randomUUID
• We removed StatelessFunctionalComponent type from the 'react' module and the React$StatelessFunctionalComponent type. The name might give an incorrect assumption that Flow can actually check that a function component doesn't use stateful hooks or can be called directly. If you have code that still uses this type, we recommend you use the React.AbstractComponent type, since it forces you to not make any assumption of what kind of React component you are dealing with.

Before Flow 0.223, the autoimport system uses the filename as a hint of the name for default export. e.g. if the filename is foo.react.js or foo.js, regardless of whether the default export in that file has a name or not, or even the default name is bar, autoimport will always import it as import foo from 'foo'.

However, in the new system starting from Flow 0.223, we will use the name of the default export as a stronger hint. In a lot of files that just give a default export a random generic name, they are relying on the old system to get reasonable auto imports.

It's not practical to update every Flow codebase to avoid the UX regression, so now auto-import will provide both options.

Notable bug fixes:

• Fixed issue with saved state generation used to power auto imports.
• (from v0.223.1) Improved precision of server states, that are visible either in vscode status bar, or through the flow status command.

Notable bug fixes:

• Mitigates a bug in Linked Editing Range where typing characters quickly on one side would throw off sync on the other side. With this fix, even if some characters are skipped Flow will be able to later recover the matching of open and close tag.
• Fixed an issue that will cause some nested conditional types to be evaluated to any. (Example: Issue #9107)

IDE:

• Auto-import for default-exported values will prefer the name of the exported value over the name inferred from the module.

Misc:

• Error collation is incremental only. The incremental_error_collation flowconfig option is not recognized anymore.

Library Definitions:

• Remove status global from dom.js
• Delete declared React module. You should always import react with lowercase like require('react') or import React from 'react'

New Features:

• Go-to-definition now works for private names
• Find references and rename now work for private names

Notable bug fixes:

• Documentation will now show up for declare export statements in hover and autocomplete. This means that jsdoc for exports in declare module will finally show up in IDE services.

Library Definitions:

• Added USBConnectionEvent
• Added SecurityPolicyViolationEvent
• Added crypto.randomUUID, http$Server.closeAllConnections, http$Server.closeIdleConnections

Likely to cause new Flow errors:

• Changed the signature of React.Fragment to only accept children and the key prop.
• Changed the signature of React.useRef to return an opaque type.
• Fixed a case where, in some cases, contextually-typed callbacks being passed as props would be typed as any rather than producing underconstrained-implicit-instantiation errors. This will result in new underconstrained errors, but removes a source of untracked unsoundness.
• Banned non-tuple arrays from being spread into tuple types. It previously resulted in any without error.

Notable bug fixes:

• Improved signature help support for optional chaining calls and intersection types. Now we will show all possible signature possibilities for overloaded functions.

Performance:

• Incremental error collation, which helps IDE performance when you have a lot of suppressed errors, is now the default.
• Optimized the way we generate global types for normal source files. You might see a reduction in checking times (3-9% as measured internally at Meta).
• Optimized the way we analyze syntactic environment required for type checking. On a large file like this, it improves the checking time from 4s to 2s.
• Optimized substitution performance when conditional type and mapped types are operating on large and deep objects.

Library Definitions:

• Updated IntersectionObserver types.
• IndexedDB transaction now allows consuming storeNames as DOMStringList.
• Added options to IndexedDB transaction.
• Added durability to IDBTransaction.

Notable bug fixes:

• We will now provide auto type import for default-exported classes.
• We no longer suggest defined values when doing auto complete in object keys when we are under a type annotation.

Likely to cause new Flow errors:

• Fixed an issue where access of optional tuple element was not considered | void
• We rewrote how we generate types for library definitions, which makes the validation of libdef files stricter. You might see more errors as a result of the stricter validation. e.g. all unbound names in libdef files will cause an error, instead of the first reference of the unbound name.

Notable bug fixes:

• Fixed a bug in "refactor to react component" code actions. Previously, it would incorrectly replace all jsx children with the newly refactored JSX elements
• Fixed signature help when the function called is typed as an alias (e.g. try-Flow)
• Fixed some spurious errors in generic calls when the solution involves unions (e.g. try-Flow)
• Fixed a bug that caused weird errors when you try to use indexed access in export positions. example

Misc:

• Bug fixes in preparation of new feature rollout

Misc:

• Bug fixes in preparation of new feature rollout

Misc:

• Bug fixes in preparation of new feature rollout

Misc:

• Bug fixes in preparation of new feature rollout

Likely to cause new Flow errors:

• We changed the upper bound of React.Element to be an inexact empty object, effectively making it opaque. React doesn't recommend inspecting children and React.Element, so we make the change to increase friction. See https://react.dev/reference/react/Children#alternatives for alternatives. To keep existing code type safe, you can add a function like the following to explicitly expose the internal of React.Element:

export default function DangerouslyAccessReactElementInternals_DO_NOT_USE_IN_NEW_CODE<
  E: React$ElementType,
  P,
>(e: React$Element<E, P>): {
  +key: React$Key | null,
  +props: P,
  +ref: any,
  +type: C,
} {
  return e;
}

• Conditional types will now only distribute over a union if A in A extends B ? C : D is a generic type. This is a behavior change that might cause new errors (example). Previously, we distribute over unions in more cases, which contradicts what we said in the docs, and caused some weird behavior that's fixed in this version.
• If an exported class contains unannotated propTypes, Flow will now emit signature-verification-failure.

New Features:

• Hovering on enum members in IDE now show documentation if it's available.
• Added casting_syntax option which can be colon (current), as, or both. If setting is both, both (x: T) and x as T are allowed. If set to colon or as, only (x: T) and x as T are allowed respectively.

Notable bug fixes:

• Previously, when Flow cannot decide which branch to take in a generic conditional type, Flow will produce a abstract type that's unusable almost everywhere. Now Flow will still produce an abstract type, but it will be bounded above by a union type of both branches of conditional type. example.

Misc:

• Flow's insert type quickfix in IDE will stop inserting very specific React.Element types. Instead, it will insert general types like React.MixedElement.

Library Definitions:

• Add type definition for CanvasRenderingContext2D.roundRect.
• Add tagName to DOM element declarations (thanks @aselbie).

New Features:

• Error collation during rechecks should become faster thanks to incremental computation. (Available with the flag --incremental-error-collation.)

Likely to cause new Flow errors:

• We start to validate variance inside $ReadOnly, which is previously completely unchecked. It also results in Flow complaining about some incorrect bounds. example

New Features:

• Hover types will now show a specialized version of the callee expression at a call to a generic or intersection-typed function.

Notable bug fixes:

• improve coverage accuracy for the element access portion on element calls, obj[m](arg).

Misc:

• We slightly optimized Flow's performance of subtyping check between two union types.

Library Definitions:

• Add defintions Array.prototype.findLastIndex(), String.prototype.at(), TypedArray.prototype.at() and Object.hasOwn() (thanks @pascalduez).
• Update URL defintions (thanks @pascalduez).
• Add typing for cause option in Error constructor.

This is same as 0.217.1, but we have some issue publishing 0.217.1 to npm, so we will publish this new version instead.

Notable bug fixes:

• Previously, while global find ref/rename (experimental.global_find_ref=true/experimental.global_rename=true) is ongoing, all other IDE services will be blocked. We fixed it so that other IDE requests can still be served.

Likely to cause new Flow errors:

• Flow will now ban variance annotations in function or function type parameters. example
• React.Element is now opaque, but we still expose some of its internal structure via the bound on the opaque type. You should not depend on the internal structure. In a future release, we plan to make React.Element truly opaque.
• Fixed an issue with implicit instantiation in operations over unions that caused many errors to be missed.
• Changed the ref params on forwardRef and useImperativeHandle to be write-only. Patterns that rely on refining these params to an object and reading the ref field are misusing these APIs. example
• React.ElementProps is now more precise when applied to AbstractComponents, resulting in the config type of the component rather than mixed. This will cause errors when elements of components with different props are passed into React.Element<> types.

Parser:

• We now parse type arguments after typeof annotations. e.g. typeof MyGenericClass<string, number>. Type checking for this syntax is still not supported.

Library Definitions:

• Update URLSearchParams definitions (thanks @pascalduez).
• Update AbortSignal definitions (thanks @pascalduez).
• Add Array copying methods (toReversed, toSorted, toSpliced and with) the $ReadOnlyArray class definitions (thanks @pascalduez).

Notable bug fixes:

• We fixed local find references for namespace imported variables. It will no longer error or return empty results.

Likely to cause new Flow errors:

• The ability to configure module.system.haste.use_name_reducers=false is removed. For now this option defaults to true and can only be set to true. The option to set the only possible value will be removed in a future release.

Notable bug fixes:

• Fixed cases where hovering over a parser error could cause the Flow server to appear to hang.

Library Definitions:

• Add USB web API definitions.

Notable bug fixes:

• We fixed a bug that causes us to insert extra quote in autocomplete string literal in indexed access types.

Likely to cause new Flow errors:

• Improved analysis determining if a function has an implicit void return. As a result, some incorrectly typed code will no longer type check. (example)
• Fixed a bug where global assignments in generics wouldn't flag errors. (example)

New features:

• Flow now supports contextual typing for class private property assignments. (example)

IDE:

• Local find all references will now return a more comprehensive result list.
• Go to definition now supports indexed access types.

Library Definitions:

• Added inert attribute, showPicker() method and hasPointerCapture() method

Likely to cause new Flow errors:

• Flow now has stricter behavior with $Call, $ObjMap, $ObjMapi, $ObjMapConst, $TupleMap. Previously hidden type errors might be revealed now.
• You can no longer disable tuple_ehancements, conditional_type, mapped_type, type_guards in flowconfig, since these options have been removed. They were enabled by default since v0.212.0.

IDE:

• We now provide a new refactor that extracts JSX elements into a new React component.
• Extract to constant refactors now works for nested JSX elements and fragments.

Notable bug fixes:

• Added default type arguments for the built-in React$AbstractComponent to match the React.AbstractComponent type alias in our libdefs. [try-flow]

Library Definitions:

• Added parseArgs to the Node.js util module library definition

Notable bug fixes:

• Fixed a bug where local find references do not return references in jsx props.

Likely to cause new Flow errors:

• Builtin idx support is removed. idx functions can now be typed with conditional type and mapped type. The v3 release of idx contains these typing changes.
• When using module.system=haste, it will now be an error if a .js.flow file shadows a .js file with a different path prefix.

Notable bug fixes:

• Fixed a bug that used to cause spurious internal errors when you have non-binding patterns. example

Parser:

• Fixed parsing of multiple as/satisfies casts in a row.

Library Definitions:

• Added support for Intl.Locale class

Likely to cause new Flow errors:

• Flow is now stricter with regards to type checking of spreads, $NonMaybeType, and $ReadOnly. You might see new errors revealed as a result.
• Experimental utility types $Pred and $Refine have been deleted. These are replaced by type guards.

New Features:

• Updated Pick and Omit to work on interfaces and instances.
• Conditional types, mapped types, type guards, and tuple enhancements are now enabled by default.

Notable bug fixes:

• Prevented hover and go-to-definition requests that infinitely loop.

IDE:

• For imported names using require, go-to-definition will now jump to the location of the original definition's name.

Notable bug fixes:

• Improve fuzzy matching of autoimports

Likely to cause new Flow errors:

• We fixed an issue where the intersection of two identical object types are turned into empty in spreads. As a result, more errors might be revealed. example

Notable bug fixes:

• We fixed an eager evaluation bug that can lead to some bad interactions between conditional type and mapped type. (example)

Parser:

• We fixed the parser size regression since 0.210.0.

Library Definitions:

• We rewrote the Omit type implementation. Now it will preserve the optionality and the variance of the input object. example

Notable bug fixes:

• Fix a bug where autocompleting a keyword deleted the next 7 characters on the same line
• "Fix" sorting of autoimports. An experimental option (autoimports_ranked_by_usage=true) to sort autoimports by how often they are imported was influencing the sorting even when the option was not enabled. This was likely an improvement, but it was a bug to not obey the option.

Misc:

• Improvements in preparation of new feature rollout

Likely to cause new Flow errors:

• We further strictified React.Element and React refs related typing. You might also see some existing errors related to React.Element and React ref moved around. Example

New Features:

• Added Pick, Omit, and Record utility types. [try-flow]

Notable bug fixes:

• Fixed a bug where void would appear in autocomplete suggestions more than once

Misc:

• Improved keyword autocomplete ordering

Parser:

Library Definitions:

• Added missing CSSOM replace and replaceSync
• Added arrayBuffers to Node libdefs for process.memoryUsage()'s return type

Misc:

• Bug fixes in preparation of new feature rollout

Likely to cause new Flow errors:

• We removed support for React PropTypes. All related Flow builtin types like React$PropType$Primitive are deleted. React has deprecated PropTypes since v15.5.
• We will now catch errors related to generic indexed access types. Example
• Fixed issues with indexed access on interfaces/instances. Access with string literals will now access named properties. example
• We now require annotation for computed access of instances, when that access is directly exported.
• The return annotation of a function can now reference a parameter name (e.g try-Flow). This may cause new errors if the return type used to reference a name that aliases a parameter name. This will now be captured by the parameter and cause a [value-as-type] error.
• We now error when using the name of a variable in its own annotation (e.g. const x: typeof x = ...). An exception is when the name of the variable appears under an object type constructor. For example, the annotation const o: { f: typeof o } = ... is allowed.

Notable bug fixes:

• Fix a bug in the previous version that makes declare let/const function scoped. We fixed it to be lexically scoped again.

Library Definitions:

• Array.flat will now have better typing support for flattening heterogeneous inputs. e.g. [1, [1,2]].flat() will now correctly have inferred type of Array<number>.
• We added support for the following builtin types that are also found in TypeScript:
  • ReturnType
  • Parameters
  • Exclude
  • Extract
  • ThisParameterType
  • OmitThisParameter

Notable bug fixes:

• Fixed a crash when we are trying to produce a quick fix for missing imports. The autofix for missing imports broken in the previous release would be working again now.

Likely to cause new Flow errors:

• Flow will now error on unsupported statements in library definitions, instead of silently ignoring them.
• Flow will error more consistently when variables of type any and empty are used as types (e.g. try-Flow)

IDE:

• Get definition request will now consistently jump to the name of the definition for ES module exports.
• In find local references, if a reference appears in a named import, it will no longer highlight the entire import as reference. Instead, it will only highlight the relevant name.

Notable bug fixes:

• Parameter types can now refer to previous parameters in the same parameter list (e.g. function f(x: number, y: typeof x) {})
• Report error when a function parameter is redeclared in its body in functions that have default params (e.g. try-Flow)
• For all declared names (declare class/var/let/const), we will allow full forward reference. All reads of these values will be considered to be initialized.

Misc:

• Changed React.Element to support a second type argument, as supported by React$Element

Library Definitions:

• Updated dom libdefs to allow Trusted Type objects