No TS2367 error when using unary not

[kkmuffme]

🔎 Search Terms

TS2367 unary not

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about TS2367

⏯ Playground Link

https://www.typescriptlang.org/play?#code/FAMwrgdgxgLglgewgAhgRgDxSQZxsgFQD4AKZAQwCcBzALkIEp6DkBTADxlYgBMdkIYALYAjVpWQB+ZAG9y9PJTgRqAX2T0Q5ADY5Ws4AEhKrGGEooA5JYDcwVcGDYIeZO2QBeVGjJoArMgMdnAgyGQAhO4MssgA9LHIAO4AFgCeAghslJQIEsnirJJGzq7pXux2DsAhYW6eHl5auvrRMsW4+GVulcBAA

💻 Code

function t1<const T>( arg: T): T extends number ? {a: string} : false {
	return '';
}

const x = t1( 15 );
if ( !x ) { // why no error here?
	const y = x;
}

if ( x === false ) {
	const y = x;
}

🙁 Actual behavior

Only error for line 11, even though line 7 should give an error too, since it's logically the same behavior.

🙂 Expected behavior

Error for line 11 and line 7 since it's logically the same behavior.

Additional information about the issue

Vaguely the opposite of #44366

This issue is annoying, because of #44366 - since in some cases it only works with false and in some with unary not.

[jcalz]

!x and x === false are not the same comparison, since !x only checks whether x is falsy as opposed to false.

The only way those are "logically the same behavior" is because we know that since x is of type {x: string} (but confusingly "" at runtime, why?) then !x and x === false are both false. So if (!x) {} and if (x === false) {} are the same as each other but also the same as if (3 > 5) {} or if (false) {}... but I wouldn't expect that to mean that the type checker should treat x === false and !x the same as each other or as 3 > 5 or as false. What am I missing here?

[kkmuffme]

They are not identical in a general case but their result is identical in this case, as typescript knows the types.

And this is the basis of TS2367 too - it only works/reports an error because it is aware of the types. This logic should also extend to ! and === false.

[RyanCavanaugh]

They are not identical in a general case but their result is identical in this case, as typescript knows the types.

This is just trading one inconsistency for another. We always allow

if (x) {

since x could be an actually-falsy value, e.g.

const arr: object[] = /* some array */;
const x = arr[3];
if (x) { // truthy according to type system

so it'd be inconsistent to allow

if (x) {
} else { // <- !x must be true
}

but not

if (x) {

[typescript-bot]

This issue has been marked as "Working as Intended" and has seen no recent activity. It has been automatically closed for house-keeping purposes.