type guard about const enum and string

[bluelovers]

TypeScript Version: 3.4.0-dev.201xxxxx

Search Terms:

Code

/**
 * Created by user on 2019/5/9.
 */

export const enum EnumTypeNode
{
	Pattern = "Pattern",
	Disjunction = "Disjunction",
}

export type NodeA = Disjunction | Pattern;

export interface NodeBase
{
	type: NodeA["type"]
}

export interface Disjunction extends NodeBase {
	type: EnumTypeNode.Disjunction
	alternatives: string[]
}

export interface Pattern extends NodeBase {
	type: EnumTypeNode.Pattern
	elements: string[]
}

let n: NodeA

if (n.type === "Disjunction")
{
	n.alternatives.slice()
}
else
{
	n.elements.slice()
	// Error: TS2339: Property 'elements' does not exist on type 'NodeA'.  Property 'elements' does not exist on type 'Disjunction'.
}

if (n.type === EnumTypeNode.Disjunction)
{
	n.alternatives.slice()
}
else
{
	n.elements.slice()
	// didn't have error
}

Expected behavior:

no error, if (n.type === "Disjunction") everything same as use if (n.type === EnumTypeNode.Disjunction)

Actual behavior:

Error: TS2339: Property 'elements' does not exist on type 'NodeA'.
Property 'elements' does not exist on type 'Disjunction'.

if (n.type === "Disjunction")
{
	n.alternatives.slice()
}
else
{
	n.elements.slice()
	// Error: TS2339: Property 'elements' does not exist on type 'NodeA'.
  Property 'elements' does not exist on type 'Disjunction'.
}

Playground Link:

Related Issues:

#14210

[jack-williams]

I think the issue here is that negative narrowing for discriminants works on inequality, while positive narrowing works on the comparability relation.

The raw types of EnumTypeNode.Disjunction and "Disjunction" are comparable which is why the narrowing works in the positive case, but the types are represented by distinct objects which why is Disjunction is not filtered from the union in the negative case.

Below fixes the problem, but probably has bad regressions:

if (isUnitType(valueType)) {
    const regularType = getRegularTypeOfLiteralType(valueType);
    // was: return filterType(type, t => getRegularTypeOfLiteralType(t) !== regularType);
    return filterType(type, t => !areTypesComparable(getRegularTypeOfLiteralType(t), regularType));
}