📎 Implement nursery/noFloatingPromises - typescript-eslint/no-floating-promises

[kaykdm]

Description

The rule will cover no-floating-promises

Some context here

Feature support / tasks checklist

• support regular async functions

async function returnsPromiseFunction() {
    return 'value';
}
returnsPromiseFunction();

• assigned functions

const returnsPromiseAssignedArrowFunction = async (): Promise<string> => {
  return 'value'; 
}
returnsPromiseArrowFunction();

const returnsPromiseAssignedFunction = async function (): Promise<string> {
  return 'value'; 
}
returnsPromiseAssignedFunction();

• Promise

Promise.all([]);
Promise.reject('value').catch();

const promise = new Promise((resolve, reject) => resolve('value'));  
promise;

• Class methods

class Api {
    async returnsPromise(): Promise<string> {
        return 'value';
    }

    async someMethod() {
        this.returnsPromise();
    }
}

const api = new Api();
api.returnsPromise();

• Object method

const obj = {
    async returnsPromise() {
        return 'value';
    }
};
obj.returnsPromise();

• Multi-file analysis - after this is implemented

[arendjr]

Other important bullet points to add would be “inferred types” and “derived types”.

The first refers to working with functions that don’t have an explicit return type annotation, and are contextual inference. After you support assigned functions and promises, you’re already partly there, but you also need to consider control flow within a function to determine the possible return values.

Derived types are where the TypeScript type system gets really funky, and you need to support all the generics handling and other way to create types from types. There’s a lot of libraries that do stuff like that, and if you invoke methods on such types we’d also like to detect if they return a promise.

Both can get quite complex, but I expect I may start work on those sooner rather than later. I think we can coordinate by adding subtasks to this issue.