TSLint core rules

Lint rules encode logic for syntactic & semantic checks of TypeScript source code.

TypeScript-specific

These rules find errors related to TypeScript features:

• TS Only
  adjacent-overload-signatures - Enforces function overloads to be consecutive.
• TS Only
  ban-ts-ignore - Bans “// @ts-ignore” comments from being used.
• TS Only
  ban-types - Bans specific types from being used. Does not ban the corresponding runtime objects from being used.
• TS Only Has Fixer
  member-access - Requires explicit visibility declarations for class members.
• Has Fixer
  member-ordering - Enforces member ordering.
• TS Only
  no-any - Disallows usages of any as a type declaration.
• TS Only
  no-empty-interface - Forbids empty interfaces.
• no-for-in - Ban the usage of for…in statements.
• no-import-side-effect - Avoid import statements with side-effect.
• TS Only Has Fixer
  no-inferrable-types - Disallows explicit type declarations for variables or parameters initialized to a number, string, or boolean.
• TS Only Has Fixer
  no-internal-module - Disallows internal module
• no-magic-numbers - Disallows the use constant number values outside of variable assignments. When no list of allowed values is specified, -1, 0 and 1 are allowed by default.
• TS Only
  no-namespace - Disallows use of internal modules and namespaces.
• TS Only
  no-non-null-assertion - Disallows non-null assertions using the ! postfix operator.
• no-parameter-reassignment - Disallows reassigning parameters.
• no-reference - Disallows /// <reference path=> imports (use ES6-style imports instead).
• TS Only Has Fixer Requires Type Info
  no-unnecessary-type-assertion - Warns if a type assertion does not change the type of an expression.
• TS Only
  no-var-requires - Disallows the use of require statements except in import statements.
• only-arrow-functions - Disallows traditional (non-arrow) function expressions.
• prefer-for-of - Recommends a ‘for-of’ loop over a standard ‘for’ loop if the index is only used to access the array being iterated.
• Requires Type Info
  promise-function-async - Requires any function or method that returns a promise to be marked async.
• TS Only
  typedef - Requires type definitions to exist.
• TS Only
  unified-signatures - Warns for any two overloads that could be unified into one by using a union or an optional/rest parameter.

Functionality

These rules catch common errors in JS programming or otherwise confusing constructs that are prone to producing bugs:

• TS Only Requires Type Info
  await-promise - Warns for an awaited value that is not a Promise.
• ban-comma-operator - Disallows the comma operator to be used.
• ban - Bans the use of specific functions or global methods.
• Has Fixer
  curly - Enforces braces for if/for/do/while statements.
• forin - Requires a for ... in statement to be filtered with an if statement.
• function-constructor - Prevents using the built-in Function constructor.
• import-blacklist - Disallows importing the specified modules via import and require, or importing specific named exports of the specified modules, or using imports matching specified regular expression patterns.
• label-position - Only allows labels in sensible locations.
• no-arg - Disallows use of arguments.callee.
• no-async-without-await - Functions marked async must contain an await or return statement.
• no-bitwise - Disallows bitwise operators.
• no-conditional-assignment - Disallows any type of assignment in conditionals.
• no-console - Bans the use of specified console methods.
• no-construct - Disallows access to the constructors of String, Number, and Boolean.
• no-debugger - Disallows debugger statements.
• no-duplicate-super - Warns if ‘super()’ appears twice in a constructor.
• no-duplicate-switch-case - Prevents duplicate cases in switch statements.
• no-duplicate-variable - Disallows duplicate variable declarations in the same block scope.
• no-dynamic-delete - Bans usage of the delete operator with computed key expressions.
• no-empty - Disallows empty blocks.
• no-eval - Disallows eval function invocations.
• TS Only Requires Type Info
  no-floating-promises - Promises returned by functions must be handled appropriately.
• Requires Type Info
  no-for-in-array - Disallows iterating over an array with a for-in loop.
• no-implicit-dependencies - Disallows importing modules that are not listed as dependency in the project’s package.json
• TS Only Requires Type Info
  no-inferred-empty-object-type - Disallow type inference of {} (empty object type) at function and constructor call sites
• no-invalid-template-strings - Warns on use of ${ in non-template strings.
• no-invalid-this - Disallows using the this keyword outside of classes.
• TS Only
  no-misused-new - Warns on apparent attempts to define constructors for interfaces or new for classes.
• Has Fixer
  no-null-keyword - Disallows use of the null keyword literal.
• TS Only Requires Type Info
  no-null-undefined-union - Disallows explicitly declared or implicitly returned union types with both null and undefined as members.
• TS Only
  no-object-literal-type-assertion - Forbids an object literal to appear in a type assertion expression. Casting to any or to unknown is still allowed.
• TS Only Requires Type Info
  no-promise-as-boolean - Warns for Promises that are used for boolean conditions.
• Requires Type Info
  no-restricted-globals - Disallow specific global variables.
• Has Fixer
  no-return-await - Disallows unnecessary return await.
• no-shadowed-variable - Disallows shadowing variable declarations.
• no-sparse-arrays - Forbids array literals to contain missing elements.
• Has Fixer
  no-string-literal - Forbids unnecessary string literal property access. Allows obj["prop-erty"] (can’t be a regular property access). Disallows obj["property"] (should be obj.property).
• Has Fixer
  no-string-throw - Flags throwing plain strings or concatenations of strings.
• no-submodule-imports - Disallows importing any submodule.
• no-switch-case-fall-through - Disallows falling through case statements.
• no-tautology-expression - Enforces that relational/equality binary operators does not take two equal variables/literals as operands. Expression like 3 === 3, someVar === someVar, “1” > “1” are either a tautology or contradiction, and will produce an error.
• no-this-assignment - Disallows unnecessary references to this.
• TS Only Requires Type Info
  no-unbound-method - Warns when a method is used outside of a method call.
• no-unnecessary-class - Disallows classes that are not strictly necessary.
• TS Only Requires Type Info
  no-unsafe-any - Warns when using an expression of type ‘any’ in a dynamic way. Uses are only allowed if they would work for {} | null | undefined. Downcasting to unknown is always safe. Type casts and tests are allowed. Expressions that work on all values (such as "" + x) are allowed.
• no-unsafe-finally - Disallows control flow statements, such as return, continue, break and throws in finally blocks.
• no-unused-expression - Disallows unused expression statements.
• TS Only Has Fixer Requires Type Info
  no-unused-variable - Disallows unused imports, variables, functions and private class members. Similar to tsc’s –noUnusedParameters and –noUnusedLocals options, but does not interrupt code compilation.
• Requires Type Info
  no-use-before-declare - Disallows usage of variables before their declaration.
• Has Fixer
  no-var-keyword - Disallows usage of the var keyword.
• Requires Type Info
  no-void-expression - Requires expressions of type void to appear in statement position.
• prefer-conditional-expression - Recommends to use a conditional expression instead of assigning to the same thing in each branch of an if statement.
• Has Fixer
  prefer-object-spread - Enforces the use of the ES2018 object spread operator over Object.assign() where appropriate.
• radix - Requires the radix parameter to be specified when calling parseInt.
• Requires Type Info
  restrict-plus-operands - When adding two variables, operands must both be of type number or of type string.
• Has Fixer
  static-this - Ban the use of this in static methods.
• TS Only Requires Type Info
  strict-boolean-expressions - Restricts the types allowed in boolean expressions. By default only booleans are allowed. The following nodes are checked:
  • Arguments to the !, &&, and || operators
  • The condition in a conditional expression (cond ? x : y)
  • Conditions for if, for, while, and do-while statements.
• Requires Type Info
  strict-comparisons - Only allow comparisons between primitives.
• TS Only Has Fixer Requires Type Info
  strict-string-expressions - Disable implicit toString() calls
• TS Only Requires Type Info
  strict-type-predicates - Warns for type predicates that are always true or always false. Works for ‘typeof’ comparisons to constants (e.g. ‘typeof foo === “string”’), and equality comparison to ‘null’/’undefined’. (TypeScript won’t let you compare ‘1 === 2’, but it has an exception for ‘1 === undefined’.) Does not yet work for ‘instanceof’. Does not warn for ‘if (x.y)’ where ‘x.y’ is always truthy. For that, see strict-boolean-expressions. This rule requires strictNullChecks to work properly.
• switch-default - Require a default case in all switch statements.
• triple-equals - Requires === and !== in place of == and !=.
• typeof-compare - Makes sure result of typeof is compared to correct string values
• unnecessary-constructor - Prevents blank constructors, as they are redundant.
• TS Only Requires Type Info
  use-default-type-parameter - Warns if an explicitly specified type argument is the default for that type parameter.
• use-isnan - Enforces use of the isNaN() function to check for NaN references instead of a comparison to the NaN constant.

Maintainability

These rules make code maintenance easier:

• cyclomatic-complexity - Enforces a threshold of cyclomatic complexity.
• Requires Type Info
  deprecation - Warns when deprecated APIs are used.
• TS Only
  invalid-void - Disallows usage of void type outside of generic or return types. If void is used as return type, it shouldn’t be a part of intersection/union type.
• max-classes-per-file - A file may not contain more than the specified number of classes
• max-file-line-count - Requires files to remain under a certain number of lines
• no-default-export - Disallows default exports in ES6-style modules.
• no-default-import - Disallows importing default members from certain ES6-style modules.
• no-duplicate-imports - Disallows multiple import statements from the same module.
• TS Only
  no-mergeable-namespace - Disallows mergeable namespaces in the same file.
• no-require-imports - Disallows invocation of require().
• object-literal-sort-keys - Checks ordering of keys in object literals. When using the default alphabetical ordering, additional blank lines may be used to group object properties together while keeping the elements within each group in alphabetical order. To opt out of this use ignore-blank-lines option.
• Has Fixer
  prefer-const - Requires that variable declarations use const instead of let and var if possible.
• TS Only Requires Type Info
  prefer-readonly - Requires that private variables are marked as readonly if they’re never modified outside of the constructor.

Style

These rules enforce consistent style across your codebase:

• TS Only Has Fixer
  array-type - Requires using either ‘T[]’ or ‘Array' for arrays.
• Has Fixer
  arrow-return-shorthand - Suggests to convert () => { return x; } to () => x.
• binary-expression-operand-order - In a binary expression, a literal should always be on the right-hand side if possible. For example, prefer ‘x + 1’ over ‘1 + x’.
• TS Only Has Fixer
  callable-types - An interface or literal type with just a call signature can be written as a function type.
• class-name - Enforces PascalCased class and interface names.
• Has Fixer
  comment-format - Enforces formatting rules for single-line comments.
• comment-type - Allows a limited set of comment types
• completed-docs - Enforces JSDoc comments for important items be filled out.
• encoding - Enforces UTF-8 file encoding.
• Has Fixer
  file-header - Enforces a certain header comment for all files, matched by a regular expression.
• file-name-casing - Enforces a consistent file naming convention
• increment-decrement - Enforces using explicit += 1 or -= 1 operators.
• TS Only
  interface-name - Requires interface names to begin with a capital ‘I’
• TS Only Has Fixer
  interface-over-type-literal - Prefer an interface declaration over a type literal (type T = { ... })
• TS Only Requires Type Info
  match-default-export-name - Requires that a default import have the same name as the declaration it imports. Does nothing for anonymous default exports.
• newline-per-chained-call - Requires that chained method calls be broken apart onto separate lines.
• TS Only Has Fixer
  no-angle-bracket-type-assertion - Requires the use of as Type for type assertions instead of <Type>.
• TS Only Has Fixer Requires Type Info
  no-boolean-literal-compare - Warns on comparison to a boolean literal, as in x === true.
• TS Only
  no-parameter-properties - Disallows parameter properties in class constructors.
• TS Only
  no-redundant-jsdoc - Forbids JSDoc which duplicates TypeScript functionality.
• TS Only
  no-reference-import - Don’t <reference types="foo" /> if you import foo anyway.
• no-unnecessary-callback-wrapper - Replaces x => f(x) with just f. To catch more cases, enable only-arrow-functions and arrow-return-shorthand too.
• Has Fixer
  no-unnecessary-initializer - Forbids a ‘var’/’let’ statement or destructuring initializer to be initialized to ‘undefined’.
• TS Only Has Fixer Requires Type Info
  no-unnecessary-qualifier - Warns when a namespace qualifier (A.x) is unnecessary.
• Has Fixer
  object-literal-key-quotes - Enforces consistent object literal property quote style.
• Has Fixer
  object-literal-shorthand - Enforces/disallows use of ES6 object literal shorthand.
• Has Fixer
  one-line - Requires the specified tokens to be on the same line as the expression preceding them.
• one-variable-per-declaration - Disallows multiple variable definitions in the same declaration statement.
• Has Fixer
  ordered-imports - Requires that import statements be alphabetized and grouped.
• prefer-function-over-method - Warns for class methods that do not use ‘this’.
• Has Fixer
  prefer-method-signature - Prefer foo(): void over foo: () => void in interfaces and types.
• prefer-switch - Prefer a switch statement to an if statement with simple === comparisons.
• prefer-template - Prefer a template expression over string literal concatenation.
• Has Fixer
  prefer-while - Prefer while loops instead of for loops without an initializer and incrementor.
• Requires Type Info
  return-undefined - Prefer return; in void functions and return undefined; in value-returning functions.
• Has Fixer
  space-before-function-paren - Require or disallow a space before function parenthesis
• Has Fixer
  space-within-parens - Enforces spaces within parentheses or disallow them. Empty parentheses () are always allowed.
• Has Fixer
  switch-final-break - Checks whether the final clause of a switch statement ends in break;.
• TS Only Has Fixer
  type-literal-delimiter - Checks that type literal members are separated by semicolons. Enforces a trailing semicolon for multiline type literals.
• Requires Type Info
  unnecessary-bind - Prevents unnecessary and/or misleading scope bindings on functions.
• unnecessary-else - Disallows else blocks following if blocks ending with a break, continue, return, or throw statement.
• variable-name - Checks variable names for various errors.

Format

These rules enforce consistent use of whitespace and punctuation:

• Has Fixer
  align - Enforces vertical alignment.
• Has Fixer
  arrow-parens - Requires parentheses around the parameters of arrow function definitions.
• Has Fixer
  eofline - Ensures the file ends with a newline.
• import-spacing - Ensures proper spacing between import statement keywords
• Has Fixer
  indent - Enforces indentation with tabs or spaces.
• jsdoc-format - Enforces basic format rules for JSDoc comments.
• Has Fixer
  linebreak-style - Enforces a consistent linebreak style.
• max-line-length - Requires lines to be under a certain max length.
• Has Fixer
  newline-before-return - Enforces blank line before return when not the only line in the block.
• new-parens - Requires parentheses when invoking a constructor via the new keyword.
• Has Fixer
  no-consecutive-blank-lines - Disallows one or more blank lines in a row.
• Has Fixer
  no-irregular-whitespace - Disallow irregular whitespace within a file, including strings and comments.
• Has Fixer
  no-trailing-whitespace - Disallows trailing whitespace at the end of a line.
• Has Fixer
  number-literal-format - Checks that decimal literals should begin with ‘0.’ instead of just ‘.’, and should not end with a trailing ‘0’.
• Has Fixer
  quotemark - Enforces quote character for string literals.
• Has Fixer
  semicolon - Enforces consistent semicolon usage at the end of every statement.
• Has Fixer
  trailing-comma - Requires or disallows trailing commas in array and object literals, destructuring assignments, function typings, named imports and exports and function parameters.
• TS Only Has Fixer
  typedef-whitespace - Requires or disallows whitespace for type definitions.
• Has Fixer
  whitespace - Enforces whitespace style conventions.