no-unused-vars does not report error when comma operator is used

[M393]

With no-unused-vars enabled eslint does not mark a variable as unused if assignment is combined with the comma operator.

What did you do? Please include the actual source code causing the issue, as well as the command that you used to run ESLint.

Both produce no warning:

let x = 0;
x++, x = 0;

let x = 0;
x++, x = 0;
x = 3;

What did you expect to happen?
It should mark the last occurance of x as an unused variable.

What actually happened? Please copy-paste the actual, raw output from ESLint.
eslint thinks everything is fine.

Steps to reproduce this issue:

1. eslint demo

Are you willing to submit a pull request to fix this bug?
No

[nzakas]

This is occurring because of the x++, not because of the comma operator. The post fix increment operation counts as both a read and a write, which is why there is no warning.

This looks like a bug but I’d like another set of eyes. @eslint/eslint-tsc

[M393]

The increment operator also writes (to itself) after reading.
It has to be related to the comma operator in some way.
These are correctly marked:

let x = 0;
x++;
^

let x = 0;
x++; x = 0;
     ^

[nzakas]

It appears you’re right. Here is an example without the increment operator that makes it clear:

let x = 0;
x=2, x = 0;
x = 3;

[snitin315]

I will take this issue 👍🏻

[aladdin-add]

seems it was not exactly related to comma operator. imagine this code:

var a;
a; // => rvalue

a will not be marked unused. (demo).
Technologically, it's working as expected. the 2nd a was used as rvalue (its value was read).

and these cases can be caught by some other rules:

var a;
a; // => caught by no-unused-expressions

var a;
a, b; // caught by no-sequences

[mdjermanovic]

and these cases can be caught by some other rules:

var a;
a; // => caught by no-unused-expressions

I think it's fine to not account for this in no-unused-vars, because a; itself is a possible error and it's reasonable to expect that no-unused-expressions is enabled.

var a;
a, b; // caught by no-sequences

no-sequences is mostly stylistic, but this is also caught by no-unused-expressions.