Compiler warning for always true/false strict inequality expression

Search Terms

type guard warning if always true false non-identity inequality

Suggestion

The compiler should emit a warning if it can determine that an expression using a strict inequality check (!==) always returns true or false. It already does this for strict equality checks (===).

Use Cases

Like the warnings for the strict equality check, it helps identifying unreachable code blocks or unnecessary if blocks which can get introduced during refactoring of existing code or during carefree creation of new code.

Examples

The following function definition emits an error ("This condition will always return 'false' since the types '"abc"' and '"xyz"' have no overlap."):

function fn(p: "abc") {
  if (p === "xyz") {
    
  }
}

But this function definition compiles just fine (a possible error message could be "This condition will always return 'true' since the types '"abc"' and '"abc"' overlap completely":

function fn2(p: "abc") {
  if (p !== "abc") {
    
  }
}

It even correctly type-guards the type of p inside the if block (it becomes never).

Two other scenarios which trigger this non-warning, but could be harder to detect:

// typeof checks
function fn3(p: string) {
  if (typeof p !== "string") {

  }
}

// the length of a tuple
function fn4(p: []) {
  if (p.length !== 0) {

  }
}

The last example doesn't type-guard the value of p correctly to never even though p.length is correctly of type 0, maybe this is a separate feature request.

Problems / Discussion Points

• I'm not sure whether this qualifies as a breaking change, since it introduces a warning for code constructs which compile totally fine at the moment.
• This could be extended for other checks as well (e.g. for the </<= and >/>= operators) even though this would be pretty edge-casey.

Checklist

My suggestion meets these guidelines:

• (Unsure) This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Aucun fichier, test ou point d’entrée du compilateur n’est indiqué. Commencez par localiser les diagnostics existants pour les vérifications d’égalité stricte et comparez la manière dont sont analysés l’inégalité stricte, typeof et les expressions de longueur de tuple. Le travail est terminé lorsque des diagnostics sont ajoutés pour les conditions !== dont on peut prouver qu’elles sont toujours vraies ou toujours fausses, sans modifier le JavaScript généré.