allow unused private well-known symbol members

src/compiler/checker.ts

@@ -31559,6 +31559,18 @@ namespace ts {
             }
         }
 
+        function isWellKnownSymbol(node: Node) {
+            const symbol = getSymbolAtLocation(node);
+            if (!symbol) {
+                return false;
+            }
+            const symbolConstructorSymbol = getGlobalESSymbolConstructorSymbol(/*reportErrors*/ false);
+            if (!symbolConstructorSymbol) {
+                return false;
+            }
+            return !!getPropertiesOfObjectType((getTypeOfSymbol(symbolConstructorSymbol) as ObjectType)).includes(symbol);
+        }
+
         function isSymbolOrSymbolForCall(node: Node) {
             if (!isCallExpression(node)) return false;
             let left = node.expression;
@@ -31569,13 +31581,17 @@ namespace ts {
                 return false;
             }
 
+            return isReferenceToGlobalESSymbolConstructorSymbol(left);
+        }
+
+        function isReferenceToGlobalESSymbolConstructorSymbol(node: Identifier) {
             // make sure `Symbol` is the global symbol
             const globalESSymbol = getGlobalESSymbolConstructorSymbol(/*reportErrors*/ false);
             if (!globalESSymbol) {
                 return false;
             }
 
-            return globalESSymbol === resolveName(left, "Symbol" as __String, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false);
+            return globalESSymbol === resolveName(node, "Symbol" as __String, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false);
         }
 
         function checkImportCallExpression(node: ImportCall): Type {
@@ -36858,7 +36874,8 @@ namespace ts {
                         const symbol = getSymbolOfNode(member);
                         if (!symbol.isReferenced
                             && (hasEffectiveModifier(member, ModifierFlags.Private) || isNamedDeclaration(member) && isPrivateIdentifier(member.name))
-                            && !(member.flags & NodeFlags.Ambient)) {
+                            && !(member.flags & NodeFlags.Ambient)
+                            && !(isNamedDeclaration(member) && isComputedPropertyName(member.name) && isWellKnownSymbol(member.name.expression))) {
                             addDiagnostic(member, UnusedKind.Local, createDiagnosticForNode(member.name!, Diagnostics._0_is_declared_but_its_value_is_never_read, symbolToString(symbol)));
                         }
                         break;

tests/baselines/reference/unusedWellKnownSymbolsInClass.errors.txt

@@ -0,0 +1,148 @@
+tests/cases/compiler/unusedWellKnownSymbolsInClass.ts(128,14): error TS6133: '[Symbol.iterator]' is declared but its value is never read.
+tests/cases/compiler/unusedWellKnownSymbolsInClass.ts(136,12): error TS6133: '[iteratorSymbol]' is declared but its value is never read.
+
+
+==== tests/cases/compiler/unusedWellKnownSymbolsInClass.ts (2 errors) ====
+    export class Polling {
+      private async *[Symbol.asyncIterator]() {}
+      private *[Symbol.iterator]() {}
+
+      async loop() {
+        for await (const updates of this) {
+          void updates
+        }
+      }
+      syncLoop() {
+        for (const updates of this) {
+          void updates
+        }
+      }
+    }
+
+    export class WellknownSymbolMethods {
+      private async *[Symbol.asyncIterator]() {
+        yield "hello";
+      }
+
+      private static [Symbol.hasInstance](instance: unknown) {
+        return Array.isArray(instance);
+      }
+
+      private get [Symbol.isConcatSpreadable]() {
+        return false
+      }
+
+      private *[Symbol.iterator]() {
+        yield "hello";
+      }
+
+      private get [Symbol.match]() {
+        return false;
+      }
+
+      private *[Symbol.matchAll](str: string) {
+        for (const n of str.matchAll(/[0-9]+/g))
+          yield n[0];
+      }
+
+      private [Symbol.replace](str: string) {
+        return `s/${str}/foo/g`;
+      }
+
+      private [Symbol.search](str: string) {
+        return str.indexOf('foo');
+      }
+
+      private [Symbol.split](str: string) {
+        return 'foo'
+      }
+
+      private static get [Symbol.species]() { return Array; }
+
+      private [Symbol.toPrimitive](hint: any) {
+        if (hint === 'number') {
+          return 42;
+        }
+        return null;
+      }
+
+      private get [Symbol.toStringTag]() {
+        return 'foo';
+      }
+
+      private get [Symbol.unscopables]() {
+        return {};
+      }
+    }
+
+    export class WellknownSymbolProperties {
+      private [Symbol.asyncIterator] = function*() {
+        yield "hello";
+      }
+
+      private static [Symbol.hasInstance] = (instance: unknown) => {
+        return Array.isArray(instance);
+      }
+
+      private [Symbol.isConcatSpreadable] = false;
+
+      private [Symbol.iterator] = function*() {
+        yield "hello";
+      }
+
+      private [Symbol.match] = false;
+
+      private [Symbol.matchAll] = function*(str: string) {
+        for (const n of str.matchAll(/[0-9]+/g))
+          yield n[0];
+      }
+
+      private [Symbol.replace] = (str: string) => {
+        return `s/${str}/foo/g`;
+      }
+
+      private [Symbol.search] = (str: string) => {
+        return str.indexOf('foo');
+      }
+
+      private [Symbol.split] = (str: string) => {
+        return 'foo'
+      }
+
+      private static [Symbol.species] = Array;
+
+      private [Symbol.toPrimitive] = (hint: any) => {
+        if (hint === 'number') {
+          return 42;
+        }
+        return null;
+      }
+
+      private [Symbol.toStringTag] = 'foo';
+
+      private [Symbol.unscopables] = {};
+    }
+
+    const MyIterator = Symbol();
+    export function testLocalSymbols() {
+      const Symbol = {
+        iterator: MyIterator
+      };
+
+      return class Foo{
+        private *[Symbol.iterator]() {
+                 ~~~~~~~~~~~~~~~~~
+!!! error TS6133: '[Symbol.iterator]' is declared but its value is never read.
+          yield 1;
+        }
+      }
+    }
+
+    const iteratorSymbol = Symbol.iterator;
+    export class C {
+      private *[iteratorSymbol]() {
+               ~~~~~~~~~~~~~~~~
+!!! error TS6133: '[iteratorSymbol]' is declared but its value is never read.
+
+      }
+    }