Type inference fails to recognize never when it's the result of a template tag function

🔎 Search Terms

tagged template literal never type

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about the never type and about template literals.

⏯ Playground Link

https://www.typescriptlang.org/play/?#code/GYVwdgxgLglg9mABMAhjANgFQKYFsAO6KU2AFAM5QBOMYA5uQFyI4FEkDK1tDAglVRQBPADSIAdJIBuKdCGxNEKMEIDaAXQCUzMNinYqiAN4AoROcRQAFlTgB3RLocBRAXCqkA5KgytCxbCV0O2FySxt7ck9NAG4TAF8TE1BIWARkNHQAMXBoeDBSbUc9A2MzC2tbBydEV1sPb0yc1PygkKEwysjouMSTAHp+xABhdypsaHQhRHGIODowGAAvBXDAlLz0iFl0RAATOFWwOCgZ7CgQKjBk3LSkKCF8bGGrCYBrA1GBCagpgBkYB9yJgrDByKQUFQ6AB+ZiUGj0IrwnhlCyIGDARAQqGaVFoizjC5XJRQuJoxJonzZW75Qq9JKDRAASUgYx+U2QRAYazORPuj0Cdhg1mYzU2SCIEDeYWwYD2KMJlyQlACuFlp2Ue15SssAv2hzCx1OtAgcj2gU84HNwFo2D2nnEpAATABmABsbs0Nxa6QeTxe7wMLLm30mQgAIgaAHInAEfEFg7EwuHcREphF0PHmDFYyF0XGmfEE846vNkiwUixUvzsbAAAwARig9nX6QMhl9Zr9puRsKtrMQeb25nLtcSVSQ1WBjWFwOMUBArCgG+hsN7xbr-a8pZ82WHIwoY1A49gE+C87DEMi01fU5nCxYc0mC+Ui4riWXX4hK+YqWK7nSX7vkgnivOg6BwJ4baMlkmSdHAV59uEg7WIEw4IFqwG3qq6rorOYDzouy6ruudybs824fFQwZ7t2J7AqC55Qpe175umKIPtmmLPlm+JYZ+5JftWeD+CQjbNq2QElsSoHYOBkH0kAA

💻 Code

function failTemplate(strings: TemplateStringsArray, ...values: any[]): never {
    throw new Error('failTemplate always throws');
}

function failFunction(): never {
    throw new Error('failFunction always throws');
}

// Correctly recognizes the function call does not return
function typeCheckerCorrectlyLikesThis(arg?: string): string {
    if (arg) {
        return arg;
    }
    failFunction();
}

// Incorrectly flags the return type with: Function lacks ending return statement and return type does not include 'undefined'.(2366)
function typeCheckerIncorrectlyDoesNotLikeThis(arg?: string): string {
    if (arg) {
        return arg;
    }
    failTemplate`bad`;
}

// Correctly sees that the second return statement is unreachable
function typeCheckerCorrectlyDoesNotLikeThis(arg?: string): string {
    if (arg) {
        return arg;
    }
    failFunction();
    return 'hello';
}

// Fails to see that the second return statement is unreachable
function typeCheckerIncorrectlyLikesThis(arg?: string): string {
    if (arg) {
        return arg;
    }
    failTemplate`bad`;
    return 'hello';
}

🙁 Actual behavior

The invocation of a template tag function (via a tagged template literal) that is declared to return type never terminates the flow of control of the containing function, but the type checker does not recognize this and complains as if execution had continued beyond the invocation.

It appears, to my naive sensibilities, that the use of a tagged template literal is not recognized as a function invocation even though it is one. However, if the return type of the tag function is, say, number, the type inference engine does correctly recognize this, so it seems like the issue is specifically with the flow control logic associated with never.

🙂 Expected behavior

A template literal using a never returning template tag function should be recognized the same as an ordinary invocation of a never returning function.

Additional information about the issue

No response

Beginnen Sie mit der bereitgestellten Playground-Reproduktion und vergleichen Sie die Behandlung des Kontrollflusses für den gewöhnlichen Aufruf, der nie zurückkehrt, mit der Invocation des getaggten Template-Literals. Verfolgen Sie den Typprüfpfad für getaggte Template-Literale und überprüfen Sie, dass ein Tag, der nie zurückkehrt, den Kontrollfluss als beendet behandelt, einschließlich des im Bericht gezeigten Falls einer unerreichbaren Rückgabe.