flow-parser

Notable bug fixes:

• Fix a crash that could happen when canceling a recheck during module resolution

Likely to cause new Flow errors:

• Some heap refinements might be invalidated more aggressively, when method calls appear in conditionals. This brings us closer to what happens in the case of the regular function call. (Example)
• Always error on the deprecated existential type *, it's just an alias for any

New Features:

• Experimental support for Mapped Types like {[k in keyof T]: ?T[k]}! (Example). Look out for a blog post, documentation and support in other tools in the near future. You can try mapped types in your project by setting the experimental.mapped_type=true flag in the options section of your flowconfig.

Notable bug fixes:

• Fix autocomplete for super members (e.g., super.|)
• Fix hover type of JSX attribute names
• Fix showing documentation in signature help for member expressions (e.g., o.m(|))
• Fix unused-promise lint false positives for logical and conditional expressions
• Fix spurious error in overloaded generic calls when a contextual type is available (Example)
• Properly remove the : with inferred predicates in flow-remove-types

Parser:

• Error on classes with static prototype fields
• Fix missing parse error for class constructors that are async, generators or accessors. The former two were previously type errors rather than syntax errors.

Library Definitions:

• Add NodeJS stream promises (thanks @moroine)

Misc:

• Add useful information to poorly located error messages. For example, for code like this try-Flow where the error points to a library definition, the error message will show the file that caused the error.

Likely to cause new Flow errors:

• $Partial has been renamed to Partial, use the latter instead. Read the blog post for more details.
• Support for inference_mode config and related infra such as codemods were removed. You should follow the instructions in the Local Type Inference for Flow blog post to switch to use LTI before upgrading if you haven't already done so.
• We replaced the implementation which checks nested $Call and $ObjMap during the check of a polymorphic function call. As a result, more underconstrained errors or type incompatibility errors might appear.
• Removed the sharedmemory.log_level flowconfig option and the --sharedmemory-log-level command line option.

IDE:

• Implement linked editing for JSX elements.
• Added code actions for adding/removing braces from arrow functions.
• Adds a quick fix from the deprecated $Partial to Partial.

Notable bug fixes:

• Fixed a bug that caused instances of nested utility types to be considered equivalent to empty. e.g. try Flow example.
• Make Flow's behavior more consistent by not erroring on .constructor accesses. e.g. try Flow example.
• Fixed the file watcher not reacting to any changes on Windows.
• Improve the error messages when underconstrained-implicit-instantiation errors are raised in overloaded function calls. e.g. try Flow example
• We now propagate any to instance types' type arguments. As a result, some spurious errors under LTI might be fixed (e.g. try Flow example), and some new errors might be revealed.
• Fixed the hover type result when an enum object type appears nested in another type structure. e.g. try Flow example.
• Fixed the hover type on certain kinds of union types. e.g. try Flow example.
• Fixed the hover type on class constructors.

Misc:

• Try Flow's behavior can now be configured.

Parser:

• Leading (, & and | are now included in intersection and union ranges, respectively.
• Improve error recovery for mismatched JSX tags.

Library Definitions:

• Change setState in React lib defs to use $ReadOnly<Partial<T>> instead of $Shape<T>.
• Make $ReadOnlySet entry type covariant.
• Expand the Performance typing with the eventCounts property, according to the W3C standard.
• Adjust the type definitions of the mark and measure properties on Performance interface according to the W3C standard.

Misc:

• Fix a crash when using experimental.channel_mode=socket on Windows

Parser:

• Add "ObjectTypeMappedTypeProperty" node for mapped types
• Change "ConditionalType" and "InferType" nodes to "ConditionalTypeAnnotation" and "InferTypeAnnotation"

Likely to cause new Flow errors:

• Don't error for tuple element type incompatibility if we have already errored for invalid tuple arity.
• Fix a bug that causes certain errors in annotations to be hidden. As a result, more legitimate errors might appear. Example here.

New Features:

• Add support for optional tuple elements, e.g. ['s'] and ['s', 1] are both valid values for [foo: string, bar?: number].
• Add autocomplete for keywords to the LSP.
• Add a code action that inserts jsdoc on a function.
• exact_by_default=true is now the default value if the option is omitted from the .flowconfig. Read this blog post for more details.

Notable bug fixes:

• Fix LSP rename command to consider aliased named exports.
• If a contextually typed parameter has a default, we will filter out null and void from the inferred type of the parameter. This removes spurious errors like this.
• Some spurious prop-missing errors might be removed. Example here
• Remove some spurious internal errors of Flow. Example here

Misc:

• Add option for module.system.haste.module_ref_prefix_LEGACY_INTEROP in the config to allow migration from the automatic_require_default flag and to ES module syntax.

Parser:

• Include InterpreterDirective in the AST.
• Fix loc/range of postfix arrays that start with a parenthesis, like (A | B)[].
• Fix missing error when arrow functions have duplicate params.

Local Type Inference:

• Local Type Inference is a rewrite of Flow’s type inference algorithm. This change makes Flow’s inference behavior more reliable and predictable. It replaces a global inference scheme that Flow has relied on since its inception and that has often been the culprit of confusing action-at-a-distance behavior, in exchange for modestly increased type annotations. It is now enabled by default! See this blog post for more details on the new system and steps to upgrade your project.

Likely to cause new Flow errors:

• When a variable is initialized at declaration, subsequent assignment in a conditional branch will no longer cause later reads to get a union type. This is already the case if the variable is annotated. As a result of this change, you might get new type errors. Example
• When a variable is uninitialized or initialized to null, we use all the assignments to the variables as its initial type. We now no longer consider assignments from a child generic function. As a result, you might get new invalid-declaration errors. Example
• Fix object value rest. It will now error if attempting to read a write-only or setter-only property (it reads while copying the properties). Additionally, the resulting rest object will no longer preserve read-only variance (as it is a copy).
• The type utility $Partial will now preserve the variance of the input object type's properties. For example, if the the input was a read-only object, now that output will also be a read-only object (with optional properties).
• string and symbol are no longer subtypes of an interface
• Error on with statements in non-strict mode. It was already a syntax error in strict mode.

New Features:

• A native Apple Silicon precompiled binary is now available via the GitHub Releases page. It is not yet available via flow-bin. Internally, we see about 2X faster performance than using Rosetta, and 4X faster performance than on actual Intel Macs.
• Add local variable renaming capabilities to the LSP
• Add "Find All References" functionality to the LSP for showing local references
• JSDoc autocomplete will automatically trigger after typing /**
• Add option for automatically closing JSX tags in the IDE
• Hovering in the IDE now shows both the unevaluated and evaluated type of the target expression.
• Add use_mixed_in_catch_variables config option that makes catch variables default to mixed instead of any
• Rename $Partial utility type to Partial. $Partial will continue working as an alias for at least one more version - use that period of time to codemod it to Partial.
• Add the Required utility type. It does the opposite of Partial: it makes optional properties required in object types.
• Improve error when attempting to call Object.values on a Flow Enum, to point the user to using .members()
• Improve error when using number and boolean primitives as a subtype of an interface
• Improve error on tuple arity mismatch

Notable bug fixes:

• Fix a bug preventing annotation hints from being used in tagged template expressions. This fix may get rid of some underconstrained-implicit-instantiation errors that were otherwise impossible to fix.
• Fix error when autocompleting the method stub for a function type without parameter names
• Document highlight in the IDE now correctly highlights destructured object keys
• Autocomplete can suggest literals when the target type is $Keys

flow-upgrade:

• Add codemod to convert usage of the $Shape utility type to Partial. It is possible that this will create type errors that you will have to resolve.
• Add codemod to rename $Partial to Partial

Misc:

• Remove unused-promise-in-async-scope and unused-promise-in-sync-scope. They can be enabled with unused-promise.
• Remove --evaluate-type-destructors flag from type-at-pos command
• Add flow save-state --scm flag to ease creation of SCM-aware saved states

Parser:

• Fix missing decorators on class fields
• Make infer a reserved word in types

Notable bug fixes: We fixed a bug that causes spurious Array is not an array errors in try-flow. Example

Likely to cause new Flow errors:

• We now require all generic functions to be fully annotated to prevent generic-escape issues. Some escaped-generic errors will be removed with missing-local-annot errors on return type annotation positions.
• Under LTI, we will no longer silently give unannotated parameters in destructuring assignment any type. Instead, they will be properly contextually typed. e.g. try Flow example.
• Some additional errors might be revealed after a correctness fix in implicit instantiation. e.g. try Flow example
• The exact_by_default option is now required to be set in the [options] section of the .flowconfig. Add either exact_by_default=true or exact_by_default=false to your [options] section. Previously the absence of the option was equivalent to exact_by_default=false. In the future, we will make the absence of the option equivalent to exact_by_default=true. Read more about the option here: https://flow.org/en/docs/config/options/#toc-exact-by-default-boolean. To create a valid new .flowconfig, use flow init.
• Changes to type variable unification may cause new errors to surface or old errors to be shifted to new locations.
• Fixed a bug where an unannotated parameter does not cause a missing-local-annot error under LTI. e.g. try Flow example
• Flow will stop emitting some spurious errors and uncover some hidden bugs under local type inference, as a result of removing a cache that no longer makes sense.
• The this type of exported classes' methods are no longer unsoundly typed as any. As a result, more underconstrained implicit instantiation errors might show up in LTI.
• Relational comparisons between dates and numbers are no longer allowed.

New Features:

• We added flow autofix missing-local-annot command that will try to add annotations to autofix all missing-local-annot errors in a given file.
• We now provide autofixes in IDE for all missing-local-annot errors where we can locally infer a type. Previously, this kind of autofix is only provided for unannotated parameters.
• Added an unused-promise-in-sync-scope lint which will detect unused promises in sync scopes (like unused-promise-in-async-scope does for async scopes). Enabling unused-promise will enable both of these rules. The individual rules will be removed in a future release.
• Pragmas (e.g. // @flow strict, // @jsx custom_jsx_fun) are now supported in try-flow.

IDE:

• Added autocomplete for jsdoc comments on functions.
• Added autocomplete for $FlowFixMe comments.
• Autocomplete will no longer suggest existing type names for type binding identifiers (e.g., in the name of a type alias).

Notable bug fixes:

• We will no longer warn about missing-local-annot when there is a proper typing context in super call. e.g. super(x => x) will now pass type checking under LTI if the super constructor call expects such function.
• Builtin types like $ReadOnly will no longer shadow your local definitions with the same name.
• We will no longer emit spurious errors when we are doing contextual typing while trying to resolve an overload. e.g. try Flow example
• We fixed a bug that over-zealously uses contextual type information from sibling nodes to type generic function calls. As a result, examples like the following no longer error: try Flow example
• fixed a bug where optional chaining on a value typed as a type application would not filter out the null or undefined value. e.g. try Flow example
• Some spurious errors might be removed as a result of Flow doing proper cache invalidation.
• Fix sorting of auto-imports with the same similarity score and length.

Parser:

• Parse and error on JSX type arguments.
• Add custom parse error for abstract classes.
• Add custom parse error when attempting to use template literal types in Flow.
• Add custom parse errors for TS class visibility modifiers public/private/protected.
• Remove function as an alias to Function, and don't allow function as a type name in general. (closes issue #9000).

Notable bug fixes:

• Fix crash related to deleted files in Haste

Likely to cause new Flow errors:

• Support for spread argument in the builtin special-cased $Compose function is dropped. If you need this, you can write it yourself:

declare function compose<T>(
  fns:...$ReadOnlyArray<T=>T>,
): T;

• Flow now consistently disallows implicit coercion of dates to numbers. Prefer explicit conversion with getTime().
• When a type argument is inferred from type argument bound or default, and such inference causes error downstream, we will provide better explanations in the error message where the type is coming from. Examples in try Flow.
• We fixed a bug under LTI that causes us to incorrectly skip checking for some function expressions Example. Some previously hidden errors might be revealed.
• We fixed a bug that causes some empty arrays to be incorrectly inferred as Array<empty> under LTI. e.g. Array.from(nullableStringArray ?? []). As a result, previously hidden errors might be revealed.
• Errors for bad == or === comparisons will now consistently show up. Previously, some errors might be hidden when some optimizations are hit, which heavily depends on the implementation details. Example
• More missing-local-annot error might be shown in cases when we cannot resolve overload. Example
• We fixed a bug where an unannotated parameter does not cause a missing-local-annot error under LTI. e.g.

declare function id<T>(T): T;
id([(item) => 1]); // now errors

New Features:

• Improved behavior of string literal autocomplete. Results will be provided regardless of the quote style used, and extra quotes won't be inserted when one is already typed.
• Add support for declare let and declare const. These work like declare var, but follow the rules of let and const respectively.

Notable bug fixes:

• We will no longer emit escaped-generic errors for predicate function bodies.
• $Compose now works under LTI mode.
• Remove spurious illegal-this error when a this annotation is used in contextual typing.
• Under LTI mode, we will no longer emit spurious incompatibility errors in invalid predicate function like function f({a: b}): boolean %checks { return typeof b === 'string'; }. Instead, you will only get error on this unsupported syntax.
• Fix type created by tagged template literals and String.raw. (Closes #7580. Fixes #5705. Fixes #2616.)
• We will emit fewer underconstrained-implicit-instantiation errors, when we decide that using type parameter default or bound won't cause downstream errors.
• Fixed a bug in LTI where some errors in utility types were not properly shown. Example
• Fix IDE services that stopped working while a file contained a setter with the wrong number of parameters.
• Fix an issue with lazy mode where deleting a file before the server starts did not check files that were depending on the deleted file.

Misc:

• Try Flow is now using the new local type inference algorithm.

Parser:

• Parse bigint object keys (but type checking is not support yet).

Notable bug fixes:

• Fix a crash on Windows
• Fix a bug that could possibly result in a crash

Parser:

• Fix bugs concerning await in async formal parameters (including a regression in 0.198.0)

• Fix a regression in 0.198.0 that can lead to a crash

Likely to cause new Flow errors:

• Implicit coercion of booleans to numbers is consistently disallowed. Previously, booleans could be implicitly coerced to numbers in addition expressions. Prefer explicitly converting booleans to numbers.
• Binary arithmetic errors are now reported on the expression rather than the operands, and use error code unsafe-arithmetic.
• keyof, undefined, never, unknown, and readonly are now reserved types. If you have a user-defined types of these names, rename them to something else.

New Features:

• TypeScript syntax helpers. To help people familiar with TypeScript syntax ramp up on similar Flow syntax:
  • Parse and error on keyof type operator, recommending $Keys<...> instead.
  • Parse and error on undefined type, recommending void instead.
  • Parse and error on never type, recommending empty instead.
  • Parse and error on unknown type, recommending mixed instead.
  • Parse and error on readonly applied to tuple and array type syntax.
  • Parse and error on usage of in/out/in out variance annotations.
  • Parse and error on as, as const, and satisfies cast expressions.
• Add a codemod to fix underconstrained-implicit-instantiation errors only detectable under LTI. You can run flow codemod annotate-implicit-instantiations --include-lti --ignore-suppressed --write .

Notable bug fixes:

• Fix a bug in LTI mode where some errors were hidden in implicit instantiation calls (e.g. Try Flow)
• Fix unsound behavior of sentinel refinement with unions of numeric types as tags (e.g. Try Flow)
• No annotation is required in LTI for callback parameters when the callee is a refined object member (e.g. Try Flow)

IDE:

• When typing in an object literal, entire method signatures from the object type will be suggested.
• Method signature autocomplete items are now visually distinguished from other kinds of autocomplete items.
• Fix manually triggering autocomplete on the last empty line of a file giving no results.
• Members from Object.prototype are no longer included in autocomplete results.

Parser:

• Fix parsing of for await (async of ...) (regressed in 0.197.0)
• Fix parsing of for (let in x) in non-strict mode
• Fix parsing of class fields named static
• Fix missing parse errors on keywords containing escape sequences (regressed in 0.180.0)
• Fix missing parse error when using await as a parameter in an async arrow function
• Fix missing parse error for export { ReservedWord as ... }
• Fix incorrect parse error on export * as ReservedWord from ..., which is now allowed
• Treat && and || as tokens when parsing types to improve error messages
• Parse the argument of the typeof type argument as a value, not a type, as it is a value

Library Definitions:

• Add Element.getAttributeNames(): Array<string>

Local Type Inference:

We are releasing a new inference mode called local type inference. You can enable this new mode in your codebase by adding inference_mode=lti to the [options] section in the flowconfig. We will describe more details on this inference mode in an upcoming blog post.

Likely to cause new Flow errors:

• Unannotated class properties initialized with null will now errors.
• We now require all generic functions to be fully annotated.
• bool is a deprecated alias for boolean. Added a deprecated-type-bool lint and flow fix --error-codes deprecated-type codemod to help migrate to boolean. This lint is also included in the deprecated-type lint; if deprecated-type is enabled, you can opt out with deprecated-type-bool=off

New Features:

• Tuple improvements:
  • $ReadOnly utility makes tuples read-only. E.g. $ReadOnly<[string, number]> is the same as [+a: string, +b: number].
  • Tuple elements can now have their variance annotated, when the element is labeled. E.g. type T = [+foo: number, +bar: string] creates a read-only tuple.
  • You can now label tuple elements (like TypeScript allows). The labels have no type-checking effect, they just help with self documentation (like indexer labels). When a function argument rest element is a tuple type, the labels work like parameter names in signature help.
  • We now parse tuple spread elements, but type checking of this feature is still unsupported.
  • These new features are now supported in Flow, but we have not upgraded related tools yet. For example, Prettier won't be able to format your code that uses variance annotations on tuples.
• Allow mixed or any as an annotation to a catch parameter (but not anything else)
• When typing in a class body, method signatures from super classes and interfaces will be suggested to make overriding/implementing these methods easier.

Notable bug fixes:

• Improve the parser's error recovery when in the middle of adding type parameters.
• Trigger autocomplete in JSX tags, JSX attribute values, and private class fields.
• Improves performance of bigints in big union checks

Misc:

• Inferred recursive types are shown as any (instead of V$n) in hover types.

Parser:

• symbol is now a reserved type
• for (async of []) is now a parse error

Library Definitions:

• Updated AbortController and AbortSignal signatures
• Actually expose ReactSetStateFunction type introduced in the last release.

• Fix a bug that could cause IDE commands to fail while a recheck is ongoing

🎁 This is (hopefully) our last release of the year. Happy holidays! 🎁

• Improve performance when unions flow to intersections
• Fix a crash when using the experimental saved_state.allow_reinit option

• Fix some missing autocomplete results (regression in 0.196.0)

Likely to cause new Flow errors:

• Instead of mixed, type the result of Object.values and Object.entries on a dictionary to be the dictionary values, and Object.entries keys to behave like Object.keys. Closes #2174, #2221, #4771, #4997, #5838.
• Ban array inputs to Object.values and Object.entries.
• Function's name and length property are now not writable.
• Fix Object.keys, $Values, and $Keys on interfaces with indexers.
• Delete $Subtype and $SuperType utilities.
• Delete deprecated-utility Flow lint.

New Features:

• An annotation is no longer required when exporting + expressions (e.g., export default (3 + 3 : number) can now just be export default 3 + 3;).

Notable bug fixes:

• Fix unary and binary arithmetic operations on bigints being exported/imported across modules as any or number.
• Fix autocomplete of string literals in bracket syntax, after a quote has already been typed.
• Improve sorting of results when autocompleting types.
• Boolean CLI flags must now be 1 or true to be truthy. Before, anything other than 0 and false was considered truthy.

Misc:

• Autocomplete results are now sorted case-insensitively.
• Autocomplete results are now sorted using a fuzzy score, in the same manner as VSCode.

Library Definitions:

• Add ReactSetStateFunction type alias in react. This is the type of setVal in const [val, setVal] = React.useState(...).

Misc:

• Adds an --experimental.run-post-inference-implicit-instantiation true/false CLI flag to override the respective experimental flowconfig option.

Misc:

• Improved performance for the experimental post-inference implicit instantiation checks.

• Add a quick fix for the unused-promise-in-async-scope lint which will insert void.
• Add symbol and bigint to $NotNullOrVoid
• Add findLast to Array definition

Likely to cause new Flow errors:

• Casting an enum to empty will now properly error, e.g. (E.A: empty).

New Features:

• Added a quick fix for the unused-promise-in-async-scope lint which will insert await.
• Added support for a number of additional bigint features. These include allowing comparison (<, >, <=, >=), update (++, --) and arithmetic operators (+, -, ~, *) to be used with bigints.
• Added sketchy-null-bigint lint to match the behavior of the other sketchy-null-* lints for bigints.
• Added Flow Enums support for declare enum and declare export enum. Keep in mind that users need to have enabled Flow Enums if you wish to create library definitions that use them.

Parser:

• Switch to dune to build and install the flow_parser OPAM package. Some modules in src/parser/ like Comment_utils are newly available.
• Decrease the size of flow_parser.js by roughly 25%, to 768kb.
• Fix a bug where declare opaque type was parsed as an OpaqueType when interned comments are disabled.

New Features:

• Add support for bigint. This includes the bigint type itself, subtyping with literals, libdefs, typeof, and sentinel refinement. For now, literal types are limited to 64 bit ints. Later changes may lift this restriction as well as implement support for operators.

Notable bug fixes:

• Fix a few bugs related to the Haste package resolver. The Haste resolver falls back to the Node resolver when resolving packages. It now obeys the module.system.node.root_relative_dirname setting when doing so. Also, scoped package names are now supported in the Haste module resolver.
• Allow private readonly properties to be written to in constructors, just like regular readonly properties.

Misc:

• Update team members in CONTRIBUTING.md.
• When using module.system=haste, importing packages in node_modules folders now obeys Node's resolution algorithm, rather than being able to be required from anywhere in the project.

Library Definitions:

• Add a default generic value for getOwnPropertyDescriptor.

Notable changes:

• The exact_empty_objects flag and the annotate_empty_object codemod are now deleted, See https://medium.com/flow-type/improved-handling-of-the-empty-object-in-flow-ead91887e40c for more details.
• We have announced in a previous blog post that we are working on a new inference mode in Flow. Now the inference mode is mostly working, but there might still be some bugs remaining. You can try it out by adding inference_mode=experimental.lti to your flowconfig.

Likely to cause new Flow errors:

• Unknown computed properties assignments are now completely banned. Previously, they were still allowed if the object is inexact.
• cannot-resolve-name errors now are emitted for every use of an undefined variable, not just the first.

New Features:

• Added an experimental flow lint for unused promises in async scope. You can enable it by adding unused-promise-in-async-scope in the lint section of your flowconfig.

Misc:

• annotate-use-state and annotate-use-callback codemod commands have been merged into annotate-react-hooks4
• Added an experimental "scm" saved state fetcher, which selects a saved state based on your currently source control revision.

Library Definitions:

• Added support for Array.prototype.at
• Fixed WeakSet type parameter bound to be interface {}

Likely to cause new Flow errors:

• The exact_empty_objects option is now enabled by default. Details about this change and how to update your codebase are covered on our blog.
• The typeof X type annotation now respects the initialization state of X: if X hasn't been declared it will be an error to get its type.

Notable changes:

• The enforce_local_inference_annotations config option was removed. To migrate your codebase, run the following codemod to add the required annotations: flow codemod annotate-lti. More details on the changes are explained in the Requiring More Annotations to Functions and Classes in Flow blog post.
• Literals can be suggested by autocomplete in more cases
• Fixed autocompleting specifiers in an import statement

• Fix a bug on Windows where the server would exit unexpectedly after hg update
• Performance improvements

Note: Due to large number of likely new Flow errors that will be introduced in the next release, we decided to create an extra release to ease the upgrade process. We announced in the recent blog post that we would remove the enforce_local_inference_annotations option in flowconfigs, as it became the default in v0.189.0. This change will be delayed to v0.191.0 instead.

Likely to cause new Flow errors:

• Flow will now error on indexed write to exact objects without indexed type.
• Flow now requires that the target of extends clauses in class definitions are either variables, casts, or member expressions, rather than allowing arbitrary expressions.
• We fixed a bug in which type arguments were not passed to the type parameters of static callable methods.
• We unblocked constraints involving any and type applications like Promise<T>, which may cause new downstream errors to be discovered.

Notable bug fixes:

• Fix a bug that can cause the Flow server to unnecessarily restart when Watchman restarts

Likely to cause new Flow errors:

• enforce_local_inference_annotations is now on by default. To migrate your codebase run the following codemod to add the required annotations: flow codemod annotate-lti. More details on the changes are explained in the Requiring More Annotations to Functions and Classes in Flow blog post.

New Features:

• Class members can be suggested by autocomplete even if this is not typed explicitly.

Notable bug fixes:

• We will now consistently emit object-this-reference errors. Previously these errors were missing when the object is an argument of Object.freeze(), Object.defineProperties() or Object.create().
• Fix crash when walking directories that can't be accessed.
• Fixed a potential crash when two type identifiers are declared in the same block.

Library Definitions:

• Improve fs.readFile type definition when the encoding config option is supplied.

Bug fixes:

• Fix crash during incremental recheck

Performance:

• Improve performance of auto-imports index update for large codebases

Bug fixes:

• Fix a crash when querying hg

Misc:

• We renamed the codemod command flow codemod annotate-lti to flow codemod annotate-functions-and-classes to clarify that this is not the only codemod necessary for enabling LTI eventually.

Likely to cause new Flow errors:

• Previously we supported a weird JS runtime rule for constructor returns when you call new SomeClass:

  • If the returned value is primitive, then it's ignored and the instance will be returned instead.
  • If the returned value is object like, then the return object will be the eval result of new SomeClass.

  This is confusing, and we dropped support for this feature in this release. Now we enforce that all class constructors must return void.

• Fixed a bug preventing refinements from being invalidated in inline && expressions: examples like typeof x === 'number' && reassignXToString() && (x: number) were passing even if reassignXToString() assigned a a string value to x.

New Features:

• flow codemod annotate-lti is now provided to help prepare your codebase to enable the enforce_local_inference_annotations=true flag. In order to eventually enable local type inference, we will require additional annotations in places we can't contextually type your code. You can enable the annotation enforcement now with enforce_local_inference_annotations=true in flowconfig. This flag enables the behaviors of all the following experimental flags, which will be deleted in the next release:

experimental.enforce_local_inference_annotations=true
experimental.enforce_this_annotations=true
experimental.enforce_class_annotations=true

To migrate your codebase, you can run the following codemod to prepare your codebase for the new requirement: flow codemod annotate-lti. Check out an upcoming blog post for more details.

Misc:

• Remove the file_watcher.watchman.survive_restarts flowconfig option, which was deprecated in 0.158.0. We will always try to survive Watchman restarts.
• Remove the experimental.refactor flowconfig option. It has been true by default since v0.158.0.

Library Definitions:

• Updates the typing of fs.promises.readdir() to reflect the possibility of passing withFileTypes: true and receiving an array of Dirent objects

• Fix a crash introduced in 0.187.0 when the file walker fails to open a directory

Likely to cause new Flow errors:

• JSX expressions in a file with jsx pragma of member expressions (e.g. @jsx Foo.bar) will no longer be incorrectly considered as unreachable. This might uncover previously hidden errors.
• Functions statics (i.e. assigning properties to functions) are safer, but also a bit more restricted. Function statics should be assigned in the same statement list as the function (i.e. not conditionally).

New Features:

• When autocompleting in the middle of a word, autocomplete now inserts the suggestion, instead of replacing the entire word. For example, if you are completing in foo|Baz (cursor at |) and choose fooBar, you'll now get fooBarBaz instead of fooBar. In VS Code, you can press shift-enter to replace instead of insert.

Bug fixes:

• Fix Go to Definition on certain kinds of import statements
• Improve location of error references pointing at imported namespaces (D38978756 mroch)
• Fix some missing references in CLI errors (D38977164 mroch)
• Improve location of error messages referring to declare module exports (D38977152 mroch)
• Change flow get-def --json to write {"error": message} to stdout on error, instead of writing non-JSON to stderr
• Fix a garbage collector bug that rarely could lead to crashes

Library Definitions:

• Allow access of arbitrary properties from import.meta. They are typed as mixed
• Add support for MediaSourceHandle

Notable breaking changes:

• Support for inference_mode=classic has been removed. The default is now inference_mode=constrain_writes. Please refer to the blog post for migration paths. Additionally we have removed all codemod commands that depend on the classic inference mode. This includes the annotate-declarations, rename-redefinitions and annotate-escaped-generics codemods.

Likely to cause new Flow errors:

• Exported functions can only have properties assigned in the same scope as the function.
• Improve behavior of index property access with union types (try-Flow example). May cause new errors in interaction with computed properties.
• Referencing this in object getters and setters are now banned. Referencing this in object methods are already banned, and this change makes Flow's behavior more consistent.

Notable bug fixes:

• Fixed a regression in destructuring checking with computed properties (issue).

Library Definitions:

• Added PerformanceServerTiming definition and the serverTiming attribute to PerformanceResourceTiming.

New Features:

• Flow now supports the @jsxRuntime pragma in the top docblock of each JS module. Allowed values are classic and automatic.

Misc:

• Improve the experimental mode to rank autoimport suggestions by how often they're imported (autoimports_ranked_by_usage=true)

Likely to cause new Flow errors:

• Unbound names in jsx-pragma when the jsx-pragma is not a simple identifier will now consistently point to the jsx pragma.
• Errors previously hidden by method-unbinding will reappear.
• Fix a bug that makes assignments in loop guards like x = some expression containing x have a type that's effectively any. If you turned on inference_mode=constrain_writes since the last release, there will be new errors.
• Remove esproposal_export_star_as as an option and make this the default as it made it into the JS standard in 2018.
• Additional value-as-type errors might be emitted, as a result of existing importing errors.
• Object rest on instances no longer results in an unsealed object (that can have properties added after the fact)

New Features:

• inference_mode=constrain_writes will be the default. inference_mode=classic, which is the current default, will be removed in the next release. Please refer to the blog post for migration paths.

Misc:

• Fix flow-remove-types/jest transformer to be compatible with Jest 28. (Thanks @carloscuesta)
• Add codemod to remove annotations in destructuring - which we banned in 0.176

Library Definitions:

• Add missing .x and .y properties to DOMRect. (Thanks @pmer)

Upcoming Breaking Changes:

• New Inference Mode:

  We are releasing a new inference mode that marks significant progress on our way to local type inference. You can enable this new mode in your codebase by adding inference_mode=constrain_writes to the [options] section in the flowconfig.

  We will make inference_mode default to constrain_writes in v0.185, and remove the classic option in v0.186. To migrate your codebase, you can run the following codemods to prepare your codebase for the new inference mode:

  flow codemod rename-redefinitions
  flow codemod annotate-declarations
  

  We will describe more details on this inference mode in an upcoming blog post.

• Additional Annotation Requirements:

  In order to eventually enable local type inference, we will require additional annotations in places we can't contextually type your code. You can enable the annotation enforcement now with the following flags in flowconfig:

  experimental.enforce_local_inference_annotations=true
  experimental.enforce_this_annotations=true
  experimental.enforce_class_annotations=true
  

  To migrate your codebase, you can run the following codemod to prepare your codebase for the new requirement: flow codemod annotate-lti-experimental

Likely to cause new Flow errors:

• Object.create now results in a sealed object. Arbitrary properties can no longer be read/written from/to it. You can use the __proto__ property in object annotations to create an annotation if you need to.

Notable bug fixes:

• Fix spurious object subtyping errors when an object literal is passed into rest arguments with tuple type

  function emit(...args: [{+bar: string}]): void {}
  emit({ bar: "" }); // no longer emits incompatible-variance
  

• Fix a bug on Windows that could lead to a crash if files are changed faster than they can be rechecked

flow-upgrade:

• Add a codemod to collapse multiline object initialization into one object literal - useful for enabling the exact_empty_objects flowconfig option

Library Definitions:

• Add DOMTokenList index signature

• Fix a regression in 0.183.0 on Windows where inconsistent handling of slashes within paths led to mismatches like "duplicate provider" errors

Likely to cause new Flow errors:

• We now emit new errors in places where an object literal has literal types, but doesn't have an annotation. You can usually fix these errors by adding annotations to object literals.

New Features:

• Allow export of empty object without annotation when exact_empty_objects is enabled.
• Improve annotate useState codemod to support null/undefined/empty-array arguments.

Notable bug fixes:

• Allow flowconfigs with blank lines before the first config section.
• Fix location of error message about legacy octal number types.
• Fix inconsistent blank lines around auto-imports.
• Fix bug where Watchman events might be ignored on Windows.

Parser:

• Fix parser exception on negative binary and octal number types that contain whitespace after the minus sign.

Library Definitions:

• Improved fs.readdir and fs.readdirSync to allow better overload resolution.
• Add String.prototype.replaceAll() (Thanks @dav-s).

Likely to cause new Flow errors:

• var re-declarations are now banned. You should use let or const instead.
• Flow will now emit escaped-generic errors when the return type of a generic predicate function contains type parameters defined by the function.

Notable bug fixes:

• Improve ordering of autoimport suggestions, so that globals are suggested above named imports.

Misc:

• Errors related to class expressions might have new locations.

• Fix the rendering of classes in autocomplete results
• Fix the ordering of class methods in autocomplete results
• Improve ability to recover from Watchman restarting (the fix in 0.181.0 was incomplete)
• Fix a bug where warnings would be incorrectly reported when using saved state, and could cause a crash.
• Add --saved-state-verify flag to check that a saved state matches what is expected to be on disk.

Notable bug fixes:

• The JS build for try-flow is now fixed. It's recently broken since the 0.181.0 release.

Notable bug fixes:

• Fix unsound spreading of empty array literals (example)
• Fix a race condition that could cause individual requests from the IDE to hang indefinitely
• Improve ability to recover from Watchman restarting

Parser:

• Fix parsing of invalid UTF-8 to raise the correct "Malformed unicode" parse error
• Fix line numbers when regex character classes contain an (invalid) newline, which could've led to a crash

Library Definitions:

• Add AudioContext constructor options
• Update Node's v8 module

Notable bug fixes: Reverted changes that cause Flow to generate a corrupted saved-state when libdef changes.

Likely to cause new Flow errors:

• Generator functions without return type annotations now default the type of the next parameter to void. If a non-void next type is desired for a function, it will have to be annotated.
• When experimental.enforce_local_inference_annotations is enabled, Flow now requires annotations on functions returned from async or generator functions.
• Return statements that return objects no longer widen the object type to match the return annotation, if present. This may lead to additional errors, which can be addressed by adding annotations onto variables that are returned.

New Features:

• Optimize initialization from saved state.
• When experimental.enforce_local_inference_annotations is enabled, Flow now has a code action to auto-annotate parameters of functions that have missing-local-annot errors.

Notable bug fixes:

• Fix broken IDE services when the file contains certain invalid type annotations, import type * ..., export async ... statements or nameless named exports.
• Fix some potential deadlocks on Windows.

Misc:

• Add --no-enums flag to flow ast.

Parser:

• Fix a runtime exception when parsing regexes via the JS version of the parser.
• Fix crash when the input is a lone quote.
• Fix missing syntax errors when functions with non-simple params contain "use strict"

Library Definitions:

• Add type signature for Navigator.canShare().

Likely to cause new Flow errors:

• Improve the type checking of function parameters that use destructuring, have an annotation, and also have a default value.

Notable bug fixes:

• Fix IDE services in the presence of certain types of parse errors.
• Fix crash when encountering an unexpected \/. This could have broken IDE integrations while typing.
• Fix crash with invalid for-await loops.

Parser:

• Add parser support for ES2022 d RegExp flag (see RegExp Match Indices).

Library Definitions:

• Add void to the React$Node type.

Notable Bug Fixes:

• [fix] Fix a crash during incremental recheck when an empty string import (e.g. import '') is added.
• [fix] Fix a stackoverflow caused by extremely large objects
• [fix] Fix an incremental update issue where Flow would sometimes resolve requires to stale Haste modules which have no provider files

Likely to cause new Flow errors:

• Improve type incompatibility error messages on default function parameters
• Invalidate refinements on calls of require, since requiring a module can have side effects

New Features:

• Add types for React 18 hooks: useId, useInsertionEffect and useSyncExternalStore

Notable bug fixes:

• x instanceof A when x is typed as any refines it to A instead of empty
• Fix an issue with [include] entries containing both globs and relative paths on Windows
• Fix crash when declaring a destructured binding in a library definition
• Fix missing autocomplete results for JSX component properties when the component's type is recursive
• Fix analysis of unreachable += expressions
• Fix incremental typechecking bug when adding files in Haste mode

Parser:

• Fix parser exception when parsing export interface ... or export enum ...

Likely to cause new Flow errors:

• Fix a bug where refinements should be invalidated when going through multiple control flow branches (thanks @gnprice)
• Make catch parameters explicitely any typed
• Ban object spreads of numbers and strings
• Fix a bug that makes Flow consider some function names to have the empty type
• Numbers, booleans, and enums are no longer subtypes of the empty interface interface {}
• Previously incorrectly missing errors might appear in expressions of the form name === 'literal' and name.prop === 'literal' complaining that literal is incompatible with the type of name or name.prop.
• Update input type of Object.{values,entries} to be interface {} rather than $NotNullOrVoid; number and boolean inputs will now error

New Features:

• Add codemod to add explicit type arguments to useState when it is called with an empty object. Use with flow codemod annotate-use-state
• Continue type checking files with indeterminate module types.

Notable bug fixes:

• Do not add further errors when we already errored on the illegal reassignment.
• Flow now checks whether literal is a subtype of expr in expr === literal, regardless of whether expr === literal can be applied as a refinement
• Fix a crash when deleting a file or saving a file with parse errors in certain circumstances
• Fix a rare crash when files are deleted during rechecks
• Fix a parser bug that allowed missing commas between object properties (regression in 0.175.0)

Parser:

• Improve error recovery when in the middle of adding a property to an object type literal

Library Definitions:

• Add NotificationEvent to service workers API

Notable bug fixes:

• The Haste module resolver now chooses Haste modules before node_modules, to match what Metro does. That is, if you use module.system=haste and have both a @providesModule foo file (or use "haste paths" to derive the module name from its filename) and a node_modules/foo folder, require('foo') will now resolve to the Haste module, even when node_modules/foo is in that file's parent directories. This is also a significant perf improvement because resolving a Haste module is much cheaper than searching for node_modules.
• Fix several bugs responsible for crashes
• Fix bugs responsible for some LSP "server is stopped" errors

Revert changes that are causing bugs in non-lazy mode.

Fix crash when comparing abstract and concrete locations when simplifying normalized types.

Likely to cause new Flow errors:

• Banned usage of new on functions. Move usages of this pattern to use ES6 classes instead. If the pattern exists in third-party code that cannot be changed directly, you can use a declaration file to type the legacy pattern with a declare class.
• Error on type annotations nested inside of destructuring - these were always invalid, we just ignored them before

Notable changes:

• Removed special support for React.createClass from Flow. It is now just typed as any. Migrate any components using it to class components or function components.
• Added the module.missing_module_generators option, which can be used (multiple times) to specify 'regex' -> 'command' pairs. When a module is missing, if its name matches one of the regexes, we will add a suggestion in the error message to run command to generate it (and resolve the error).
• Fixed bugs responsible for some LSP "server is stopped" errors
• Fixed a bug that could cause the server to become unresponsive on Windows

Bug fixes:

• Fix an incremental bug which would sometimes cause Flow to choose the wrong provider for a haste module, most commonly when one of those providers is a .js.flow file.
• Fix ability of flow stop to kill stuck servers
• Fix rare crashes when processes exit unexpectedly

Notable changes:

• Improve error messages when using a type as a value
• Improve error messages in for loops
• Correctly determine the scope of default expressions in function params
• Add FLOW_CONFIG_NAME env as alternative to passing --flowconfig-name
• Add file_watcher.mergebase_with.{git,hg} configs to support projects accessible via multiple VCSs (e.g. git mirrors of hg repositories)

IDE integration:

• Surface deprecated autocompletion results so they appear with a strikethrough in VS Code
• Fix a bug where changing libdefs, package.json files or the .flowconfig multiple times will cause the IDE to report "server is stopped".
• Fix a bug where the IDE is unable to start the server if it is downgraded
• Improve suggestions when autocompleting keys in an object literal
• Fix an exception when autocompleting a result that would add to an import to an existing require()

flow-remove-types:

• Fix handling of this param with trailing commas

Fix crash when Flow receives duplicate file deletion notifications introduced in v0.174.