Use before declaration errors when using let statements within a switch case

TypeScript Version: 2.5.3

Code

function test(value) {
    switch (value) {
        case 1:
            let foo = 10;
            break;
        case 2:
            foo = 20; // Runtime ReferenceError: foo is not defined
            break;
        default:
    }
}

test(2);

tsc --target es2015 (or higher)

Expected behavior:
This should probably produce a compile time error: Block-scoped variable 'pen' used before its declaration. on reference to foo in case 2.

Actual behavior:

The code type-checks and compiles fine, however, when running the es2015 transpiled output, you will receive a ReferenceError error at runtime. Ideally this type of error could be caught at compile time.

The current algorithm we use to detect use before def checks locations of declarations in the source file. this works in most cases, but not in cases where control flow is involved.

In case anyone has the same issue: this bug also affects classes and enums declared in a preceding case clause.

I've found a case that is related to this bug, but TS only catch it when strictNullChecks is true
I get a runtime error ReferenceError: Cannot access 'message' before initialization

code on playground

detected when "strictNullChecks": true,

not detected when "strictNullChecks": false,

"strictNullChecks": false should only allow cases where the variable is initialized but it's value is undefined like in this example

Real world example of this causing a bug (the commit is the fix): microsoft/vscode@7e266b2

entry was declared in the first case but then incorrectly used in the second case even though fall through is impossible

I'm trying to think of a reasonably-efficient algorithm to detect this and not coming up with many good ideas. switch is goto 😕

Update: Have something reasonable

Detect usage of block-scoped variables from earlier case blocks

So the only caveat here is that we'll have unavoidable false positives:

let n = 0;
switch (n) {
    case 0:
        let s = "ok";
    case 1:
        if (n === 0) {
            s; // ok by construction
        }
        break;
}

not clear what to do about that...

If I understand correctly, for a var-scoped variable, maybe that's a false-positive; however, s is in a temporal dead zone in case 1, and that's a runtime error in the following case.

switch (100) {
    case 99:
      let x;
    case 100:
      x = 0;
      console.log(x);
}

Daniel Rosenwasser (@DanielRosenwasser)

Daniel Rosenwasser (@DanielRosenwasser) the problem is that the code runs without error in the 0 case, but we'd flag it

Okay, I misread. Here's one that would've been more obvious to me.

let sHasBeenSet = false;
switch (n) {
    case 0:
        let s = "ok";
        sHasBeenSet = true;
    case 1:
        if (sHasBeenSet) {
            s; // ok by construction
        }
        break;
}

Navigation Menu

Repository navigation

Use before declaration errors when using let statements within a switch case #19503

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Use before declaration errors when using let statements within a switch case #19503

Description

Activity

mhegazy commented on Oct 26, 2017

ajafff commented on Mar 18, 2018

IlanFrumer commented on Feb 22, 2021

mjbvz commented on Dec 15, 2021

RyanCavanaugh commented on Dec 15, 2021

RyanCavanaugh commented on Dec 15, 2021

DanielRosenwasser commented on Dec 15, 2021

RyanCavanaugh commented on Dec 15, 2021

DanielRosenwasser commented on Dec 15, 2021

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions