Report error for common no-op statements

[elisee]

Assuming the following code:

function doSomething() {
  alert("Did something");
}

doSomething;

Would it be possible for TypeScript to complain about the doSomething; line, notifying the user that the statement is a no-op and maybe even suggesting adding parentheses to call the function? Or do you folks consider that kind of problems to definitely be a linter error, rather than something the compiler should look out for?

I searched the bugtracker but couldn't find any similar requests, my apologies if I missed them. I don't even know how feasible this would be, maybe ECMAScript has intricacies that make it impossible in all but the simplest cases, but I thought it couldn't hurt to suggest it.

[mhegazy]

What if doSomething was implemented as a getter?

this looks like a tslinlt rule to me.

[DanielRosenwasser]

doSomething in this context can't be a getter though because it's a standalone identifier. This would only be a problem as a property/element access.

[DanielRosenwasser]

Though I'm leaning towards this being a linter rule like @mhegazy says. For this purpose, I think tslint's no-unused-expression would be the rule you're looking for @elisee.

[elisee]

I expect the vast majority of getters to have no side-effects in pratice and as such, they don't make sense as standalone expressions either (whether this is too a big assumption to make in the compiler or not, I don't know.)

Thanks for the pointers to tslint, I started looking at it right after posting this and it's a nifty tool indeed.

Still thinking it would be nice to prevent this kind of footgun at the language level, similarly to #2575 and the upcoming reachability analysis, but I'll defer to you. Please close if you still think it doesn't belong in the language.

[DanielRosenwasser]

So one reason a person might use a standalone identifier as a statement expression is to ensure that we don't perform module import elision. Basically, if we never use any value entity from a module, then we assume it was only used for types. This means people end up needing to do something like

import * as foo from "fooModule";
import "fooModule";

However, another reasonable way to trigger this would be

import * as foo from "fooModule";
foo;

So I'm going to lean on the side that this is more in the scope of linters.