# Quick Lint Js

> The following contributors are copyright holders of portions of quick-lint-js:

## Pages

- [quick-lint-js authors](authors.md): The following contributors are copyright holders of portions of quick-lint-js:
- [Contributor License Agreement](cla-v1.md): This document is based on the Fiduciary License Agreement 2.0, based on the
- [Code-signing quick-lint-js](code-signing.md): In order to sign quick-lint-js, you need a code signing certificate.
- [Fuzz-testing quick-lint-js](fuzzing.md): This document describes quick-lint-js' self fuzz-testing for contributors.
- [quick-lint-js infrastructure](infrastructure.md): This document describes the infrastructure used for managing builds, releases,
- [Installing quick-lint-js](installing.md): For quick-lint-js installation instructions, see the [installation
- [Releasing quick-lint-js](release.md): To release a new version of quick-lint-js, run the`dist/release.go`tool:
- [Tracing in quick-lint-js](tracing.md): quick-lint-js supports a binary log format. This document describes the format
- [Translating quick-lint-js](translating.md): After editing quick-lint-js' source code, build the`quick-lint-js-i18n`CMake
- [ADR001: Feature testing with have.h](architecture-adr001-feature-testing-with-have-h.md): **Status**: Accepted and active.
- [ADR002: Programming language](architecture-adr002-programming-language.md): **Status**: Accepted and active.
- [ADR003: Vendor sources](architecture-adr003-vendor-sources.md): **Status**: Accepted and active.
- [ADR004: Generated sources](architecture-adr004-generated-sources.md): **Status**: Accepted and active.
- [ADR005: Incremental lexing](architecture-adr005-incremental-lexing.md): **Status**: Accepted and active.
- [ADR006: Location tracking](architecture-adr006-location-tracking.md): **Status**: Accepted and active.
- [ADR007: Expression stack](architecture-adr007-expression-stack.md): **Status**: Rejected.
- [ADR008: Exceptions](architecture-adr008-exceptions.md): **Status**: Accepted and active.
- [ADR009: Website](architecture-adr009-website.md): **Status**: Accepted and active.
- [ADR010: LSP server](architecture-adr010-lsp-server.md): **Status**: Accepted and active.
- [ADR011: IO errors](architecture-adr011-io-errors.md): **Status**: Accepted and active.
- [ADR012: Assertions](architecture-adr012-assertions.md): **Status**: Accepted and active.
- [ADR013: Dependencies](architecture-adr013-dependencies.md): **Status**: Accepted and active.
- [ADR014: Plugins](architecture-adr014-plugins.md): **Status**: Accepted and active.
- [ADR015: Logging and tracing](architecture-adr015-logging-and-tracing.md): **Status**: Accepted and active.
- [ADR016: Collections](architecture-adr016-collections.md): **Status**: Accepted and active.
- [ADR017: Lexer tables](architecture-adr017-lexer-tables.md): **Status**: Rejected.
- [ADR018: Naming style](architecture-adr018-naming-style.md): **Status**: Accepted and active.
- [ADR019: I/O manager](architecture-ard019-io-manager.md): **Status**: Accepted and active.
- [E0001: variable assigned before its declaration](errors-e0001.md): Variables declared with`let`can only be reassigned by code below the
- [E0002: assignment to const global variable](errors-e0002.md): `Infinity`,`NaN`, and`undefined`are global variables which cannot be changed.
- [E0003: cannot assign to const variable](errors-e0003.md): You cannot reassign variables declared with`const`. The assignment will crash
- [E0004: assignment to const variable before its declaration](errors-e0004.md): You cannot reassign variables declared with`const`, and you cannot reference a
- [E0005: BigInt literal contains decimal point](errors-e0005.md): `BigInt`literals are number literals with an`n`suffix. These literals must
- [E0006: BigInt literal contains exponent](errors-e0006.md): `BigInt`literals are number literals with an`n`suffix. These literals must
- [E0007: classes cannot be named 'let'](errors-e0007.md): Classes declared with`class`cannot be named`let`.
- [E0008: let statement cannot declare variables named 'let'](errors-e0008.md): Variables declared with`let`cannot be named`let`.
- [E0009: cannot export variable named 'let'](errors-e0009.md): An exported function cannot be named`let`:
- [E0010: cannot import 'let'](errors-e0010.md): An imported function or variable cannot be named`let`:
- [E0011: character is not allowed in identifiers](errors-e0011.md): {
- [E0012: escaped character is not allowed in identifiers](errors-e0012.md): A function or variable name includes a Unicode escape sequence, and the escape sequence
- [E0013: code point out of range](errors-e0013.md): This error has been renamed to E0207.
- [E0014: expected expression before newline](errors-e0014.md): `throw`statements cannot have a newline between the`throw`keyword and the
- [E0015: expected expression before semicolon](errors-e0015.md): `throw`statements require an expression following the`throw`keyword. It is an
- [E0016: expected hexadecimal digits in Unicode escape sequence](errors-e0016.md): In variable names and strings, a Unicode escape sequence must contain only
- [E0017: if statement needs parentheses around condition](errors-e0017.md): In JavaScript,`if`statements require parentheses around the condition. It is
- [E0018: if statement is missing '(' or ')' around condition](errors-e0018.md): An`if`statement is missing either`(`before the condition or`)`after the
- [E0019: escaping '-' is not allowed in tag names; write '-' instead](errors-e0019.md): JSX tag names and attributes can contain Unicode escape sequences starting with
- [E0020: invalid expression left of assignment](errors-e0020.md): {
- [E0021: invalid lone literal in object literal](errors-e0021.md): An object literal entry must either be a`key: value`pair, a method, or
- [E0022: invalid UTF-8 sequence](errors-e0022.md): JavaScript files are normally encoded using UTF-8. It is an error for a
- [E0023: keywords cannot contain escape sequences](errors-e0023.md): Outside a string or template literal, Unicode escape sequences (like`\u{65}`)
- [E0024: const/let/var with no bindings](errors-e0024.md): `const`,`let`, or`var`statements need to declare at least one variable. It is
- [E0025: missing comma between object literal entries](errors-e0025.md): Object literal entries, including methods, are separated by commas. It is an
- [E0026: missing operand for operator](errors-e0026.md): Binary operators (such as`*`and`>>`) require an expression (e.g. a variable
- [E0027: missing semicolon after statement](errors-e0027.md): {
- [E0028: number literal contains consecutive underscores](errors-e0028.md): Number literals can contain underscores (`_`) to separate digits for legibility.
- [E0029: number literal contains trailing underscores](errors-e0029.md): Number literals can contain underscores (`_`) to separate digits for legibility.
- [E0030: octal literal may not have exponent](errors-e0030.md): Decimal number literals can contain exponents. Octal number literals, which
- [E0031: octal literal may not have decimal](errors-e0031.md): Decimal number literals can contain a decimal (fraction). Octal number literals,
- [E0032: legacy octal literal may not be BigInt](errors-e0032.md): Decimal number literals can be`BigInt`with an`n`suffix. Legacy octal number
- [E0033: redeclaration of global variable](errors-e0033.md): {
- [E0034: redeclaration of variable](errors-e0034.md): {
- [E0035: RegExp literal flags cannot contain Unicode escapes](errors-e0035.md): {
- [E0036: stray comma in let statement](errors-e0036.md): {
- [E0037: unclosed block comment](errors-e0037.md): {
- [E0038: unclosed identifier escape sequence](errors-e0038.md): Identifiers can contain Unicode escape sequences starting with`\u`. It is a
- [E0039: unclosed regexp literal](errors-e0039.md): Regular expression literals start with`/`and end with`/`. The`/`symbol is
- [E0040: unclosed string literal](errors-e0040.md): String literals start with`"`or`'`and end with`"`or`'`, respectively.
- [E0041: unclosed template](errors-e0041.md): Template literals start with and end with \`.
- [E0042: unexpected '@'](errors-e0042.md): This diagnostic has been removed in quick-lint-js version 2.17.0.
- [E0043: unexpected '\\' in identifier](errors-e0043.md): {
- [E0044: unexpected characters in number literal](errors-e0044.md): {
- [E0045: unexpected control character](errors-e0045.md): JavaScript treats some Unicode control characters, such as newlines, tabs, and
- [E0046: unexpected characters in binary literal](errors-e0046.md): Binary number literals start with`0b`and can only contain`0`or`1`digits
- [E0047: unexpected characters in octal literal](errors-e0047.md): Octal number literals start with`0`or`0o`and can only contain digits`0`
- [E0048: unexpected characters in hex literal](errors-e0048.md): Hexadecimal (hex) number literals start with`0x`and can only contain digits
- [E0049: binary number literal has no digits](errors-e0049.md): Decimal number literals start with`0b`and require at least one digit. It is an
- [E0050: hex number literal has no digits](errors-e0050.md): Hexadecimal (hex) number literals start with`0x`and require at least one
- [E0051: octal number literal has no digits](errors-e0051.md): Octal number literals start with`0o`and require at least one digit. It is an
- [E0052: unexpected '#'](errors-e0052.md): {
- [E0053: missing property name between '.' and '.'](errors-e0053.md): {
- [E0054: unexpected token](errors-e0054.md): If you get error E0054, quick-lint-js does not understand your code for some
- [E0055: unmatched indexing bracket](errors-e0055.md): {
- [E0056: unmatched parenthesis](errors-e0056.md): It is an error to write the`(`without its matching`)`:
- [E0057: use of undeclared variable](errors-e0057.md): {
- [E0058: variable used before declaration](errors-e0058.md): {
- [E0059: assignment to undeclared variable](errors-e0059.md): {
- [E0060: invalid hex escape sequence](errors-e0060.md): {
- [E0061: missing name in function statement](errors-e0061.md): If a statement begins with the`function`keyword, the declared function must
- [E0062: missing name or parentheses for function](errors-e0062.md): {
- [E0063: missing operator between expression and arrow function](errors-e0063.md): The left-hand side of`=>`must be a list of parameters. It is a syntax error if
- [E0064: missing body for 'if' statement](errors-e0064.md): {
- [E0065: 'else' has no corresponding 'if'](errors-e0065.md): {
- [E0066: exporting requires '{' and '}'](errors-e0066.md): When exporting a class, function, or variable, you must either export while
- [E0067: exporting requires 'default'](errors-e0067.md): It is a syntax error to export an expression without using the`default`
- [E0068: extra ',' is not allowed between function call arguments](errors-e0068.md): In a function call, an extra`,`can be added to the end of the argument list.
- [E0069: cannot declare 'await' inside async function](errors-e0069.md): {
- [E0070: commas are not allowed after spread parameter](errors-e0070.md): In a function declaration, an extra`,`can be added to the end of the parameter
- [E0071: cannot declare 'yield' inside generator function](errors-e0071.md): In non-strict mode, a variable can be named`yield`. In strict mode and inside
- [E0072: methods should not use the 'function' keyword](errors-e0072.md): Classes and object literals can contain methods. It is an error to use the
- [E0073: missing function parameter list](errors-e0073.md): Functions declared with`function`can have zero or more parameters. It is a
- [E0074: '.' operator needs a key name; use + to concatenate strings; use [] to access with a dynamic key](errors-e0074.md): The right-hand side of the`.`operator must be a property name or a private
- [E0075: indexing requires an expression](errors-e0075.md): {
- [E0076: cannot declare and export variable with 'export default'](errors-e0076.md): In modules, you can declare and export a variable at the same time. However, it
- [E0077: function call before declaration in blocked scope](errors-e0077.md): A function can't be called before its declaration in block scope in some
- [E0078: missing expression between parentheses](errors-e0078.md): {
- [E0079: missing name of exported function](errors-e0079.md): {
- [E0080: missing name of class](errors-e0080.md): If a statement begins with the`class`keyword, the declared class must have a
- [E0081: missing name of exported class](errors-e0081.md): {
- [E0082: assigning to 'async' in a for-of loop requires parentheses](errors-e0082.md): If a variable is named`async`, it is a syntax error to assign to that variable
- [E0083: missing value for object property](errors-e0083.md): {
- [E0084: do-while loop needs parentheses around condition](errors-e0084.md): `do`-`while`loops have a condition after the`while`keyword. It is a syntax
- [E0085: do-while loop is missing '(' or ')' around condition](errors-e0085.md): `do`-`while`loops have a condition after the`while`keyword. It is a syntax
- [E0086: redundant delete statement on variable](errors-e0086.md): The following delete statement is redundant on variable:
- [E0087: while loop needs parentheses around condition](errors-e0087.md): `while`loops have a condition after the`while`keyword. It is a syntax error
- [E0088: while loop is missing '(' or ')' around condition](errors-e0088.md): `while`loops have a condition after the`while`keyword. It is a syntax error
- [E0089: with statement needs parentheses around expression](errors-e0089.md): {
- [E0090: with statement is missing '(' or ')' around expression](errors-e0090.md): {
- [E0091: switch statement needs parentheses around condition](errors-e0091.md): `switch`statements have a condition after the`switch`keyword. It is a syntax
- [E0092: switch statement is missing '(' or ')' around condition](errors-e0092.md): `switch`statements have a condition after the`switch`keyword. It is a syntax
- [E0093: C-style for loop is missing its third component](errors-e0093.md): C-style`for`loops have three components, each separated by`;`: an
- [E0094: missing body for 'for' loop](errors-e0094.md): {
- [E0095: Unicode byte order mark (BOM) cannot appear before #! at beginning of script](errors-e0095.md): A script cannot have Unicode byte order mark (BOM) before`#!`
- [E0096: missing for loop header](errors-e0096.md): {
- [E0097: for loop needs an iterable, or condition and update clauses](errors-e0097.md): {
- [E0098: for loop needs an iterable, or condition and update clauses](errors-e0098.md): {
- [E0099: missing semicolon between init and condition parts of for loop](errors-e0099.md): C-style`for`loops require two semicolons: one`;`between the init and the
- [E0100: missing semicolon between condition and update parts of for loop](errors-e0100.md): C-style`for`loops require two semicolons: one`;`between the init and the
- [E0101: missing body for do-while loop](errors-e0101.md): {
- [E0102: C-style for loops have only three semicolon-separated components](errors-e0102.md): {
- [E0103: missing 'while (condition)' for do-while statement](errors-e0103.md): A`do`-`while`loop has three parts: the`do`keyword, a body (a statement, or a
- [E0104: missing body for while loop](errors-e0104.md): {
- [E0105: missing parameters for arrow function](errors-e0105.md): Arrow functions need a parameter list. It is a syntax error to omit the
- [E0106: missing body for 'switch' statement](errors-e0106.md): `switch`statements require a body, which must be a list of statements
- [E0107: expected '{'](errors-e0107.md): A`switch`statement has a list of cases. It is a syntax error to omit`{`after
- [E0108: 'in' disallowed in C-style for loop initializer](errors-e0108.md): {
- [E0109: for-of loop expression cannot have semicolons](errors-e0109.md): {
- [E0110: for-in loop expression cannot have semicolons](errors-e0110.md): {
- [E0111: missing body for class](errors-e0111.md): {
- [E0112: unexpected token in export; expected 'export default ...' or 'export {name}' or 'export * from ...' or 'export class' or 'export function' or 'export let'](errors-e0112.md): {
- [E0113: incomplete export; expected 'export default ...' or 'export {name}' or 'export * from ...' or 'export class' or 'export function' or 'export let'](errors-e0113.md): {
- [E0114: unexpected token in variable declaration; expected variable name](errors-e0114.md): {
- [E0115: unexpected 'case' outside switch statement](errors-e0115.md): `switch`statements can contain`case`labels. It is a syntax error to write a
- [E0116: unexpected 'default' outside switch statement](errors-e0116.md): `switch`statements can contain a`default`label. It is a syntax error to write
- [E0117: unexpected 'catch' without 'try'](errors-e0117.md): {
- [E0118: unexpected 'finally' without 'try'](errors-e0118.md): `try`statements can have a`finally`clause. It is a syntax error to have a
- [E0119: missing body for catch clause](errors-e0119.md): {
- [E0120: missing body for try statement](errors-e0120.md): `try`statements require a body, which must be a list of statements
- [E0121: missing body for finally clause](errors-e0121.md): `finally`clauses in`try`statements require a body, which must be a list of
- [E0122: missing catch or finally clause for try statement](errors-e0122.md): {
- [E0123: missing variable name](errors-e0123.md): {
- [E0124: cannot declare variable named keyword](errors-e0124.md): It is a syntax error to declare a variable named certain keywords like
- [E0125: missing header and body for 'for' loop](errors-e0125.md): {
- [E0126: expected 'as' between '\*' and variable](errors-e0126.md): You can import all of a module's exports using`import *`. It is a syntax error
- [E0127: TypeScript's 'enum' feature is not allowed in JavaScript](errors-e0127.md): JavaScript does not support TypeScript-style enums. It is a syntax error to
- [E0128: expected 'from' before module specifier](errors-e0128.md): `import`statements load things from other files. It is a syntax error to omit
- [E0129: expected 'from "name_of_module.mjs"'](errors-e0129.md): `import`statements load things from other files. It is a syntax error to omit
- [E0130: missing catch variable name between parentheses](errors-e0130.md): {
- [E0131: expected ',' between object literal entries](errors-e0131.md): {
- [E0132: missing ',' between variable declarations](errors-e0132.md): {
- [E0133: error generator function star belongs before name](errors-e0133.md): The following code has misplaced '*'.
- [E0134: unclosed code block; expected '}' by end of file](errors-e0134.md): {
- [E0135: expected variable name for 'catch'](errors-e0135.md): {
- [E0136: cannot update variable with '+=' while declaring it](errors-e0136.md): {
- [E0137: missing condition for switch statement](errors-e0137.md): A`switch`statement has a condition which determines which`case`or`default`
- [E0138: missing condition for if statement](errors-e0138.md): {
- [E0139: missing condition for while statement](errors-e0139.md): {
- [E0140: expected expression after 'case'](errors-e0140.md): A`switch`statement has a list of cases, each beginning with either the`case`
- [E0141: expected ')' to close function call](errors-e0141.md): {
- [E0142: missing property name after '.' operator](errors-e0142.md): {
- [E0143: unmatched '}'](errors-e0143.md): {
- [E0144: cannot export variable named keyword](errors-e0144.md): An`export`statement can export a list of classes, functions, and variables. It
- [E0145: cannot import variable named keyword](errors-e0145.md): An`import`statement can import a list of classes, functions, and variables. It
- [E0146: missing ':' in conditional expression](errors-e0146.md): {
- [E0147: unexpected identifier in expression; missing operator before](errors-e0147.md): {
- [E0148: missing body for statement; a function statement is not allowed as the body of statement](errors-e0148.md): {
- [E0149: missing body for statement; a class statement is not allowed as the body of statement](errors-e0149.md): {
- [E0150: missing body for statement; a lexical declaration is not allowed as the body of statement](errors-e0150.md): {
- [E0151: invalid function parameter](errors-e0151.md): {
- [E0152: legacy octal literals may not contain underscores](errors-e0152.md): A legacy octal literal is a`0`digit followed by one or more octal digits (`0`
- [E0153: forwarding exports are only allowed in export-from](errors-e0153.md): An`export`statement can forward exports from another module. It is a syntax
- [E0154: unexpected expression; missing key for object entry](errors-e0154.md): {
- [E0155: cannot reference private variables without object; use 'this.'](errors-e0155.md): {
- [E0156: private properties are not allowed in object literals](errors-e0156.md): {
- [E0157: missing end of array; expected ']'](errors-e0157.md): An array literal requires a list of items surrounded by`[`and`]`. It is a
- [E0158: unexpected '=>'; expected parameter for arrow function, but got a literal instead](errors-e0158.md): {
- [E0159: unexpected literal in parameter list; expected parameter name](errors-e0159.md): A function parameter can be a variable name, an array destructuring, or an
- [E0160: unexpected '=>'; expected parameter for arrow function, but got an expression instead](errors-e0160.md): The left-hand side of`=>`must be a list of parameters. It is a syntax error if
- [E0161: unclosed object literal; expected '}'](errors-e0161.md): {
- [E0162: 'await' is only allowed in async functions](errors-e0162.md): {
- [E0163: newline is not allowed between 'async' and arrow function parameter list](errors-e0163.md): {
- [E0164: JSON syntax error](errors-e0164.md): quick-lint-js configuration files (named`quick-lint-js.config`) contain
- [E0165: TypeScript style const field](errors-e0165.md): `const`fields are only allowed in TypeScript, not JavaScript
- [E0166: "globals" descriptor "shadowable" property must be a boolean](errors-e0166.md): In a quick-lint-js configuration file, a entry in`"globals"`can have a
- [E0167: "globals" descriptor "writable" property must be a boolean](errors-e0167.md): In a quick-lint-js configuration file, a entry in`"globals"`can have a
- [E0168: "globals" must be an object](errors-e0168.md): In a quick-lint-js configuration file,`"globals"`must be an object or
- [E0169: "global-groups" must be a boolean or an array](errors-e0169.md): In a quick-lint-js configuration file,`"global-groups"`must be an array of
- [E0170: "global-groups" entries must be strings](errors-e0170.md): In a quick-lint-js configuration file, items in the`"global-groups"`array
- [E0171: "globals" descriptor must be a boolean or an object](errors-e0171.md): In a quick-lint-js configuration file, each entry in`"globals"`
- [E0172: missing body for function](errors-e0172.md): {
- [E0173: cannot assign to loop variable in for of/in loop](errors-e0173.md): {
- [E0174: functions/methods should not have '=>'](errors-e0174.md): {
- [E0175: expected variable name for 'import'-'as'](errors-e0175.md): {
- [E0176: missing arrow operator for arrow function](errors-e0176.md): Arrow functions have a parameter list followed by`=>`followed by a function
- [E0177: React/JSX is not allowed in vanilla JavaScript code](errors-e0177.md): {
- [E0178: 'await' cannot be followed by an arrow function; use 'async' instead](errors-e0178.md): {
- [E0179: return statement returns nothing (undefined)](errors-e0179.md): A`return`statement can have an optional expression. If the expression is
- [E0180: stray comma in function parameter](errors-e0180.md): {
- [E0181: unclosed string literal](errors-e0181.md): JSX attribute values can be strings. These strings need to be closed with either
- [E0182: '>' is not allowed directly in JSX text; write {'>'} or > instead](errors-e0182.md): In the children of a JSX element, you can write arbitrary text. However, it is a
- [E0183: '}' is not allowed directly in JSX text; write {'}'} instead](errors-e0183.md): In the children of a JSX element, you can write arbitrary text. However, it is a
- [E0184: missing 'if' after 'else'](errors-e0184.md): In an`if`-`else if`-`else`chain, it is a syntax error to omit the`if`keyword
- [E0185: assignment to imported variable; imported variable declared here](errors-e0185.md): It is a`ReferenceError`to assign to variables imported from another module:
- [E0186: missing '...' in JSX attribute spread](errors-e0186.md): In a JSX tag, you can use an object as a source of attributes. It is a syntax
- [E0187: mismatched JSX tags; expected </foo>](errors-e0187.md): {
- [E0188: '=' changes variables; to compare, use '===' instead](errors-e0188.md): {
- [E0189: missing '<>' and '</>' to enclose multiple children](errors-e0189.md): To return multiple JSX elements from a component, you must return a fragment. It
- [E0190: missing comparison; '===' does not extend to the right side of '||'](errors-e0190.md): In English, we might say “if the selection is ‘agree’ or ‘strongly agree’,
- [E0191: event attributes must be camelCase](errors-e0191.md): In HTML, attributes are case-insensitive;`onclick`is the same as`onClick`and
- [E0192: attribute has wrong capitalization](errors-e0192.md): In HTML, attributes are case-insensitive;`colspan`is the same as`colSpan`and
- [E0193: misspelled React attribute; write 'className' instead](errors-e0193.md): React has a different name for some attributes than HTML. It is a mistake to
- [E0194: missing parentheses around left-hand side of `**`; `**` operator cannot be used after unary `-` without parentheses](errors-e0194.md): JavaScript does not allow unary operators left of a`**`expression. It is a
- [E0195: missing parentheses around operand of `typeof`; `typeof` operator cannot be used before `**` without parentheses](errors-e0195.md): {
- [E0196: new variable shadows existing variable](errors-e0196.md): {
- [E0197: '“' is not allowed for strings; use " instead](errors-e0197.md): JavaScript string literals start with either`"`or`'`(straight quotes). It is
- [E0198: unexpected statement before first switch case, expected 'case' or 'default'](errors-e0198.md): {
- [E0199: unclosed class; expected '}' by end of file](errors-e0199.md): Every`{`introducing a class block must have a matching`}`ending a class
- [E0200: break can only be used inside of a loop or switch](errors-e0200.md): {
- [E0201: continue can only be used inside of a loop](errors-e0201.md): {
- [E0202: missing '=' after variable](errors-e0202.md): The following code has a missing equal '=' after variable name.
- [E0203: depth limit exceeded](errors-e0203.md): JavaScript code can contain nested functions, arrays, objects, classes, etc.
- [E0204: error generator function star belongs after keyword function](errors-e0204.md): The following code has misplaced '*'.
- [E0205: error missing initializer in const declaration](errors-e0205.md): The following code is missing initialization for const
- [E0206: label named 'await' not allowed in async function](errors-e0206.md): The following code is using label named 'await' in an async
- [E0207: code point in Unicode escape sequence must not be greater than U+10FFFF](errors-e0207.md): Identifiers, string literals, and template literals can contain Unicode escape
- [E0208: cannot access private identifier outside class](errors-e0208.md): The following code is accessing a private identifier outside
- [E0209: commas are not allowed between class methods](errors-e0209.md): Classes and object literals have a similar syntax for declaring methods. Object
- [E0210: unopened block comment](errors-e0210.md): {
- [E0211: missing parentheses around self-invoked function](errors-e0211.md): Invoking an arrow function immediately without parentheses is a syntax error.
- [E0212: integer cannot be represented and will be rounded](errors-e0212.md): JavaScript stores integers as 64-bit floating-point numbers. Integers outside
- [E0213: TypeScript's 'interface' feature is not allowed in JavaScript code](errors-e0213.md): JavaScript does not support interfaces. It is a syntax error to write a
- [E0214: use of undeclared type](errors-e0214.md): A TypeScript type annotation must refer to a class, enum, generic parameter,
- [E0215: unclosed interface; expected '}' by end of file](errors-e0215.md): Every`{`introducing an interface block must have a matching`}`ending an
- [E0216: TypeScript interface properties cannot be 'static'](errors-e0216.md): TypeScript interfaces describe objects (instances), not classes. It is a syntax
- [E0217: TypeScript interface methods cannot be marked 'async'](errors-e0217.md): {
- [E0218: TypeScript interface methods cannot be marked as a generator](errors-e0218.md): {
- [E0219: interface properties are always public and cannot be private](errors-e0219.md): TypeScript interfaces describe the properties of objects usable from outside
- [E0220: TypeScript interface methods cannot contain a body](errors-e0220.md): TypeScript interfaces describe the properties of objects, but do not describe
- [E0221: TypeScript interface fields cannot be initalized](errors-e0221.md): TypeScript interfaces describe the properties of objects, but do not describe
- [E0222: 'private' is not allowed in JavaScript](errors-e0222.md): JavaScript private properties are declared using`#`. It is a syntax error to
- [E0223: missing semicolon after field](errors-e0223.md): Class fields and TypeScript interface fields must end with either a semicolon
- [E0224: TypeScript type annotations are not allowed in JavaScript code](errors-e0224.md): JavaScript variables and function returns cannot be explicitly typed with an
- [E0225: index signatures require a value type](errors-e0225.md): A TypeScript index signature has a key type and a value type. It is a syntax
- [E0226: missing semicolon after index signature](errors-e0226.md): TypeScript index signatures in interfaces must end with either a semicolon
- [E0227: index signature must be a field, not a method](errors-e0227.md): A TypeScript index signature describes a property. TypeScript only supports the
- [E0228: TypeScript optional properties are not allowed in JavaScript code](errors-e0228.md): `?`on class properties is a TypeScript feature. It is a syntax error to write
- [E0229: missing name for class method](errors-e0229.md): JavaScript class methods must have a name. It is a syntax error to omit the
- [E0230: TypeScript's 'readonly' feature is not allowed in JavaScript code](errors-e0230.md): `readonly`on class properties is a TypeScript feature. It is a syntax error to
- [E0231: methods cannot be readonly](errors-e0231.md): Class and interface methods cannot be marked as read-only. It is a syntax error
- [E0232: 'readonly static' is not allowed; write 'static readonly' instead](errors-e0232.md): The order of property specifiers like`readonly`and`static`matters. The
- [E0233: TypeScript generics are not allowed in JavaScript code](errors-e0233.md): It is a syntax error to write TypeScript generic parameters or arguments in
- [E0234: 'protected' is not allowed in JavaScript](errors-e0234.md): JavaScript does not support protected properties. It is a syntax error to
- [E0235: missing quotes around module name](errors-e0235.md): Module names are strings. It is a syntax error to import a module without
- [E0236: assignment-asserted field must have a type annotation](errors-e0236.md): {
- [E0237: interface properties cannot be marked public explicitly](errors-e0237.md): In TypeScript interfaces, all properties are public.
- [E0238: assignment-asserted fields are not supported in interfaces](errors-e0238.md): In TypeScript,`!`after a field name indicates a *definite assignment
- [E0239: TypeScript assignment-asserted fields are not supported in JavaScript](errors-e0239.md): In TypeScript,`!`after a class field name indicates a *definite assignment
- [E0240: '!' is not allowed on methods](errors-e0240.md): {
- [E0241: newline is not allowed between field name and '!'](errors-e0241.md): {
- [E0243: interfaces cannot contain static blocks](errors-e0243.md): `static`blocks in classes contain code which runs when the class is created at
- [E0244: abstract classes are not allowed in JavaScript](errors-e0244.md): {
- [E0245: missing body for TypeScript interface](errors-e0245.md): {
- [E0246: 'extends' must be before 'implements'](errors-e0246.md): TypeScript classes can extend another class and implement interfaces. It is a
- [E0247: TypeScript 'implements' is not allowed in JavaScript](errors-e0247.md): TypeScript interfaces are not supported in JavaScript. Therefore, using
- [E0248: extra ',' is not allowed between enum members](errors-e0248.md): In a TypeScript enum, members are separated with commas. It is a syntax error to
- [E0249: computed enum member name must be a simple string](errors-e0249.md): TypeScript enum members can be named using a string literal. The string literal
- [E0250: enum member name cannot be numeric](errors-e0250.md): TypeScript enum members can be named using an identifier or a string literal.
- [E0251: enum value must be a compile-time constant](errors-e0251.md): {
- [E0252: enum member needs initializer; computed value disables enum autoincrement](errors-e0252.md): {
- [E0253: use ':' instead of '=' in object literals](errors-e0253.md): JavaScript object literals are key-value pairs. In an expression, it is a syntax
- [E0254: unexpected ':' in expression; did you mean 'as'?](errors-e0254.md): {
- [E0255: missing parentheses around parameter; TypeScript type annotation requires parentheses](errors-e0255.md): {
- [E0256: catch variable can only be typed as '\*', 'any', or 'unknown'](errors-e0256.md): {
- [E0257: missing ',', ';', or newline between object type entries](errors-e0257.md): In TypeScript, properties in object types are separated by commas, semicolons,
- [E0258: missing type between '|' and '|' (or '&' and '&')](errors-e0258.md): An extra`|`or`&`is allowed at the beginning of a TypeScript type. However,
- [E0259: '.' is not allowed after generic arguments](errors-e0259.md): In TypeScript types, you can look up a property of a generic type using
- [E0260: TypeScript non-null assertion is not allowed on parameters](errors-e0260.md): In TypeScript,`!`after an expression is a *non-null assertion*. It is a syntax
- [E0261: TypeScript non-null assertions are not allowed in JavaScript](errors-e0261.md): {
- [E0262: leading commas are not allowed in generic parameter lists](errors-e0262.md): In a TypeScript generic class, function, or type alias, the generic parameter
- [E0263: only one comma is allowed between or after generic parameters](errors-e0263.md): {
- [E0264: expected at least one parameter in generic parameter list](errors-e0264.md): {
- [E0265: missing comma between generic parameters](errors-e0265.md): In a TypeScript generic class, function, or type alias, the generic parameter
- [E0266: redundant 'await'](errors-e0266.md): {
- [E0267: TypeScript types are not allowed in JavaScript](errors-e0267.md): TypeScript type aliases can be declared with the`type`keyword. It is a syntax
- [E0268: TypeScript type imports cannot import both default and named exports](errors-e0268.md): In TypeScript,`import type`can be used to import types from another module. It
- [E0269: 'async static' is not allowed; write 'static async' instead](errors-e0269.md): {
- [E0270: TypeScript type imports are not allowed in JavaScript](errors-e0270.md): TypeScript supports importing types using`import type`. It is a syntax error to
- [E0271: TypeScript type imports are not allowed in JavaScript](errors-e0271.md): This error has been renamed to E0270.
- [E0272: 'type' cannot be used twice in import](errors-e0272.md): When importing in TypeScript,`type`can be used to indicate that the symbol
- [E0273: TypeScript namespaces are not allowed in JavaScript](errors-e0273.md): TypeScript supports namespaces to describe objects. JavaScript does not support
- [E0274: TypeScript import aliases are not allowed in JavaScript](errors-e0274.md): TypeScript supports import alias using`import`. It is
- [E0275: newline is not allowed after 'interface'](errors-e0275.md): In TypeScript, the`interface`keyword must be followed by the interface's name.
- [E0276: newline is not allowed after 'namespace'](errors-e0276.md): In TypeScript, the`namespace`keyword must be followed by the namespace's name.
- [E0277: newline is not allowed after 'type'](errors-e0277.md): In TypeScript, the`type`keyword must be followed by the type's name.
- [E0278: TypeScript type exports are not allowed in JavaScript](errors-e0278.md): TypeScript supports exporting types using`export type`. It is a syntax error to
- [E0279: TypeScript type exports are not allowed in JavaScript](errors-e0279.md): This error has been renamed to E0279.
- [E0280: 'type' cannot be used twice in export](errors-e0280.md): {
- [E0281: TypeScript 'as' type assertions are not allowed in JavaScript](errors-e0281.md): {
- [E0282: use ':' instead of 'as' to type a function parameter](errors-e0282.md): The`as`operator is not allowed in function parameters. It is a syntax error to
- [E0283: TypeScript <Type> casts are not allowed in JSX mode](errors-e0283.md): {
- [E0284: missing TypeScript type](errors-e0284.md): In TypeScript, you can annotate the type of a variable by writing`:`after its
- [E0285: generic arrow function needs ',' here in TSX](errors-e0285.md): In TypeScript, generic arrow functions have syntax like`(params) =>
- [E0286: lower case letters compared with toUpperCase](errors-e0286.md): Comparing the result of a function named`toUpperCase`to a string literal with
- [E0287: upper case letters compared with toLowerCase](errors-e0287.md): Comparing the result of a function named`toLowerCase`to a string literal with
- [E0288: TypeScript interface properties are always public and cannot be marked protected](errors-e0288.md): TypeScript interfaces describe the properties of objects usable from outside
- [E0289: 'public' is not allowed in JavaScript](errors-e0289.md): JavaScript properties are public by default. It is a syntax error to
- [E0290: assignment-assertion fields cannot have default values](errors-e0290.md): {
- [E0291: 'as const' is only allowed on literals (array, object, string, boolean) and enum members](errors-e0291.md): {
- [E0292: missing semicolon after interface method](errors-e0292.md): TypeScript methods in interfaces must end with either a semicolon (`;`) or a
- [E0293: missing semicolon after abstract method](errors-e0293.md): TypeScript abstract methods in classes do not have bodies. Therefore, they
- [E0294: abstract methods cannot contain a body](errors-e0294.md): {
- [E0295: abstract fields cannot have default values](errors-e0295.md): TypeScript abstract fields in classes cannot have initializers. It is a syntax
- [E0296: abstract properties are only allowed in abstract classes](errors-e0296.md): {
- [E0297: abstract properties are not allowed in interfaces](errors-e0297.md): {
- [E0298: abstract methods cannot be marked 'async'](errors-e0298.md): {
- [E0299: abstract methods cannot be marked as a generator](errors-e0299.md): {
- [E0300: newline is not allowed after 'abstract'](errors-e0300.md): In TypeScript, the`abstract`keyword can be used to mark a class as abstract.
- [E0301: 'this' parameters are not allowed in arrow functions](errors-e0301.md): {
- [E0302: 'this' parameter not allowed when destructuring](errors-e0302.md): {
- [E0303: 'this' must be the first parameter](errors-e0303.md): TypeScript allows you to explicitly declare the`this`parameter. It is a syntax
- [E0304: cannot use '...' on 'this' parameter](errors-e0304.md): {
- [E0305: 'this' parameters are not allowed in JavaScript](errors-e0305.md): TypeScript allows you to explicitly declare the`this`parameter. It is a syntax
- [E0306: React/JSX is not allowed in vanilla TypeScript code](errors-e0306.md): {
- [E0307: unexpected '?'](errors-e0307.md): In JavaScript,`?`is used for the conditional operator (e.g.
- [E0308: TypeScript optional parameters are not allowed in JavaScript](errors-e0308.md): {
- [E0309: unexpected '?' when destructuring](errors-e0309.md): In TypeScript,`?`can be used to mark a function parameter as optional. It is a
- [E0310: optional parameter cannot have both '?' and initializer; remove '?'](errors-e0310.md): In TypeScript, parameters can be explicitly marked as optional with`?`. It is a
- [E0311: missing parentheses around parameter; TypeScript optional parameter requires parentheses](errors-e0311.md): In TypeScript, parameters can be explicitly marked as optional with`?`. It is a
- [E0312: missing parentheses around parameter; TypeScript optional parameter with type annotation requires parentheses](errors-e0312.md): {
- [E0313: 'readonly' only works with array types and tuple types](errors-e0313.md): {
- [E0315: (name) is not the name of a parameter](errors-e0315.md): {
- [E0316: function overload signature must be named (function name)](errors-e0316.md): In TypeScript, functions can have overload signatures. Each signature should
- [E0317: newline is not allowed between 'async' and 'function'](errors-e0317.md): {
- [E0318: function overload signature cannot have generator '\*'](errors-e0318.md): In TypeScript, functions can have overload signatures. Overload signatures work
- [E0319: missing name for element in named tuple type](errors-e0319.md): In TypeScript, a tuple type can have names for each element. It is a syntax
- [E0320: missing name for element in named tuple type](errors-e0320.md): In TypeScript, a tuple type can have names for each element. It is a syntax
- [E0321: expected '?' to mark tuple element as optional](errors-e0321.md): TypeScript tuple types can contain optional elements. These optional elements
- [E0323: optional tuple elements cannot come after spread elements](errors-e0323.md): TypeScript tuple types can contain spread elements and optional elements.
- [E0324: spread tuple elements cannot be optional](errors-e0324.md): {
- [E0325: cannot delete variables in TypeScript](errors-e0325.md): In JavaScript, it is possible to use`delete`on a variable. In TypeScript,
- [E0326: 'async export' is not allowed; write 'export async' instead](errors-e0326.md): Functions can be marked using the`async`keyword like`async function f() {`.
- [E0327: 'function async' is not allowed; write 'async function' instead](errors-e0327.md): Functions can be marked with the`async`keyword. It is a syntax error to write
- [E0341: using '===' or '!==' against an array literal does not compare items](errors-e0341.md): Using the strict equality or inequality operator against an array literal will not compare the items in them, e.g.
- [E0342: using equality or inequality operators against an arrow function will always produce the same result](errors-e0342.md): Using equality or inequality operators against an arrow function will always yield the same result (false or true), e...
- [E0343: using '==' against a class literal always returns 'false'](errors-e0343.md): {
- [E0344: using '===' or '!==' against an empty array literal always produces the same result](errors-e0344.md): Using the strict equality operator against an empty array literal will always return 'false', and using the strict in...
- [E0345: using equality or inequality operators against an object literal always produces the same result](errors-e0345.md): Using equality or inequality operators against any object literal will always yield false or true respectively, e.g.
- [E0346: using '==' against a regular expression literal always returns 'false'](errors-e0346.md): In JavaScript, writing`/regularexpression/`creates a new`RegExp`object. so
- [E0347: duplicated case clause in switch statement](errors-e0347.md): It's common to copy-paste case clauses when writing switch statements,
- [E0348: unexpected '?' in type; use '| void' to make an optional type](errors-e0348.md): Using a question mark as a prefix or suffix to make parameter types optional is invalid. Instead add a second 'void' ...
- [E0349: function parameter cannot be parenthesized](errors-e0349.md): Using parenthesis around the function parameter is invalid.
- [E0358: 'declare' should not be written inside a 'declare namespace'](errors-e0358.md): Inside`declare namespace`, declarations (functions, classes, etc.) are
- [E0369: nullish coalescing operator does nothing when left operand is never null](errors-e0369.md): When left operand is never null (such as comparisons and string literals), the expression will always resolve to the ...
- [E0373: unexpected whitespace between '!' and '=='; '!' here treated as the TypeScript non-null assertion operator](errors-e0373.md): While`x! == y`is legal TypeScript for a non-null assertion, it may be a typo for a strict inequality, as in`x !== y`:
- [E0374: unexpected whitespace between '!' and '=='](errors-e0374.md): `x! == y`is a typo for a strict inequality, as in`x !== y`:
- [E0376: JSX prop is missing an expression](errors-e0376.md): Every attribute in JSX with a prop requires an expression:
- [E0379: optional parameter cannot be followed by a required parameter](errors-e0379.md): Optional parameters need to be placed after the required ones.
- [E0381: Typescript does not allow keywords to contain escape sequence](errors-e0381.md): The following code is legal in JavaScript but is illegal in TypeScript
- [E0383: variable assignment to self is no-op](errors-e0383.md): {
- [E0427: missing 'break;' or '// fallthrough' comment between statement and 'case'](errors-e0427.md): Switch Cases in javascript fallthrough to the next case if the`break`statement is not added at the end of the case.
- [E0450: misleading use of ',' operator in index](errors-e0450.md): Using comma operator within an indexing operation is misleading, as it
- [E0451: misleading use of ',' operator in conditional statement](errors-e0451.md): Using comma operator within a conditional statement of a control block (`if`,`for`,`while`,`switch`) is misleading...
- [E0452: empty parenthesis after control statement](errors-e0452.md): Leaving parenthesis empty after control statements (`if`,`while`,`switch`,
- [E0458: typeof result is of type string and so will never equal undefined; use 'undefined' instead](errors-e0458.md): The`typeof`operator will always return a string, so comparing to undefined will always yield false.
- [E0707: classes cannot be named 'await' in async function](errors-e0707.md): This error has been renamed to E0069.
- [E0708: unexpected '...'; expected expression](errors-e0708.md): The spread ('...') operator must precede an expression:
- [E0709: expected variable name after '...'](errors-e0709.md): The spread operator ('...') must precede a variable name.
- [E0710: '^' is the XOR operator; to exponentiate, use '**' instead](errors-e0710.md): The Exclusive OR operator ^ can sometimes be mistaken for the
- [E0711: missing expression in placeholder within template literal](errors-e0711.md): Everytime you use`${}`within a template literal, which is a string defined
- [E0712: missing ',' between array elements](errors-e0712.md): This error occurs when there is a missing comma (',') between elements in an array
- [E0713: getters and setters cannot be generators](errors-e0713.md): Use of the '*' character, defining generator functions, is not allowed on getters or setters.
- [E0714: 'async' keyword is not allowed on getters or setters](errors-e0714.md): Use of 'async' keyword, defining asynchronous functions, is not allowed on getters or setters.
- [E0715: cannot use multiple `export default` statements in one module](errors-e0715.md): Modules in JavaScript can use two types of exports: default export and named export. While a module
- [E0716: unintuitive operator precedence when using & and << or >>](errors-e0716.md): {
- [E0717: namespace alias cannot use 'import type'](errors-e0717.md): The error message "namespace alias cannot use 'import type'" occurs when
- [E0718: using a '.' after a '?.' might fail, since '?.' might return 'undefined'](errors-e0718.md): This diagnostic has been removed in quick-lint-js version 3.2.0.
- [E0719: TypeScript namespace aliases are not allowed in JavaScript](errors-e0719.md): {
- [E0720: function 'let' call may be confused for destructuring; remove parentheses to declare a variable](errors-e0720.md): {
- [Profiling quick-lint-js](profiling.md): * Speed