feat(typescript-lint): implement consistent indexed object style

[todor-a]

implements https://typescript-eslint.io/rules/consistent-indexed-object-style/

[codspeed-hq]

CodSpeed Performance Report

Merging #3126 will not alter performance

_{Comparing todor-a:feat-consistent-indexed-object-style (f799919) with main (2064ae9)}

Summary

✅ 27 untouched benchmarks

[mysteryven]

Why do we need to diagnostic here? 🤔

[todor-a]

the TSAnyKeyword is for this test:

interface Foo {
  [key: string]: any;
}

you might ask, why not just error if there is an index signature, and the answer is that in some cases, even though the setting is Record, an index signature is allowed. For example this:

interface Foo<T> {
  [key: string]: Foo<T> | string;
}

[mysteryven]

interface Foo {
[key: string]: Foo | string;
}

This is a case of circle.

you might ask, why not just error if there is an index signature

Yeah, I am curious about this. If we set it to use "index-signature", it has a false positive report to interface, which is not expected:

 typescript-eslint(consistent-indexed-object-style):A "record" is preferred over an "index signature".
   ╭─[consistent_indexed_object_style.tsx:2:13]
 1 │ interface Foo {
 2 │             [key: string]: any
   ·             ─────────┬────────
   ·                      ╰── A record is preferred over an index signature.
 3 │         }
   ╰────

the TSAnyKeyword is for this test:

Look like the test case failed because the default option "record".

So, to sum up, I think this part can be removed 🤔

TSType::TSUnknownKeyword(_) | TSType::TSAnyKeyword(_) => {
      ctx.diagnostic(ConsistentIndexedObjectStyleDiagnostic(
          "record",
          "index signature",
          idx.span,
      ));
  }

[todor-a]

I played around wit this but could not find a way to remove the TSUnknownKeyword & TSAnyKeyword checks and still have the tests pass 🤔

[mysteryven]

Maybe we need to add early bailout if we find a circle?

interface Foo {
    [key: string]: Foo | string;
}

The above case is a circle because Foo is used in its body, the minimal code of find a circle may like:

fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
    match node.kind() {
        AstKind::TSInterfaceDeclaration(decl) => {
           // --snip--
            if let Some(symbol_id) =  &decl.id.symbol_id.get() {
                for reference in ctx.symbols().get_resolved_references(*symbol_id) {
                    let node_id = reference.node_id();
                    let node = ctx.nodes().get_node(node_id);
                    if let AstKind::TSTypeReference(type_reference) = node.kind() {
                        // if the range of `type_reference`'s span is included in decl's body, 
                       // we think it's a circle.
                    }
            }
    }
}

[mysteryven]

Why do we need to check idx.type_annotation.type_annotation, looks like original codes only check parameter's type?

[todor-a]

for the following case:

interface Foo {
   [key: string]: Foo;
}

even with a setting of Record, the above is still valid

[mysteryven]

Also a circle case?

[todor-a]

not sure I got what you meant here

[mysteryven]

For case

interface Foo {
   [key: string]: Foo;
}

It is valid because it has been treated as a circle, Foo in the second line refers to the interface name Foo, hope I understand right from here :)

[mysteryven]

Perhaps we don't need to revisit TSType::TSTypeLiteral, since all TSType::TSTypeLiteral has been visited.

// if we want to visit all `TSTypeLiteral` in our rule 
fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
      match node.kind() {
          AstKind::TSTypeLiteral(lit) => { } // here will visit all TSTypeLiteral in our file
      }
}

[mysteryven]

Thanks to your effort on this rule, take your time!