Typescript should prevent invalid variable assigning in if conditions

Suggestion

🔍 Search Terms

“assigning if”, I don’t know what else to look for

✅ Viability Checklist

My suggestion meets these guidelines:

• This wouldn’t be a breaking change in existing TypeScript/JavaScript code (would only detect errors that are already occurring)
• 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, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript’s Design Goals.

⭐ Suggestion

I believe a lot of JavaScript programmers have accidentally written code that assigns a new value to a variable instead of comparing it to something else by doing the following

let variable = "text"
if (variable = "value") // rest of the code

When they actually meant to do this

let variable = "text"
if (variable === "value") // rest of the code

And this code is invalid and an error should be thrown by TypeScript before runtime because it is essentially creating an invalid if condition that will never run. A possible problem that could come from creating an error in this would be situations where variables are correctly reassigned and then compared to something, like in the following example:

	let matches;
    while ((matches = this.constructor.CHANNELS_PATTERN.exec(this._content)) !== null) {
      const chan = this.client.channels.cache.get(matches[1]);
      if (chan) this._channels.set(chan.id, chan);
    }

Even though the above example uses a while, it’s still a valid use case where an error should not be thrown since it is being compared later.

📃 Motivating Example

TypeScript will now be able to detect invalid if conditions and help you improve them before runtime so that they aren’t ignored.

💻 Use Cases

Basically, whenever you’re coding while tired and accidentally write this, TS would alert you like all other TS features.

[andrewbranch]

Seems like a reasonable candidate for This condition will always return true if the RHS is an always-truthy type, or at least a truthy literal… I don’t think we’d ban this pattern outright (that feels solidly in the domain of a linter), but obviously-truthy conditions look beyond suspicious.

[ImRodry]

Related: #38826

Although I can see how that suggestion can relate to this one, it goes one step forward in enforcing a boolean on every condition, which wouldn’t be ideal at least to me. What I’m talking about here is producing an error on something that is actually invalid, so I believe this should be checked for without any additional settings