Assertion function must be enforced over flow type inference

[SQReder]

TypeScript Version: 3.7.2

Search Terms:
callback, never, narrow, assert

Expected behavior:

1. foo type should be inferred as Foo, as described in the variable declaration

let foo: Foo | null = null;
/* ... */
if (foo != null) {
  /* foo must be Foo type here */
}

Actually, if IIFE used inference behave as expected

let foo: Foo | null = null;

(function () { foo = {} })()

if (foo != null) {
  /* foo is of type Foo here */
}

2. Assertion function must be preferred over flow type inference

Actual behavior:
foo type inferred as never and even assertion does not change it

Related Issues:
no

Code

function assertNonEmpty<T>(value: T | null | undefined): asserts value is T {
    if (value == null) {
        throw new Error("Should not be null or undefined");
    }
}

function absurd<T extends never>(value: T): asserts value is never { };

type AssertEqual<A, B> = A extends B ? B extends A ? true : never : never;

function runCallback(cb: () => void) { cb() };

type Foo = { __TYPE__?: any };

let foo: Foo | null = null;

runCallback(() => foo = {});

if (foo != null) {
    const shouldBeInferredAsFoo: AssertEqual<typeof foo, Foo> = true;

    assertNonEmpty<{}>(foo);

    const mustBeFoo: AssertEqual<typeof foo, Foo> = true;

    absurd(foo); // foo actually is never
} else {
    const nullish: AssertEqual<typeof foo, null> = true;
}

Output

"use strict";
function assertNonEmpty(value) {
    if (value == null) {
        throw new Error("Should not be null or undefined");
    }
}
function absurd(value) { }
;
function runCallback(cb) { cb(); }
;
let foo = null;
runCallback(() => foo = {});
if (foo != null) {
    const shouldBeInferredAsFoo = true;
    assertNonEmpty(foo);
    const mustBeFoo = true;
    absurd(foo); // foo actually is never
}
else {
    const nullish = true;
}

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

[MartinJohns]

Duplicate of #9998 and #26914 (you run into both issues).

[nmain100]

The very first example given is explained well in #31734. In short, foo is pre-narrowed to null only because typescript saw you assign null to it.

[SQReder]

Ok, I've replaced null with undefined, remove the assignment and it begins to work as expected.
Playground

[typescript-bot]

This issue has been marked as a 'Duplicate' and has seen no recent activity. It has been automatically closed for house-keeping purposes.