Support non-bool assertions

[kkmuffme]

🔍 Search Terms

assertion is typeguard

✅ Viability Checklist

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

Currently only the is syntax with a bool return is supported.

Asserting on non-bool return should be possible to return the type one expects to avoid having to write separate assertion functions.

📃 Motivating Example

function getString<const T>(arg: T): T extends string ? T : false {
    if ( typeof arg === 'string' ) {
        return arg;
    }

    return false;
}

function isString(val: any): val is string {
  return typeof val === "string";
}

function t1(arg: string|number): string {
    if ( getString(arg) === false ) {
        const y = arg; // should be number
        return '';
    }

    const z = arg; // should be string
    return '';
}

function t2(arg: string|number): string {
    const u = getString(arg);
    if ( u === false ) {
        const y = u;
        return '';
    }

    const z = u;
    return '';
}

function t3(arg: string|number): string {
    if ( isString(arg) === false ) {
        const y = arg;
        return '';
    }

    const z = arg;
    return '';
}

💻 Use Cases

We already have a getString function in the codebase, which technically does assert something but typescript is unaware of it.
Now instead we have to write a separate is assert function which does the same thing, bloating the codebase unnecessary and increasing the maintenance burden.
You could argue that we should is functions only in the first place - however this would create lots of redundant code - where we could do just return getString(arg); we have to do return isString(arg) ? arg : false; which is the reason why there is "get" function in the first place.

[jcalz]

Assertion functions and user-defined type guard functions are different, but you seem to be using the former term to refer to the latter.

Duplicate of #46650, found via repo:microsoft/TypeScript boolean guard in:title