🤔 this strikes me as "working as intended". Per the ignoreVoidReturningFunctions option description (emphasis mine):

Whether to ignore returns from functions with explicit void return types and functions with contextual void return types.

The void return types in this issue are contextually inferred. So this is what the option is asking for, no?

@JoshuaKGoldberg

returns from functions with explicit void return types and functions with contextual void return types

So basically all returns?

Then it should also ignore

function foo() {
  return console.log("foo")
}

because void return is inferred here too.

And if that's the expected behavior then this option should just be called ignoreReturn, because it ignores basically all returns.

There's a complicating factor with your examples in the OP - they use type parameters.
Type parameters are both inferred from the function signature AND they form the contextual type of the function.

This means that when we inspect the context of the function we see that it is expecting a void return type and thus we ignore the cases.

It's a tricky detail of type parameters that is very difficult for us to really separate and analyse for. TS doesn't give us information to determine how the type parameters are filled in - it just tells us their type. So we haven't got much choice other than to just treat them as given.

OTOH a function like this has no contextual type and has no explicit return type

function foo() { return console.log("foo") }

And so it is reported as it's assumed it was an accident. If you explicitly annotate the void return type then we ignore the case.

I get it now. The docs are indeed correct.

It's just the fact that one is ignored and other isn't seems very arbitrary.

I would imagine this option to do one of these:

1. ignore return when containing function has a void type annotation (simple ast check)
2. ignore return when an explicit void can be found anywhere in the types.
3. ignore return always.

Right now it does 2 and sometimes 3.

3. ignore return always

Apologies for nitpicking, but it's not always: it's if a void is inferred. If the generic function is given a type argument that's not void then it's not ignored:

const p = Promise.resolve(1).then<undefined>(() => console.log())
//                                           ~~~~~~~~~~~~~~~~~~~
// Returning a void expression from an arrow function shorthand is forbidden. Please add braces to the arrow function.

Closing as "working as intended", with a subtitle of "inferred type parameters are the zaniest part of a language". Thanks for the discussion!