Detect uncalled functions that appear in void expressions

[mjbvz]

Suggestion

🔍 Search Terms

• uncalled function
• check
• statement

⭐ Suggestion

Today TS can detect uncalled functions that appear in conditionals. I propose also extending this to detect uncalled functions that appear an an expression where the result is unused

📃 Motivating Example

export interface Foo {
    doImportantStuff(): void;
}

declare const foo: Foo;

if (foo.doImportantStuff) { // This one is detected
  ...
}

[foo].forEach(x => foo.doImportantStuff);  // Mistake here. The user forgot to call `doImportantStuff`

💻 Use Cases

This was inspired by a real world bug in the VS Code codebase. The case with forEach shows the problem we ran into

Off the top of my head, I don't think there would be false positives but may need some more thought to make sure

Related issues

• Detect uncalled function statements #47698

[RyanCavanaugh]

This specific example isn't detectable in practice. We have a function isSideEffectFree that we used in other positions like the comma-sequence operator. It explicitly doesn't consider a.b side-effect free because JS getters can and do have side effects, and we don't know from the declaration of Foo that doImportantStuff isn't a getter.

[fatcerberus]

It still does seem a bit inconsistent that if (a.b) {}
is detected as a "forgot-to-call" error, while the similar construction [ a ].forEach(a => a.b)
isn't.

[mjbvz]

Yes getters make this difficult to reason about. Just as a code example of the problem:

export class Foo {
    private state = 1;

    get bar() {
        ++this.state;
        return () => this.state;
    }
}

const foo = new Foo();

[foo].forEach(x => x.bar);

Famous last words, but the above does seem uncommon though. Would be interesting to see how often it appears in real world code