lint against throw Fail

[turadg]

What is the Problem Being Solved?

It's redundant and seeing it trains people to be lax in when errors are created vs thrown.

Description of the Design

Fail is only for the condition || Fail pattern.

throw Fail is not allowed.

Bonus points for auto-fixing to throw makeError

Security Considerations

Scaling Considerations

Test Plan

Upgrade Considerations

[michaelfig]

The reasons to use if (!condition) throw Fail`xxx`; instead of condition || Fail`xxx`; or if (!condition) throw makeError(...); are:

1. There's a Typescript deficiency where condition || functionReturningNever() does not properly narrow types implied by condition in the subsequent statements, but if (!condition) functionReturningNever(); does.
2. There's a Typescript deficiency where calling a template tag that returns never (like Fail) is not treated the same as throw ... (i.e. it isn't handled as a terminal statement in the control-flow graph).
3. makeError only redacts (like Fail does) if you use makeError(redacted`xxx`) (also aliased as makeError(details`xxx`) or makeError(X`xxx`)).

If you really want to weed out the redundancy of throw Fail`xxx`;, I'd propose a new errorWith (name to be bikeshodden) template tag that would compose both makeError and redacted so throw errorWith`xxx`; is equivalent to throw makeError(redacted`xxx`);. With some trickery, you could smuggle other arguments into makeError so that throw errorWith(...otherArgs)`xxx`; is equivalent to throw makeError(redacted`xxx`, ...otherArgs);.

[turadg]

Issues for 1-2,

• Missing type narrowing based on control flow analysis of logical expressions microsoft/TypeScript#50739 (closed as by design)
• support control flow analysis of tagged template calls microsoft/TypeScript#51426

The latter might get done, since the PR had some positive feedback,

• Support control flow analysis for tagged template calls microsoft/TypeScript#53962

[turadg]

Closing this for now with the expectation that 51426 will be fixed eventually. Then we can ban throw Fail but we won't have to come up with a replacement.