diff --git a/README.md b/README.md index c882ab3f..2f152e53 100644 --- a/README.md +++ b/README.md @@ -222,7 +222,74 @@ If it is `'shorthand'` then a problem is raised when using `Array` instead The default value is `'verbose'`. - +The following patterns are considered problems: + +```js +type X = (?string)[] +// Message: Use "Array", not "(?string)[]" + +// Options: ["verbose"] +type X = (?string)[] +// Message: Use "Array", not "(?string)[]" + +// Options: ["shorthand"] +type X = Array +// Message: Use "(?string)[]", not "Array" + +// Options: ["shorthand"] +type X = Array<{foo: string}> +// Message: Use "{foo: string}[]", not "Array<{foo: string}>" + +type X = (string | number)[] +// Message: Use "Array", not "(string | number)[]" + +type X = (string & number)[] +// Message: Use "Array", not "(string & number)[]" + +type X = [string, number][] +// Message: Use "Array<[string, number]>", not "[string, number][]" + +type X = {foo: string}[] +// Message: Use "Array<{foo: string}>", not "{foo: string}[]" + +type X = (string => number)[] +// Message: Use "Array number>", not "(string => number)[]" + +type X = { + foo: string, + bar: number +}[] +// Message: Use "Array<{ foo: string, bar: number }>", not "{ foo: string, bar: number }[]" + +type X = { + foo: string, + bar: number, + quo: boolean, + hey: Date +}[] +// Message: Use "Array", not "Type[]" +``` + +The following patterns are not considered problems: + +```js +type X = Array + +// Options: ["verbose"] +type X = Array + +// Options: ["shorthand"] +type X = (?string)[] + +// Options: ["shorthand"] +type X = Array + +// Options: ["shorthand"] +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +type X = Array +``` + + ### array-style-simple-type @@ -249,7 +316,81 @@ If it is `'shorthand'` then a problem is raised when using `Array` instead The default value is `'verbose'`. - +The following patterns are considered problems: + +```js +type X = string[] +// Message: Use "Array", not "string[]" + +// Options: ["verbose"] +type X = string[] +// Message: Use "Array", not "string[]" + +// Options: ["shorthand"] +type X = Array +// Message: Use "string[]", not "Array" + +type X = Date[] +// Message: Use "Array", not "Date[]" + +type X = Promise[] +// Message: Use "Array>", not "Promise[]" + +type X = $Keys<{foo: string}>[] +// Message: Use "Array<$Keys<{foo: string}>>", not "$Keys<{foo: string}>[]" + +type X = any[] +// Message: Use "Array", not "any[]" + +type X = mixed[] +// Message: Use "Array", not "mixed[]" + +type X = void[] +// Message: Use "Array", not "void[]" + +type X = null[] +// Message: Use "Array", not "null[]" + +type X = string[][] +// Message: Use "Array", not "string[][]" +// Message: Use "Array", not "string[]" + +type X = Promise<{ + foo: string, + bar: number +}>[] +// Message: Use "Array>", not "Promise<{ foo: string, bar: number }>[]" + +type X = Promise<{ + foo: string, + bar: number, + quo: boolean +}>[] +// Message: Use "Array", not "Type[]" +``` + +The following patterns are not considered problems: + +```js +type X = Array + +// Options: ["verbose"] +type X = Array + +// Options: ["shorthand"] +type X = string[] + +type X = Array> + +// Options: ["verbose"] +type X = (?string)[] + +// Options: ["verbose"] +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +type X = string[] +``` + + ### boolean-style @@ -264,7 +405,38 @@ If it is `'bool'` then a problem is raised when using `boolean` instead of `bool The default value is `'boolean'`. - +The following patterns are considered problems: + +```js +type X = bool +// Message: Use "boolean", not "bool" + +// Options: ["boolean"] +type X = bool +// Message: Use "boolean", not "bool" + +// Options: ["bool"] +type X = boolean +// Message: Use "bool", not "boolean" +``` + +The following patterns are not considered problems: + +```js +type X = boolean + +// Options: ["boolean"] +type X = boolean + +// Options: ["bool"] +type X = bool + +// Options: ["boolean"] +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +type X = bool +``` + + ### define-flow-type @@ -273,677 +445,4017 @@ Marks Flow type identifiers as defined. Used to suppress [`no-undef`](http://eslint.org/docs/rules/no-undef) reporting of type identifiers. - - - -### delimiter-dangle - -_The `--fix` option on the command line automatically fixes problems reported by this rule._ +The following patterns are not considered problems: -Enforces consistent use of trailing commas in Object and Tuple annotations. +```js +var a: AType +// Additional rules: {"no-undef":2} -This rule takes one argument which mirrors ESLint's default `comma-dangle` rule. +var a: AType; var b: AType +// Additional rules: {"no-undef":2} -If it is `'never'` then a problem is raised when there is a trailing comma. +var a; (a: AType) +// Additional rules: {"no-undef":2} -If it is `'always'` then a problem is raised when there is no trailing comma. +var a: AType +// Additional rules: {"no-undef":2} -If it is `'always-multiline'` then a problem is raised when there is no trailing comma on a multi-line definition, or there _is_ a trailing comma on a single-line definition. +type A = AType +// Additional rules: {"no-undef":2} -If it is `'only-multiline'` then a problem is raised when there is a trailing comma on a single-line definition. It allows, but does not enforce, trailing commas on multi-line definitions. +declare type A = number +// Additional rules: {"no-undef":2} -The default value is `'never'`. +opaque type A = AType +// Additional rules: {"no-undef":2} - +function f(a: AType) {} +// Additional rules: {"no-undef":2} - -### generic-spacing +function f(a: AType.a) {} +// Additional rules: {"no-undef":2} -_The `--fix` option on the command line automatically fixes problems reported by this rule._ +function f(a: AType.a.b) {} +// Additional rules: {"no-undef":2} -Enforces consistent spacing within generic type annotation parameters. +function f(a): AType {}; var a: AType +// Additional rules: {"no-undef":2} -This rule takes one argument. If it is `'never'` then a problem is raised when there is a space surrounding the generic type parameters. If it is `'always'` then a problem is raised when there is no space surrounding the generic type parameters. +function f(a): AType {} +// Additional rules: {"no-undef":2} -The default value is `'never'`. +class C { a: AType } +// Additional rules: {"no-undef":2} - +class C { a: AType.a } +// Additional rules: {"no-undef":2} - -### newline-after-flow-annotation +class C { a: AType.a.b } +// Additional rules: {"no-undef":2} -This rule requires an empty line after the Flow annotation. +class C implements AType {} +// Additional rules: {"no-undef":2} - -#### Options +declare interface A {} +// Additional rules: {"no-undef":2} -The rule has a string option: +({ a: ({b() {}}: AType) }) +// Additional rules: {"no-undef":2} -* `"always"` (default): Enforces that `@flow` annotations be followed by an empty line, separated by newline (LF) -* `"always-windows"`: Identical to "always", but will use a CRLF when autofixing -* `"never"`: Enforces that `@flow` annotations are not followed by empty lines +type X = {Y(): BType} +// Additional rules: {"no-undef":2} -```js -{ - "rules": { - "flowtype/newline-after-flow-annotation": [ - 2, - "always" - ] - } -} -``` +var a: AType +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} +var a: AType; var b: AType +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} - +var a; (a: AType) +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} - -### no-dupe-keys +var a: AType +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} -Checks for duplicate properties in Object annotations. +type A = AType +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} -This rule mirrors ESLint's [no-dupe-keys](http://eslint.org/docs/rules/no-dupe-keys) rule. +declare type A = number +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} -```js -{ - "rules": { - "flowtype/no-dupe-keys": 2 - } -} -``` +opaque type A = AType +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} - +function f(a: AType) {} +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} - -### no-existential-type +function f(a: AType.a) {} +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} -Disallows use of the existential type (*). [See more](https://flow.org/en/docs/types/utilities/#toc-existential-type) +function f(a: AType.a.b) {} +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} -```js -{ - "rules": { - "flowtype/no-existential-type": 2 - } -} -``` +function f(a): AType {}; var a: AType +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} +function f(a): AType {} +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} - +class C { a: AType } +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} - -### no-flow-fix-me-comments +class C { a: AType.a } +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} -Disallows `$FlowFixMe` comment suppressions. +class C { a: AType.a.b } +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} -This is especially useful as a warning to ensure instances of `$FlowFixMe` in your codebase get fixed over time. +class C implements AType {} +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} - -#### Options +declare interface A {} +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} -This rule takes an optional RegExp that comments a text RegExp that makes the supression valid. +({ a: ({b() {}}: AType) }) +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} -```js -{ - "rules": { - "flowtype/no-flow-fix-me-comments": [ - 1, - "TODO\s+[0-9]+" - ] - } -} +type X = {Y(): BType} +// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} ``` - - -### no-mutable-array + + +### delimiter-dangle _The `--fix` option on the command line automatically fixes problems reported by this rule._ -Requires use of [`$ReadOnlyArray`](https://github.com/facebook/flow/blob/v0.46.0/lib/core.js#L185) instead of just `Array` or array [shorthand notation](https://flow.org/en/docs/types/arrays/#toc-array-type-shorthand-syntax). `$ReadOnlyArray` is immutable array collection type and the superclass of Array and tuple types in Flow. Use of `$ReadOnlyArray` instead of `Array` can solve some "problems" in typing with Flow (e.g., [1](https://github.com/facebook/flow/issues/3425), [2](https://github.com/facebook/flow/issues/4251)). +Enforces consistent use of trailing commas in Object and Tuple annotations. -General reasons for using immutable data structures: +This rule takes one argument which mirrors ESLint's default `comma-dangle` rule. -* They are simpler to construct, test, and use -* They help to avoid temporal coupling -* Their usage is side-effect free (no defensive copies) -* Identity mutability problem is avoided -* They always have failure atomicity -* They are much easier to cache +If it is `'never'` then a problem is raised when there is a trailing comma. -Note that initialization of a variable with an empty array is considered valid (e.g., `const values: Array = [];`). This behavior resembles the behavior of Flow's [unsealed objects](https://flow.org/en/docs/types/objects/#toc-unsealed-objects), as it is assumed that empty array is intended to be mutated. +If it is `'always'` then a problem is raised when there is no trailing comma. - +If it is `'always-multiline'` then a problem is raised when there is no trailing comma on a multi-line definition, or there _is_ a trailing comma on a single-line definition. - -### no-primitive-constructor-types +If it is `'only-multiline'` then a problem is raised when there is a trailing comma on a single-line definition. It allows, but does not enforce, trailing commas on multi-line definitions. -Disallows use of primitive constructors as types, such as `Boolean`, `Number` and `String`. [See more](https://flowtype.org/docs/builtins.html). +The default value is `'never'`. + +The following patterns are considered problems: ```js -{ - "rules": { - "flowtype/no-primitive-constructor-types": 2 - } -} -``` +type X = { foo: string, } +// Message: Unexpected trailing delimiter - +// Options: ["never"] +type X = { foo: string, } +// Message: Unexpected trailing delimiter - -### no-types-missing-file-annotation +// Options: ["never"] +type X = { foo: string; } +// Message: Unexpected trailing delimiter -Disallows Flow type imports, aliases, and annotations in files missing a valid Flow file declaration (or a @noflow annotation). +// Options: ["never"] +type X = { +foo: string, +} +// Message: Unexpected trailing delimiter -```js -{ - "rules": { - "flowtype/no-types-missing-file-annotation": 2 - } +// Options: ["always"] +type X = { foo: string } +// Message: Missing trailing delimiter + +// Options: ["always"] +type X = { +foo: string } -``` +// Message: Missing trailing delimiter - +// Options: ["always-multiline"] +type X = { foo: string, } +// Message: Unexpected trailing delimiter - -### no-unused-expressions +// Options: ["always-multiline"] +type X = { +foo: string +} +// Message: Missing trailing delimiter -An extension of [ESLint's `no-unused-expressions`](https://eslint.org/docs/rules/no-unused-expressions). -This rule ignores type cast expressions, but otherwise behaves the same as ESLint's -`no-unused-expressions`. +// Options: ["only-multiline"] +type X = { foo: string; } +// Message: Unexpected trailing delimiter -Bare type casts are useful, for example to assert the exhaustiveness of a `switch`: +// Options: ["never"] +type X = { [key: string]: number, } +// Message: Unexpected trailing delimiter -```js -type Action - = { type: 'FOO', doFoo: (_: number) => void } - | { type: 'BAR', doBar: (_: string) => void }; +// Options: ["always"] +type X = { [key: string]: number } +// Message: Missing trailing delimiter -type State = { foo: number, bar: string }; +// Options: ["always-multiline"] +type X = { [key: string]: number, } +// Message: Unexpected trailing delimiter -function runFooBar(action: Action, state: State): void { - switch (action.type) { - case 'FOO': - doFoo(state.foo); - break; - case 'BAR': - doBar(state.bar); - break; - default: - (action: empty); // type error when `Action` is extended with new types - console.error(`Impossible action: ${action.toString()}`); - } +// Options: ["always-multiline"] +type X = { +[key: string]: number } -``` +// Message: Missing trailing delimiter -This rule takes the same arguments as ESLint's `no-unused-expressions`. See -[that rule's documentation](https://eslint.org/docs/rules/no-unused-expressions) for details. +// Options: ["only-multiline"] +type X = { [key: string]: number; } +// Message: Unexpected trailing delimiter - +// Options: ["never"] +type X = { [key: string]: number, foo: string, } +// Message: Unexpected trailing delimiter - -### no-weak-types +// Options: ["never"] +type X = { +[key: string]: number, +foo: string, +} +// Message: Unexpected trailing delimiter -Warns against weak type annotations *any*, *Object* and *Function*. -These types can cause flow to silently skip over portions of your code, -which would have otherwise caused type errors. +// Options: ["never"] +type X = { +[key: string]: number, +aReallyLongPropertyNameHere: string, +} +// Message: Unexpected trailing delimiter -This rule optionally takes one argument, an object to configure which type warnings to enable. By default, all of the -warnings are enabled. e.g. to disable the `any` warning (allowing it to exist in your code), while continuing to warn -about `Object` and `Function`: +// Options: ["always"] +type X = { [key: string]: number, foo: string } +// Message: Missing trailing delimiter -```js -{ - "rules": { - "flowtype/no-weak-types": [2, { - "any": false, - "Object": true, - "Function": true - }] - } +// Options: ["always"] +type X = { +[key: string]: number; +foo: string } +// Message: Missing trailing delimiter -// or, the following is equivalent as default is true: +// Options: ["always-multiline"] +type X = { [key: string]: number, foo: string, } +// Message: Unexpected trailing delimiter -{ - "rules": { - "flowtype/no-weak-types": [2, { - "any": false - }] - } +// Options: ["always-multiline"] +type X = { +[key: string]: number, +foo: string } -``` +// Message: Missing trailing delimiter - +// Options: ["only-multiline"] +type X = { [key: string]: number, foo: string, } +// Message: Unexpected trailing delimiter - -### object-type-delimiter +// Options: ["never"] +type X = { foo: string, [key: string]: number, } +// Message: Unexpected trailing delimiter -_The `--fix` option on the command line automatically fixes problems reported by this rule._ +// Options: ["never"] +type X = { +foo: string, +[key: string]: number, +} +// Message: Unexpected trailing delimiter -Enforces consistent separators between properties in Flow object types. +// Options: ["never"] +type X = { +aReallyLongPropertyNameHere: string, +[key: string]: number, +} +// Message: Unexpected trailing delimiter -This rule takes one argument. +// Options: ["always"] +type X = { foo: string, [key: string]: number } +// Message: Missing trailing delimiter -If it is `'comma'` then a problem is raised when using `;` as a separator. +// Options: ["always"] +type X = { foo: string; [key: string]: number } +// Message: Missing trailing delimiter -If it is `'semicolon'` then a problem is raised when using `,` as a separator. +// Options: ["always-multiline"] +type X = { foo: string, [key: string]: number; } +// Message: Unexpected trailing delimiter -The default value is `'comma'`. +// Options: ["always-multiline"] +type X = { +foo: string, +[key: string]: number +} +// Message: Missing trailing delimiter + +// Options: ["only-multiline"] +type X = { foo: string, [key: string]: number; } +// Message: Unexpected trailing delimiter + +type X = [string, number,] +// Message: Unexpected trailing delimiter + +// Options: ["never"] +type X = [string, number,] +// Message: Unexpected trailing delimiter + +// Options: ["never"] +type X = [ +string, +number, +] +// Message: Unexpected trailing delimiter + +// Options: ["always"] +type X = [string, number] +// Message: Missing trailing delimiter + +// Options: ["always"] +type X = [ +string, +number +] +// Message: Missing trailing delimiter + +// Options: ["always-multiline"] +type X = [string, number,] +// Message: Unexpected trailing delimiter + +// Options: ["always-multiline"] +type X = [ +foo, string +] +// Message: Missing trailing delimiter + +// Options: ["only-multiline"] +type X = [ number, string, ] +// Message: Unexpected trailing delimiter +``` -_This rule is ported from `babel/flow-object-type`, however the default option was changed._ +The following patterns are not considered problems: - +```js +type X = { foo: string } - -### require-compound-type-alias +// Options: ["never"] +type X = { foo: string } -Requires to make a type alias for all [union](https://flow.org/en/docs/types/unions/) and [intersection](https://flow.org/en/docs/types/intersections/) types. If these are used in "raw" forms it might be tempting to just copy&paste them around the code. However, this brings sort of a source code pollution and unnecessary changes on several parts when these compound types need to be changed. +// Options: ["always"] +type X = { foo: string, } - -#### Options +// Options: ["always"] +type X = { foo: string; } -The rule has a string option: +// Options: ["never"] +type X = { +foo: string +} -* `"never"` -* `"always"` +// Options: ["always"] +type X = { +foo: string, +} -The default value is `"always"`. +// Options: ["always-multiline"] +type X = { foo: string } - +// Options: ["always-multiline"] +type X = { +foo: string, +} - -### require-exact-type +// Options: ["always-multiline"] +type X = { +foo: string; +} -This rule enforces [exact object types](https://flow.org/en/docs/types/objects/#toc-exact-object-types). +// Options: ["only-multiline"] +type X = { foo: string } - +// Options: ["only-multiline"] +type X = { +foo: string +} + +// Options: ["only-multiline"] +type X = { +foo: string, +} + +// Options: ["only-multiline"] +type X = { +foo: string; +} + +// Options: ["never"] +type X = {} + +// Options: ["always"] +type X = {} + +// Options: ["always-multiline"] +type X = {} + +// Options: ["only-multiline"] +type X = {} + +// Options: ["never"] +type X = { [key: string]: number } + +// Options: ["always"] +type X = { [key: string]: number, } + +// Options: ["always"] +type X = { [key: string]: number; } + +// Options: ["always-multiline"] +type X = { [key: string]: number } + +// Options: ["always-multiline"] +type X = { +[key: string]: number, +} + +// Options: ["only-multiline"] +type X = { +[key: string]: number, +} + +// Options: ["only-multiline"] +type X = { +[key: string]: number +} + +// Options: ["only-multiline"] +type X = { [key: string]: number } + +// Options: ["never"] +type X = { [key: string]: number, foo: string } + +// Options: ["always"] +type X = { [key: string]: number, foo: string, } + +// Options: ["always"] +type X = { [key: string]: number; foo: string; } + +// Options: ["always-multiline"] +type X = { [key: string]: number, foo: string } + +// Options: ["always-multiline"] +type X = { +[key: string]: number, +foo: string, +} + +// Options: ["only-multiline"] +type X = { +[key: string]: number, +foo: string, +} + +// Options: ["only-multiline"] +type X = { +[key: string]: number; +foo: string +} + +// Options: ["only-multiline"] +type X = { [key: string]: number, foo: string } + +// Options: ["never"] +type X = { foo: string, [key: string]: number } + +// Options: ["always"] +type X = { foo: string, [key: string]: number, } + +// Options: ["always"] +type X = { foo: string; [key: string]: number; } + +// Options: ["always-multiline"] +type X = { foo: string, [key: string]: number } + +// Options: ["always-multiline"] +type X = { +foo: string, +[key: string]: number, +} + +// Options: ["only-multiline"] +type X = { +foo: string, +[key: string]: number, +} + +// Options: ["only-multiline"] +type X = { +foo: string; +[key: string]: number +} + +// Options: ["only-multiline"] +type X = { foo: string, [key: string]: number } + +type X = [string, number] + +// Options: ["never"] +type X = [string, number] + +// Options: ["never"] +type X = [ +string, +number +] + +// Options: ["always"] +type X = [string, number,] + +// Options: ["always"] +type X = [ +string, +number, +] + +// Options: ["always-multiline"] +type X = [ foo, string ] + +// Options: ["always-multiline"] +type X = [ +foo, string, +] + +// Options: ["only-multiline"] +type X = [ number, string ] + +// Options: ["only-multiline"] +type X = [ +number, +string +] + +// Options: ["only-multiline"] +type X = [ +number, +string, +] + +// Options: ["never"] +type X = [] + +// Options: ["always"] +type X = [] + +// Options: ["always-multiline"] +type X = [] + +// Options: ["only-multiline"] +type X = [] +``` + + + + +### generic-spacing + +_The `--fix` option on the command line automatically fixes problems reported by this rule._ + +Enforces consistent spacing within generic type annotation parameters. + +This rule takes one argument. If it is `'never'` then a problem is raised when there is a space surrounding the generic type parameters. If it is `'always'` then a problem is raised when there is no space surrounding the generic type parameters. + +The default value is `'never'`. + +The following patterns are considered problems: + +```js +type X = Promise< string> +// Message: There must be no space at start of "Promise" generic type annotation + +// Options: ["never"] +type X = Promise< string> +// Message: There must be no space at start of "Promise" generic type annotation + +type X = FooBar +// Message: There must be no space at end of "FooBar" generic type annotation + +type X = Promise< string > +// Message: There must be no space at start of "Promise" generic type annotation +// Message: There must be no space at end of "Promise" generic type annotation + +type X = Promise< (foo), bar, (((baz))) > +// Message: There must be no space at start of "Promise" generic type annotation +// Message: There must be no space at end of "Promise" generic type annotation + +// Options: ["always"] +type X = Promise +// Message: There must be a space at start of "Promise" generic type annotation + +// Options: ["always"] +type X = FooBar< string> +// Message: There must be a space at end of "FooBar" generic type annotation + +// Options: ["always"] +type X = Promise +// Message: There must be a space at start of "Promise" generic type annotation +// Message: There must be a space at end of "Promise" generic type annotation + +// Options: ["always"] +type X = Promise<(foo), bar, (((baz)))> +// Message: There must be a space at start of "Promise" generic type annotation +// Message: There must be a space at end of "Promise" generic type annotation + +// Options: ["always"] +type X = FooBar< string > +// Message: There must be one space at start of "FooBar" generic type annotation + +// Options: ["always"] +type X = FooBar< string > +// Message: There must be one space at end of "FooBar" generic type annotation + +// Options: ["always"] +type X = Promise< (foo), bar, (((baz))) > +// Message: There must be one space at start of "Promise" generic type annotation +// Message: There must be one space at end of "Promise" generic type annotation +``` + +The following patterns are not considered problems: + +```js +type X = Promise + +type X = Promise<(string)> + +type X = Promise<(foo), bar, (((baz)))> + +// Options: ["always"] +type X = Promise< string > + +// Options: ["always"] +type X = Promise< (string) > + +// Options: ["always"] +type X = Promise< (foo), bar, (((baz))) > +``` + + + + +### newline-after-flow-annotation + +This rule requires an empty line after the Flow annotation. + + #### Options -The rule has one string option: +The rule has a string option: -* `"always"` (default): Report all object type definitions that aren't exact. -* `"never"`: Report all object type definitions that are exact. +* `"always"` (default): Enforces that `@flow` annotations be followed by an empty line, separated by newline (LF) +* `"always-windows"`: Identical to "always", but will use a CRLF when autofixing +* `"never"`: Enforces that `@flow` annotations are not followed by empty lines ```js { "rules": { - "flowtype/require-exact-type": [ + "flowtype/newline-after-flow-annotation": [ 2, "always" ] } } +``` -{ - "rules": { - "flowtype/require-exact-type": [ - 2, - "never" - ] - } -} + +The following patterns are considered problems: + +```js +// @flow +import Foo from './foo'; +// Message: Expected newline after flow annotation + +// Options: ["always"] +// @flow +import Foo from './foo'; +// Message: Expected newline after flow annotation + +// Options: ["always-windows"] +// @flow +import Foo from './foo'; +// Message: Expected newline after flow annotation + +// Options: ["never"] +// @flow + + +// Message: Expected no newline after flow annotation ``` - +The following patterns are not considered problems: - -### require-parameter-type +```js +// Options: ["always"] +// @flow -Requires that all function parameters have type annotations. +import Foo from './foo'; - -#### Options +// Options: ["always-windows"] +// @flow + +import Foo from './foo'; -You can skip all arrow functions by providing the `excludeArrowFunctions` option with `true`. +// Options: ["never"] +// @flow +import Foo from './foo'; +``` -Alternatively, you can want to exclude only concise arrow functions (e.g. `x => x * 2`). Provide `excludeArrowFunctions` with `expressionsOnly` for this. + + + +### no-dupe-keys + +Checks for duplicate properties in Object annotations. + +This rule mirrors ESLint's [no-dupe-keys](http://eslint.org/docs/rules/no-dupe-keys) rule. ```js { "rules": { - "flowtype/require-parameter-type": [ - 2, - { - "excludeArrowFunctions": true - } - ] + "flowtype/no-dupe-keys": 2 } } +``` -{ - "rules": { - "flowtype/require-parameter-type": [ - 2, - { - "excludeArrowFunctions": "expressionsOnly" - } - ] - } -} +The following patterns are considered problems: + +```js +type f = { a: number, b: string, a: number } +// Message: Duplicate property. + +type f = { a: number, b: string, a: string } +// Message: Duplicate property. + +type f = { get(key: "a"): string, get(key: "a"): string } +// Message: Duplicate property. + +type f = { get(key: 1): string, get(key: 1): string } +// Message: Duplicate property. + +type f = { get(key: 1.1): string, get(key: 1.1): string } +// Message: Duplicate property. + +type f = { get(key: true): string, get(key: true): string } +// Message: Duplicate property. + +type f = { get(key: {a: 1}): string, get(key: {a: 1}):string } +// Message: Duplicate property. + +var a = "a"; type f = { get(key: a): string, get(key: a): string } +// Message: Duplicate property. + +var b = 1; type f = { get(key: b): string, get(key: b): string } +// Message: Duplicate property. + +var c = true; type f = { get(key: c): string, get(key: c): string } +// Message: Duplicate property. + +var d = {}; type f = { get(key: d): string, get(key: d): string } +// Message: Duplicate property. + +var e = []; type f = { get(key: e): string, get(key: e): string } +// Message: Duplicate property. + +var e = [1, "a"]; type f = { get(key: e): string, get(key: e): string } +// Message: Duplicate property. + +function fn() {}; type f = { get(key: fn): string, get(key: fn): string } +// Message: Duplicate property. ``` -You can exclude parameters that match a certain regex by using `excludeParameterMatch`. +The following patterns are not considered problems: + +```js +type FooType = { a: number, b: string, c: number } + +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +type FooType = { a: number, b: string, a: number } + +type f = { get(key: "a"): string, get(key: "b"): string } + +type f = { get(key: 1): string, get(key: 2): string } + +type f = { get(key: 1.1): string, get(key: 1.2): string } + +type f = { get(key: true): string, get(key: false): string } + +type f = { get(key: ["a", 1]): string, get(key: ["a", 2]): string } + +type f = { get(key: ["a", ["b", 1]]): string, get(key: ["a", ["b", 2]]): string } + +type f = { a: number, b: string, c: number } + +type f = { get(key: "a"): string, get(key: "b"): string } + +type f = { get(key: "a"): string, get(key: "a", key2: "b"): string } + +type f = { get(key: "a"): string, get(key: 1): string } + +type f = { get(key: { a: 1 }): string, get(key: { a: 2 }): string} + +var a = {}; var b = {}; type f = { get(key: a): string, get(key: b): string } + +var a = 1; var b = 1; type f = { get(key: a): string, get(key: b): string } +``` + + + + +### no-existential-type + +Disallows use of the existential type (*). [See more](https://flow.org/en/docs/types/utilities/#toc-existential-type) ```js { - "rules": { - "flowtype/require-parameter-type": [ - 2, - { - "excludeParameterMatch": "^_" - } - ] - } + "rules": { + "flowtype/no-existential-type": 2 + } } ``` -This excludes all parameters that start with an underscore (`_`). -The default pattern is `a^`, which doesn't match anything, i.e., all parameters are checked. - +The following patterns are considered problems: - -### require-return-type +```js +type T = *; +// Message: Unexpected use of existential type (*). -Requires that functions have return type annotation. +type T = U<*, *>; +// Message: Unexpected use of existential type (*). +// Message: Unexpected use of existential type (*). - -#### Options +const f: (*) => null = () => null; +// Message: Unexpected use of existential type (*). +``` -You can skip all arrow functions by providing the `excludeArrowFunctions` option with `true`. +The following patterns are not considered problems: -Alternatively, you can exclude a concise arrow function (e.g. `() => 2`). Provide `excludeArrowFunctions` with `expressionsOnly` for this. +```js +type T = string | null +``` + + + + +### no-flow-fix-me-comments + +Disallows `$FlowFixMe` comment suppressions. + +This is especially useful as a warning to ensure instances of `$FlowFixMe` in your codebase get fixed over time. + + +#### Options + +This rule takes an optional RegExp that comments a text RegExp that makes the supression valid. ```js { "rules": { - "flowtype/require-return-type": [ - 2, - "always", - { - "excludeArrowFunctions": true - } + "flowtype/no-flow-fix-me-comments": [ + 1, + "TODO\s+[0-9]+" ] } } +``` -{ - "rules": { - "flowtype/require-return-type": [ - 2, - "always", - { - "excludeArrowFunctions": "expressionsOnly" - } - ] +The following patterns are considered problems: + +```js +// $FlowFixMe I am doing something evil here +const text = 'HELLO'; +// Message: $FlowFixMe is treated as `any` and should be fixed. + +// Options: ["TODO [0-9]+"] +// $FlowFixMe I am doing something evil here +const text = 'HELLO'; +// Message: $FlowFixMe is treated as `any` and should be fixed. Fix it or match `/TODO [0-9]+/`. + +// Options: ["TODO [0-9]+"] +// $FlowFixMe TODO abc 47 I am doing something evil here +const text = 'HELLO'; +// Message: $FlowFixMe is treated as `any` and should be fixed. Fix it or match `/TODO [0-9]+/`. + +// $$FlowFixMeProps I am doing something evil here +const text = 'HELLO'; +// Message: $FlowFixMe is treated as `any` and should be fixed. + +// Options: ["TODO [0-9]+"] +// $FlowFixMeProps I am doing something evil here +const text = 'HELLO'; +// Message: $FlowFixMe is treated as `any` and should be fixed. Fix it or match `/TODO [0-9]+/`. +``` + +The following patterns are not considered problems: + +```js +const text = 'HELLO'; + +// Options: ["TODO [0-9]+"] +// $FlowFixMe TODO 48 +const text = 'HELLO'; +``` + + + + +### no-mutable-array + +_The `--fix` option on the command line automatically fixes problems reported by this rule._ + +Requires use of [`$ReadOnlyArray`](https://github.com/facebook/flow/blob/v0.46.0/lib/core.js#L185) instead of just `Array` or array [shorthand notation](https://flow.org/en/docs/types/arrays/#toc-array-type-shorthand-syntax). `$ReadOnlyArray` is immutable array collection type and the superclass of Array and tuple types in Flow. Use of `$ReadOnlyArray` instead of `Array` can solve some "problems" in typing with Flow (e.g., [1](https://github.com/facebook/flow/issues/3425), [2](https://github.com/facebook/flow/issues/4251)). + +General reasons for using immutable data structures: + +* They are simpler to construct, test, and use +* They help to avoid temporal coupling +* Their usage is side-effect free (no defensive copies) +* Identity mutability problem is avoided +* They always have failure atomicity +* They are much easier to cache + +Note that initialization of a variable with an empty array is considered valid (e.g., `const values: Array = [];`). This behavior resembles the behavior of Flow's [unsealed objects](https://flow.org/en/docs/types/objects/#toc-unsealed-objects), as it is assumed that empty array is intended to be mutated. + +The following patterns are considered problems: + +```js +type X = Array +// Message: Use "$ReadOnlyArray" instead of "Array" + +type X = string[] +// Message: Use "$ReadOnlyArray" instead of array shorthand notation + +const values: Array> = []; +// Message: Use "$ReadOnlyArray" instead of "Array" + +let values: Array>; +// Message: Use "$ReadOnlyArray" instead of "Array" +// Message: Use "$ReadOnlyArray" instead of "Array" +``` + +The following patterns are not considered problems: + +```js +type X = $ReadOnlyArray + +const values: Array<$ReadOnlyArray> = []; + +const values: $ReadOnlyArray[] = []; + +const values: Array<$ReadOnlyArray> = new Array(); + +const values: Array<$ReadOnlyArray> = Array(); +``` + + + + +### no-primitive-constructor-types + +Disallows use of primitive constructors as types, such as `Boolean`, `Number` and `String`. [See more](https://flowtype.org/docs/builtins.html). + +```js +{ + "rules": { + "flowtype/no-primitive-constructor-types": 2 } } ``` -You can exclude or include specific tests with the `includeOnlyMatching` and `excludeMatching` rules. +The following patterns are considered problems: + +```js +type x = Number +// Message: Unexpected use of Number constructor type. + +type x = String +// Message: Unexpected use of String constructor type. + +type x = Boolean +// Message: Unexpected use of Boolean constructor type. + +type x = { a: Number } +// Message: Unexpected use of Number constructor type. + +type x = { a: String } +// Message: Unexpected use of String constructor type. + +type x = { a: Boolean } +// Message: Unexpected use of Boolean constructor type. + +(x: Number) => {} +// Message: Unexpected use of Number constructor type. + +(x: String) => {} +// Message: Unexpected use of String constructor type. + +(x: Boolean) => {} +// Message: Unexpected use of Boolean constructor type. +``` + +The following patterns are not considered problems: + +```js +type x = number + +type x = string + +type x = boolean + +type x = { a: number } + +type x = { a: string } + +type x = { a: boolean } + +(x: number) => {} + +(x: string) => {} + +(x: boolean) => {} + +type x = MyNumber + +type x = MyString + +type x = MyBoolean +``` + + + + +### no-types-missing-file-annotation + +Disallows Flow type imports, aliases, and annotations in files missing a valid Flow file declaration (or a @noflow annotation). ```js { "rules": { - "flowtype/require-return-type": [ - 2, - "always", - { - "includeOnlyMatching": [ - "^F.*", - "Ba(r|z)" - ] - } - ] + "flowtype/no-types-missing-file-annotation": 2 + } +} +``` + +The following patterns are considered problems: + +```js +const x: number = 42; +// Message: Type annotations require valid Flow declaration. + +type FooType = number; +// Message: Type aliases require valid Flow declaration. + +import type A from "a" +// Message: Type imports require valid Flow declaration. + +import type {A} from "a" +// Message: Type imports require valid Flow declaration. + +import {type A} from "a" +// Message: Type imports require valid Flow declaration. + +export type {A} from "a" +// Message: Type exports require valid Flow declaration. + +function t(): T{} +// Message: Type annotations require valid Flow declaration. + +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +const x: number = 42; +// Message: Type annotations require valid Flow declaration. +``` + +The following patterns are not considered problems: + +```js +// @flow +const x: number = 42; + +/* @flow weak */ +type FooType = number; + +/* @noflow */ +type FooType = number; + +/* @noflow */ +import type A from "a" + +/* @noflow */ +import {type A} from "a" + +/* @noflow */ +export type {A} from "a" + +// an unrelated comment +// @flow +export type {A} from "a" +``` + + + + +### no-unused-expressions + +An extension of [ESLint's `no-unused-expressions`](https://eslint.org/docs/rules/no-unused-expressions). +This rule ignores type cast expressions, but otherwise behaves the same as ESLint's +`no-unused-expressions`. + +Bare type casts are useful, for example to assert the exhaustiveness of a `switch`: + +```js +type Action + = { type: 'FOO', doFoo: (_: number) => void } + | { type: 'BAR', doBar: (_: string) => void }; + +type State = { foo: number, bar: string }; + +function runFooBar(action: Action, state: State): void { + switch (action.type) { + case 'FOO': + doFoo(state.foo); + break; + case 'BAR': + doBar(state.bar); + break; + default: + (action: empty); // type error when `Action` is extended with new types + console.error(`Impossible action: ${action.toString()}`); + } +} +``` + +This rule takes the same arguments as ESLint's `no-unused-expressions`. See +[that rule's documentation](https://eslint.org/docs/rules/no-unused-expressions) for details. + +The following patterns are considered problems: + +```js +foo + 1 +// Message: Expected an assignment or function call and instead saw an expression. +``` + +The following patterns are not considered problems: + +```js +(foo: number) +``` + + + + +### no-weak-types + +Warns against weak type annotations *any*, *Object* and *Function*. +These types can cause flow to silently skip over portions of your code, +which would have otherwise caused type errors. + +This rule optionally takes one argument, an object to configure which type warnings to enable. By default, all of the +warnings are enabled. e.g. to disable the `any` warning (allowing it to exist in your code), while continuing to warn +about `Object` and `Function`: + +```js +{ + "rules": { + "flowtype/no-weak-types": [2, { + "any": false, + "Object": true, + "Function": true + }] + } +} + +// or, the following is equivalent as default is true: + +{ + "rules": { + "flowtype/no-weak-types": [2, { + "any": false + }] } } +``` + +The following patterns are considered problems: + +```js +function foo(thing): any {} +// Message: Unexpected use of weak type "any" + +function foo(thing): Promise {} +// Message: Unexpected use of weak type "any" + +function foo(thing): Promise> {} +// Message: Unexpected use of weak type "any" + +function foo(thing): mixed {} +// Message: Unexpected use of weak type "mixed" + +function foo(thing): Promise {} +// Message: Unexpected use of weak type "mixed" + +function foo(thing): Promise> {} +// Message: Unexpected use of weak type "mixed" + +function foo(thing): Object {} +// Message: Unexpected use of weak type "Object" + +function foo(thing): Promise {} +// Message: Unexpected use of weak type "Object" + +function foo(thing): Promise> {} +// Message: Unexpected use of weak type "Object" + +function foo(thing): Function {} +// Message: Unexpected use of weak type "Function" + +function foo(thing): Promise {} +// Message: Unexpected use of weak type "Function" + +function foo(thing): Promise> {} +// Message: Unexpected use of weak type "Function" + +(foo: any) => {} +// Message: Unexpected use of weak type "any" + +(foo: Function) => {} +// Message: Unexpected use of weak type "Function" + +(foo?: any) => {} +// Message: Unexpected use of weak type "any" + +(foo?: Function) => {} +// Message: Unexpected use of weak type "Function" + +(foo: { a: any }) => {} +// Message: Unexpected use of weak type "any" + +(foo: { a: Object }) => {} +// Message: Unexpected use of weak type "Object" + +(foo: any[]) => {} +// Message: Unexpected use of weak type "any" + +type Foo = any +// Message: Unexpected use of weak type "any" + +type Foo = Function +// Message: Unexpected use of weak type "Function" + +type Foo = { a: any } +// Message: Unexpected use of weak type "any" + +type Foo = { a: Object } +// Message: Unexpected use of weak type "Object" + +type Foo = { (a: Object): string } +// Message: Unexpected use of weak type "Object" + +type Foo = { (a: string): Function } +// Message: Unexpected use of weak type "Function" + +function foo(thing: any) {} +// Message: Unexpected use of weak type "any" + +function foo(thing: Object) {} +// Message: Unexpected use of weak type "Object" + +var foo: Function +// Message: Unexpected use of weak type "Function" + +var foo: Object +// Message: Unexpected use of weak type "Object" + +class Foo { props: any } +// Message: Unexpected use of weak type "any" + +class Foo { props: Object } +// Message: Unexpected use of weak type "Object" + +var foo: any +// Message: Unexpected use of weak type "any" + +// Options: [{"Function":false}] +type X = any; type Y = Function; type Z = Object +// Message: Unexpected use of weak type "any" +// Message: Unexpected use of weak type "Object" + +// Options: [{"any":false,"Object":false}] +type X = any; type Y = Function; type Z = Object +// Message: Unexpected use of weak type "Function" + +// Options: [{"Function":false,"Object":false}] +type X = mixed; type Y = Function; type Z = Object +// Message: Unexpected use of weak type "mixed" +``` + +The following patterns are not considered problems: + +```js +function foo(thing): string {} + +function foo(thing): Promise {} + +function foo(thing): Promise> {} + +(foo?: string) => {} + +(foo: ?string) => {} + +(foo: { a: string }) => {} + +(foo: { a: ?string }) => {} + +(foo: string[]) => {} + +type Foo = string + +type Foo = { a: string } + +type Foo = { (a: string): string } + +function foo(thing: string) {} + +var foo: string + +class Foo { props: string } + +// Options: [{"any":false,"Object":false}] +type X = any; type Y = Object + +// Options: [{"mixed":false,"Object":false}] +type X = mixed; type Y = Object + +// Options: [{"Function":false}] +type X = Function + +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +function foo(thing): Function {} +``` + + + + +### object-type-delimiter + +_The `--fix` option on the command line automatically fixes problems reported by this rule._ + +Enforces consistent separators between properties in Flow object types. + +This rule takes one argument. + +If it is `'comma'` then a problem is raised when using `;` as a separator. + +If it is `'semicolon'` then a problem is raised when using `,` as a separator. + +The default value is `'comma'`. + +_This rule is ported from `babel/flow-object-type`, however the default option was changed._ + +The following patterns are considered problems: + +```js +// Options: ["semicolon"] +type Foo = { a: Foo, b: Bar } +// Message: Prefer semicolons to commas in object and class types + +// Options: ["comma"] +type Foo = { a: Foo; b: Bar } +// Message: Prefer commas to semicolons in object and class types + +// Options: ["semicolon"] +type Foo = { [a: string]: Foo, [b: string]: Bar } +// Message: Prefer semicolons to commas in object and class types + +// Options: ["comma"] +type Foo = { [a: string]: Foo; [b: string]: Bar } +// Message: Prefer commas to semicolons in object and class types + +// Options: ["semicolon"] +type Foo = { (): Foo, (): Bar } +// Message: Prefer semicolons to commas in object and class types + +// Options: ["comma"] +type Foo = { (): Foo; (): Bar } +// Message: Prefer commas to semicolons in object and class types + +// Options: ["semicolon"] +declare class Foo { a: Foo, } +// Message: Prefer semicolons to commas in object and class types + +// Options: ["comma"] +declare class Foo { a: Foo; } +// Message: Prefer commas to semicolons in object and class types + +// Options: ["semicolon"] +declare class Foo { [a: string]: Foo, } +// Message: Prefer semicolons to commas in object and class types + +// Options: ["comma"] +declare class Foo { a: Foo; } +// Message: Prefer commas to semicolons in object and class types + +// Options: ["semicolon"] +declare class Foo { (): Foo, } +// Message: Prefer semicolons to commas in object and class types + +// Options: ["comma"] +declare class Foo { (): Foo; } +// Message: Prefer commas to semicolons in object and class types + +// Options: ["semicolon"] +declare class Foo { static (): Foo, } +// Message: Prefer semicolons to commas in object and class types + +// Options: ["comma"] +declare class Foo { static (): Foo; } +// Message: Prefer commas to semicolons in object and class types +``` + +The following patterns are not considered problems: + +```js +// Options: ["semicolon"] +type Foo = { a: Foo; b: Bar } + +// Options: ["comma"] +type Foo = { a: Foo, b: Bar } + +// Options: ["semicolon"] +type Foo = { [a: string]: Foo; [b: string]: Bar } + +// Options: ["comma"] +type Foo = { [a: string]: Foo, [b: string]: Bar } + +// Options: ["semicolon"] +type Foo = { (): Foo; (): Bar } + +// Options: ["comma"] +type Foo = { (): Foo, (): Bar } + +type Foo = { a: Foo, b: Bar } + +type Foo = { [a: string]: Foo, [b: string]: Bar } + +type Foo = { (): Foo, (): Bar } + +// Options: ["semicolon"] +declare class Foo { a: Foo; } + +// Options: ["comma"] +declare class Foo { a: Foo, } + +// Options: ["semicolon"] +declare class Foo { [a: string]: Foo; } + +// Options: ["comma"] +declare class Foo { [a: string]: Foo, } + +// Options: ["semicolon"] +declare class Foo { (): Foo; } + +// Options: ["comma"] +declare class Foo { (): Foo, } + +// Options: ["semicolon"] +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +type Foo = { a: Foo, b: Bar } +``` + + + + +### require-compound-type-alias + +Requires to make a type alias for all [union](https://flow.org/en/docs/types/unions/) and [intersection](https://flow.org/en/docs/types/intersections/) types. If these are used in "raw" forms it might be tempting to just copy&paste them around the code. However, this brings sort of a source code pollution and unnecessary changes on several parts when these compound types need to be changed. + + +#### Options + +The rule has a string option: + +* `"never"` +* `"always"` + +The default value is `"always"`. + +The following patterns are considered problems: + +```js +function foo(bar: "A" | "B") {} +// Message: All union types must be declared with named type alias. + +const foo: "A" | "B" = "A"; +// Message: All union types must be declared with named type alias. + +type Foo = { bar: "A" | "B" }; +// Message: All union types must be declared with named type alias. + +function foo(bar: { n: number } | { s: string }) {} +// Message: All union types must be declared with named type alias. + +function foo(bar: { n: number } & { s: string }) {} +// Message: All intersection types must be declared with named type alias. + +const foo: { n: number } & { s: string } = { n: 0, s: "" }; +// Message: All intersection types must be declared with named type alias. + +type Foo = { bar: { n: number } & { s: string } }; +// Message: All intersection types must be declared with named type alias. + +function foo(bar: { n: number } & { s: string }) {} +// Message: All intersection types must be declared with named type alias. +``` + +The following patterns are not considered problems: + +```js +type Foo = "A" | "B"; + +type Bar = "A" | "B"; function foo(bar: Bar) {} + +type Foo = { disjoint: "A", n: number } | { disjoint: "B", s: string }; + +type Foo = { n: number } & { s: string }; + +type Bar = { n: number } & { s: string }; function foo(bar: Bar) {} + +// Options: ["never"] +function foo(bar: "A" | "B") {} + +// Options: ["never"] +function foo(bar: { n: number } & { s: string }) {} +``` + + + + +### require-exact-type + +This rule enforces [exact object types](https://flow.org/en/docs/types/objects/#toc-exact-object-types). + + +#### Options + +The rule has one string option: + +* `"always"` (default): Report all object type definitions that aren't exact. +* `"never"`: Report all object type definitions that are exact. + +```js +{ + "rules": { + "flowtype/require-exact-type": [ + 2, + "always" + ] + } +} + +{ + "rules": { + "flowtype/require-exact-type": [ + 2, + "never" + ] + } +} +``` + +The following patterns are considered problems: + +```js +type foo = {}; +// Message: Type identifier 'foo' must be exact. + +type foo = { bar: string }; +// Message: Type identifier 'foo' must be exact. + +// Options: ["always"] +type foo = {}; +// Message: Type identifier 'foo' must be exact. + +// Options: ["always"] +type foo = { bar: string }; +// Message: Type identifier 'foo' must be exact. + +// Options: ["never"] +type foo = {| |}; +// Message: Type identifier 'foo' must not be exact. + +// Options: ["never"] +type foo = {| bar: string |}; +// Message: Type identifier 'foo' must not be exact. +``` + +The following patterns are not considered problems: + +```js +type foo = {| |}; + +type foo = {| bar: string |}; + +type foo = { [key: string]: string }; + +type foo = number; + +// Options: ["always"] +type foo = {| |}; + +// Options: ["always"] +type foo = {| bar: string |}; + +// Options: ["always"] +type foo = number; + +// Options: ["never"] +type foo = { }; + +// Options: ["never"] +type foo = { bar: string }; + +// Options: ["never"] +type foo = number; +``` + + + + +### require-parameter-type + +Requires that all function parameters have type annotations. + + +#### Options + +You can skip all arrow functions by providing the `excludeArrowFunctions` option with `true`. + +Alternatively, you can want to exclude only concise arrow functions (e.g. `x => x * 2`). Provide `excludeArrowFunctions` with `expressionsOnly` for this. + +```js +{ + "rules": { + "flowtype/require-parameter-type": [ + 2, + { + "excludeArrowFunctions": true + } + ] + } +} + +{ + "rules": { + "flowtype/require-parameter-type": [ + 2, + { + "excludeArrowFunctions": "expressionsOnly" + } + ] + } +} +``` + +You can exclude parameters that match a certain regex by using `excludeParameterMatch`. + +```js +{ + "rules": { + "flowtype/require-parameter-type": [ + 2, + { + "excludeParameterMatch": "^_" + } + ] + } +} +``` + +This excludes all parameters that start with an underscore (`_`). +The default pattern is `a^`, which doesn't match anything, i.e., all parameters are checked. + +The following patterns are considered problems: + +```js +(foo) => {} +// Message: Missing "foo" parameter type annotation. + +function x(foo) {} +// Message: Missing "foo" parameter type annotation. + +// Options: [{"excludeArrowFunctions":true}] +function x(foo) {} +// Message: Missing "foo" parameter type annotation. + +(foo = 'FOO') => {} +// Message: Missing "foo" parameter type annotation. + +(...foo) => {} +// Message: Missing "foo" parameter type annotation. + +({foo}) => {} +// Message: Missing "{foo}" parameter type annotation. + +([foo]) => {} +// Message: Missing "[foo]" parameter type annotation. + +({foo = 1} = {}) => {} +// Message: Missing "{foo = 1}" parameter type annotation. + +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +// @flow +(foo) => {} +// Message: Missing "foo" parameter type annotation. + +// Options: [{"excludeArrowFunctions":"expressionsOnly"}] +(foo) => {} +// Message: Missing "foo" parameter type annotation. + +// Options: [{"excludeArrowFunctions":"expressionsOnly"}] +function x(foo) {} +// Message: Missing "foo" parameter type annotation. + +// Options: [{"excludeParameterMatch":"^_"}] +(_foo: number, bar) => {} +// Message: Missing "bar" parameter type annotation. + +// Options: [{"excludeParameterMatch":"^_"}] +(_foo, bar) => {} +// Message: Missing "bar" parameter type annotation. +``` + +The following patterns are not considered problems: + +```js +(foo: string) => {} + +(foo: string = 'FOO') => {} + +(...foo: string) => {} + +({foo}: {foo: string}) => {} + +([foo]: Array) => {} + +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +(foo) => {} + +// Options: [{"excludeArrowFunctions":true}] +(foo) => {} + +// Options: [{"excludeArrowFunctions":"expressionsOnly"}] +(foo) => 3 + +// Options: [{"excludeParameterMatch":"^_"}] +(_foo, bar: string) => {} + +// Options: [{"excludeParameterMatch":"^_"}] +(_foo: number, bar: string) => {} + +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +(foo) => {} +``` + + + + +### require-return-type + +Requires that functions have return type annotation. + + +#### Options + +You can skip all arrow functions by providing the `excludeArrowFunctions` option with `true`. + +Alternatively, you can exclude a concise arrow function (e.g. `() => 2`). Provide `excludeArrowFunctions` with `expressionsOnly` for this. + +```js +{ + "rules": { + "flowtype/require-return-type": [ + 2, + "always", + { + "excludeArrowFunctions": true + } + ] + } +} + +{ + "rules": { + "flowtype/require-return-type": [ + 2, + "always", + { + "excludeArrowFunctions": "expressionsOnly" + } + ] + } +} +``` + +You can exclude or include specific tests with the `includeOnlyMatching` and `excludeMatching` rules. + +```js +{ + "rules": { + "flowtype/require-return-type": [ + 2, + "always", + { + "includeOnlyMatching": [ + "^F.*", + "Ba(r|z)" + ] + } + ] + } +} + +{ + "rules": { + "flowtype/require-return-type": [ + 2, + "always", + { + "excludeMatching": [ + "^F.*", + "Ba(r|z)" + ] + } + ] + } +} + +``` + +Both rules take an array that can contain either strings or valid RegExp statements. + +The following patterns are considered problems: + +```js +(foo) => { return "foo"; } +// Message: Missing return type annotation. + +// Options: ["always"] +(foo) => { return "foo"; } +// Message: Missing return type annotation. + +// Options: ["always"] +(foo) => "foo" +// Message: Missing return type annotation. + +(foo) => ({}) +// Message: Missing return type annotation. + +(foo): undefined => { return; } +// Message: Must not annotate undefined return type. + +(foo): void => { return; } +// Message: Must not annotate undefined return type. + +(foo): undefined => { return undefined; } +// Message: Must not annotate undefined return type. + +(foo): void => { return void 0; } +// Message: Must not annotate undefined return type. + +// Options: ["always",{"annotateUndefined":"never"}] +(foo): undefined => { return; } +// Message: Must not annotate undefined return type. + +// Options: ["always",{"annotateUndefined":"never"}] +(foo): void => { return; } +// Message: Must not annotate undefined return type. + +// Options: ["always",{"annotateUndefined":"always"}] +(foo) => { return; } +// Message: Must annotate undefined return type. + +// Options: ["always",{"annotateUndefined":"never"}] +(foo): undefined => { return undefined; } +// Message: Must not annotate undefined return type. + +// Options: ["always",{"annotateUndefined":"always"}] +(foo) => { return undefined; } +// Message: Must annotate undefined return type. + +// Options: ["always",{"annotateUndefined":"always"}] +(foo) => { return void 0; } +// Message: Must annotate undefined return type. + +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +// @flow +(foo) => { return 1; } +// Message: Missing return type annotation. + +// Options: ["always",{"annotateUndefined":"always"}] +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +// @flow + (foo) => { return undefined; } +// Message: Must annotate undefined return type. + +// Options: ["always"] +async () => { return 2; } +// Message: Missing return type annotation. + +// Options: ["always",{"annotateUndefined":"always"}] +async () => {} +// Message: Missing return type annotation. + +// Options: ["always",{"annotateUndefined":"always"}] +async function x() {} +// Message: Missing return type annotation. + +// Options: ["always",{"annotateUndefined":"always"}] +class Test { constructor() { } } +// Message: Must annotate undefined return type. + +class Test { foo() { return 42; } } +// Message: Missing return type annotation. + +class Test { foo = () => { return 42; } } +// Message: Missing return type annotation. + +class Test { foo = () => 42; } +// Message: Missing return type annotation. + +// Options: ["always"] +async () => { return; } +// Message: Missing return type annotation. + +// Options: ["always"] +function* x() {} +// Message: Missing return type annotation. + +// Options: ["always",{"excludeArrowFunctions":"expressionsOnly"}] +() => { return 3; } +// Message: Missing return type annotation. + +// Options: ["always",{"excludeArrowFunctions":"expressionsOnly"}] +async () => { return 4; } +// Message: Missing return type annotation. + +// Options: ["always",{"includeOnlyMatching":["bar"]}] +function foo() { return 42; } +function bar() { return 42; } +// Message: Missing return type annotation. + +// Options: ["always",{"includeOnlyMatching":["bar"]}] +const foo = () => { return 42; }; +const bar = () => { return 42; } +// Message: Missing return type annotation. +``` + +The following patterns are not considered problems: + +```js +return; + +(foo): string => {} + +// Options: ["always"] +(foo): string => {} + +(foo) => { return; } + +(foo): Object => ( {} ) + +(foo) => { return undefined; } + +(foo) => { return void 0; } + +// Options: ["always",{"annotateUndefined":"always"}] +(foo): undefined => { return; } + +// Options: ["always",{"annotateUndefined":"always"}] +(foo): void => { return; } + +// Options: ["always",{"annotateUndefined":"never"}] +(foo) => { return; } + +// Options: ["always",{"annotateUndefined":"never"}] +(foo) => { return undefined; } + +// Options: ["always",{"annotateUndefined":"never"}] +(foo) => { return void 0; } + +// Options: ["always",{"annotateUndefined":"always"}] +(foo): undefined => { return undefined; } + +// Options: ["always",{"annotateUndefined":"always"}] +(foo): void => { return void 0; } + +// Options: ["always"] +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +(foo) => { return 1; } + +// Options: ["always",{"annotateUndefined":"always"}] +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +(foo) => { return undefined; } + +// Options: ["always",{"annotateUndefined":"always"}] +async function doThing(): Promise {} + +// Options: ["always",{"annotateUndefined":"always"}] +function* doThing(): Generator { yield 2; } + +// Options: ["always",{"annotateUndefined":"always","excludeMatching":["constructor"]}] +class Test { constructor() { } } + +class Test { constructor() { } } + +// Options: ["always",{"excludeMatching":["foo"]}] +class Test { foo() { return 42; } } + +// Options: ["always",{"excludeMatching":["foo"]}] +class Test { foo = () => { return 42; } } + +// Options: ["always",{"excludeMatching":["foo"]}] +class Test { foo = () => 42; } + +class Test { foo = (): number => { return 42; } } + +class Test { foo = (): number => 42; } + +async (foo): Promise => { return 3; } + +// Options: ["always",{"excludeArrowFunctions":true}] +() => 3 + +// Options: ["always",{"excludeArrowFunctions":true}] +() => { return 4; } + +// Options: ["always",{"excludeArrowFunctions":true}] +() => undefined + +// Options: ["always",{"annotateUndefined":"always","excludeArrowFunctions":true}] +() => undefined + +// Options: ["always",{"annotateUndefined":"always","excludeArrowFunctions":true}] +() => { return undefined; } + +// Options: ["always",{"excludeArrowFunctions":"expressionsOnly"}] +() => 3 + +// Options: ["always",{"excludeArrowFunctions":"expressionsOnly"}] +async () => 3 + +// Options: ["always",{"excludeMatching":["foo"]}] +function foo() { return 42; } + +// Options: ["always",{"includeOnlyMatching":["bar"]}] +function foo() { return 42; } + +// Options: ["always",{"excludeMatching":["bar"]}] +function foo(): number { return 42; } +function bar() { return 42; } + +// Options: ["always",{"includeOnlyMatching":["foo","baz"]}] +function foo(): number { return 42; } +function bar() { return 42; } + +// Options: ["always",{"excludeMatching":["^b.*","qux"]}] +function foo(): number { return 42; } +function bar() { return 42; } + +// Options: ["always",{"includeOnlyMatching":["^f.*"]}] +function foo(): number { return 42; } +function bar() { return 42; } +``` + + + + +### require-types-at-top + +Requires all type declarations to be at the top of the file, after any import declarations. + + +#### Options + +The rule has a string option: + +* `"never"` +* `"always"` + +The default value is `"always"`. + +The following patterns are considered problems: + +```js +const foo = 3; +type Foo = number; +// Message: All type declaration should be at the top of the file, after any import declarations. + +const foo = 3; +opaque type Foo = number; +// Message: All type declaration should be at the top of the file, after any import declarations. + +const foo = 3; +export type Foo = number; +// Message: All type declaration should be at the top of the file, after any import declarations. + +const foo = 3; +export opaque type Foo = number; +// Message: All type declaration should be at the top of the file, after any import declarations. + +const foo = 3; +type Foo = number | string; +// Message: All type declaration should be at the top of the file, after any import declarations. + +import bar from "./bar"; +const foo = 3; +type Foo = number; +// Message: All type declaration should be at the top of the file, after any import declarations. +``` + +The following patterns are not considered problems: + +```js +type Foo = number; +const foo = 3; + +opaque type Foo = number; +const foo = 3; + +export type Foo = number; +const foo = 3; + +export opaque type Foo = number; +const foo = 3; + +type Foo = number; +const foo = 3; + +import bar from "./bar"; +type Foo = number; + +type Foo = number; +import bar from "./bar"; + +// Options: ["never"] +const foo = 3; +type Foo = number; +``` + + + + +### require-valid-file-annotation + +This rule validates Flow file annotations. + +This rule can optionally report missing or missed placed annotations, common typos (e.g. `// @floww`), and enforce a consistant annotation style. + + +#### Options + +The rule has a string option: + +* `"never"` (default): Never report files that are missing an `@flow` annotation. +* `"always"`: Always report files that are missing an `@flow` annotation + +This rule has an object option: + +* `"annotationStyle"` - Enforce a consistant file annotation style. + * `"none"` (default): Either annotation style is accepted. + * `"line"`: Require single line annotations (i.e. `// @flow`). + * `"block"`: Require block annotations (i.e. `/* @flow */`). + +```js +{ + "rules": { + "flowtype/require-valid-file-annotation": [ + 2, + "always" + ] + } +} + +{ + "rules": { + "flowtype/require-valid-file-annotation": [ + 2, + "always", { + "annotationStyle": "block" + } + ] + } +} +``` + +The following patterns are considered problems: + +```js +;// @flow +// Message: Flow file annotation not at the top of the file. + +; +// @flow +// Message: Flow file annotation not at the top of the file. + +// @Flow +// Message: Malformed Flow file annotation. + +// @NoFlow +// Message: Malformed Flow file annotation. + +// @Noflow +// Message: Malformed Flow file annotation. + +// @floweeeeeee +// Message: Misspelled or malformed Flow file annotation. + +// @nofloweeeeeee +// Message: Misspelled or malformed Flow file annotation. + +// Options: ["always"] +a; +// Message: Flow file annotation is missing. + +// Options: ["always",{"annotationStyle":"line"}] +/* @flow */ +// Message: Flow file annotation style must be `// @flow` + +// Options: ["always",{"annotationStyle":"block"}] +// @flow +// Message: Flow file annotation style must be `/* @flow */` + +// Options: ["always",{"annotationStyle":"line"}] +/* @noflow */ +// Message: Flow file annotation style must be `// @noflow` + +// Options: ["always",{"annotationStyle":"block"}] +// @noflow +// Message: Flow file annotation style must be `/* @noflow */` + +// Options: ["always"] +a; +// Message: Flow file annotation is missing. + +// Options: ["always",{"annotationStyle":"block"}] +a; +// Message: Flow file annotation is missing. +``` + +The following patterns are not considered problems: + +```js +a; + +// @flow +a; + +//@flow +a; + +//**@flow +a; + +/* foo @flow bar */ +a; + + + +// @flow +a; + +// @flow +// @FLow + +// @noflow +a; + +// Options: ["always"] +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +a; + +// Options: ["always",{"annotationStyle":"line"}] +// @flow + +// Options: ["never",{"annotationStyle":"none"}] +// @function + +// Options: ["never"] +// @fixable + +// Options: ["always",{"annotationStyle":"block"}] +/* @flow */ +``` + + + + +### require-variable-type + +Requires that all variable declarators have type annotations. + + +#### Options + +You can exclude variables that match a certain regex by using `excludeVariableMatch`. + +This excludes all parameters that start with an underscore (`_`). +The default pattern is `a^`, which doesn't match anything, i.e., all parameters are checked. + +```js +{ + "rules": { + "flowtype/require-variable-type": [ + 2, + { + "excludeVariableMatch": "^_" + } + ] + } +} +``` + + +You can choose specific variable types (`var`, `let`, and `const`) to ignore using `excludeVariableTypes`. + +This excludes `var` and `let` declarations from needing type annotations, but forces `const` declarations to have it. +By default, all declarations are checked. + +```js +{ + "rules": { + "flowtype/require-variable-type": [ + 2, + { + "excludeVariableTypes": { + "var": true, + "let": true, + "const": false, + } + } + ] + } +} +``` + + + +The following patterns are considered problems: + +```js +var foo = "bar" +// Message: Missing "foo" variable type annotation. + +var foo : string = "bar", bar = 1 +// Message: Missing "bar" variable type annotation. + +// Options: [{"excludeVariableMatch":"^_"}] +var _foo = "bar", bar = 1 +// Message: Missing "bar" variable type annotation. + +// Options: [{"excludeVariableTypes":{"let":false,"var":true}}] +var foo = "bar", bar = 1; const oob : string = "oob"; let hey = "yah" +// Message: Missing "hey" variable type annotation. +``` + +The following patterns are not considered problems: + +```js +var foo : string = "bar" + +var foo : string = "bar", bar : number = 1 + +// Options: [{"excludeVariableMatch":"^_"}] +var _foo = "bar", bar : number = 1 + +// Options: [{"excludeVariableTypes":{"var":true}}] +var foo = "bar", bar = 1 + +// Options: [{"excludeVariableTypes":{"let":true,"var":true}}] +var foo = "bar", bar = 1; const oob : string = "oob"; let hey = "yah" +``` + + + + +### semi + +_The `--fix` option on the command line automatically fixes problems reported by this rule._ + +Enforces consistent use of semicolons after type aliases. + +This rule takes one argument. If it is `'never'` then a problem is raised when there is a semicolon after a type alias. If it is `'always'` then a problem is raised when there is no semicolon after a type alias. + +The default value is `'always'`. + +The following patterns are considered problems: + +```js +// Options: [] +type FooType = {} +// Message: Missing semicolon. + +// Options: ["always"] +type FooType = {} +// Message: Missing semicolon. + +// Options: ["never"] +type FooType = {}; +// Message: Extra semicolon. + +// Options: [] +opaque type FooType = {} +// Message: Missing semicolon. +``` + +The following patterns are not considered problems: + +```js +type FooType = {}; + +// Options: ["always"] +type FooType = {}; + +// Options: ["always"] +type FooType = { a: number; + b: string; + }; + +// Options: ["never"] +type FooType = { a: number; + b: string; + } + +// Options: ["never"] +type FooType = {} + +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +type FooType = {} + +opaque type FooType = {}; +``` + + + + +### sort-keys + +_The `--fix` option on the command line automatically fixes problems reported by this rule._ + +Enforces sorting of Object annotations. + +This rule mirrors ESlint's [sort-keys](http://eslint.org/docs/rules/sort-keys) rule. + + +#### Options + +The first option specifies sort order. + +* `"asc"` (default) - enforce ascending sort order. +* `"desc"` - enforce descending sort order. + +The second option takes an object with two possible properties. + +* `caseSensitive` - if `true`, enforce case-sensitive sort order. Default is `true`. +* `natural` - if `true`, enforce [natural sort order](https://en.wikipedia.org/wiki/Natural_sort_order). Default is `false`. + +```js +{ + "rules": { + "flowtype/sort-keys": [ + 2, + "asc", { + "caseSensitive": true, + "natural": false + } + ] + } +} +``` + +The following patterns are considered problems: + +```js +type FooType = { a: number, c: number, b: string } +// Message: Expected type annotations to be in ascending order. "b" should be before "c". + +type FooType = { a: number, b: number, C: number } +// Message: Expected type annotations to be in ascending order. "C" should be before "b". + +type FooType = { 1: number, 2: number, 10: number } +// Message: Expected type annotations to be in ascending order. "10" should be before "2". + +// Options: ["desc"] +type FooType = { a: number, b: number } +// Message: Expected type annotations to be in descending order. "b" should be before "a". + +// Options: ["desc"] +type FooType = { C: number, b: number, a: string } +// Message: Expected type annotations to be in descending order. "b" should be before "C". + +// Options: ["desc"] +type FooType = { 10: number, 2: number, 1: number } +// Message: Expected type annotations to be in descending order. "2" should be before "10". + +// Options: ["asc",{"caseSensitive":false}] +type FooType = { a: number, c: number, C: number, b: string } +// Message: Expected type annotations to be in insensitive ascending order. "b" should be before "C". + +// Options: ["asc",{"caseSensitive":false}] +type FooType = { a: number, C: number, c: number, b: string } +// Message: Expected type annotations to be in insensitive ascending order. "b" should be before "c". + +// Options: ["asc",{"natural":true}] +type FooType = { 1: number, 10: number, 2: boolean } +// Message: Expected type annotations to be in natural ascending order. "2" should be before "10". + +type FooType = { a: number, c: number, b: string } +// Message: Expected type annotations to be in ascending order. "b" should be before "c". + + + type FooType = { + a: number, + c: number, + b: string, + } + +// Message: Expected type annotations to be in ascending order. "b" should be before "c". + + + type FooType = { + +a: number, + c: number, + b: string, + } + +// Message: Expected type annotations to be in ascending order. "b" should be before "c". + + + type FooType = { + -a: number, + c: number, + b: string, + } + +// Message: Expected type annotations to be in ascending order. "b" should be before "c". + + + type FooType = { + a?: number, + c: ?number, + b: string, + } + +// Message: Expected type annotations to be in ascending order. "b" should be before "c". + + + type FooType = { + a: (number) => void, + c: number, + b: (param: string) => number, + } + +// Message: Expected type annotations to be in ascending order. "b" should be before "c". + + + type FooType = { + a: number | string | boolean, + c: number, + b: (param: string) => number, + } + +// Message: Expected type annotations to be in ascending order. "b" should be before "c". + + + type FooType = { + c: number, + a: number | string | boolean, + b: (param: string) => number, + } + +// Message: Expected type annotations to be in ascending order. "a" should be before "c". + + + type FooType = { + c: { + z: number, + x: string, + y: boolean, + }, + a: number | string | boolean, + b: (param: string) => number, + } + +// Message: Expected type annotations to be in ascending order. "x" should be before "z". +// Message: Expected type annotations to be in ascending order. "a" should be before "c". + + + type FooType = { + c: { + z: { + j: string, + l: number, + k: boolean, + }, + x: string, + y: boolean, + }, + a: number | string | boolean, + b: (param: string) => number, + } + +// Message: Expected type annotations to be in ascending order. "k" should be before "l". +// Message: Expected type annotations to be in ascending order. "x" should be before "z". +// Message: Expected type annotations to be in ascending order. "a" should be before "c". + + + type FooType = { + +c: number, + -b: number, + a: number, + } + +// Message: Expected type annotations to be in ascending order. "b" should be before "c". +// Message: Expected type annotations to be in ascending order. "a" should be before "b". + + + type FooType = {| + +c: number, + -b: number, + a: number, + |} + +// Message: Expected type annotations to be in ascending order. "b" should be before "c". +// Message: Expected type annotations to be in ascending order. "a" should be before "b". +``` + +The following patterns are not considered problems: + +```js +type FooType = { a: number } + +type FooType = { a: number, b: number, c: (boolean | number) } + +type FooType = { C: number, a: string, b: foo } + +type FooType = { 1: number, 10: number, 2: boolean } + +// Options: ["desc"] +type FooType = { c: number, b: number, a: number } + +// Options: ["desc"] +type FooType = { b: string, a: {}, C: number } + +// Options: ["desc"] +type FooType = { 2: number, 10: number, 1: boolean } + +// Options: ["asc",{"caseSensitive":false}] +type FooType = { a: number, b: number, c: number, C: number } + +// Options: ["asc",{"caseSensitive":false}] +type FooType = { a: number, b: number, C: number, c: number } + +// Options: ["asc",{"natural":true}] +type FooType = { 1:number, 2: number, 10: number } + +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +type FooType = { b: number, a: number } +``` + + + + +### space-after-type-colon + +_The `--fix` option on the command line automatically fixes problems reported by this rule._ + +Enforces consistent spacing after the type annotation colon. + + +#### Options + +This rule has a string argument. + +* `"always"` (default): Require a space after the type annotation colon (e.g. foo: BarType). +* `"never"`: Require no spaces after the type annotation colon (e.g. foo:BarType). + +This rule has an option object. + +* `"allowLineBreak"` - Allow a line break to count as a space following the annotation colon. + * `"true"`: Enable + * `"false"`: Disable + +{ + "rules": { + "flowtype/space-after-type-colon": [ + 2, + "always", { + "allowLineBreak": false + } + ] + } +} + +The following patterns are considered problems: + +```js +// Options: ["never"] +(foo: string) => {} +// Message: There must be no space after "foo" parameter type annotation colon. + +// Options: ["always"] +(foo: string) => {} +// Message: There must be 1 space after "foo" parameter type annotation colon. + +// Options: ["always"] +(foo:(() => void)) => {} +// Message: There must be a space after "foo" parameter type annotation colon. + +// Options: ["never"] +(foo: (() => void)) => {} +// Message: There must be no space after "foo" parameter type annotation colon. + +// Options: ["always"] +(foo: (() => void)) => {} +// Message: There must be 1 space after "foo" parameter type annotation colon. + +({ lorem, ipsum, dolor } : SomeType) => {} +// Message: There must be 1 space after "{ lorem, ipsum, dolor }" parameter type annotation colon. + +(foo:{ a: string, b: number }) => {} +// Message: There must be a space after "foo" parameter type annotation colon. + +({ a, b } :{ a: string, b: number }) => {} +// Message: There must be a space after "{ a, b }" parameter type annotation colon. + +([ a, b ] :string[]) => {} +// Message: There must be a space after "[ a, b ]" parameter type annotation colon. + +(i?:number) => {} +// Message: There must be a space after "i" parameter type annotation colon. + +(i?: number) => {} +// Message: There must be 1 space after "i" parameter type annotation colon. + +// Options: ["never"] +(i?: number) => {} +// Message: There must be no space after "i" parameter type annotation colon. + +(foo: + { a: string, b: number }) => {} +// Message: There must not be a line break after "foo" parameter type annotation colon. + +(foo: +{ a: string, b: number }) => {} +// Message: There must not be a line break after "foo" parameter type annotation colon. + +(foo: +{ a: string, b: number }) => {} +// Message: There must not be a line break after "foo" parameter type annotation colon. + +// Options: ["always"] +():Object => {} +// Message: There must be a space after return type colon. + +// Options: ["never"] +(): Object => {} +// Message: There must be no space after return type colon. + +// Options: ["always"] +(): Object => {} +// Message: There must be 1 space after return type colon. + +// Options: ["always"] +():(() => void) => {} +// Message: There must be a space after return type colon. + +// Options: ["never"] +(): (() => void) => {} +// Message: There must be no space after return type colon. + +// Options: ["always"] +(): (() => void) => {} +// Message: There must be 1 space after return type colon. + +// Options: ["never"] +export default function (foo: string) {} +// Message: There must be no space after "foo" parameter type annotation colon. + +// Options: ["never"] +function foo (foo: string) {} +// Message: There must be no space after "foo" parameter type annotation colon. + +// Options: ["always"] +(foo:string) => {} +// Message: There must be a space after "foo" parameter type annotation colon. + +function foo (foo:string) {} +// Message: There must be a space after "foo" parameter type annotation colon. + +async function foo({ lorem, ipsum, dolor }:SomeType) {} +// Message: There must be a space after "{ lorem, ipsum, dolor }" parameter type annotation colon. + +function x(i?:number) {} +// Message: There must be a space after "i" parameter type annotation colon. + +function x(i?: number) {} +// Message: There must be 1 space after "i" parameter type annotation colon. + +// Options: ["never"] +function x(i?: number) {} +// Message: There must be no space after "i" parameter type annotation colon. + +function a():x {} +// Message: There must be a space after return type colon. + +// Options: ["always"] +function a(): x {} +// Message: There must be 1 space after return type colon. + +// Options: ["never"] +function a(): x {} +// Message: There must be no space after return type colon. + +type X = (foo:number) => string +// Message: There must be a space after "foo" parameter type annotation colon. + +// Options: ["never"] +type X = (foo: number) => string +// Message: There must be no space after "foo" parameter type annotation colon. + +type X = (foo: number) => string +// Message: There must be 1 space after "foo" parameter type annotation colon. + +type X = (foo:?number) => string +// Message: There must be a space after "foo" parameter type annotation colon. + +type X = (foo:(number)) => string +// Message: There must be a space after "foo" parameter type annotation colon. + +type X = (foo:((number))) => string +// Message: There must be a space after "foo" parameter type annotation colon. + +type X = (foo: ((number))) => string +// Message: There must be 1 space after "foo" parameter type annotation colon. + +// Options: ["never"] +type X = (foo: ((number))) => string +// Message: There must be no space after "foo" parameter type annotation colon. + +type X = (foo:?(number)) => string +// Message: There must be a space after "foo" parameter type annotation colon. + +type TArrayPredicate = (el: T, i?:number) => boolean +// Message: There must be a space after "i" parameter type annotation colon. + +type TArrayPredicate = (el: T, i?: number) => boolean +// Message: There must be 1 space after "i" parameter type annotation colon. + +// Options: ["never"] +type TArrayPredicate = (el:T, i?: number) => boolean +// Message: There must be no space after "i" parameter type annotation colon. + +class X { foo:string } +// Message: There must be a space after "foo" class property type annotation colon. + +// Options: ["never"] +class X { foo: string } +// Message: There must be no space after "foo" class property type annotation colon. + +class X { foo:?string } +// Message: There must be a space after "foo" class property type annotation colon. + +// Options: ["never"] +class X { foo: ?string } +// Message: There must be no space after "foo" class property type annotation colon. + +class X { static foo:number } +// Message: There must be a space after "foo" class property type annotation colon. + +// Options: ["never"] +class X { static foo: number } +// Message: There must be no space after "foo" class property type annotation colon. + +class X { static foo :number } +// Message: There must be a space after "foo" class property type annotation colon. + +// Options: ["never"] +class X { static foo : number } +// Message: There must be no space after "foo" class property type annotation colon. + +declare class X { static foo:number } +// Message: There must be a space after "foo" type annotation colon. + +// Options: ["never"] +declare class X { static foo: number } +// Message: There must be no space after "foo" type annotation colon. + +declare class X { static foo :number } +// Message: There must be a space after "foo" type annotation colon. + +// Options: ["never"] +declare class X { static foo : number } +// Message: There must be no space after "foo" type annotation colon. + +class X { +foo:string } +// Message: There must be a space after "foo" class property type annotation colon. + +class X { +foo: string } +// Message: There must be 1 space after "foo" class property type annotation colon. + +// Options: ["never"] +class X { +foo: string } +// Message: There must be no space after "foo" class property type annotation colon. + +class X { static +foo:string } +// Message: There must be a space after "foo" class property type annotation colon. + +class X { static +foo: string } +// Message: There must be 1 space after "foo" class property type annotation colon. + +// Options: ["never"] +class X { static +foo: string } +// Message: There must be no space after "foo" class property type annotation colon. + +type X = { foo:string } +// Message: There must be a space after "foo" type annotation colon. + +// Options: ["always"] +type X = { foo:string } +// Message: There must be a space after "foo" type annotation colon. + +// Options: ["never"] +type X = { foo: string } +// Message: There must be no space after "foo" type annotation colon. + +type X = { foo: string } +// Message: There must be 1 space after "foo" type annotation colon. + +type X = { foo?:string } +// Message: There must be a space after "foo" type annotation colon. + +// Options: ["never"] +type X = { foo?: string } +// Message: There must be no space after "foo" type annotation colon. + +type X = { foo?:?string } +// Message: There must be a space after "foo" type annotation colon. + +type X = { foo?: ?string } +// Message: There must be 1 space after "foo" type annotation colon. + +type Foo = { barType:(string | () => void) } +// Message: There must be a space after "barType" type annotation colon. + +type Foo = { barType:(((string | () => void))) } +// Message: There must be a space after "barType" type annotation colon. + +// Options: ["never"] +type Foo = { barType: (string | () => void) } +// Message: There must be no space after "barType" type annotation colon. + +type Foo = { barType: (string | () => void) } +// Message: There must be 1 space after "barType" type annotation colon. + +type Foo = { barType: ((string | () => void)) } +// Message: There must be 1 space after "barType" type annotation colon. + +type X = { get:() => A; } +// Message: There must be a space after "get" type annotation colon. + +type X = { get:() => A; } +// Message: There must be a space after "get" type annotation colon. + +// Options: ["never"] +type X = { get: () => A; } +// Message: There must be no space after "get" type annotation colon. + +// Options: ["never"] +type X = { get: () => A; } +// Message: There must be no space after "get" type annotation colon. + +type X = { get: () => A; } +// Message: There must be 1 space after "get" type annotation colon. + +type X = { get: () => A; } +// Message: There must be 1 space after "get" type annotation colon. + +type X = { +foo:string } +// Message: There must be a space after "foo" type annotation colon. + +type X = { +foo: string } +// Message: There must be 1 space after "foo" type annotation colon. + +// Options: ["never"] +type X = { +foo: string } +// Message: There must be no space after "foo" type annotation colon. + +type X = { +foo?:string } +// Message: There must be a space after "foo" type annotation colon. + +type X = { +foo?: string } +// Message: There must be 1 space after "foo" type annotation colon. + +// Options: ["never"] +type X = { +foo?: string } +// Message: There must be no space after "foo" type annotation colon. + +// Options: ["always"] +type X = { [a:b]: c } +// Message: There must be a space after type annotation colon. + +// Options: ["never"] +type X = { [a: b]:c } +// Message: There must be no space after type annotation colon. + +// Options: ["always"] +type X = { [a: b]: c } +// Message: There must be 1 space after type annotation colon. + +// Options: ["always"] +type X = { +[a:b]: c } +// Message: There must be a space after type annotation colon. + +// Options: ["never"] +type X = { +[a: b]:c } +// Message: There must be no space after type annotation colon. + +// Options: ["always"] +type X = { +[a: b]: c } +// Message: There must be 1 space after type annotation colon. + +// Options: ["always"] +type X = { [a: b]:c } +// Message: There must be a space after type annotation colon. + +// Options: ["never"] +type X = { [a:b]: c } +// Message: There must be no space after type annotation colon. + +// Options: ["always"] +type X = { [a: b]: c } +// Message: There must be 1 space after type annotation colon. + +// Options: ["always"] +type X = { [a:b]:c } +// Message: There must be a space after type annotation colon. +// Message: There must be a space after type annotation colon. + +// Options: ["never"] +type X = { [a: b]: c } +// Message: There must be no space after type annotation colon. +// Message: There must be no space after type annotation colon. + +// Options: ["always"] +type X = { [a: b]: c } +// Message: There must be 1 space after type annotation colon. +// Message: There must be 1 space after type annotation colon. + +// Options: ["always"] +type X = { [a:(b)]:(c) } +// Message: There must be a space after type annotation colon. +// Message: There must be a space after type annotation colon. + +// Options: ["never"] +type X = { [a: (b)]: (c) } +// Message: There must be no space after type annotation colon. +// Message: There must be no space after type annotation colon. + +// Options: ["never"] +const x = ({}: {}) +// Message: There must be no space after type cast colon. + +// Options: ["always"] +const x = ({}:{}) +// Message: There must be a space after type cast colon. + +// Options: ["always"] +const x = ({}: {}) +// Message: There must be 1 space after type cast colon. + +// Options: ["never"] +((x): (string)) +// Message: There must be no space after type cast colon. + +// Options: ["always"] +((x):(string)) +// Message: There must be a space after type cast colon. + +// Options: ["always"] +((x): (string)) +// Message: There must be 1 space after type cast colon. + +// Options: ["always"] +const x:number = 7; +// Message: There must be a space after const type annotation colon. + +// Options: ["always"] +let x:number = 42; +// Message: There must be a space after let type annotation colon. + +// Options: ["always"] +var x:number = 42; +// Message: There must be a space after var type annotation colon. +``` + +The following patterns are not considered problems: + +```js +(foo) => {} + +(foo: string) => {} + +(foo: (string|number)) => {} + +// Options: ["never"] +(foo:string) => {} + +// Options: ["always"] +(foo: string) => {} + +// Options: ["never"] +(foo:(() => void)) => {} + +// Options: ["always"] +(foo: (() => void)) => {} + +({ lorem, ipsum, dolor }: SomeType) => {} + +(foo: { a: string, b: number }) => {} + +({ a, b }: ?{ a: string, b: number }) => {} + +([ a, b ]: string[]) => {} + +(i?: number) => {} + +// Options: ["never"] +(i?:number) => {} + +// Options: ["always",{"allowLineBreak":true}] +(foo: + { a: string, b: number }) => {} + +// Options: ["always",{"allowLineBreak":true}] +(foo: + { a: string, b: number }) => {} + +// Options: ["never"] +():Object => {} + +// Options: ["always"] +(): Object => {} + +// Options: ["never"] +():(number | string) => {} + +// Options: ["always"] +(): (number | string) => {} + +// Options: ["never"] +():number|string => {} + +// Options: ["always"] +(): number|string => {} + +// Options: ["never"] +():(() => void) => {} + +// Options: ["always"] +(): (() => void) => {} + +// Options: ["never"] +():( () => void ) => {} + +// Options: ["always"] +(): ( () => void ) => {} + +(): { a: number, b: string } => {} + +// Options: ["never"] +() :{ a:number, b:string } => {} + +function x(foo: string) {} + +class Foo { constructor(foo: string) {} } + +// Options: ["never"] +function x(foo:string) {} + +// Options: ["never"] +class Foo { constructor(foo:string) {} } + +async function foo({ lorem, ipsum, dolor }: SomeType) {} + +function x({ a, b }: { a: string, b: number }) {} + +function x(i?: number) {} + +// Options: ["never"] +function x(i?:number) {} + +function a(): x {} + +// Options: ["never"] +function a():x {} + +function a(): (number | string) {} + +// Options: ["never"] +function a() :(number | string) {} + +type X = (foo: number) => string; + +type X = (foo : number) => string; + +type X = (foo: ?number) => string; + +type X = (foo? : ?number) => string; + +type X = (foo: ?{ x: number }) => string; + +// Options: ["never"] +type X = (foo:number) => string; + +// Options: ["never"] +type X = (foo:?{ x:number }) => string; + +type X = (foo: (number)) => string + +type X = (foo: ((number))) => string + +// Options: ["never"] +type X = (foo:((number))) => string + +type X = ?(foo: ((number))) => string + +// Options: ["never"] +type X = ?(foo:((number))) => string + +type TArrayPredicate = (el: T, i?: number) => boolean + +// Options: ["never"] +type TArrayPredicate = (el:T, i?:number) => boolean + +type X = (number) => string; + +type X = (?number) => string; + +type X = number => string; + +type X = ?number => string; + +type X = ({ foo: bar }) => string; + +// Options: ["always"] +type X = (number) => string; + +// Options: ["always"] +type X = (?number) => string; + +// Options: ["always"] +type X = number => string; + +// Options: ["always"] +type X = ?number => string; + +// Options: ["always"] +type X = ({ foo: bar }) => string; + +class Foo { bar } + +class Foo { bar = 3 } + +class Foo { bar: string } + +class Foo { bar: ?string } + +// Options: ["never"] +class Foo { bar:string } + +// Options: ["never"] +class Foo { bar:?string } + +class X { static foo : number } + +// Options: ["never"] +class X { static foo :number } + +declare class X { static foo : number } + +// Options: ["never"] +declare class X { static foo :number } + +class X { +foo: string } + +class X { static +foo: string } + +// Options: ["never"] +class X { +foo:string } + +// Options: ["never"] +class X { static +foo:string } + +type X = { foo: string } + +// Options: ["never"] +type X = { foo:string } + +type X = { foo?: string } + +type X = { foo?: ?string } + +// Options: ["never"] +type X = { foo?:?string } + +type Foo = { barType: (string | () => void) } + +type Foo = { barType: ((string | () => void)) } + +// Options: ["never"] +type Foo = { barType:(string | () => void) } + +// Options: ["never"] +type Foo = { barType:((string | () => void)) } + +type X = { get(): A; } + +type X = { get(): A; } + +// Options: ["never"] +type X = { get(): A; } + +// Options: ["never"] +type X = { get(): A; } + +type X = { get: () => A; } + +type X = { get: () => A; } + +// Options: ["never"] +type X = { get:() => A; } + +// Options: ["never"] +type X = { get:() => A; } + +type X = { +foo: string } + +type X = { +foo?: string } + +// Options: ["never"] +type X = { +foo:string } + +// Options: ["never"] +type X = { +foo?:string } + +// Options: ["always"] +type X = { [a: b]: c } + +// Options: ["never"] +type X = { [a:b]:c } + +// Options: ["always"] +type X = { +[a: b]: c } + +// Options: ["never"] +type X = { +[a:b]:c } + +// Options: ["always"] +type X = { [string]: c } + +// Options: ["never"] +type X = { [string]:c } + +// Options: ["never"] +const x = ({}:{}) + +// Options: ["always"] +const x = ({}: {}) + +// Options: ["never"] +((x):(string)) + +// Options: ["always"] +((x): (string)) + +// Options: ["always"] +const x: number = 7; + +// Options: ["always"] +let x: number = 42; + +// Options: ["always"] +var x: number = 42; +``` + + + + +### space-before-generic-bracket + +_The `--fix` option on the command line automatically fixes problems reported by this rule._ + +Enforces consistent spacing before the opening `<` of generic type annotation parameters. + +This rule takes one argument. If it is `'never'` then a problem is raised when there is a space before the `<`. If it is `'always'` then a problem is raised when there is no space before the `<`. + +The default value is `'never'`. + +The following patterns are considered problems: + +```js +type X = Promise +// Message: There must be no space before "Promise" generic type annotation bracket + +// Options: ["never"] +type X = Promise +// Message: There must be no space before "Promise" generic type annotation bracket + +type X = Promise +// Message: There must be no space before "Promise" generic type annotation bracket + +// Options: ["always"] +type X = Promise +// Message: There must be a space before "Promise" generic type annotation bracket + +// Options: ["always"] +type X = Promise +// Message: There must be one space before "Promise" generic type annotation bracket +``` + +The following patterns are not considered problems: + +```js +type X = Promise + +// Options: ["always"] +type X = Promise +``` + + + + +### space-before-type-colon + +_The `--fix` option on the command line automatically fixes problems reported by this rule._ + +Enforces consistent spacing before the type annotation colon. + +This rule takes one argument. If it is `'always'` then a problem is raised when there is no space before the type annotation colon. If it is `'never'` then a problem is raised when there is a space before the type annotation colon. The default value is `'never'`. + +The following patterns are considered problems: + +```js +// Options: ["never"] +(foo : string) => {} +// Message: There must be no space before "foo" parameter type annotation colon. + +// Options: ["never"] +(foo ? : string) => {} +// Message: There must be no space before "foo" parameter type annotation colon. + +// Options: ["always"] +(foo: string) => {} +// Message: There must be a space before "foo" parameter type annotation colon. + +// Options: ["always"] +(foo : string) => {} +// Message: There must be 1 space before "foo" parameter type annotation colon. + +// Options: ["always"] +(foo?: string) => {} +// Message: There must be a space before "foo" parameter type annotation colon. + +// Options: ["always"] +(foo ? : string) => {} +// Message: There must be 1 space before "foo" parameter type annotation colon. + +// Options: ["always"] +(foo ?: string) => {} +// Message: There must be a space before "foo" parameter type annotation colon. + +({ lorem, ipsum, dolor } : SomeType) => {} +// Message: There must be no space before "{ lorem, ipsum, dolor }" parameter type annotation colon. + +(foo : { a: string, b: number }) => {} +// Message: There must be no space before "foo" parameter type annotation colon. + +({ a, b } : { a: string, b: number }) => {} +// Message: There must be no space before "{ a, b }" parameter type annotation colon. + +([ a, b ] : string[]) => {} +// Message: There must be no space before "[ a, b ]" parameter type annotation colon. + +() : x => {} +// Message: There must be no space before return type colon. + +// Options: ["always"] +(): x => {} +// Message: There must be a space before return type colon. + +// Options: ["always"] +() : x => {} +// Message: There must be 1 space before return type colon. + +function x(foo : string) {} +// Message: There must be no space before "foo" parameter type annotation colon. + +// Options: ["always"] +function x(foo: string) {} +// Message: There must be a space before "foo" parameter type annotation colon. + +var x = function (foo : string) {} +// Message: There must be no space before "foo" parameter type annotation colon. + +// Options: ["always"] +var x = function (foo: string) {} +// Message: There must be a space before "foo" parameter type annotation colon. + +class Foo { constructor(foo : string ) {} } +// Message: There must be no space before "foo" parameter type annotation colon. + +// Options: ["always"] +class Foo { constructor(foo: string ) {} } +// Message: There must be a space before "foo" parameter type annotation colon. + +async function foo({ lorem, ipsum, dolor } : SomeType) {} +// Message: There must be no space before "{ lorem, ipsum, dolor }" parameter type annotation colon. + +function a() : x {} +// Message: There must be no space before return type colon. + +// Options: ["always"] +function a(): x {} +// Message: There must be a space before return type colon. + +// Options: ["always"] +function a() : x {} +// Message: There must be 1 space before return type colon. + +type X = (foo :string) => string; +// Message: There must be no space before "foo" parameter type annotation colon. + +// Options: ["always"] +type X = (foo:string) => string; +// Message: There must be a space before "foo" parameter type annotation colon. + +// Options: ["always"] +type X = (foo :string) => string; +// Message: There must be 1 space before "foo" parameter type annotation colon. + +type X = (foo? :string) => string; +// Message: There must be no space before "foo" parameter type annotation colon. + +type X = (foo? :string) => string; +// Message: There must be no space before "foo" parameter type annotation colon. + +// Options: ["always"] +type X = (foo?:string) => string; +// Message: There must be a space before "foo" parameter type annotation colon. + +type X = (foo? :?string) => string; +// Message: There must be no space before "foo" parameter type annotation colon. + +class X { foo :string } +// Message: There must be no space before "foo" class property type annotation colon. + +// Options: ["always"] +class X { foo: string } +// Message: There must be a space before "foo" class property type annotation colon. + +class X { foo :?string } +// Message: There must be no space before "foo" class property type annotation colon. + +// Options: ["always"] +class X { foo: ?string } +// Message: There must be a space before "foo" class property type annotation colon. + +class X { static foo : number } +// Message: There must be no space before "foo" class property type annotation colon. + +class X { static foo :number } +// Message: There must be no space before "foo" class property type annotation colon. + +// Options: ["always"] +class X { static foo: number } +// Message: There must be a space before "foo" class property type annotation colon. + +// Options: ["always"] +class X { static foo:number } +// Message: There must be a space before "foo" class property type annotation colon. + +declare class Foo { static bar :number; } +// Message: There must be no space before "bar" type annotation colon. + +declare class Foo { static bar : number; } +// Message: There must be no space before "bar" type annotation colon. + +// Options: ["always"] +declare class Foo { static bar:number; } +// Message: There must be a space before "bar" type annotation colon. + +// Options: ["always"] +declare class Foo { static bar: number; } +// Message: There must be a space before "bar" type annotation colon. + +// Options: ["always"] +class X { +foo: string } +// Message: There must be a space before "foo" class property type annotation colon. + +// Options: ["always"] +class X { +foo : string } +// Message: There must be 1 space before "foo" class property type annotation colon. + +// Options: ["never"] +class X { +foo : string } +// Message: There must be no space before "foo" class property type annotation colon. + +// Options: ["always"] +class X { static +foo: string } +// Message: There must be a space before "foo" class property type annotation colon. + +// Options: ["always"] +class X { static +foo : string } +// Message: There must be 1 space before "foo" class property type annotation colon. + +// Options: ["never"] +class X { static +foo : string } +// Message: There must be no space before "foo" class property type annotation colon. + +type X = { foo : string } +// Message: There must be no space before "foo" type annotation colon. + +// Options: ["never"] +type X = { foo : string } +// Message: There must be no space before "foo" type annotation colon. + +// Options: ["always"] +type X = { foo: string } +// Message: There must be a space before "foo" type annotation colon. + +// Options: ["always"] +type X = { foo : string } +// Message: There must be 1 space before "foo" type annotation colon. + +type X = { foo? : string } +// Message: There must be no space before "foo" type annotation colon. + +// Options: ["always"] +type X = { foo?: string } +// Message: There must be a space before "foo" type annotation colon. + +// Options: ["always"] +type X = { foo? : string } +// Message: There must be 1 space before "foo" type annotation colon. + +// Options: ["always"] +type X = { foo ?: string } +// Message: There must be a space before "foo" type annotation colon. + +// Options: ["always"] +type X = { +foo: string } +// Message: There must be a space before "foo" type annotation colon. + +// Options: ["always"] +type X = { +foo : string } +// Message: There must be 1 space before "foo" type annotation colon. + +// Options: ["never"] +type X = { +foo : string } +// Message: There must be no space before "foo" type annotation colon. + +// Options: ["always"] +type X = { +foo?: string } +// Message: There must be a space before "foo" type annotation colon. + +// Options: ["always"] +type X = { +foo? : string } +// Message: There must be 1 space before "foo" type annotation colon. + +// Options: ["never"] +type X = { +foo? : string } +// Message: There must be no space before "foo" type annotation colon. + +// Options: ["always"] +type X = { [a: b] : c } +// Message: There must be a space before type annotation colon. + +// Options: ["never"] +type X = { [a : b]: c } +// Message: There must be no space before type annotation colon. + +// Options: ["always"] +type X = { [a : b] : c } +// Message: There must be 1 space before type annotation colon. + +// Options: ["always"] +type X = { +[a:b] : c } +// Message: There must be a space before type annotation colon. + +// Options: ["never"] +type X = { +[a : b]: c } +// Message: There must be no space before type annotation colon. + +// Options: ["always"] +type X = { +[a : b] : c } +// Message: There must be 1 space before type annotation colon. + +// Options: ["always"] +type X = { [a : b]: c } +// Message: There must be a space before type annotation colon. + +// Options: ["never"] +type X = { [a: b] : c } +// Message: There must be no space before type annotation colon. + +// Options: ["always"] +type X = { [a : b] : c } +// Message: There must be 1 space before type annotation colon. + +// Options: ["always"] +type X = { [a:b]:c } +// Message: There must be a space before type annotation colon. +// Message: There must be a space before type annotation colon. + +// Options: ["never"] +type X = { [a : b] : c } +// Message: There must be no space before type annotation colon. +// Message: There must be no space before type annotation colon. + +// Options: ["always"] +type X = { [a : b] : c } +// Message: There must be 1 space before type annotation colon. +// Message: There must be 1 space before type annotation colon. + +// Options: ["always"] +type X = { [a:(b)]:(c) } +// Message: There must be a space before type annotation colon. +// Message: There must be a space before type annotation colon. + +// Options: ["never"] +type X = { [a : (b)] : (c) } +// Message: There must be no space before type annotation colon. +// Message: There must be no space before type annotation colon. + +// Options: ["never"] +const x = ({} :{}) +// Message: There must be no space before type cast colon. + +// Options: ["always"] +const x = ({}:{}) +// Message: There must be a space before type cast colon. + +// Options: ["always"] +const x = ({} :{}) +// Message: There must be 1 space before type cast colon. + +// Options: ["never"] +((x) : string) +// Message: There must be no space before type cast colon. + +// Options: ["always"] +((x): string) +// Message: There must be a space before type cast colon. + +// Options: ["always"] +((x) : string) +// Message: There must be 1 space before type cast colon. + +// Options: ["always"] +const x:number = 7; +// Message: There must be a space before const type annotation colon. + +// Options: ["always"] +let x:number = 42; +// Message: There must be a space before let type annotation colon. + +// Options: ["always"] +var x:number = 42; +// Message: There must be a space before var type annotation colon. +``` + +The following patterns are not considered problems: + +```js +(foo) => {} + +(foo: string) => {} + +(foo?: string) => {} + +(foo ?: string) => {} + +// Options: ["never"] +(foo: string) => {} + +// Options: ["always"] +(foo : string) => {} + +// Options: ["always"] +(foo? : string) => {} + +// Options: ["always"] +(foo ? : string) => {} + +// Options: ["always"] +(foo ? : string) => {} + +({ lorem, ipsum, dolor }: SomeType) => {} + +(foo: { a: string, b: number }) => {} + +({ a, b }: ?{ a: string, b: number }) => {} + +(): { a: number, b: string } => {} + +// Options: ["always"] +() : { a : number, b : string } => {} + +([ a, b ]: string[]) => {} + +(): x => {} + +// Options: ["always"] +() : x => {} + +(): (number | string) => {} + +// Options: ["always"] +() : (number | string) => {} -{ - "rules": { - "flowtype/require-return-type": [ - 2, - "always", - { - "excludeMatching": [ - "^F.*", - "Ba(r|z)" - ] - } - ] - } -} +function x(foo: string) {} -``` +// Options: ["always"] +function x(foo : string) {} -Both rules take an array that can contain either strings or valid RegExp statements. +var x = function (foo: string) {} - +// Options: ["always"] +var x = function (foo : string) {} - -### require-types-at-top +class X { foo({ bar }: Props = this.props) {} } -Requires all type declarations to be at the top of the file, after any import declarations. +class Foo { constructor(foo: string ) {} } - -#### Options +// Options: ["always"] +class Foo { constructor(foo : string ) {} } -The rule has a string option: +async function foo({ lorem, ipsum, dolor }: SomeType) {} -* `"never"` -* `"always"` +function x({ a, b }: { a: string, b: number }) {} -The default value is `"always"`. +function a(): x {} - +// Options: ["always"] +function a() : x {} - -### require-valid-file-annotation +function a(): (number | string) {} -This rule validates Flow file annotations. +// Options: ["always"] +function a() : (number | string) {} -This rule can optionally report missing or missed placed annotations, common typos (e.g. `// @floww`), and enforce a consistant annotation style. +type X = (foo:string) => number; - -#### Options +type X = (foo: string) => number; -The rule has a string option: +type X = (foo: ?string) => number; -* `"never"` (default): Never report files that are missing an `@flow` annotation. -* `"always"`: Always report files that are missing an `@flow` annotation +type X = (foo?: string) => number; -This rule has an object option: +type X = (foo?: ?string) => number; -* `"annotationStyle"` - Enforce a consistant file annotation style. - * `"none"` (default): Either annotation style is accepted. - * `"line"`: Require single line annotations (i.e. `// @flow`). - * `"block"`: Require block annotations (i.e. `/* @flow */`). +type X = (foo ?: string) => number; -```js -{ - "rules": { - "flowtype/require-valid-file-annotation": [ - 2, - "always" - ] - } -} +// Options: ["always"] +type X = (foo? : string) => number -{ - "rules": { - "flowtype/require-valid-file-annotation": [ - 2, - "always", { - "annotationStyle": "block" - } - ] - } -} -``` +// Options: ["always"] +type X = (foo? : ?string) => number - +type X = (number) => string; - -### require-variable-type +type X = (?number) => string; -Requires that all variable declarators have type annotations. +type X = number => string; - -#### Options +type X = ?number => string; -You can exclude variables that match a certain regex by using `excludeVariableMatch`. +type X = ({ foo: bar }) => string; -This excludes all parameters that start with an underscore (`_`). -The default pattern is `a^`, which doesn't match anything, i.e., all parameters are checked. +// Options: ["always"] +type X = (number) => string; -```js -{ - "rules": { - "flowtype/require-variable-type": [ - 2, - { - "excludeVariableMatch": "^_" - } - ] - } -} -``` +// Options: ["always"] +type X = (?number) => string; +// Options: ["always"] +type X = number => string; -You can choose specific variable types (`var`, `let`, and `const`) to ignore using `excludeVariableTypes`. +// Options: ["always"] +type X = ?number => string; -This excludes `var` and `let` declarations from needing type annotations, but forces `const` declarations to have it. -By default, all declarations are checked. +// Options: ["always"] +type X = ({ foo : bar }) => string; -```js -{ - "rules": { - "flowtype/require-variable-type": [ - 2, - { - "excludeVariableTypes": { - "var": true, - "let": true, - "const": false, - } - } - ] - } -} -``` +class Foo { bar } +class Foo { bar = 3 } +class Foo { bar: string } - +class Foo { bar: ?string } - -### semi +class Foo { bar:?string } -_The `--fix` option on the command line automatically fixes problems reported by this rule._ +// Options: ["always"] +class Foo { bar : string } -Enforces consistent use of semicolons after type aliases. +class X { static foo:number } -This rule takes one argument. If it is `'never'` then a problem is raised when there is a semicolon after a type alias. If it is `'always'` then a problem is raised when there is no semicolon after a type alias. +class X { static foo: number } -The default value is `'always'`. +// Options: ["always"] +class X { static foo :number } - +// Options: ["always"] +class X { static foo : number } - -### sort-keys +declare class Foo { static bar:number; } -_The `--fix` option on the command line automatically fixes problems reported by this rule._ +// Options: ["always"] +declare class Foo { static bar :number; } -Enforces sorting of Object annotations. +declare class Foo { static bar: number; } -This rule mirrors ESlint's [sort-keys](http://eslint.org/docs/rules/sort-keys) rule. +// Options: ["always"] +declare class Foo { static bar : number; } - -#### Options +class X { +foo: string } -The first option specifies sort order. +class X { static +foo: string } -* `"asc"` (default) - enforce ascending sort order. -* `"desc"` - enforce descending sort order. +// Options: ["always"] +class X { +foo : string } -The second option takes an object with two possible properties. +// Options: ["always"] +class X { static +foo : string } -* `caseSensitive` - if `true`, enforce case-sensitive sort order. Default is `true`. -* `natural` - if `true`, enforce [natural sort order](https://en.wikipedia.org/wiki/Natural_sort_order). Default is `false`. +type X = { foo: string } -```js -{ - "rules": { - "flowtype/sort-keys": [ - 2, - "asc", { - "caseSensitive": true, - "natural": false - } - ] - } -} -``` +// Options: ["always"] +type X = { foo : string } - +type X = { foo?: string } - -### space-after-type-colon +type X = { foo ?: string } -_The `--fix` option on the command line automatically fixes problems reported by this rule._ +// Options: ["always"] +type X = { foo? : string } -Enforces consistent spacing after the type annotation colon. +type X = { +foo: string } - -#### Options +type X = { +foo?: string } -This rule has a string argument. +// Options: ["always"] +type X = { +foo : string } -* `"always"` (default): Require a space after the type annotation colon (e.g. foo: BarType). -* `"never"`: Require no spaces after the type annotation colon (e.g. foo:BarType). +// Options: ["always"] +type X = { +foo? : string } -This rule has an option object. +// Options: ["always"] +type X = { [a : b] : c } -* `"allowLineBreak"` - Allow a line break to count as a space following the annotation colon. - * `"true"`: Enable - * `"false"`: Disable +// Options: ["never"] +type X = { [a:b]:c } -{ - "rules": { - "flowtype/space-after-type-colon": [ - 2, - "always", { - "allowLineBreak": false - } - ] - } -} +// Options: ["always"] +type X = { [string] : c } - +// Options: ["never"] +type X = { [string]:c } - -### space-before-generic-bracket +// Options: ["always"] +type X = { +[a : b] : c } -_The `--fix` option on the command line automatically fixes problems reported by this rule._ +// Options: ["never"] +type X = { +[a:b]:c } -Enforces consistent spacing before the opening `<` of generic type annotation parameters. +// Options: ["always"] +type X = { [a : (b)] : (c) } -This rule takes one argument. If it is `'never'` then a problem is raised when there is a space before the `<`. If it is `'always'` then a problem is raised when there is no space before the `<`. +// Options: ["never"] +type X = { [a:(b)]:(c) } -The default value is `'never'`. +// Options: ["never"] +const x = ({}:{}) - +// Options: ["always"] +const x = ({} :{}) - -### space-before-type-colon +// Options: ["never"] +((x): string) -_The `--fix` option on the command line automatically fixes problems reported by this rule._ +// Options: ["always"] +((x) : string) -Enforces consistent spacing before the type annotation colon. +// Options: ["always"] +const x :number = 7; + +// Options: ["always"] +let x :number = 42; + +// Options: ["always"] +var x :number = 42; +``` -This rule takes one argument. If it is `'always'` then a problem is raised when there is no space before the type annotation colon. If it is `'never'` then a problem is raised when there is a space before the type annotation colon. The default value is `'never'`. - ### type-id-match @@ -968,7 +4480,30 @@ This rule needs a text RegExp to operate with Its signature is as follows: `'^([A-Z][a-z0-9]*)+Type$'` is the default pattern. - +The following patterns are considered problems: + +```js +type foo = {}; +// Message: Type identifier 'foo' does not match pattern '/^([A-Z][a-z0-9]*)+Type$/'. + +// Options: ["^foo$"] +type FooType = {}; +// Message: Type identifier 'FooType' does not match pattern '/^foo$/'. +``` + +The following patterns are not considered problems: + +```js +type FooType = {}; + +// Options: ["^foo$"] +type foo = {}; + +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +type foo = {}; +``` + + ### type-import-style @@ -992,7 +4527,43 @@ The rule has a string option: * `"declaration"`: Enforces that type imports are all in the 'declaration' style. - +The following patterns are considered problems: + +```js +import type {A, B} from 'a'; +// Message: Unexpected "import type" + +// Options: ["identifier"] +import type {A, B} from 'a'; +// Message: Unexpected "import type" + +// Options: ["identifier"] +import type {A, B as C} from 'a'; +// Message: Unexpected "import type" + +// Options: ["identifier"] +import type A from 'a'; +// Message: Unexpected "import type" + +// Options: ["declaration"] +import {type A, type B} from 'a'; +// Message: Unexpected type import +// Message: Unexpected type import +``` + +The following patterns are not considered problems: + +```js +import {type A, type B} from 'a'; + +// Options: ["identifier"] +import {type A, type B} from 'a'; + +// Options: ["declaration"] +import type {A, B} from 'a'; +``` + + ### union-intersection-spacing @@ -1005,7 +4576,147 @@ This rule takes one argument. If it is `'always'` then a problem is raised when The default value is `'always'`. - +The following patterns are considered problems: + +```js +type X = string| number; +// Message: There must be a space before union type annotation separator + +// Options: ["always"] +type X = string| number; +// Message: There must be a space before union type annotation separator + +type X = string |number; +// Message: There must be a space after union type annotation separator + +type X = string|number; +// Message: There must be a space before union type annotation separator +// Message: There must be a space after union type annotation separator + +type X = {x: string}|{y: number}; +// Message: There must be a space before union type annotation separator +// Message: There must be a space after union type annotation separator + +type X = string | number |boolean; +// Message: There must be a space after union type annotation separator + +type X = string|number|boolean; +// Message: There must be a space before union type annotation separator +// Message: There must be a space after union type annotation separator +// Message: There must be a space before union type annotation separator +// Message: There must be a space after union type annotation separator + +type X = (string)| number; +// Message: There must be a space before union type annotation separator + +type X = ((string))|(number | foo); +// Message: There must be a space before union type annotation separator +// Message: There must be a space after union type annotation separator + +// Options: ["never"] +type X = string |number; +// Message: There must be no space before union type annotation separator + +// Options: ["never"] +type X = string| number; +// Message: There must be no space after union type annotation separator + +type X = string& number; +// Message: There must be a space before intersection type annotation separator + +// Options: ["always"] +type X = string& number; +// Message: There must be a space before intersection type annotation separator + +type X = string &number; +// Message: There must be a space after intersection type annotation separator + +type X = {x: string}&{y: number}; +// Message: There must be a space before intersection type annotation separator +// Message: There must be a space after intersection type annotation separator + +type X = string&number; +// Message: There must be a space before intersection type annotation separator +// Message: There must be a space after intersection type annotation separator + +type X = string & number &boolean; +// Message: There must be a space after intersection type annotation separator + +type X = string&number&boolean; +// Message: There must be a space before intersection type annotation separator +// Message: There must be a space after intersection type annotation separator +// Message: There must be a space before intersection type annotation separator +// Message: There must be a space after intersection type annotation separator + +type X = (string)& number; +// Message: There must be a space before intersection type annotation separator + +type X = ((string))&(number & foo); +// Message: There must be a space before intersection type annotation separator +// Message: There must be a space after intersection type annotation separator + +// Options: ["never"] +type X = string &number; +// Message: There must be no space before intersection type annotation separator + +// Options: ["never"] +type X = string& number; +// Message: There must be no space after intersection type annotation separator +``` + +The following patterns are not considered problems: + +```js +type X = string | number; + +type X = string | number | boolean; + +type X = (string) | number; + +type X = ((string)) | (number | foo); + +// Options: ["never"] +type X = string|number + +type X = +| string +| number + +function x() { +type X = +| string +| number +} + +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +type X = string| number; + +type X = string & number; + +type X = string & number & boolean; + +type X = (string) & number; + +type X = ((string)) & (number & foo); + +// Options: ["never"] +type X = string&number + +type X = +& string +& number + +function x() { +type X = +& string +& number +} + +// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}} +type X = string& number; +``` + + ### use-flow-type @@ -1014,7 +4725,26 @@ Marks Flow [type alias](https://flowtype.org/docs/type-aliases.html) declaration Used to suppress [`no-unused-vars`](http://eslint.org/docs/rules/no-unused-vars) errors that are triggered by type aliases. - +The following patterns are not considered problems: + +```js +declare class A {} +// Additional rules: {"no-unused-vars":1} + +declare function A(): Y +// Additional rules: {"no-unused-vars":1} + +declare module A {} +// Additional rules: {"no-unused-vars":1} + +declare module A { declare var a: Y } +// Additional rules: {"no-unused-vars":1} + +declare var A: Y +// Additional rules: {"no-unused-vars":1} +``` + + ### valid-syntax @@ -1023,5 +4753,13 @@ Used to suppress [`no-unused-vars`](http://eslint.org/docs/rules/no-unused-vars) Checks for simple Flow syntax errors. - +The following patterns are not considered problems: + +```js +function x(foo: string = "1") {} + +function x(foo: Type = bar()) {} +``` + +