Page MenuHomePhabricator

Disable the JSHint "function called before it is defined" and "unused parameter" warnings
ClosedPublic

Authored by epriestley on Feb 17 2019, 2:36 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Mar 26, 1:58 PM
Unknown Object (File)
Tue, Mar 5, 7:34 AM
Unknown Object (File)
Feb 10 2024, 9:31 PM
Unknown Object (File)
Feb 9 2024, 2:47 PM
Unknown Object (File)
Feb 3 2024, 9:26 PM
Unknown Object (File)
Feb 1 2024, 10:20 PM
Unknown Object (File)
Jan 14 2024, 2:41 PM
Unknown Object (File)
Dec 22 2023, 1:40 AM
Subscribers
None

Details

Summary

Ref T12822. The next change hits these warnings but I think neither is a net positive.

The "function called before it is defined" error alerts on this kind of thing:

function a() {
  b();
}

function b() {
}

a();

Here, b() is called before it is defined. This code, as written, is completely safe. Although it's possible that this kind of construct may be unsafe, I think the number of programs where there's unsafe behavior here AND the whole thing doesn't immediately break when you run it at all is very very small.

Complying with this warning is sometimes impossible -- at least without cheating/restructuring/abuse -- for example, if you have two functions which are mutually recursive.

Although compliance is usually possible, it forces you to define all your small utility functions at the top of a behavior. This isn't always the most logical or comprehensible order.

I think we also have some older code which did var a = function() { ... } to escape this, which I think is just silly/confusing.

Bascially, this is almost always a false positive and I think it makes the code worse more often than it makes it better.


The "unused function parameter" error warns about this:

function onevent(e) {
  do_something();

We aren't using e, so this warning is correct. However, when the function is a callback (as here), I think it's generally good hygiene to include the callback parameters in the signature (onresponse(response), onevent(event), etc), even if you aren't using any/all of them. This is a useful hint to future editors that the function is a callback.

Although this can catch mistakes, I think this is also a situation where the number of cases where it catches a mistake and even the most cursory execution of the code doesn't catch the mistake is vanishingly small.

Test Plan

Egregiously violated both rules in the next diff. Before change: complaints. After change: no complaints.

Diff Detail

Repository
rP Phabricator
Lint
Lint Not Applicable
Unit
Tests Not Applicable