Variable isn't narrowed within a capturing closure

TypeScript 3.7.2 Playground link

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,
    "experimentalDecorators": false,
    "emitDecoratorMetadata": false,
    "target": "ES2017",
    "module": "ESNext"
  }
}

Input:

let i: number | undefined;
i = 0;
let j:number = i+1; // works
(k: number) => k === i+1; // error: Object i is possibly undefined

Output:

"use strict";
let i;
i = 0;
let j = i + 1; // works
(k) => k === i + 1; // error: Object i is possibly undefined

Expected behavior:

The compiler should not complain about the last i+1 because it’s clearly a number type after assigning 0 to it.

I suspect the closure uses the type of i from the let statement and ignores it being narrowed down later on. Is this expected behavior?

[RyanCavanaugh]

If I had to draw the most realistic picture of a warning on a closed-over variable that really shouldn’t exist, it’d look like this:

function makeAdder(n?: number) {
  n = n ?? 0;
  return (m: number) => n + m;
}

It seems like the rule is “If a closure is lexically after all assignments to a bare identifier, then the last narrowing can apply”.

You can break this, though:

function adderWrapper(n?: number) {
  function setValue(v?: number) {
    n = v;
  }
  n = n ?? 0;
  return {
    setValue,
    add: (m: number) => m + n
  }
}
const k = adderWrapper(0);
k.setValue(undefined);
k.add(3); // NaN

So the rule would need to be amended to “All assignments to a bare identifier occur lexically and CFA-before the closure expression”, though possibly that could be broken too.

[j-oliveras]

Duplicate of #9998.

Typescript warns you that the i can be undefined when the function is called:

let i: number | undefined;
i = 0;
let j:number = i+1; // works
const func = (k: number) => k === i + 1; // error: Object i is possibly undefined
i = undefined;
func(3);

Playground.