biomejs · vladimir-ivanov · Oct 12, 2025 · Oct 14, 2025 · Oct 14, 2025 · Oct 14, 2025
diff --git a/.changeset/no_unused_private_class_members_amended.md b/.changeset/no_unused_private_class_members_amended.md
@@ -0,0 +1,47 @@
+---
+"@biomejs/biome": patch
+---
+
+Changed [`noUnusedPrivateClassMembers`](https://biomejs.dev/linter/rules/no-unused-private-class-members/) to align more fully with meaningful reads.
+
+This rule now distinguishes more carefully between writes and reads of private class members.
+
+- A *meaningful read* is any access that affects program behavior.
+- For example, `this.#x += 1` both reads and writes `#x`, so it counts as usage.
+- Pure writes without a read (e.g. `this.#x = 1` with no getter) are no longer treated as usage.
+
+This change ensures that private members are only considered “used” when they are actually read in a way that influences execution.
+
+***Invalid examples (previously valid)***
+
+```ts
+class UsedMember {
+  set #x(value) {
+    doSomething(value);
+  }
+
+  foo() {
+    // This assignment does not actually read #x, because there is no getter.
+    // Previously, this was considered a usage, but now it’s correctly flagged.
+    this.#x = 1;
+  }
+}
+```
+
+***Valid example (Previously invalid)***
+
+```js
+class Foo {
+  #usedOnlyInWriteStatement = 5;
+
+  method() {
+    // This counts as a meaningful read because we both read and write the value.
+    this.#usedOnlyInWriteStatement += 42;
+  }
+}
+```
+
+***Summary***
+•	Only accesses that read a value are considered meaningful for the purpose of this rule.
+•	Simple assignments to a setter without a corresponding getter no longer count as usage.
+•	Operations like +=, method calls returning a value, or reading the property for computation are considered meaningful reads.
diff --git a/.changeset/no_unused_private_class_members_dynamic_usages.md b/.changeset/no_unused_private_class_members_dynamic_usages.md
@@ -0,0 +1,30 @@
+---
+"@biomejs/biome": patch
+---
+
+**Improved detection of used private class members**
+
+The analysis for private class members has been improved: now the tool only considers a private member “used” if it is actually referenced in the code.
+
+- Previously, some private members might have been reported as used even if they weren’t actually accessed.
+- With this change, only members that are truly read or called in the code are counted as used.
+- Members that are never accessed will now be correctly reported as unused.
+
+This makes reports about unused private members more accurate and helps you clean up truly unused code.
+
+***Example (previously valid)***
+
+```ts
+type YesNo = "yes" | "no";
+
+export class SampleYesNo {
+  private yes: () => void;
+  private no: () => void;
+  private dontKnow: () => void; // <- will now report as unused
+
+  on(action: YesNo): void {
+    this[action]();
+  }
+}
+
+```