add an option that flags coercion

[zpdDG4gta8XKpMCd]

There is a category of bugs caused by unintended coercion at runtime. Such bugs can be found by the compiler. Having an option that bans such coercion would be a great addition.

examples of the problem:

// before (typechecks)
let isFirst: boolean;
// ... later in code
if (!isFirst) {
   // do stuff
}

// after refactoring (still typechecks)
let isFirst: () => boolean;
// ... later in code
if (!isFirst) {
  // got a bug, unreachable code
}

// before (typechecks)
let counter: number;
let kind: string;
// ... later in code
let id = '--' + kind + (counter++); // works: --blah-blah-341279

// after refactoring (still typechecks)
let counter: number;
let kind: {
    type: string;
    sort: string;
};
// ... later in code
let id = '--' + kind + (counter++); // now a bug: --[object Object]-341279

[RyanCavanaugh]

Your first example is identical to a suggestion you've already logged.

Your second example doesn't typecheck.

[zpdDG4gta8XKpMCd]

1. technically it was about a more specific case (and probably because of that it got closed), which alone didn't make much sense, this is a broader request that might have more sense
2. fixed

[zpdDG4gta8XKpMCd]

another example out of the oven

// before
declare function toBypassReasons(): string[];
let message = toBypassReasons().join(', ');

// after refactoring
interface BypassReason { reason: string; ruleKey: string; }
declare function toBypassReasons() : BypassReason[];
let message = toBypassReasons().join(', '); // <-- bug

[RyanCavanaugh]

There is literally zero coercion in that example. You'd need completely different mechanics (somehow disallowing certain methods when a type parameter is one value vs another) to detect that "bug" vs the other two examples.

[mhegazy]

closing in favor of #7989

[RyanCavanaugh]

Tracking a new issue at #9041 that solves some of these cases