Technically speaking, this is not a floating promise, because the return type of map is Array<Promise>, not Promise<Array>. This is why the rule is not able to detect that there's a promise at the top level.

This is the same if you wrap the promise in anything:

function getObj(p: Promise<any>) {
  return { p };
}

getObj(Promise.resolve(1));

no-misused-promises can't catch this either, because that's definitely a legitimate thing to write (passing a promise to another function; returning a promise-containing value from a function).

Let's see if others have ideas; I don't think there's a great heuristic to catch these cases unless we special-case object types and array types.

I think this would be a pretty good addition to the lint rule!
We could error on this case and suggest wrapping the expression in await Promise.all(expression) (could also add suggestions for .race and .allSettled).

We'd have to put this behind an option (default false for now) to avoid a breaking change, but i'd hazard a guess that we could turn it on by default eventually. Would be good to audit some codebases to be sure.

WDYT @Josh-Cena?

Does that mean we special-case array types and object types? I was talking with @JoshuaKGoldberg and he seemed to dislike special-casing.

Object types - no I don't think so because there is no construct to handle them natively. So our rule would report and then someone would have to refactor their code completely to extract and await the promise.

But array types are different to object types - they have the native promise methods to await them. This means there's no difficult code change to make - as I mentioned the simplest would be expression to await Promise.all(expression) - which isn't too different to the non-array case (await (expression))

To me at least handling the array case isn't a special case - instead it's just a natural extension to the rule.

I'm on the fence here and fine either way. It feels like we're entering "there's no perfect answer" territory. The case of array types being special & built-in makes sense to me but I wouldn't mind either way. 🤷

Is this the issue causing the following code to be marked incorrectly as okay?

Is: array.map(async () => await foo()).join(','); // [object Promise],[object Promise]
Expected: await Promise.all(array.map(() => foo())).join(',') // value1,value2