The message is bad but the report is kind of correct.

You can rewrite this to remove a parameter

export const mapObj =
  <Obj extends object, T>(
    obj: Obj,
    fn: (key: keyof Obj, val: Obj[keyof Obj]) => T,
  ) =>
    Object.entries(obj)
      .map(entry => fn(...entry as [keyof Obj, Obj[keyof Obj]]));

mapObj(
  { a: "", b: 1 },
  (
    k,
 // ^? "a" | "b"
    v
 // ^? string | number
  ) => true
)

playground

While the type parameter may not strictly be needed, this rule is nowhere near smart enough to figure that out. :) The issue is that visitType isn't descending into all parts of a mapped type. Fix coming up…

@danvk since the rule reports that the type parameter is only used once, but it is actually used three times, does that mean that two occurences of the type parameter have been missed?

If one missed occurrence was in the mapped type, what is the other missed occurrence?

@abrahamguo this is a reduced version of your code (playground):

declare function mapObj<
  K extends string,
  V,  // Type parameter V is used only once
>(
  obj: { [key in K]: V },
  fn: (key: K, val: V) => number,
): number[];

I've removed the function implementation because it's not relevant to this rule. V is declared once and used twice, so it appears a total of three times. So this is considered valid with my change, but not valid if you drop the use in { [key in K]: V }.

Ah. So the usage of V in the type assertion in the function implementation body (as [K, V]) doesn't count as a "usage" according to this lint rule?

No. Type parameters are used to relate types in a type signature. If they only appear once in the type signature (other than their declaration), then they're not relating anything. The implementation of a function can only affect its type signature if it has an inferred return type, which this rule specifically checks.