Code Inspections in JavaScript and TypeScript
This topic lists all JetBrains Rider code inspections available in JavaScript and TypeScript.
You can toggle specific inspections or change their severity level on the Editor | Inspection Settings | Inspection Severity | Other Languages settings page Ctrl+Alt+S.
Code quality tools
Inspection | Description | Default Severity |
---|---|---|
ESLint | 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. | |
JSHint | Reports a problem detected by the JSHint linter. | |
Standard code style | 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. | |
TSLint | 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. |
Assignment issues
Inspection | Description | Default Severity |
---|---|---|
Assignment could be replaced with operator assignment | Reports an assignment operation that can be replaced by an operator assignment to make your code shorter and probably clearer. Example: x = x + 3;
After the quick fix is applied the result looks like: x += 3;
| |
Assignment to 'for' loop parameter | Reports an assignment to a variable declared as a | |
Assignment to function parameter | 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. | |
Assignment used as condition | Reports an assignment that is used as the condition of an | |
Nested assignment | Reports an assignment expression nested inside another expression, for example, | |
Result of assignment used | Reports an assignment expression where the result of the assignment is used in the containing expression. Such assignments often indicate coding errors, for example, Expressions in parentheses are ignored. | |
Variable is assigned to itself | Reports an assignment in the form |
Potentially confusing code constructs
Inspection | Description | Default Severity |
---|---|---|
Confusing floating point literal | 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. | |
Confusing sequence of '+' or '-' | Reports a suspicious combination of | |
Execution of dynamically generated code | Reports a call of the Ignores the cases when a callback function is provided to these methods statically, without code generation. | |
Magic number | 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 unchanged in another. The numbers 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1000, 0.0 and 1.0 are ignored. | |
Negated 'if' statement | 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. | |
Negated conditional expression | 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: | |
Nested conditional expression | Reports a ternary conditional expression within another ternary condition. Such nested conditionals may be extremely confusing, and best replaced by more explicit conditional logic. | |
Nested function | 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. | |
Overly complex arithmetic expression | 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. | |
Overly complex boolean 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. | |
Pointless 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. | |
Result of increment or decrement used | Reports an increment ( | |
Statement with empty body | Reports an Use the checkbox below to specify whether the statements with empty block statements as bodies should be reported. | |
Unnecessary block statement | Reports a block statement that is not used as the body of | |
Use of 'caller' property | Reports a usage of the |
Validity issues
Inspection | Description | Default Severity |
---|---|---|
'this' expression which references the global object | Reports a | |
Attempt to assign to const or readonly variable | Reports reassigning a value to a constant or a readonly variable. | |
Expression statement which is not assignment or call | Reports an expression statement that is neither an assignment nor a call. Such statements usually indicate an error. | |
Function with inconsistent returns | Reports a function that returns a value in some cases while in other cases no value is returned. This usually indicates an error. Example:
function foo() {
if (true)
return 3;
return;
}
| |
Octal integer | Reports a deprecated octal integer literal prefixed with 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. | |
Reserved word used as name | 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. | |
String literal which breaks HTML parsing | Reports a string literal that contains a |
Data flow
Inspection | Description | Default Severity |
---|---|---|
Redundant local variable | Reports an unnecessary local variable that does not make a function more comprehensible:
Use the checkbox below to have this inspection ignore variables that are immediately returned or thrown. Some coding styles suggest using such variables for clarity and ease of debugging. | |
Reuse of local variable | 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. |
TypeScript
Inspection | Description | Default Severity |
---|---|---|
Abstract class constructor can be made protected | Reports a public constructor of an abstract class and suggests making it protected (because it is useless to have it public). | |
Assigned constructor field parameter | 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.
class Foo {
constructor(private p: number) {
p = 1; //must be this.p = 1;
}
}
| |
Duplicate union or intersection type component | Reports a duplicate type inside a union or intersection. | |
Explicit types | 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:
In some cases it is preferable to always have explicit types - this prevents accidental type changes and makes code more explicit. | No highlighting, only fix |
Field can be readonly | Reports a private field that can be made readonly (for example, if the field is assigned only in the constructor). | |
Inconsistent tsconfig.json properties | Reports inconsistency of a The The | |
Incorrect generic type argument | Reports an invalid type argument in a function, interface, or class declaration. | |
Missing augmentation import | Reports a usage from augmentation module without an explicit import. | No highlighting, only fix |
Missing global library | Reports a TypeScript library file that is required for a symbol but is not listed under the | |
Missing tsconfig.json option | Reports a usage that requires an explicit option in | |
Narrowed type | 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. | |
Redundant type arguments | Reports a type argument that is equal to the default one and can be removed. Example:
type Foo<T=number> = T;
let z: Foo<number>;
| |
Referenced UMD global variable | Reports a usage of a Universal Module Definition (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. | |
Type mismatch | Reports a parameter, return value, or assigned expression of incorrect type. | |
Type mismatch in 'any' type | 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
declare var test: any;
test.hasOwnProperty(true); //reports 'true'
| |
Unresolved TypeScript reference | Reports an unresolved reference in TypeScript code. | |
Unresolved imported name | Reports an unresolved name or binding in an |
Probable bugs
Inspection | Description | Default Severity |
---|---|---|
'for' loop where update or condition does not use loop variable | Reports a | |
'typeof' comparison with non-standard value | Reports a comparison of a | |
Comparison of expressions having incompatible types | Reports a comparison with operands of incompatible types or an operand with a type without possible common values. | |
Comparison with NaN | Reports a comparison with NaN. Comparisons like | |
Consecutive commas in array literal | Reports a consecutive comma in an array literal. The skipped element accepts the | |
Constructor returns primitive value | Reports a constructor function that returns a primitive value. When called with | |
Division by zero | Reports division by zero or a remainder by zero. | |
Equality operator may cause type coercion | Reports a usage of an equality operator that may cause unexpected type coercions. Suggests replacing Depending on the option selected, one of the following cases will be reported:
| |
Infinite loop statement | Reports a | |
Infinite recursion | Reports a function which must either recurse infinitely or throw an exception. Such functions may not return normally. | |
Possibly incorrect target of indexed property access | Reports a potentially invalid indexed property access, for example, | |
Potentially invalid constructor usage | Reports a usage of a potentially invalid constructor function, for example: a function that is not a constructor after | |
Potentially invalid reference to 'this' from closure | Reports a Example:
function Outer() {
this.outerProp = 1;
function inner() {
// bad, because 'outerProp' of Outer
// won't be updated here
// on calling 'new Outer()' as may be expected
this.outerProp = 2;
}
inner();
}
| |
Potentially invalid reference to 'this' of a class from closure | Reports an attempt to reference a member of an ECMAScript class via the | |
Result of object allocation ignored | Reports object allocation where the result of the allocated object is ignored, for example, | |
Suspicious '=+' assignment | Reports an assignment in the form | |
Suspicious usage of 'bind' with arrow function | Reports Because arrow functions use lexical See here for details. | |
Suspicious variable/parameter name combination | 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:
var x = 0;
var y = x;
or
var x = 0, y = 0;
var rc = new Rectangle(y, x, 20, 20);
Here the inspection guesses that Specify the names that should not be used together. An error is reported if a parameter name or an assignment target name contains words from one group while the name of the assigned or passed variable contains words from another group. | |
Void function return value used | Reports a return value of a function that doesn't return anything. Calling of such functions always produces an Example:
let a = console.log('foo');
The following usages are ignored:
|
Try statement issues
Inspection | Description | Default Severity |
---|---|---|
'continue' or 'break' inside 'finally' block | Reports a | |
'return' inside 'finally' block | Reports a | |
'throw' inside 'finally' block | Reports s | |
Empty 'catch' block | Reports an empty Any comment in a | |
Empty 'finally' block | Reports an empty | |
Empty 'try' block | Reports an empty | |
Exception used for local control-flow | Reports a | |
Unused 'catch' parameter | Reports a Use the checkbox below to disable this inspection for |
Naming conventions
Inspection | Description | Default Severity |
---|---|---|
Class naming convention | Reports a class or a function that is annotated with a JSDoc Use the fields provided below to specify minimum length, maximum length, and a regular expression expected for classes names. Use the standard | |
Function naming convention | 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 | |
Function parameter naming convention | 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 | |
Identifiers with non-ASCII symbols | Reports a non-ASCII symbol in a name. If the 'Allow only ASCII names' option is selected, reports all names that contain non-ASCII symbols. Otherwise reports all names that contain both ASCII and non-ASCII symbols. | |
Local variable naming convention | 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 |
Flow type checker
Inspection | Description | Default Severity |
---|---|---|
Code is not covered by Flow | Reports JavaScript code fragments that are not covered by the Flow type checker. To use this inspection, configure the Flow executable in Settings | Languages & Frameworks | JavaScript. | |
Flow type checker | Reports errors from Flow. | |
Misplaced @flow flag | Reports a | |
Missing .flowconfig | Reports a JavaScript file with a |
Function metrics
Inspection | Description | Default Severity |
---|---|---|
Function with more than three negations | Reports a function with three or more negation operations ( | |
Function with multiple loops | Reports a function with multiple loop statements. | |
Function with multiple return points | Reports a function with multiple return points. Such functions are hard to understand and maintain. | |
Function with too many parameters | 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. | |
Overly complex 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. | |
Overly long 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. | |
Overly nested 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. |
Code style issues
Inspection | Description | Default Severity |
---|---|---|
'var' declared not at the beginning of 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. | |
Chained equality | Reports a chained equality comparison (i.e. | |
Chained function call | Reports a function call whose target is another function call, for example, | |
Constant on left side of comparison | 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. | |
Constant on right side of comparison | 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. | |
Nested function call | Reports a function call that is used as an argument in another function call, for example, | |
Redundant braces around arrow function body | Reports an arrow function whose body only consists of braces and exactly one statement. Suggests converting to concise syntax without braces.
After the quick-fix is applied, the code fragment looks as follows:
| No highlighting, only fix |
Statement body without braces | Reports a | |
Undefined property assignment | Reports an assignment to a property that is not defined in the type of a variable. Example:
/**
* @type {{ property1: string, property2: number }}
*/
let myVariable = create();
myVariable.newProperty = 3; // bad
| |
Unnecessary parentheses | Reports redundant parentheses. In expressions: In arrow function argument lists: In TypeScript and Flow type declarations: | No highlighting, only fix |
Unterminated statement | 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. |
Potentially undesirable code constructs
Inspection | Description | Default Severity |
---|---|---|
'break' statement | Reports a | |
'break' statement with label | Reports a labeled | |
'continue' statement | Reports a | |
'continue' statement with label | Reports a labeled | |
'debugger' statement | Reports a | |
'void' expression | Reports a | |
'with' statement | Reports a | |
Anonymous function | 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 | |
Comma expression | 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 | |
Conditional expression | Reports a ternary conditional expression. Some coding standards prohibit such expressions in favor of explicit | |
Labeled statement | Reports a labeled statement. |
DOM issues
Inspection | Description | Default Severity |
---|---|---|
Call to 'document.write()' | Reports a method call to | |
Inaccurate platform detection | 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:
| |
Incompatible XHTML usages | 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. | |
Use of 'innerHTML' property | Reports a JavaScript access to DOM nodes as text using the |
Imports and dependencies
Inspection | Description | Default Severity |
---|---|---|
Mismatched dependencies in package.json | Reports a dependency from package.json that is not installed or doesn't match the specified version range. | |
Missing JSX namespace | Reports a usage of a JSX construction without importing namespace. Having the namespace in the file scope ensures proper code compilation. | No highlighting, only fix |
Missing module dependency | Reports a module from a Suggests installing the module and including it into package.json. For | |
URL import is used | Checks used URL imports in the JavaScript language. Suggests downloading the module for the specified remote URL. Such association enables the IDE to provide proper code completion and navigation. URLs in import specifiers are supported only for ECMAScript modules in the JavaScript language. | No highlighting, only fix |
Unused import | Reports a redundant | |
Update package.json dependencies to latest versions | Suggests to upgrade your package.json dependencies to the latest versions, ignoring specified versions. | No highlighting, only fix |
Node.js
Inspection | Description | Default Severity |
---|---|---|
Unresolved Node.js APIs | Suggests configuring coding assistance for Node.js, for example, See https://nodejs.org/api/ for the complete list. |
Unit testing
React
Inspection | Description | Default Severity |
---|---|---|
Invalid DOM element nesting | Detects HTML elements in JSX files which are not nested properly according to the DOM specification. React reports runtime warnings on incorrectly nested elements. |
Async code and promises
Inspection | Description | Default Severity |
---|---|---|
'await' in non-async function | Reports a usage of Although | |
Missing await for an async function call | Reports an Example:
async function bar() { /* ... */ }
async function foo() {
bar(); // bad
}
After the quick-fix is applied, the
async function bar() { /* ... */ }
async function foo() {
await bar(); // good
}
When the 'Report for promises in return statements' checkbox is selected, also suggests adding While this is generally not necessary, it gives two main benefits.
| |
Redundant 'await' expression | Reports a redundant usage of When the 'Report for promises' option is selected, suggests removing Removing
| |
Result of method call returning a promise is ignored | Reports a function call that returns a | |
Top-level 'await' expression | Reports a usage of a top-level While the new 'top-level async' proposal is on its way, using |
Control flow issues
Inspection | Description | Default Severity |
---|---|---|
'for' loop may be replaced by 'while' loop | Reports a Example:
for(; exitCondition(); ) {
process();
}
After the quick-fix is applied the result looks like:
while(exitCondition()) {
process();
}
Use the checkbox below if you wish this inspection to ignore for loops with trivial or non-existent conditions. | |
'if' statement with identical branches | Reports an | |
'if' statement with too many branches | Reports an Use the field below to specify the maximum number of branches expected. | |
Conditional expression with identical branches | Reports a ternary conditional expression with identical | |
Constant conditional expression | Reports a conditional expression in the format | |
Duplicate condition in 'if' statement | Reports duplicate conditions in different branches of an Example:
if (a) {
...
} else if (a) {
...
}
| |
Loop statement that doesn't loop | Reports a | |
Object is 'null' or 'undefined' | Reports an error caused by invoking a method, accessing a property, or calling a function on an object that is | |
Pointless statement or boolean expression | Reports a pointless or pointlessly complicated boolean expression or statement. Example:
let a = !(false && x);
let b = false || x;
After the quick fix is applied the result looks like:
let a = true;
let b = x;
| |
Redundant 'if' statement | Reports an Example:
if(foo())
{
return true;
}
else
{
return false;
}
After applying the quick-fix the code looks as follows: return foo(); | |
Redundant conditional expression | Reports a conditional expression of the form
condition ? true : false
condition ? false : true
These expressions may be safely converted to
condition
!condition
| |
Tail recursion | 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. | |
Unnecessary 'continue' statement | Reports an unnecessary | |
Unnecessary 'return' statement | Reports an unnecessary | |
Unnecessary label | Reports an unused label. | |
Unnecessary label on 'break' statement | Reports a labeled | |
Unnecessary label on 'continue' statement | Reports a labeled | |
Unreachable code | Reports code that can never be executed, which almost certainly indicates an error | |
Unsound type guard check | Reports a
The
|
ES2015 migration aids
Inspection | Description | Default Severity |
---|---|---|
'for..in' is used instead of 'for..of' | Reports a usage of a | No highlighting, only fix |
'let' is used instead of 'const' | Reports a | No highlighting, only fix |
'module.exports' is used instead of 'export' | Reports a Please note that the quick-fix for converting | No highlighting, only fix |
'require()' is used instead of 'import' | Reports a Enable 'Convert require() inside inner scopes with Fix all action' to convert all Please note that converting 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. | No highlighting, only fix |
'var' is used instead of 'let' or 'const' | Reports a Both Suggests replacing all Select the 'Conservatively convert var with Fix all action' option to prevent any changes in these complex cases when using the 'Fix all' action. | |
Function expression is used instead of arrow function | Reports a function expression. Suggests converting it to an arrow function. Example: arr.map(function(el) {return el + 1}) After applying the quick-fix the code looks as follows: arr.map(el => el + 1) | No highlighting, only fix |
Indexed 'for' is used instead of 'for..of' | Reports an indexed | No highlighting, only fix |
String concatenation is used instead of template literal | Reports a string concatenation. Suggests replacing it with a template literal Example "result: " + a + "." After applying the quick-fix the code looks as follows: `result: ${a}.` | No highlighting, only fix |
General
Inspection | Description | Default Severity |
---|---|---|
Deprecated symbol used | Reports a usage of a deprecated function variable. | |
Destructuring properties with the same key | Reports multiple destructuring properties with identical keys. Suggests merging the properties. | |
Duplicate declaration | Reports multiple declarations in a scope. | |
ECMAScript specification is not followed | 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. | |
Implicitly declared global JavaScript variable | Reports an implicit declaration of a global variable. Example:
var aaa = 1; // good
bbb = 2; // bad, if bbb is not declared with 'var' somewhere
| |
Import can be shortened | Reports an ES6 import whose | |
Inaccessible @private and @protected members referenced | Reports a reference to a JavaScript member that is marked with a | |
Incorrect usage of JSDoc tags | Reports warnings implied by Google Closure Compiler annotations including correct use of | |
JQuery selector can be optimized | Reports a duplicated jQuery selector that can be cached or a usage of an attribute or a pseudo-selector (optional). | |
JSX syntax used | Reports a usage of a JSX tag in JavaScript code. | |
Method can be made 'static' | Reports a class method that can be safely made Use the first checkbox below to inspect only | No highlighting, only fix |
Mismatched JSDoc and function signature | Reports mismatch between the names and the number of parameters within a JSDoc comment and the actual parameters of a function. Suggests updating parameters in JSDoc comment. Example:
/**
* @param height Height in pixels
*/
function sq(height, width) {} // width is not documented
After the quick-fix is applied:
/**
* @param height Height in pixels
* @param width
*/
function sq(height, width) {}
| |
Mismatched query and update of collection | 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. | |
Missed locally stored library for HTTP link | 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. | |
Non-strict mode used | Reports a JavaScript file that is not in the | |
Primitive type object wrapper used | 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. | |
Property can be replaced with shorthand | Reports an object property that can be converted to ES6 shorthand style and provides a quick-fix to do it. Example:
var obj = {foo:foo}
After applying the quick-fix the code looks as follows:
var obj = {foo}
| No highlighting, only fix |
Redundant nesting in template literal | Reports nested instances of a string or a template literal. Suggests inlining the nested instances into the containing template string. Example:
let a = `Hello, ${`Brave ${"New"}`} ${"World"}!`
After applying the quick-fix the code looks as follows:
let a = `Hello, Brave New World!`
| |
Referencing mutable variable from closure | Reports access to outer mutable variables from functions. Example:
for (var i = 1; i <= 3; i++) {
setTimeout(function() {
console.log(i); // bad
}, 0);
}
| |
Signature mismatch | 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. | |
Syntax errors and unresolved references in JSDoc | Reports a syntax discrepancy in a documentation comment. | |
Unfiltered for..in loop | Reports unfiltered 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.prototype.myMethod = function myMethod() {};
let a = { foo: 42 };
for (let i in a) {
console.log(a[i]);
}
Suggests replacing the whole loop with a
for (let i in a) {
if (a.hasOwnProperty(i)) {
console.log(a[i]);
}
}
| |
Unnecessary semicolon | Reports an unneeded semicolon. | |
Unneeded last comma in array literal | 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. | |
Unneeded last comma in object literal | 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. | |
Unresolved Ext JS xtype | Reports an Ext JS | |
Unresolved JSX component | Reports an unresolved reference to a JSX component. Suggests adding a missing import statement if the referenced component is defined in the project or its dependencies or creating a new component with this name. The template for a new component can be modified in Editor | File and Code Templates. | |
Unresolved JavaScript reference | Reports an unresolved reference in JavaScript code. TypeScript code is ignored. | |
Unresolved file reference | Reports an unresolved file reference in a JavaScript file, including CommonJS and AMD modules references. | |
Use of possibly unassigned property in a static initializer | 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. | |
Variable declaration can be merged with the first assignment to the variable | 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. | No highlighting, only fix |
Webpack config compliance with JSON Schema | 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. |
Switch statement issues
Inspection | Description | Default Severity |
---|---|---|
'default' not last case in 'switch' | Reports a | |
'switch' statement has missing branches | Reports a | No highlighting, only fix |
'switch' statement has no 'default' branch | Reports a | No highlighting, only fix |
'switch' statement is redundant and can be replaced | Reports a | No highlighting, only fix |
Duplicate 'case' label | Reports a duplicated | |
Fallthrough in 'switch' statement | Reports a | |
Nested 'switch' statement | Reports a | |
Text label in 'switch' statement | Reports a labeled statement inside a Example:
switch(x)
{
case 1:
case2: //typo!
case 3:
break;
}
| |
Unreachable 'case' branch of a 'switch' statement | Reports an unreachable Example:
/**
* @param {('foo' | 'bar')} p
*/
function foo(p) {
switch (p) {
case 'foo': break;
case 'bar': break;
case 'baz': break; // unreachable
}
}
| |
Variable is declared and being used in different 'case' clauses | Reports a variable that is declared in one Disable the inspection for |
Bitwise operation issues
Inspection | Description | Default Severity |
---|---|---|
Bitwise expression can be simplified | Reports an expression that includes | |
Bitwise operator usage | Reports a suspicious usage of a bitwise AND (" | |
Incompatible bitwise mask operation | Reports a bitwise mask expression which for sure evaluates to Example:
// Incompatible mask: as the last byte in mask is zero,
// something like 0x1200 would be possible, but not 0x1234
if ((mask & 0xFF00) == 0x1234) {...}
| |
Shift operation by possibly wrong constant | Reports a shift operation where the second operand is a constant outside the reasonable range, for example, an integer shift operation outside the range |
Unused symbols
Inspection | Description | Default Severity |
---|---|---|
Unused assignment | 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:
| |
Unused global symbol | Reports an unused globally accessible public function, variable, class, or property. | |
Unused local symbol | Reports an unused locally accessible parameter, local variable, function, class, or private member declaration. |