+= on private property doesn't count as a read for --noUnusedLocals

[DaveCousineau]

TypeScript Version: 2.9.2

Search Terms:
--noUnusedLocals
+=
private property

Code
tsconfig.json:

{
   "compileOnSave": true,
   "compilerOptions": {
      "target": "es6",
      "module": "none",
      "noImplicitAny": true,
      "removeComments": false,
      "outFile": "test.js",
      "declaration": false,
      "noEmitOnError": true,
      "sourceMap": false,
      "strictNullChecks": true,
      "noUnusedLocals": true,
      "noUnusedParameters": true
   }
}

test.ts

export class TestClass {
   private mNumber: number = 0;
   private get Number(): number { return this.mNumber; }
   private set Number(value: number) { this.mNumber = value; }

   public DoSomething() {
      this.Number += 1;
   }
}

Result

c:\Temp>tsc
test.ts(3,16): error TS6133: 'Number' is declared but its value is never read.

Expected behavior:
+= should count as both a read and a write

Actual behavior:
+= seems to count as a write but not a read. though this problem doesn't occur with a public property.

Playground Link:
I don't think I can set --noUnusedLocals on the playground

Related Issues:
I found this "noUnusedLocals checks don't work with private modifier": #15775
but it was closed

[mhegazy]

PRs welcomed

[DanielRosenwasser]

I still feel like this is somewhat questionable - the getter's value is still never observed outside of the assignment.

[AnyhowStep]

A better error message, then?

[DaveCousineau]

@DanielRosenwasser

In my particular case, the reason that this comes up is that the property setter recalculates something else when the value changes. I otherwise use the field to read the value, except for the one += usage. I actually temporarily removed the getter, since it was supposedly not used, but then ended up getting NaN showing up in places when += was used with no getter. What I've had to do is replace the += with this.Number = this.Number + 1;. Maybe it should be redesigned slightly and this is an indication of a code smell, but I don't see that x = x + 1 should count as a read, but x += 1 shouldn't.

[DaveCousineau]

Here is a more realistic example that's a little closer to what I really have:

export class YesNoCounter {
   private mYes: number = 0;
   private get Yes(): number { return this.mYes; }
   private set Yes(value: number) { this.mYes = value; /* raise value changed event */ }

   private mNo: number = 0;
   private get No(): number { return this.mNo; }
   private set No(value: number) { this.mNo = value; /* raise value changed event */ }

   private get Total(): number { return this.mYes + this.mNo; }

   public get LabelText(): string { return `${this.mYes}/${this.Total}`; }

   public AddYes() { this.Yes += 1; }
   public AddNo() { this.No += 1; }
}

There are many ways to avoid the error, but I don't see a good reason why there should be an error.

[DanielRosenwasser]

It seems reasonable to relax it, but since this is a private declaration, I'd think we should be able to special-case the getter/setter case.

[moccaplusplus]

Could I take this issue?
This would be my first contribution here, so any assistance is welcome.