Is it possible to tell the compiler that a method always throws an Exception

Question

Generally speaking, the Java compiler does not propagate the information that a method "always" throw an Exception, and therefore, does not detect that all code paths are complete.

(This is due to the fact that Java compiler compiles each class independently).

It's a problem when you want to write something like that.

public class ErrorContext {
    public void fatalISE(String message) {
        String context = "gather lots of information about the context of the error";
        throw new IllegalStateException(context +": " + message);
    }
}

public class A {
    public MyObject myMethod() {
        if (allIsGood()) {
            return new MyObject();
        }
        ErrorContext.fatalISE("all is not good");
    }
}

(ie, a kind of "assertion helper" that gathers context information).

Because the compiler will complain that myMethod does not always return a MyObject.

To my knowledge, there is no specific annotation to indicate that a method always throws.

Answer 1

A simple workaround is to let your fatalISE method not throw the exception, but only create it:

public class ErrorContext {
    public IllegalStateException fatalISE(String message) {
        String context = "gather lots of information about the context of the error";
        return new IllegalStateException(context +": " + message);
    }
}

public class A {
    public MyObject myMethod() {
        if (allIsGood()) {
            return new MyObject();
        }
        throw ErrorContext.fatalISE("all is not good");
    }
}

This way the compiler will know not to complain about a missing return. And forgetting to use the throw is unlikely, exactly because the compiler will usually complain.

Answer 2

A trick that I use is to replace

public void fatalISE(String message) {
    String context = "gather lots of information about the context of the error";
    throw new IllegalStateException(context +": " + message);
}

with

public <T> T fatalISE(String message) {
    String context = "gather lots of information about the context of the error";
    throw new IllegalStateException(context +": " + message);
}

Then, in myMethod, use:

public MyObject myMethod() {
   if (allIsGood()) {
        return new MyObject();
    }
    return ErrorContext.fatalISE("all is not good");
}

It will work whatever the return type of myMethod, including primitive types. You can still use fatalISE in a void method, by just not using the returnkeyword.

Answer 3

How about reversing the if condition?

public MyObject myMethod() {
    if (!allIsGood()) {
        ErrorContext.fatalISE("all is not good");
    }
    return new MyObject();
}

Good luck!

Answer 4

add

return null;

at the end. (it will never reach there anyway, but to silent the compiler this should do)

Answer 5

What you're trying to do is declare that a function never returns, which isn't something that Java knows how to do. Kotlin, for contrast, has a Nothing type. If you declare that your function returns "Nothing", that means it never returns.

Zorglub's answer above, with the type parameter that a function returns the type parameter "T" is the closest you can come to this in Java. Here's something I wrote recently, which logs a string and then throws an exception with that same string:

/**
 * Error logging. Logs the message and then throws a {@link RuntimeException} with the given
 * string.
 *
 * @param tag String indicating which code is responsible for the log message
 * @param msg String or object to be logged
 */
@CanIgnoreReturnValue
@SuppressWarnings("TypeParameterUnusedInFormals")
public static <T> T logAndThrow(String tag, Object msg) {
    String s = msg.toString();
    Log.e(tag, s);
    throw new RuntimeException(s);
}

This code, using Android's standard logging API, is something I want to be able to use anywhere that a value might be called for. I want to be able to have a lambda whose body is just a call to this function. This solution turns out to work great, but it's worth explaining some of the tricky bits:

• You can't do this somewhere that a Java primitive type (int, double, boolean, etc.) is expected.
• The two @-annotations are necessary if you're using error-prone (a fantastic static Java bug checking tool), because it will otherwise complain at the callsite that you're not using the return value and it will complain at the method definition that you're doing unspeakably evil things with the type parameter.

Answer 6

I just came across this use case but with a method that should always throw 2 or more type of exceptions.

To make the code compile you can add return null; As MouseEvent said.

or better replace it with throw new AssertionError() that prevent returning null value, improve readability and ensure that if someone modify checkAndAlwaysThrowException() it wil continue to Always throw exception

public Object myMehtod() throws ExceptionType1, ExceptionType2 {
    //....
    checkAndAlwaysThrowException();
    throw new AssertionError("checkAndAlwaysThrowException should have throw exception");
}

public void checkAndAlwaysThrowException() throws ExceptionType1, ExceptionType2 {
    if (cond) {
        throw new ExceptionType1();
    } else {
        throw new ExceptionType2();
    }
}