eslint-config-sonar

eslint-config-sonar

eslint configuration to ensure SonarJS rules are met, following the 'Sonar way' preset.

Usage

npm install eslint-config-sonar --save-dev

Then add the following to your .eslintrc:

{
  "extends": [
    "sonar",
  ]
}

In Development

This package is in development. The intention is for it to eventually include:

• Documentation of all SonarJS rules and their equivalent in eslint.
• Ports of any rules not covered by existing eslint rules.
• eslint configs for Sonar way (eslint-config-sonar) and Sonar way Recommended (eslint-config-sonar:recommended) profiles.

PRs are welcomed and I'd also encourage @SonarSource to take over ownership of this.

Supported rules

Initially I am only aiming to include those listed in the Sonar way preset, rather than every rule supported by SonarJS, purely because this is the preset I'm currently using.

Where I have found an equivalent in eslint, it has been listed here and included in the config.

Where no equivalent is listed, it is listed in the next section and has not yet been implemented in the eslint config.

Bugs

"delete" should be used only with object properties

no-delete-var

eslint throws a parsing error in strict mode.

"NaN" should not be used in comparisons

use-isnan

"super()" should be invoked appropriately

constructor-super no-this-before-super

"Symbol" should not be used as a constructor

no-new-symbol

"with" statements should not be used

no-with

eslint throws a parsing error in strict mode.

"yield" expressions should not be used outside generators

eslint throws a parsing error:

Parsing error: yield is a reserved word (Fatal)

A "for" loop update clause should move the counter in the right direction

for-direction

All branches in a conditional structure should not have exactly the same implementation

sonarjs/no-all-duplicated-branches

Attempts should not be made to update "const" variables

no-const-assign

Bitwise operators should not be used in boolean contexts

no-bitwise

Callbacks of array methods should have return statements

array-callback-return

Collection elements should not be replaced unconditionally

sonarjs/no-element-overwrite

Comma and logical OR operators should not be used in switch cases

Partially covered by no-sequences.

Destructuring patterns should not be empty

no-empty-pattern

Function argument names should be unique

no-dupe-args

eslint throws a parsing error in strict mode.

Parsing error: Argument name clash in strict mode (Fatal)

Function calls should not pass extra arguments

sonarjs/no-extra-arguments

Generators should "yield" something

require-yield

Identical expressions should not be used on both sides of a binary operator

Partially covered by no-self-compare. sonarjs/no-identical-expressions

Jump statements should not be followed by dead code

no-unreachable

Jump statements should not occur in "finally" blocks

no-unsafe-finally

Loops should not be infinite

Partially covered by no-unreachable.

Non-empty statements should change control flow or have at least one side-effect

no-unused-expressions

Non-existent operators '=+', '=-' and '=!' should not be used

space-unary-ops space-infix-ops

Property names should not be duplicated within a class or object literal

no-dupe-keys

Related "if/else if" statements and "cases" in a "switch" should not have the same condition

sonarjs/no-identical-conditions

Results of "in" and "instanceof" should be negated rather than operands

no-unsafe-negation

Special identifiers should not be bound or assigned

eslint throws a parsing error in strict mode:

Parsing error: eval is a reserved word in strict mode (Fatal)

The output of functions that don't return anything should not be used

sonarjs/no-use-of-empty-return-value

Variables should not be self-assigned

no-self-assign

Code smells

"catch" clauses should do more than rethrow

sonarjs/no-useless-catch

"future reserved words" should not be used as identifiers

All of these are picked up as parsing errors when in strict mode.

"switch" statements should have at least 3 "case" clauses

sonarjs/no-small-switch

"switch" statements should not contain non-case labels

no-restricted-syntax no-labels

"switch" statements should not have too many "case" clauses

sonarjs/max-switch-cases

A "while" loop should be used instead of a "for" loop

sonarjs/prefer-while

Boolean checks should not be inverted

sonarjs/no-inverted-boolean-check

Boolean expressions should not be gratuitous

Partial coverage from no-constant-condition

Comma operator should not be used

no-sequences

Dead stores should be removed

no-unused-vars

Default export names and file names should match

filenames/match-exported

Extra semicolons should be removed

no-extra-semi

Function call arguments should not start on new lines

no-unexpected-multiline

Functions should not be called both with and without "new"

Partial coverage with new-cap.

Functions should not be defined inside loops

no-loop-func

Jump statements should not be used unconditionally

Partial coverage with no-continue.

Labels should not be used

no-restricted-syntax no-labels

Multiline string literals should not be used

no-multi-str

Nested blocks of code should not be left empty

no-empty

Octal values should not be used

eslint will throw a parsing error (Invalid number)

Return of boolean expressions should not be wrapped into an "if-then-else" statement

sonarjs/prefer-single-boolean-return

Switch cases should end with an unconditional "break" statement

no-fallthrough

Two branches in a conditional structure should not have exactly the same implementation

sonarjs/no-duplicated-branches

Unused local variables and functions should be removed

no-unused-vars

Variables and functions should not be redeclared

no-redeclare

Variables should be declared explicitly

no-undef

Wrapper objects should not be used for primitive types

no-new-wrappers

Vulnerabilities

"alert(...)" should not be used

no-alert

Cross-document messaging domains should be carefully restricted

no-wildcard-postmessage from eslint-plugin-no-wildcard-postmessage

Debugger statements should not be used

no-debugger

Not yet supported

Please open an issue if you know of an equivalent eslint rule.

Bugs

"in" should not be used with primitive types

"new" operators should be used with functions

Calls should not be made to non-callable values

Collection sizes and array length comparisons should make sense

Conditionally executed blocks should be reachable

Errors should not be created without being thrown

Properties of variables with "null" or "undefined" values should not be accessed

Return values from functions without side effects should not be ignored

Setters should not return values

Strict equality operators should not be used with dissimilar types

Values should not be uselessly incremented

Code smells

"delete" should not be used on arrays

"indexOf" checks should not be for positive numbers

A conditionally executed single line should be denoted by indentation

Arguments to built-in functions should match documented types

Array indexes should be numeric

Assignments should not be redundant

Collection and array contents should be used

Conditionals should start on new lines

Equality operators should not be used in "for" loop termination conditions

Function parameters with default values should be last

Function returns should not be invariant

Multiline blocks should be enclosed in curly braces

Redundant pairs of parentheses should be removed

The global "this" object should not be used

Unary operators "+" and "-" should not be used with objects

Unnecessary imports should be removed