Code Inspections in JavaScript and TypeScript

Reports a method call to document.write() or document.writeln(). Most usages of such calls are performed better with explicit DOM calls, such as getElementByID() and createElement(). Additionally, the write() and writeln() calls will not work with XML DOMs, including DOMs for XHTML if viewed as XML. This can result in difficulty to point out bugs.

Reports a common JavaScript pattern for detecting the browser or operating system in which the script is run. In addition to pointing out non-portable constructs, these platform detection patterns are often incomplete and easily fooled. For most cases, detection of individual environment features is preferable to attempting to detect the entire platform.

Patterns detected include:

• document.all

• document.layers

• navigator.userAgent

• navigator.oscpu

• navigator.appName

• navigator.appCodeName

• navigator.platform

Reports common JavaScript DOM patterns which may present problems with XHTML documents. In particular, the patterns detected will behave completely differently depending on whether the document is loaded as XML or HTML. This can result in subtle bugs where script behaviour is dependent on the MIME-type of the document, rather than its content. Patterns detected include document.body, document.images, document.applets, document.links, document.forms, and document.anchors.

Reports a JavaScript access to DOM nodes as text using the innerHTML property. Most usages of innerHTML are performed better with explicit DOM calls, such as getElementByID() and createElement(). Additionally, innerHTML will not work with XML DOMs, including DOMs for XHTML if viewed as XML. This can lead to difficulties in diagnosing bugs.

Reports a dependency from package.json that is not installed or doesn't match the specified version range.

Reports a usage of a JSX construction without importing React namespace. Having React namespace in the file scope ensures proper code compilation.

The inspection is disabled in projects with React 17+ because these versions no longer require React namespace.

Reports a module from a require() call or an import statement that is not installed or is not listed in package.json dependencies.

Suggests installing the module and/or including it into package.json.

For require() calls, works only in the files from the scope of Node.js Core JavaScript library.

Reports a redundant import statement. This is usually the case if the imported symbols are not used in the source file. To avoid side-effects, consider using bare import import 'packageName' instead of the regular one.

Reports a discrepancy detected by the ESLint linter.

The highlighting is based on the rule severity specified in the ESLint configuration file for each individual rule.

Clear the 'Use rule severity from the configuration file' checkbox to use the severity configured in this inspection for all ESLint rules.

Reports a problem detected by the JSHint linter.

Reports a discrepancy detected by the JavaScript Standard Style linter.

The highlighting severity in the editor is based on the severity level the linter reports.

Reports a discrepancy detected by the TSLint linter.

The highlighting is based on the rule severity specified in the TSLint configuration file for each individual rule.

Clear the 'Use rule severity from the configuration file' checkbox to use the severity configured in this inspection for all TSLint rules.

Reports an assignment operation that can be replaced by an operator assignment to make your code shorter and probably clearer.

Example:

Reports an assignment to a variable declared as a for loop parameter. Although occasionally intended, this construct can be extremely confusing, and is often a result of an error.

Reports an assignment to a function parameter, including increment and decrement operations. Although occasionally intended, this construct can be extremely confusing, and is often a result of an error.

Reports an assignment that is used as the condition of an if, while, for, or do statement. Although occasionally intended, this usage is confusing, and often indicates a typo (for example, = instead of ==).

Reports an assignment expression nested inside another expression, for example, a = b = 1. Such expressions may be confusing and violate the general design principle that a given construct should do precisely one thing.

Reports an assignment expression where the result of the assignment is used in the containing expression. Such assignments often indicate coding errors, for example, = instead of ==. Moreover, they can result in confusion due to the order of operations, as evaluation of the assignment may affect the outer expression in unexpected ways.

Expressions in parentheses are ignored.

Reports an assignment in the form x = x.

Reports any floating point number that does not have a decimal point, or any numbers before the decimal point, or and numbers after the decimal point. Such literals may be confusing, and violate several coding standards.

Reports a suspicious combination of + or - characters in JavaScript code (for example, a+++b. Such sequences are confusing, and their semantics may change through changes in the whitespace.

Reports a call of the eval(), setTimeout(), or setInterval() function or an allocation of a Function object. These functions are used to execute arbitrary strings of JavaScript text, which often dynamically generated. This can be very confusing, and may be a security risk.

Ignores the cases when a callback function is provided to these methods statically, without code generation.

Reports a "magic number" that is a numeric literal used without being named by a constant declaration. Magic numbers can result in code whose intention is unclear, and may result in errors if a magic number is changed in one code location but remains uncahnged in another. The numbers 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1000, 0.0 and 1.0 are ignored.

Reports if statements which have an else branch and a negated condition. Flipping the order of the if and else branches will usually increase the clarity of such statements.

Reports a conditional expression whose condition is negated. Suggests flipping the order of branches in the conditional expression to increase the clarity of the statement. Example: !condition ? 2 : 1

Reports a ternary conditional expression within another ternary condition. Such nested conditionals may be extremely confusing, and best replaced by more explicit conditional logic.

Reports a function nested inside another function. Although JavaScript allows functions to be nested, such constructs may be confusing.

Use the checkbox below to ignore anonymous nested functions.

Reports an arithmetic expression with too many terms. Such expressions may be confusing and bug-prone.

Use the field below to specify the maximum number of terms allowed in an arithmetic expression.

Reports a boolean expression with too many terms. Such expressions may be confusing and bug-prone.

Use the field below to specify the maximum number of terms allowed in an arithmetic expression.

Reports an arithmetic expression that include adding or subtracting zero, multiplying by zero or one, division by one, and shift by zero. Such expressions may result from not fully completed automated refactoring.

Reports an increment (++) or decrement (--) expression where the result of the assignment is used in a containing expression. Such assignments can result in confusion due to the order of operations, as evaluation of the assignment may affect the outer expression in unexpected ways. Example: var a = b++

Reports an if, while, for, or with statement with an empty body. Such statements often result from typos, and may cause confusion.

Use the checkbox below to specify whether the statements with empty block statements as bodies should be reported.

Reports a block statement that is not used as the body of if, for, while, do, with, or try statements, or as the body of a function declaration. Starting from ECMAScript 6, JavaScript blocks introduce new scopes for let and const variables, but still free-standing block statements may be confusing and result in subtle bugs when used with var variables.

Reports a usage of the caller property in a JavaScript function. Using this property to access the stack frame of the calling method can be extremely confusing and result in subtle bugs.

Suggests configuring coding assistance for Node.js, for example, require and/or core modules ('path', 'http', 'fs', etc.).

See https://nodejs.org/api/ for the complete list.

Reports a failed method call or an assertion in a test.

Reports a potential error in a file path ('basePath', 'files') for a Karma configuration file, for example, karma.conf.js.

Reports a usage of await in a function that was possibly intended to be async but is actually missing the async modifier. Although await can be used as an identifier, it is likely that it was intended to be used as an operator, so the containing function should be made async.

Reports an async function call without an expected await prefix inside an async function. Such call returns a Promise and control flow is continued immediately.

Example:

• You won't forget to add await when surrounding your code with try-catch.

• An explicit await helps V8 runtime to provide async stack traces.

Reports a redundant usage of await, such as await await, or awaiting a non-promise result.

When the 'Report for promises' checkbox is selected, suggests removing await before promises when applicable (in return statements, and with Promise.resolve/reject).
Removing await in such contexts causes two problems.

• Surrounding your code with try-catch and forgetting to add await will change code semantics while you may fail to notice that.

• Having an explicit await may prevent the V8 runtime from providing async stack traces.

Reports a function call that returns a Promise that is not used later. Such calls are usually unintended and indicate an error.

Reports a usage of a top-level await expression. While the new 'top-level async' proposal is on its way, using await outside async functions is not allowed.

Reports a this expression outside an object literal or a constructor body. Such this expressions reference the top-level "global" JavaScript object, but are mostly useless.

Reports reassigning a value to a constant or a readonly variable.

Reports an expression statement that is neither an assignment nor a call. Such statements usually indicate an error.

Reports a function that returns a value in some cases while in other cases no value is returned. This usually indicates an error.

Example:

Reports a deprecated octal integer literal prefixed with 0 instead of 0o.
Such literals are not allowed in modern ECMAScript code, and using them in the strict mode is an error.
To force this inspection for ES5 and ES3 language levels, select the 'Warn about obsolete octal literals in ES5- code' checkbox below.

Reports a JavaScript reserved word used as a name. The JavaScript specification reserves a number of words which are currently not used as keywords. Using those words as identifiers may result in broken code if later versions of JavaScript start using them as keywords.

Reports a string literal that contains a </ sequence. Such strings may result in incorrect parsing of any HTML in which the JavaScript code is embedded.

Reports am unnecessary local variable that does not make a function more comprehensible:

• a local variable that is immediately returned

• a local variable that is immediately assigned to another variable and is not used anymore

• a local variable that always has the same value as another local variable or parameter.

Reports reusing a local variable and overwriting its value with a new value that is not related to the original variable usage. Reusing a local variable in this way may be confusing because the intended semantics of the local variable may vary with each usage. It may also cause bugs, if code changes result in values that were expected to be overwritten while they are actually live. It is good practices to keep variable lifetimes as short as possible, and not reuse local variables for the sake of brevity.

Reports a public constructor of an abstract class and suggests making it protected (because it is useless to have it public).

Reports a common mistake in TypeScript code, when a class field is declared as a constructor parameter, and then this parameter is assigned.
In this case, the corresponding field won't be assigned, only the local parameter value is modified.

Reports a duplicate type inside a union or intersection.

Reports a type annotation that doesn't match the current code style for explicit types.

Type declarations are not necessary when the type that is inferred from the context exactly matches the type annotation, for example:

var pi: number = 3.14

In some cases it is preferable to always have explicit types - this prevents accidental type changes and makes code more explicit.

Reports a private field that can be made readonly (for example, if the field is assigned only in the constructor).

Reports inconsistency of a paths, checkJs, or extends property in a tsconfig.json file. The paths property requires baseUrl.
The checkJs property requires allowJs.
The extends property should be a valid file reference.

Reports an invalid type argument in a function, interface, or class declaration.

Reports a usage from augmentation module without an explicit import.

Reports a TypeScript library file that is required for a symbol but is not listed under the lib compiler option in tsconfig.json.

Reports a usage that requires an explicit option in tsconfig.json. For example, to use JSX in .tsx files, tsconfig.json must contain "jsx": "react".

Reports a usage of a variable where the variable type is narrowed by a type guard. Note that severity level doesn't affect this inspection.

Reports a type argument that is equal to the default one and can be removed.

Example:

Reports a usages of a UMD global variable if the current file is a module (EcmaScript or CommonJS). Referencing UMD variables without explicit imports can lead to a runtime error if the library isn't included implicitly.

Reports a function call with a parameter, return value, or assigned expression or incorrect type, if the context symbol can be implicitly resolved to the any type.

Reports an unreesolved reference to a JSX (React) component. Suggests adding an import statement if the referenced component is defined in the project or its dependencies or creating a new component with the specified name.

The template for a new component can be modified in Editor | File and Code Templates.

Reports a call of a function that is not resolved.

Reports an unresolved reference to a variable or field.

Reports an unresolved name or binding in an import declaration in TypeScript code.

Reports a for loop where the condition or update does not use the for loop variable.

Reports a comparison of a typeof expression with a literal string which is not one of the standard types: undefined, object, boolean, number, string, function, or symbol. Such comparisons always return false.

Reports a comparison with operands of incompatible types or an operand with a type without possible common values.

Reports a comparison with NaN. Comparisons like expr == NaN or expr === NaN are always evaluated to false.

Reports a consecutive comma in an array literal. The skipped element accepts the undefined value, but it could be done unintentionally, for example, when commas are at the end of one line and at the beginning of the next one.

Reports a constructor function that returns a primitive value. When called with new, this value will be lost and an object will be returned instead. To avoid warnings, use the @return tag to specify the return of the function.

Reports division by zero or a remainder by zero.

Reports a usage of an equality operator that may cause unexpected type coercions. Suggests replacing == and != with type-safe equality operators === and !==.

Depending on the option selected, one of the following cases will be reported:

• All usages of == and != operators.

• All usages except comparison with null. Some code styles allow using x == null as a replacement for x === null || x === undefined.

• Only suspicious expressions, such as: == or != comparisons with 0, '', null, true, false, or undefined.

Reports a for, while, or do statement which can only exit by throwing an exception. Such statements often indicate coding errors.

Reports a function which must either recurse infinitely or throw an exception. Such functions may not return normally.

Reports a potentially invalid indexed property access, for example, Array[1].

Reports a usage of a potentially invalid constructor function, for example: a function that is not a constructor after new, using a constructor's prototype or calling a constructor without new. A constructor function is assumed to have an upper case name (optional) or have an explicit JSDoc @constructor tag.

Reports a this in closure that is used for referencing properties of outer context.

Example:

Reports an attempt to reference a member of an ECMAScript class via the this. qualifier in a nested function that is not a lambda.
this in a nested function that is not a lambda is the function's own this and doesn't relate to the outer class.

Reports object allocation where the result of the allocated object is ignored, for example, new Error(); as a statement, without any assignment. Such allocation expressions may indicate an odd object initialization strategy.

Reports an assignment in the form a =+ b. Suggests replacing with a += b.

Reports bind used together with an arrow function.
Because arrow functions use lexical this, a bind call will have no effect on them.
See here for details.

Reports an assignment or a function call where the name of the target variable or the function parameter does not match the name of the value assigned to it.

Example:

Reports a return value of a function that doesn't return anything. Calling of such functions always produces an undefined value and such assignment may indicate an error.

Example:

• Inside a return statement

• In some binary operations

• For overridden non-void functions

Reports a for loop that contains neither initialization nor an update component. Suggests replacing the loop with a simpler while statement.

Example:

Reports an if statement with identical then and else branches. Such statements are almost certainly an error.

Reports an if statement with too many branches. Such statements may be confusing, and often indicate inadequate levels of design abstraction.

Use the field below to specify the maximum number of branches expected.

Reports a ternary conditional expression with identical then and else branches.

Reports a conditional expression in the format true? result1: result2 or false? result1: result2. Suggests simplifying the expression.

Reports duplicate conditions in different branches of an if statement. Duplicate conditions usually represent programmer oversight.

Example:

Reports a for, while, or do statement whose bodies are guaranteed to execute at most once. Normally, this indicates an error.

Reports an error caused by invoking a method, accessing a property, or calling a function on an object that is undefined or null.

Reports a pointless or pointlessly complicated boolean expression or statement.

Example:

Reports an if statement that can be simplified to a single assignment or a return statement.

Example:

Reports a conditional expression of the form condition ?true:false or condition ?false:true. These expressions may be safely converted to condition or !condition respectively.

Reports a tail recursion, that is, when a function calls itself as its last action before returning. A tail recursion can always be replaced by looping, which will be considerably faster. Some JavaScript engines perform this optimization, while others do not. Thus, tail recursive solutions may have considerably different performance characteristics in different environments.

Reports an unnecessary continue statement at the end of a loop. Suggests removing such statements.

Reports an unnecessary return statement, that is, a return statement that returns no value and occurs just before the function would have "fallen through" the bottom. These statements may be safely removed.

Reports an unused label.

Reports a labeled break statement whose labels may be removed without changing the flow of control.

Reports a labeled continue statement whose labels may be removed without changing the flow of control.

Reports code that can never be executed, which almost certainly indicates an error

Reports a typeof or instanceof unsound type guard check. The typeof x type guard can be unsound in one of the following two cases:

• typeof x never corresponds to the specified value (for example, typeof x === 'number' when x is of the type 'string | boolean')

• typeof x always corresponds to the specified value (for example, typeof x === 'string' when x is of the type 'string')

• The type of x is not related to A

• The type of x is A or a subtype of A

Reports a break or continue statement inside a finally block. Such statements are very confusing, may hide exceptions, and complicate debugging.

Reports a return statement inside a finally block. Such return statements may mask exceptions thrown, and complicate debugging.

Reports s throw statement inside a finally block. Such throw statements may mask exceptions thrown, and complicate debugging.

Reports an empty catch block. This indicates that errors are simply ignored instead of handling them.

Any comment in a catch block mutes the inspection.

Reports an empty finally block, which usually indicates an error.

Reports an empty try block, which usually indicates an error.

Reports a throw statement whose exceptions are always caught by the containing try statement. Using throw statements as a goto to change the local flow of control is confusing.

Reports a catch parameter that is not used in the corresponding block. The catch parameters named ignore or ignored are ignored.

Use the checkbox below to disable this inspection for catch blocks with comments.

Reports a class or a function that is annotated with a JSDoc @constructor or @class tag whose names are too short, too long, or do not follow the specified regular expression pattern.

Use the fields provided below to specify minimum length, maximum length, and a regular expression expected for classes names. Use the standard java.util.regex format for regular expressions.

Reports a function whose name is too short, too long, or does not follow the specified regular expression pattern.

Use the fields provided below to specify minimum length, maximum length, and a regular expression for function names. Use the standard java.util.regex format for regular expressions.

Reports a function parameter whose name is too short, too long, or doesn't follow the specified regular expression pattern.

Use the fields provided below to specify minimum length, maximum length and regular expression expected for local variables names. Use the standard java.util.regex format regular expressions.

Reports a non-ASCII symbol in a name.

If the 'Allow only ASCII names' option isselected, reports all names that contain non-ASCII symbols.
Otherwise reports all names that contain both ASCII and non-ASCII symbols.

Reports a local variable whose name is too short, too long, or doesn't follow the specified regular expression pattern.

Use the fields provided below to specify minimum length, maximum length, and a regular expression expected for local variables names. Use the standard java.util.regex format regular expressions.

Reports a JavaScript code fragment that is not covered by the Flow type checker. To use this inspection, configure the Flow executable in Settings | Languages & Frameworks | JavaScript.

Reports errors from Flow.

Reports a @flow flag comment that is not located at the top of a file.

Reports a JavaScript file with a @flow flag that doesn't have an associated .flowconfig file in the project.

Reports a function with three or more negation operations (! or !=). Such functions may be unnecessarily confusing.

Reports a function with multiple loop statements.

Reports a function with multiple return points. Such functions are hard to understand and maintain.

Reports a function with too many parameters. Such functions often indicate problems with design.

Use the field below to specify the maximum acceptable number of parameters for a function.

Reports a function with too many branching points in a function (too high cyclomatic complexity). Such functions may be confusing and hard to test.

Use the field provided below to specify the maximum acceptable cyclomatic complexity for a function.

Reports an overly long function. Function length is calculated by counting up the number of non-empty statements in the function. Functions that are too long are error-prone and difficult to test.

Use the field below to specify the maximum acceptable number of statements in a function.

Reports a function whose body contains statements that are too deeply nested within other statements. Such functions may be confusing and indicate that refactoring may be necessary.

Use the field provided below to specify the maximum acceptable nesting depth allowed in a function.

Checks that declarations of local variables declared with var are at the top of a function scope.

By default, variable declarations are always moved ("hoisted") invisibly to the top of their containing scope when the code is executed. Therefore, declaring them at the top of the scope helps represent this behavior in the code.

Reports a chained equality comparison (i.e. a==b==c). Such comparisons are confusing.

Reports a function call whose target is another function call, for example, foo().bar()

Reports a comparison operation with a constant value in the left-hand side. According to coding conventions, constants should be in the right-hand side of comparisons.

Reports a comparison operation with a constant in the right-hand side. According to coding conventions, constants should only be in the left-hand side of comparisons.

Reports a function call that is used as an argument in another function call, for example, foo(bar())

Reports an arrow function whose body only consists of braces and exactly one statement. Suggests converting to concise syntax without braces.

let incrementer = (x) => {return x + 1};

After the quick-fix is applied, the code fragment looks as follows:

let incrementer = (x) => x + 1;

Reports a if, while, for, or with statements whose body is not a block statement. Using code block in statement bodies is usually safer for downstream maintenance.

Reports an assignment to a property that is not defined in the type of a variable.

Example:

Reports redundant parentheses.

In expressions: var x = ((1) + 2) + 3

In arrow function argument lists: var incrementer = (x) => x + 1

In TypeScript and Flow type declarations: type Card = (Suit & Rank) | (Suit & Number)

Reports a statement without a semicolon or a newline at the end.

Select the 'Terminate statements with semicolons' option in Editor | Code Style | JavaScript or TypeScript - Punctuation to report any statement that doesn't end with a semicolon, even if a newline is used. According to some coding styles, semicolons are preferred to line-breaks for consistency with the other languages.

Reports #x -styled access to private fields.

Such syntax was allowed in the early versions of the specification draft, but is no longer a valid syntax. Most recent versions of the draft only allow using this. qualifier explicitly.

Reports a usage of a deprecated function variable.

Reports multiple destructuring properties with identical keys. Suggests merging the properties.

Reports multiple declarations in a scope.

Reports basic syntax issues and inconsistencies with language specification, such as invalid usages of keywords, usages of incompatible numeric format, or multiple parameters to getters/setters.
Generally, such errors must always be reported and shouldn't be disabled. But in some cases, such as issues due to the dynamic nature of JavaScript, the use of not yet supported language features, or bugs in IDE's checker, it may be handy to disable reporting these very basic errors.

Reports an implicit declaration of a global variable.

Example:

Reports an ES6 import whose from part can be shortened. Suggests importing the parent directory.

Reports a reference to a JavaScript member that is marked with s @private or @protected tag but does not comply with visibility rules that these tags imply.

Reports warnings implied by Google Closure Compiler annotations including correct use of @abstract, @interface, and @implements tags.

Reports a duplicated jQuery selector that can be cached or a usage of an attribute or a pseudo-selector (optional).

Reports a class method that can be safely made static. A method can be static if it does not reference any of its class' non-static methods and non-static fields and is not overridden in a subclass.

Use the first checkbox below to inspect only private methods.

Reports mismatch between the names and the number of parameters within a JSDoc comment and the actual parameters of a function.

Reports a collection of fields or variables whose contents are either queried and not updated or updated and not queried. Such mismatched queries and updates are pointless and may indicate either dead code or a typographical error.

Query methods are automatically detected, based on whether they return something, or a callback is passed to them. Use the table below to specify which methods are update methods.

Reports a URL of an external JavaScript library that is not associated with any locally stored file. Suggests downloading the library. Such association enables the IDE to provide proper code completion and navigation.

Reports a JavaScript file that is not in the strict mode.

Reports an improper usage of a wrapper for primitive types or a property of a primitive type being modified, as in the latter case the assigned value will be lost.

Reports an object property that can be converted to ES6 shorthand style and provides a quick-fix to do it.

var obj = {foo:foo}

After applying the quick-fix the code looks as follows:

var obj = {foo}

Reports a usage of a React JSX tag in JavaScript code.

Reports nested instances of a string or a template literal. Suggests inlining the nested instances into the containing template string.

Example: `Hello, ${`Brave ${"New"}`} ${"World"}!`

After applying the quick-fix the code looks as follows: `Hello, Brave New World!`

Reports access to outer mutable variables from functions.

Example:

Reports a JavaScript call expression where the arguments do not match the signature of the referenced function, including the types of arguments and their number. Also, reports if the overloading function doesn't match the overloaded one in terms of parameters and return types.

TypeScript code is ignored.

Reports a syntax discrepancy in a documentation comment.

Reports incorrect type of:

• a parameter in a function call

• a return value

• an assigned expression

Reports unfiltered for-in loops.

The use of this construct results in processing not only own properties of an object but properties from its prototype as well. It may be unexpected in some specific cases, for example, in utility methods that copy or modify all properties or when Object 's prototype may be incorrectly modified. For example, the following code will print 42 and myMethod:

Reports an unneeded semicolon.

Reports a usage of a trailing comma in an array literal.

The warning is reported only when the JavaScript language version is set to ECMAScript 5.1.

Although trailing commas in arrays are allowed by the specification, some browsers may throw an error when a trailing comma is used.

You can configure formatting options for trailing commas in Code Style | JavaScript or TypeScript | Punctuation.

Reports usages of a trailing comma in object literals.

The warning is reported only when the JavaScript language version is set to ECMAScript 5.1.

Trailing commas in object literals are allowed by the specification, however, some browsers might throw an error when a trailing comma is used.

You can configure formatting options for trailing commas in Code Style | JavaScript or TypeScript | Punctuation.

Reports an Ext JS xtype reference that doesn't have a corresponding class.

Reports an unresolved function in a call.

TypeScript code is ignored.

Reports an unresolved referenced variable or field.

TypeScript code is ignored.

Reports an unresolved file reference in a JavaScript file, including CommonJS and AMD modules references.

Reports a class member initializer which references another non-hoisted class member while the latter may be not initialized yet.

Initialization of class members happens consequently for fields, so a field cannot reference another field that is declared later.

Reports a variable that is declared without an initializer and is used much further in the code or in a single nested scope. Suggests moving the variable closer to its usages and joining it with the initializer expression.

Validates options in webpack config files (which name should start with `webpack`, e.g. `webpack.config.js`) against webpack options schema.

Disable this inspection to turn off validation and code completion inside the configuration object.

Reports a usage of a for..in loop on an array. Suggests replacing it with a for..of loop.
for..of loops, which are introduced in ECMAScript 6, iterate over iterable objects. For arrays, this structure is preferable to for..in, because it works only with array values but not with array object's properties.

Reports a let declaration that can be made const.

Reports a module.export statement. Suggests replacing it with a export or export default statement.

Please note that the quick-fix for converting module.export into export is not available for module.export inside functions or statements because export statements can only be at the top level of a module.

Reports a require() statement. Suggests converting it to a require() call with an import statement.

Enable 'Convert require() inside inner scopes with Fix all action' to convert all require() calls inside the nested functions and statements when using the 'Fix all' action.

Please note that converting require() statements inside inner scopes to import statements may cause changes in the semantics of the code. Import statements are static module dependencies and are hoisted, which means that they are moved to the top of the current module. require() calls load modules dynamically. They can be executed conditionally, and their scope is defined by the expression in which they are used.
Clear the 'Convert require() inside inner scopes with Fix all action' checkbox to prevent any changes in these complex cases when using the 'Fix all' action.

Reports a var declaration that is used instead of let or const.
Both let and const are block-scoped and behave more strictly.

Suggests replacing all var declarations with let or const declarations, depending on the semantics of a particular value. The declarations may be moved to the top of the function or placed before the first usage of the variable to avoid Reference errors.
Select the 'Conservatively convert var with Fix all action' option to prevent any changes in these complex cases when using the 'Fix all' action.

Reports a function expression. Suggests converting it to an arrow function.

Example:

Reports an indexed for loop used on an array. Suggests replacing it with a for..of loop.
for..of loops are introduced in ECMAScript 6 and iterate over iterable objects.

Reports a string concatenation. Suggests replacing it with a template literal

Example

Reports a switch statement where the default case comes before another case instead of being the very last case, which may cause confusion.

Reports a switch statement on a variable of the type enum or union when the statement doesn't cover some value options from the type.

Reports a switch statement without a default clause when some possible values are not enumerated.

Reports a switch statement with an empty body, or with only one case branch, or with a default branch only.

Reports a duplicated case label on a switch statement, which normally indicates an error.

Reports a switch statement where control can proceed from a branch to the next one. Such "fall-through" often indicates an error, for example, a missing break or return.

Reports a switch statement that is nested in another switch statement. Nested switch statements may be very confusing, particularly if indenting is inconsistent.

Reports a labeled statement inside a switch statement, which often results from a typo.

Example:

Reports an unreachable case branch of a switch statement.

Example:

Reports a variable that is declared in one case clause of a switch statement but is used in another case clause of the same statement. For block-scoped variables, this results in throwing a ReferenceError. For var variables, it indicates a potential error.

Disable the inspection for var variables if this pattern is used intentionally.

Reports an expression that includes and with zero, or by zero, or shifting by zero. Such expressions may result from not fully completed automated refactorings.

Reports a suspicious usage of a bitwise AND (" &") or OR (" |") operator. Usually it is a typo and the result of applying boolean operations AND (" &&") and OR (" ||") is expected.

Reports a bitwise mask expression which for sure evaluates to true or false and . Expressions are of the form (var & constant1) == constant2 or (var | constant1) == constant2, where constant1 and constant2 are incompatible bitmask constants.

Example:

Reports a shift operation where the second operand is a constant outside the reasonable range, for example, an integer shift operation outside the range 0..31, shifting by negative or overly large values.

Reports a variable whose value is never used after assignment.
Suggests removing the unused variable to shorten the code and to avoid redundant allocations.

The following cases are reported:

• A variable is never read after assignment.

• The value of a variable is always overwritten with another assignment before the variable is read next time.

• The initializer of a variable is redundant (for one of the above mentioned reasons).

Reports an unused globally accessible public function, variable, class, or property.

Reports an unused locally accessible parameter, local variable, function, class, or private member declaration.

Reports a break statements. Ignores break statements that end case blocks.

Reports a labeled break statement.

Reports a continue statement.

Reports a labeled continue statement.

Reports a debugger statement used for interaction with the Javascript debuggers. Such statements should not appear in production code.

Reports a void expression.

Reports a with statements. Such statements result in potentially confusing implicit bindings, and may behave strangely in setting new variables.

Reports an anonymous function. An explicit name of a function expression may be helpful for debugging. Ignores function expressions without names if they have a name property specified in the ECMAScript 6 standard. For example, var bar = function() {}; is not reported.

Reports a comma expression. Such expressions are often a sign of overly clever code, and may lead to subtle bugs. Comma expressions in the initializer or in the update section of for loops are ignored.

Reports a ternary conditional expression. Some coding standards prohibit such expressions in favor of explicit if statements.

Reports a labeled statement.