From a04d49ee20961b563621db9bcc98117f6412f7ae Mon Sep 17 00:00:00 2001 From: Gajus Kuizinas Date: Sun, 28 Oct 2018 13:56:36 +0000 Subject: [PATCH] fix: correct addAssertions path --- README.md | 4630 +++++--------------------------------------------- package.json | 2 +- 2 files changed, 447 insertions(+), 4185 deletions(-) diff --git a/README.md b/README.md index 2f152e53..c882ab3f 100644 --- a/README.md +++ b/README.md @@ -222,74 +222,7 @@ 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 @@ -316,81 +249,7 @@ 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 @@ -405,38 +264,7 @@ 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 @@ -445,1778 +273,415 @@ Marks Flow type identifiers as defined. Used to suppress [`no-undef`](http://eslint.org/docs/rules/no-undef) reporting of type identifiers. -The following patterns are not considered problems: + -```js -var a: AType -// Additional rules: {"no-undef":2} + +### delimiter-dangle + +_The `--fix` option on the command line automatically fixes problems reported by this rule._ -var a: AType; var b: AType -// Additional rules: {"no-undef":2} +Enforces consistent use of trailing commas in Object and Tuple annotations. -var a; (a: AType) -// Additional rules: {"no-undef":2} +This rule takes one argument which mirrors ESLint's default `comma-dangle` rule. -var a: AType -// Additional rules: {"no-undef":2} +If it is `'never'` then a problem is raised when there is a trailing comma. -type A = AType -// Additional rules: {"no-undef":2} +If it is `'always'` then a problem is raised when there is no trailing comma. -declare type A = number -// 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. -opaque 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. -function f(a: AType) {} -// Additional rules: {"no-undef":2} +The default value is `'never'`. -function f(a: AType.a) {} -// Additional rules: {"no-undef":2} + -function f(a: AType.a.b) {} -// Additional rules: {"no-undef":2} + +### generic-spacing -function f(a): AType {}; var a: AType -// Additional rules: {"no-undef":2} +_The `--fix` option on the command line automatically fixes problems reported by this rule._ -function f(a): AType {} -// Additional rules: {"no-undef":2} +Enforces consistent spacing within generic type annotation parameters. -class C { 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. -class C { a: AType.a } -// Additional rules: {"no-undef":2} +The default value is `'never'`. -class C { a: AType.a.b } -// Additional rules: {"no-undef":2} + -class C implements AType {} -// Additional rules: {"no-undef":2} + +### newline-after-flow-annotation -declare interface A {} -// Additional rules: {"no-undef":2} +This rule requires an empty line after the Flow annotation. -({ a: ({b() {}}: AType) }) -// Additional rules: {"no-undef":2} + +#### Options -type X = {Y(): BType} -// Additional rules: {"no-undef":2} +The rule has a string option: -var a: AType -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} +* `"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 -var a: AType; var b: AType -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} +```js +{ + "rules": { + "flowtype/newline-after-flow-annotation": [ + 2, + "always" + ] + } +} +``` -var a; (a: AType) -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} -var a: AType -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} + -type A = AType -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} + +### no-dupe-keys -declare type A = number -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} +Checks for duplicate properties in Object annotations. -opaque 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. -function f(a: AType) {} -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} +```js +{ + "rules": { + "flowtype/no-dupe-keys": 2 + } +} +``` -function f(a: AType.a) {} -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} + -function f(a: AType.a.b) {} -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} + +### no-existential-type -function f(a): AType {}; var a: AType -// 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 {} -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} +```js +{ + "rules": { + "flowtype/no-existential-type": 2 + } +} +``` -class C { a: AType } -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} -class C { a: AType.a } -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} + -class C { a: AType.a.b } -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} + +### no-flow-fix-me-comments -class C implements AType {} -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} +Disallows `$FlowFixMe` comment suppressions. -declare interface A {} -// 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. -({ a: ({b() {}}: AType) }) -// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]} + +#### Options -type X = {Y(): BType} -// 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. +```js +{ + "rules": { + "flowtype/no-flow-fix-me-comments": [ + 1, + "TODO\s+[0-9]+" + ] + } +} +``` + - -### delimiter-dangle + +### no-mutable-array _The `--fix` option on the command line automatically fixes problems reported by this rule._ -Enforces consistent use of trailing commas in Object and Tuple annotations. - -This rule takes one argument which mirrors ESLint's default `comma-dangle` 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)). -If it is `'never'` then a problem is raised when there is a trailing comma. +General reasons for using immutable data structures: -If it is `'always'` then a problem is raised when there is no trailing comma. +* 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 `'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. +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 `'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. + -The default value is `'never'`. + +### no-primitive-constructor-types -The following patterns are considered problems: +Disallows use of primitive constructors as types, such as `Boolean`, `Number` and `String`. [See more](https://flowtype.org/docs/builtins.html). ```js -type X = { foo: string, } -// Message: Unexpected trailing delimiter - -// Options: ["never"] -type X = { foo: string, } -// Message: Unexpected trailing delimiter +{ + "rules": { + "flowtype/no-primitive-constructor-types": 2 + } +} +``` -// Options: ["never"] -type X = { foo: string; } -// Message: Unexpected trailing delimiter + -// Options: ["never"] -type X = { -foo: string, -} -// Message: Unexpected trailing delimiter + +### no-types-missing-file-annotation -// Options: ["always"] -type X = { foo: string } -// Message: Missing trailing delimiter +Disallows Flow type imports, aliases, and annotations in files missing a valid Flow file declaration (or a @noflow annotation). -// Options: ["always"] -type X = { -foo: string +```js +{ + "rules": { + "flowtype/no-types-missing-file-annotation": 2 + } } -// Message: Missing trailing delimiter +``` -// Options: ["always-multiline"] -type X = { foo: string, } -// Message: Unexpected trailing delimiter + -// Options: ["always-multiline"] -type X = { -foo: string -} -// Message: Missing trailing delimiter + +### no-unused-expressions -// Options: ["only-multiline"] -type X = { foo: string; } -// Message: Unexpected 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: ["never"] -type X = { [key: string]: number, } -// Message: Unexpected trailing delimiter +Bare type casts are useful, for example to assert the exhaustiveness of a `switch`: -// Options: ["always"] -type X = { [key: string]: number } -// Message: Missing trailing delimiter +```js +type Action + = { type: 'FOO', doFoo: (_: number) => void } + | { type: 'BAR', doBar: (_: string) => void }; -// Options: ["always-multiline"] -type X = { [key: string]: number, } -// Message: Unexpected trailing delimiter +type State = { foo: number, bar: string }; -// Options: ["always-multiline"] -type X = { -[key: string]: number +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()}`); + } } -// Message: Missing trailing delimiter +``` -// Options: ["only-multiline"] -type X = { [key: string]: number; } -// Message: Unexpected 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: ["never"] -type X = { [key: string]: number, foo: string, } -// 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, -aReallyLongPropertyNameHere: 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: ["always"] -type X = { [key: string]: number, foo: string } -// Message: Missing 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 +```js +{ + "rules": { + "flowtype/no-weak-types": [2, { + "any": false, + "Object": true, + "Function": true + }] + } } -// Message: Missing trailing delimiter -// Options: ["always-multiline"] -type X = { [key: string]: number, foo: string, } -// Message: Unexpected trailing delimiter +// or, the following is equivalent as default is true: -// Options: ["always-multiline"] -type X = { -[key: string]: number, -foo: string +{ + "rules": { + "flowtype/no-weak-types": [2, { + "any": false + }] + } } -// Message: Missing trailing delimiter +``` -// Options: ["only-multiline"] -type X = { [key: string]: number, foo: string, } -// Message: Unexpected trailing delimiter + -// Options: ["never"] -type X = { foo: string, [key: string]: number, } -// 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 = { -aReallyLongPropertyNameHere: string, -[key: string]: number, -} -// Message: Unexpected trailing delimiter +Enforces consistent separators between properties in Flow object types. -// Options: ["always"] -type X = { foo: string, [key: string]: number } -// Message: Missing 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-multiline"] -type X = { foo: string, [key: string]: number; } -// Message: Unexpected 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: 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 -``` +The default value is `'comma'`. -The following patterns are not considered problems: +_This rule is ported from `babel/flow-object-type`, however the default option was changed._ -```js -type X = { foo: string } + -// Options: ["never"] -type X = { foo: string } + +### require-compound-type-alias -// Options: ["always"] -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: ["never"] -type X = { -foo: string -} +The rule has a string option: -// Options: ["always"] -type X = { -foo: string, -} - -// Options: ["always-multiline"] -type X = { foo: string } - -// Options: ["always-multiline"] -type X = { -foo: string, -} - -// Options: ["always-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: ["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))) > -``` +* `"never"` +* `"always"` +The default value is `"always"`. + - -### newline-after-flow-annotation + +### require-exact-type -This rule requires an empty line after the Flow annotation. +This rule enforces [exact object types](https://flow.org/en/docs/types/objects/#toc-exact-object-types). - + #### Options -The rule has a string option: +The rule has one string option: -* `"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 +* `"always"` (default): Report all object type definitions that aren't exact. +* `"never"`: Report all object type definitions that are exact. ```js { "rules": { - "flowtype/newline-after-flow-annotation": [ + "flowtype/require-exact-type": [ 2, "always" ] } } -``` - -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 +{ + "rules": { + "flowtype/require-exact-type": [ + 2, + "never" + ] + } +} ``` -The following patterns are not considered problems: - -```js -// Options: ["always"] -// @flow - -import Foo from './foo'; - -// Options: ["always-windows"] -// @flow - -import Foo from './foo'; - -// Options: ["never"] -// @flow -import Foo from './foo'; -``` + + +### require-parameter-type +Requires that all function parameters have type annotations. - -### no-dupe-keys + +#### Options -Checks for duplicate properties in Object annotations. +You can skip all arrow functions by providing the `excludeArrowFunctions` option with `true`. -This rule mirrors ESLint's [no-dupe-keys](http://eslint.org/docs/rules/no-dupe-keys) rule. +Alternatively, you can want to exclude only concise arrow functions (e.g. `x => x * 2`). Provide `excludeArrowFunctions` with `expressionsOnly` for this. ```js { "rules": { - "flowtype/no-dupe-keys": 2 + "flowtype/require-parameter-type": [ + 2, + { + "excludeArrowFunctions": true + } + ] } } -``` - -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. -``` - -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/no-existential-type": 2 - } + "rules": { + "flowtype/require-parameter-type": [ + 2, + { + "excludeArrowFunctions": "expressionsOnly" + } + ] + } } ``` - -The following patterns are considered problems: - -```js -type T = *; -// Message: Unexpected use of existential type (*). - -type T = U<*, *>; -// Message: Unexpected use of existential type (*). -// Message: Unexpected use of existential type (*). - -const f: (*) => null = () => null; -// Message: Unexpected use of existential type (*). -``` - -The following patterns are not considered problems: +You can exclude parameters that match a certain regex by using `excludeParameterMatch`. ```js -type T = string | null +{ + "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. + - -### no-flow-fix-me-comments - -Disallows `$FlowFixMe` comment suppressions. + +### require-return-type -This is especially useful as a warning to ensure instances of `$FlowFixMe` in your codebase get fixed over time. +Requires that functions have return type annotation. - + #### Options -This rule takes an optional RegExp that comments a text RegExp that makes the supression valid. +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/no-flow-fix-me-comments": [ - 1, - "TODO\s+[0-9]+" + "flowtype/require-return-type": [ + 2, + "always", + { + "excludeArrowFunctions": true + } ] } } -``` - -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 - } -} -``` - -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/no-types-missing-file-annotation": 2 + "flowtype/require-return-type": [ + 2, + "always", + { + "excludeArrowFunctions": "expressionsOnly" + } + ] } } ``` -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. +You can exclude or include specific tests with the `includeOnlyMatching` and `excludeMatching` rules. ```js { @@ -2225,2237 +690,260 @@ Alternatively, you can exclude a concise arrow function (e.g. `() => 2`). Provid 2, "always", { - "excludeArrowFunctions": true + "includeOnlyMatching": [ + "^F.*", + "Ba(r|z)" + ] } ] - } -} - -{ - "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) => {} - -function x(foo: string) {} - -// Options: ["always"] -function x(foo : string) {} + } +} -var x = function (foo: string) {} +{ + "rules": { + "flowtype/require-return-type": [ + 2, + "always", + { + "excludeMatching": [ + "^F.*", + "Ba(r|z)" + ] + } + ] + } +} -// Options: ["always"] -var x = function (foo : string) {} +``` -class X { foo({ bar }: Props = this.props) {} } +Both rules take an array that can contain either strings or valid RegExp statements. -class Foo { constructor(foo: string ) {} } + -// Options: ["always"] -class Foo { constructor(foo : string ) {} } + +### require-types-at-top -async function foo({ lorem, ipsum, dolor }: SomeType) {} +Requires all type declarations to be at the top of the file, after any import declarations. -function x({ a, b }: { a: string, b: number }) {} + +#### Options -function a(): x {} +The rule has a string option: -// Options: ["always"] -function a() : x {} +* `"never"` +* `"always"` -function a(): (number | string) {} +The default value is `"always"`. -// Options: ["always"] -function a() : (number | string) {} + -type X = (foo:string) => number; + +### require-valid-file-annotation -type X = (foo: string) => number; +This rule validates Flow file annotations. -type X = (foo: ?string) => number; +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 -// Options: ["always"] -type X = (foo? : string) => number +This rule has an object option: -// Options: ["always"] -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 = (number) => string; +```js +{ + "rules": { + "flowtype/require-valid-file-annotation": [ + 2, + "always" + ] + } +} -type X = (?number) => string; +{ + "rules": { + "flowtype/require-valid-file-annotation": [ + 2, + "always", { + "annotationStyle": "block" + } + ] + } +} +``` -type X = number => string; + -type X = ?number => string; + +### require-variable-type -type X = ({ foo: bar }) => string; +Requires that all variable declarators have type annotations. -// Options: ["always"] -type X = (number) => string; + +#### Options -// Options: ["always"] -type X = (?number) => string; +You can exclude variables that match a certain regex by using `excludeVariableMatch`. -// Options: ["always"] -type X = number => 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 = ({ foo : bar }) => string; -class Foo { bar } +You can choose specific variable types (`var`, `let`, and `const`) to ignore using `excludeVariableTypes`. -class Foo { bar = 3 } +This excludes `var` and `let` declarations from needing type annotations, but forces `const` declarations to have it. +By default, all declarations are checked. -class Foo { bar: string } +```js +{ + "rules": { + "flowtype/require-variable-type": [ + 2, + { + "excludeVariableTypes": { + "var": true, + "let": true, + "const": false, + } + } + ] + } +} +``` -class Foo { bar: ?string } -class Foo { bar:?string } -// Options: ["always"] -class Foo { bar : string } + -class X { static foo:number } + +### semi -class X { static foo: number } +_The `--fix` option on the command line automatically fixes problems reported by this rule._ -// Options: ["always"] -class X { static foo :number } +Enforces consistent use of semicolons after type aliases. -// Options: ["always"] -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. -declare class Foo { static bar:number; } +The default value is `'always'`. -// Options: ["always"] -declare class Foo { static bar :number; } + -declare class Foo { static bar: number; } + +### sort-keys -// Options: ["always"] -declare class Foo { static bar : number; } +_The `--fix` option on the command line automatically fixes problems reported by this rule._ -class X { +foo: string } +Enforces sorting of Object annotations. -class X { static +foo: string } +This rule mirrors ESlint's [sort-keys](http://eslint.org/docs/rules/sort-keys) rule. -// Options: ["always"] -class X { +foo : string } + +#### Options -// Options: ["always"] -class X { static +foo : string } +The first option specifies sort order. -type X = { foo: string } +* `"asc"` (default) - enforce ascending sort order. +* `"desc"` - enforce descending sort order. -// Options: ["always"] -type X = { foo : string } +The second option takes an object with two possible properties. -type X = { 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. -// Options: ["always"] -type X = { +foo? : string } + +#### Options -// Options: ["always"] -type X = { [a : b] : c } +This rule has a string argument. -// Options: ["never"] -type X = { [a:b]:c } +* `"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 = { [string] : c } +This rule has an option object. -// Options: ["never"] -type X = { [string]:c } +* `"allowLineBreak"` - Allow a line break to count as a space following the annotation colon. + * `"true"`: Enable + * `"false"`: Disable -// Options: ["always"] -type X = { +[a : b] : c } +{ + "rules": { + "flowtype/space-after-type-colon": [ + 2, + "always", { + "allowLineBreak": false + } + ] + } +} -// Options: ["never"] -type X = { +[a:b]:c } + -// Options: ["always"] -type X = { [a : (b)] : (c) } + +### space-before-generic-bracket -// Options: ["never"] -type X = { [a:(b)]:(c) } +_The `--fix` option on the command line automatically fixes problems reported by this rule._ -// Options: ["never"] -const x = ({}:{}) +Enforces consistent spacing before the opening `<` of generic type annotation parameters. -// Options: ["always"] -const x = ({} :{}) +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"] -((x): string) +The default value is `'never'`. -// Options: ["always"] -((x) : string) + -// Options: ["always"] -const x :number = 7; + +### space-before-type-colon -// Options: ["always"] -let x :number = 42; +_The `--fix` option on the command line automatically fixes problems reported by this rule._ -// Options: ["always"] -var x :number = 42; -``` +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'`. + ### type-id-match @@ -4480,30 +968,7 @@ 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 @@ -4527,43 +992,7 @@ 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 @@ -4576,147 +1005,7 @@ 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 @@ -4725,26 +1014,7 @@ 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 @@ -4753,13 +1023,5 @@ declare var A: Y Checks for simple Flow syntax errors. -The following patterns are not considered problems: - -```js -function x(foo: string = "1") {} - -function x(foo: Type = bar()) {} -``` - - + diff --git a/package.json b/package.json index 589d4a83..3118bc19 100644 --- a/package.json +++ b/package.json @@ -55,7 +55,7 @@ "check-docs": "babel-node ./src/bin/checkDocs", "check-tests": "babel-node ./src/bin/checkTests", "create-readme": "gitdown ./.README/README.md --output-file ./README.md && npm run documentation-add-assertions", - "documentation-add-assertions": "babel-node ./bin/addAssertions", + "documentation-add-assertions": "babel-node ./src/bin/addAssertions", "format-json": "jsonlint --sort-keys --in-place --indent ' ' ./src/configs/recommended.json && echo '' >> ./src/configs/recommended.json", "lint": "eslint ./src ./tests", "test": "mocha --compilers js:babel-register ./tests/rules/index.js"