We should take a look at object literal assignments too, which suffer most of the same defects:
(playground)

const foo: Interface = {
  async identifier() { },
  async 1() { },
  async [2]() { },
  async 'stringLiteral'() { },
  async ['computedStringLiteral']() { },
  async [Symbol.iterator]() { },
  async [staticSymbol]() { },
}

This one additionally gets the 'stringLiteral' case correct though.

async [2]() { }
async ['computedStringLiteral']() { }

In general we ignore all computed property names in rules because they can be any expression at all.

We could special case the literal cases but generally we just treat computed members as a black box that we can't truly resolve cos doing the above cases is really rare.

async [Symbol.iterator]() { };

This falls into the same boat - it's a computed member so we ignore it. We could special case the Symbol special members but it's also a difficult thing because like Symbol.notIterator is valid code too - so would we special case it or ignore it?

Then you would also wanna handle and ignore like

const Symbol = {iterator: 1};
class Foo {
  [Symbol.iterator](){}
}

(people do like to reuse the name Symbol more than you'd like - eg the TS codebase itself!)

async [staticSymbol]() { };

Same case again except now the general symbol case. You'd need to check - idk if it creates a unique type which allows us to uniquely identify the symbol. Regardless it's not possible to check this case without type info which does increase the cost of the check. Often not super worth checking this either as it's really really rare to use a unique symbol in an inheritance case like this.

We should probably build some primitives around this more generally across all rules to allow us to get a property key handling the simple computed cases and similar special named cases like iterator.

yeah, we do have getStaticMemberAccessValue, which I think should handle most if not all of these already. Not super certain if it will get us the well-known symbols, but I know it handles things like Symbol.for('foo') 🤷