7.20.4.3[1] Synopsis

    #include <stdlib.h>
    void exit(int status);

7.20.4.3[6] The exit function cannot return to its caller.

-----

Seems to me that the standard offers no appropriate "function
type" for exit() [or abort or _Exit] and that the specified
prototype is misleading since exit() is a function which doesn't
return rather than a function returning void (nothing).

I think the "volatile" type qualifier would apply, but what about
the type itself? None of the existing types would seem to apply
since the notion of "return type" doesn't apply in any sense...

In fact, in order to have a different type for functions that never
return, a function type would sometimes change depending on the contents
of a different function, which I am not sure is a good idea at all.
Consider:

    void somefunc(void) {
         if(1) exit(0);
    }
    void somefunc2(void) {
         if(UserHasTypedFoo())
            return;
         else
            somefunc();
    }
    int foo(void) {
        somefunc2();
    }

What type is "foo"? Does it change if you add `while(1);` before calling
somefunc2()? Does the type change at runtime depending if the user types
"foo"? How about if you change the body of somefunc() to `if(OpSysMsg())
exit(0);`? Does it matter that OpSysMsg() can never return 0?

foo() should return an int. Otherwise I think I don't disagree with you. I
was called (I think correctly) on a constraint violation in the "exit(1)"
thread and have been having a severe case of "intellectual indigestion"
since.

It still seems reasonable and unambiguous to me to code "UserHasTypedFoo()
|| exit(EXIT_FAILURE);" because I know that the "or" will never be
performed; and that exit's function type is immaterial. Tak-Shing Chan
pointed out that this was a constraint violation because of the exit's
standard-defined function type of void.

I've never used this construct in my own code but can't imagine why the
constraint violation /need/ be applied. I think what I'm looking for is some
was of informing the compiler that the function type is immaterial because
of the function's terminal nature and so remove the constraint violation.

    int x = exit(0);    /* error, assignment of void to int */

Also, what about:

    #include <stdlib.h>

    int main(void)
    {
        exit(0);
    }

Here, main does not return. So does main not have a return type?

What about an expression that is never evaluated; does that
also not have a type?

    if (0) {
        3; /* this expression has type int */
    }

    /* no <stdlib.h> included */

    {
        extern int exit(int); /* note incorrect declaration */
        exit(0); /* undefined behavior */

The return type of a function is part of its type. Two function types are
incompatible if they do not specify the same return type, and using an
incompatible expression to call a function causes undefined behavior, even if
the incompatibility is in the return value, and the called function does not
return.

You could apply the same argument to syntax errors. For instance:

    if (0) {
        never executed
    }

Now if we could only inform the compiler that the stuff between the
braces is never executed, and so the syntax doesn't matter. ;)

    UserHasTypedFoo() || (exit(EXIT_FAILURE), 0);

I'd not even considered that aspect of the problem -- every now and then some
"feature" (or lack thereof) of C gets under my skin and sends me off on a tangent
to "find a better way".

It's almost always -- as here -- a learning experience for me.