simulate scope at let to a if statement but failed

[arex0]

TypeScript Version: 3.7.5

Search Terms: if-let, scope, closure

Expected behavior: tsc report no error

Actual behavior: tsc report "Variable 'a' is used before being assigned."

Related Issues:

Code
if-let statement is easy to control scope in golang

var a A 
if i := bytes.Index(s,sep); i != -1 {
  a = makeA(i) // use i here
}else{
  a = make(A)
  // others code do not use i here
}
a.doSomthing()

I try to use closure to simulate it, because ts can not use if-let statement. tsc reported error "Variable 'a' is used before being assigned."

class A {
    i: number | undefined
    constructor(i?: number) {
        if (i !== undefined) {
            this.i = i
        }
    }
    doSomething() {
        if (this.i === undefined) console.log("A init in else statement")
        else console.log("A init in if statement")
    }
}

function f(sep: number) {
    let a: A
    if (((i: number) => {
        if (i == -1) return false
        a = new A(i) // use i there
        return true
    })(arr.indexOf(sep))) {
    } else {
        a = new A
        // others code do not use i there
    }
    a.doSomething()
}

let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

f(10)
f(5)

Output

"use strict";
class A {
    constructor(i) {
        if (i !== undefined) {
            this.i = i;
        }
    }
    doSomething() {
        if (this.i === undefined)
            console.log("A init in else statement");
        else
            console.log("A init in if statement");
    }
}
function f(sep) {
    let a;
    if (((i) => {
        if (i == -1)
            return false;
        a = new A(i); // use i there
        return true;
    })(arr.indexOf(sep))) {
    }
    else {
        a = new A;
        // others code do not use i there
    }
    a.doSomething();
}
let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
f(10);
f(5);

Compiler Options

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictPropertyInitialization": true,
    "strictBindCallApply": true,
    "noImplicitThis": true,
    "noImplicitReturns": true,
    "useDefineForClassFields": false,
    "alwaysStrict": true,
    "allowUnreachableCode": false,
    "allowUnusedLabels": false,
    "downlevelIteration": false,
    "noEmitHelpers": false,
    "noLib": false,
    "noStrictGenericChecks": false,
    "noUnusedLocals": false,
    "noUnusedParameters": false,
    "esModuleInterop": true,
    "preserveConstEnums": false,
    "removeComments": false,
    "skipLibCheck": false,
    "checkJs": false,
    "allowJs": false,
    "declaration": true,
    "experimentalDecorators": false,
    "emitDecoratorMetadata": false,
    "target": "ES2017",
    "module": "ESNext"
  }
}

Playground Link: Provided

[jcalz]

The new issue template asks for a Playground link https://www.typescriptlang.org/play/ where your issue is reproduced. The above code has several errors due to missing declarations, but not the one you're reporting. Please consider cleaning it up if you don't want this closed as unactionable. Good luck!

[arex0]

@jcalz thank you for you commented, it is clean up now

[MartinJohns]

Duplicate of #9998.

[jcalz]

I don't know about #9998; the function here is an IIFE which, IIRC (ha ha), is inlined:

let z: string;
(() => { z = "a" })()
z.toUpperCase(); // okay

Instead I think it has to do with trying to "save" the results of CFA in variables, return them from functions, etc., and then use them later... which doesn't work, as in #12184, #20497, #24865 (and probably others):

let a: string;
const bool = Math.random() < 0.5;
if (bool) { a = ""; }
if (!bool) { a = ""; }
a.toUpperCase(); // error

In any case, a mcve for this probably looks like:

let b: string;
if ((() => {
    if (Math.random() < 0.5) return true;
    b = "";
    return false;
})()) {
    b = "";
}
b.toUpperCase(); // error

Playground link

[RyanCavanaugh]

We don't have any kind of mechanisms capable of creating inferences like "This function either returns true and makes an assignment, or returns false when it doesn't", nor frequently-encountered use cases in which case this kind of reasoning is necessary.