Rule Change: Detect comparison to always new objects in no-constant-binary-expression

[captbaritone]

What rule do you want to change?

no-constant-binary-expression

What change to do you want to make?

Generate more warnings

How do you think the change should be implemented?

A new default behavior

Example code

function isEmpty(arr) {
  return arr === [];
}

function isDefault(obj) {
  return obj === {value: 'default'};
}

What does the rule currently do for this code?

Does not warn

What will the rule do after it's changed?

Warn

Participation

• I am willing to submit a pull request to implement this change.

Additional comments

A === comparison between an any value and a newly constructed object is guaranteed to always be false and can be trivially detected based on syntax. This type of programming error can be easy to make for programmers coming from compare-by-value languages.

I originally proposed this as a new rule in #15222 (you can see more context there) and it was rejected. However, now that I've realized we are calling my other proposed rule (#15222) no-constant-binary-expression I'm thinking that it makes sense to include this type of detection in no-constant-binary-expression.

In short: foo === {} or foo === [] or foo === (() => {}) are all statically provably constant binary expressions, and thus would make sense to flag as part of the new rule no-constant-binary-expression.

Thoughts?

[nzakas]

Can’t argue with that logic. 👍

[captbaritone]

Curious what, if any, further input is needed here?

[nzakas]

We just need to wait for others to review

@eslint/eslint-tsc thoughts?

[btmills]

Logic follows, and it fits the rule, so 👍

[mdjermanovic]

Makes sense to me 👍

[nzakas]

@captbaritone you are good to go here.

[captbaritone]

Thanks everyone! I've incorporated this change into #15296.