noSwitchDeclarations (JavaScript)

Language JavaScript (and super languages)

Summary

Rule available since: v1.0.0
Diagnostic Category: lint/correctness/noSwitchDeclarations
This rule is recommended, meaning it is enabled by default.
This rule has a safe fix.
The default severity of this rule is error.
Sources:
- Same as no-case-declarations

How to configure

1
{
2
  "linter": {
3
    "rules": {
4
      "correctness": {
5
        "noSwitchDeclarations": "error"
6
      }
7
    }
8
  }
9
}

Description

Disallow declarations directly inside switch clauses.

A let, const, function, or class declared in one clause is visible throughout the entire switch, but it is initialized only when the clause containing it runs. Another clause can therefore access the declaration before initialization and cause a runtime error.

Wrap each clause in a block to limit the declaration to that clause.

Examples

Invalid

1
switch (foo) {
2
    case 0:
3
        const x = 1;
4
        break;
5
    case 2:
6
        x; // `x` can be used while it is not initialized
7
        break;
8
}

code-block.js:3:9 lint/correctness/noSwitchDeclarations  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ Other switch clauses can erroneously access this declaration.
    Wrap the declaration in a block to restrict its access to the switch clause.
  
    1 │ switch (foo) {
    2 │     case 0:
  > 3 │         const x = 1;
      │         ^^^^^^^^^^^
    4 │         break;
    5 │     case 2:
  
  ℹ The declaration is defined in this switch clause:
  
    1 │ switch (foo) {
  > 2 │     case 0:
      │     ^^^^^^^
  > 3 │         const x = 1;
  > 4 │         break;
      │         ^^^^^^
    5 │     case 2:
    6 │         x; // `x` can be used while it is not initialized
  
  ℹ Safe fix: Wrap the declaration in a block.
  
    1  1 │   switch (foo) {
    2    │ - ····case·0:
       2 │ + ····case·0:·{
    3  3 │           const x = 1;
    4    │ - ········break;
       4 │ + ········break;
       5 │ + ····}
    5  6 │       case 2:
    6  7 │           x; // `x` can be used while it is not initialized

1
switch (foo) {
2
    case 0:
3
        function f() {}
4
        break;
5
    case 2:
6
        f(); // `f` can be called here
7
        break;
8
}

code-block.js:3:9 lint/correctness/noSwitchDeclarations  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ Other switch clauses can erroneously access this declaration.
    Wrap the declaration in a block to restrict its access to the switch clause.
  
    1 │ switch (foo) {
    2 │     case 0:
  > 3 │         function f() {}
      │         ^^^^^^^^^^^^^^^
    4 │         break;
    5 │     case 2:
  
  ℹ The declaration is defined in this switch clause:
  
    1 │ switch (foo) {
  > 2 │     case 0:
      │     ^^^^^^^
  > 3 │         function f() {}
  > 4 │         break;
      │         ^^^^^^
    5 │     case 2:
    6 │         f(); // `f` can be called here
  
  ℹ Safe fix: Wrap the declaration in a block.
  
    1  1 │   switch (foo) {
    2    │ - ····case·0:
       2 │ + ····case·0:·{
    3  3 │           function f() {}
    4    │ - ········break;
       4 │ + ········break;
       5 │ + ····}
    5  6 │       case 2:
    6  7 │           f(); // `f` can be called here

1
switch (foo) {
2
    case 0:
3
        class A {}
4
        break;
5
    default:
6
        new A(); // `A` can be instantiated here
7
        break;
8
}

code-block.js:3:9 lint/correctness/noSwitchDeclarations  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ Other switch clauses can erroneously access this declaration.
    Wrap the declaration in a block to restrict its access to the switch clause.
  
    1 │ switch (foo) {
    2 │     case 0:
  > 3 │         class A {}
      │         ^^^^^^^^^^
    4 │         break;
    5 │     default:
  
  ℹ The declaration is defined in this switch clause:
  
    1 │ switch (foo) {
  > 2 │     case 0:
      │     ^^^^^^^
  > 3 │         class A {}
  > 4 │         break;
      │         ^^^^^^
    5 │     default:
    6 │         new A(); // `A` can be instantiated here
  
  ℹ Safe fix: Wrap the declaration in a block.
  
    1  1 │   switch (foo) {
    2    │ - ····case·0:
       2 │ + ····case·0:·{
    3  3 │           class A {}
    4    │ - ········break;
       4 │ + ········break;
       5 │ + ····}
    5  6 │       default:
    6  7 │           new A(); // `A` can be instantiated here

Valid

1
switch (foo) {
2
    case 0: {
3
        const x = 1;
4
        break;
5
    }
6
    case 1:
7
        // `x` is not visible here
8
        break;
9
}