Assertion functions cannot be used to narrow discriminated union types

[oleg-codaio]

Recently I tried to get creative with an assert function, but ran into a shortcoming. I think I understand why this is the behavior, but it would be nice if it wasn't the case.

TypeScript Version: 3.9.0-dev.20200304

Search Terms: assertion assert function discriminated union narrowing

Code

interface Cat {
  type: 'cat';
  canMeow: true;
}

interface Dog {
  type: 'dog';
  canBark: true;
}

type Animal = Cat | Dog;

function assertEqual<T>(value: any, type: T): asserts value is T {
  if (value !== type) {
    throw new Error('Not equal!');
  }
}

const animal = { type: 'cat', canMeow: true } as Animal;
assertEqual(animal.type, 'cat' as const);

// Error
animal.type; // "cat"
animal.canMeow; // Property 'canMeow' does not exist on type 'Dog'

// Works
if (animal.type !== 'cat') {
  throw new Error();
}
animal.canMeow; // true

Expected behavior:
Calling assertEqual(animal.type, 'cat') would infer animal as a Cat.

Actual behavior:
Only animal.type by itself is inferred; the type narrow does not "propagate" up to the union type.

Playground Link: Provided

Related Issues: #11787 (most closely related, but that's for type guards, not the new assertion functions), #34596

[jamietre]

I'm having a similar problem. It's not totally clear to me if your example exposes the same behavior, but it seems very similar: the type is not narrowed by the assertion.

interface Ok extends String {
  _nominal: null;
}

function assertIsOk(foo: string | Ok): asserts foo is Ok {
  if (foo !== "ok") {
    throw new Error("not ok");
  }
}

function acceptsOnlyString(foo: string) {
  ...
}

function checkIfOk(baz: string) {
  assertIsOk(baz);

  // compiles  - `baz` is now type "string & Ok"; expected it to be type "Ok" and would fail
  acceptsOnlyString(baz);
}

Works the same way when coded as a type guard.

[BobElDevil]

Note for a workaround in the first example, a more generic asserts value works for the original example situation, since that asserts the entirety of the statement as true, like an 'if' would

interface Cat {
  type: 'cat';
  canMeow: true;
}

interface Dog {
  type: 'dog';
  canBark: true;
}

type Animal = Cat | Dog;

function assert(value: any): asserts value {
  if (!value) {
    throw new Error();
  }
}

const animal = { type: 'cat', canMeow: true } as Animal;
assert(animal.type === 'cat');

animal.type; // "cat"
animal.canMeow; // Works

[wmaca]

It seems to be affecting other union types, as the code below demonstrates.

Code

type MyUnion = { [key: string]: any } | string[];

function assertObject(value: any): asserts value is Record<string, any> {
    if (value === null || typeof value !== "object" || Array.isArray(value)) {
        throw new Error("Assertion failed");
    }
}

function getValue(): MyUnion {
    return { foo: "bar" };
}

const value = getValue();

assertObject(value);

// Error as it does not know if it is a string[] or { [key: string]: any }
console.log(value["propName"]); 

Playground Link: here

More details

I've also observed that TypeScript is using the already known type at caller (i.e. MyType) to narrow after the assert function is called. This is resulting in never as a result.

I am not sure this part is expected.

type MyType =
	| {
			[key: string]: {
				[k: string]: number;
			};
	  }
	| string;

const a: MyType = { foo: { bar: 123 } };

function assertUndefined(value: any): asserts value is undefined {
	if (value !== undefined) throw new Error();
}

assertUndefined(a.foo);

// `a.foo` is `never`
console.log(a.foo);