Unknown types narrowed to a union won't narrow further

[Validark]

This fails on the playground, and I believe it also fails on [email protected]

TypeScript Version: [email protected]

Search Terms: unknown intersection failure types narrow

Code

interface TypeA {
	Name: "TypeA";
	Value1: "Cool stuff!";
}

interface TypeB {
	Name: "TypeB";
	Value2: 0;
}

type Type = TypeA | TypeB;

declare function isType(x: unknown): x is Type;

function WorksProperly(data: Type) {
	if (data.Name === "TypeA") {
		// data: TypeA
		const value1 = data.Value1;
	}
}

function DoesNotWork(data: unknown) {
	if (isType(data)) {
		if (data.Name === "TypeA") {
			// data: Type
			// data should be TypeA
			const value1 = data.Value1; // type error!
		}
	}
}

Expected behavior: in DoesNotWork, data should be TypeA after we can guarentee it is named "TypeA"

Actual behavior: data is still only a Type

Playground Link: Here

Related Issues: I looked through several pages of issues and did not find anything similar.

[jack-williams]

Narrowing by discriminant only applies when the declared type of the identifier is a union type; here, the declared type of data is unknown.

There are probably good reasons for this that someone more knowledgeable can provide, performance possibly among them.

There is an easy workaround which is declaring a new identifier inside the body of the first condition, then narrowing from that.

[Validark]

Personally, I wish this was the way unknown worked out of the box because it seems to me that cases like the one I am describing would be extremely common for unknown types. The point of unknown is that you have to verify what type it is before using it. If you can't use the type normally after checking its type, that is a major problem in my view.

#27706 might be related.

[zpdDG4gta8XKpMCd]

interestingly this works:

function WorksProperly(data: Type) {
	if (data.Name === "TypeA") {
		// data: TypeA
		const value1 = data.Value1;
	}
}

function DoesNotWork(data: unknown) {
	if (isType(data)) {

		WorksProperly(data); // <-- !!!

		// if (data.Name === "TypeA") {
		// 	// data: Type
		// 	// data should be TypeA
		// 	const value1 = data.Value1;
		// }
	}
}

[jack-williams]

I’m pretty certain the linked issue is not related. The behaviour as I describe is consistent with @Aleksey-Bykov ‘s example. The declared argument type of DoesNotWork is not a union, while the declared argument type of WorksProperly is.

While it is nice to have full reasoning applied to every situation, TypeScript gains a lot of performance wins by judiciously picking when and where to apply expensive checks.

I think this might be one of those cases, but I’m not certain. Someone on the team will be able to correct me.

I’ll add that I do agree that your example would be nice to have, and iteratively narrowing unknown is a good use case. The trade-off is whether you would special case unknown or apply the checks uniformly to all types.

[zpdDG4gta8XKpMCd]

what i've been told one day here is that narrowing doesn't make new types it only narrows what's given, in case of unknown it is implied all the types that only can be imagined out there (over 9000), which is well...
so... in the case of narrowing from unknown the design team clearly took a shortcut, and here we see the consequences

[RyanCavanaugh]

This feels like it might be a bug. Once data is narrowed to a union type, narrowing by the discriminant is entirely reasonable

[jack-williams]

Fix here #30593

[talbenari1]

Out of curiosity, is this related? I didn't have to use unknown to lose type refinement.

type Foo = Bar | Baz;

interface Bar {
    kind: 'Bar';
    prop: string | void;
}


interface Baz {
    kind: 'Baz';
    prop: string;
}

function fn(el: Foo): number {
    switch (el.kind) {
        case 'Bar':
            if (!el.prop) {
                return 0;
            }
        // falls through
        case 'Baz':
            return el.prop.length; // Property 'length' does not exist on type 'string | void'
    }
}