Watch finally eat an exception

/**
 * Warm-up: finally is not as safe as it looks.
 *
 * Predict all three outputs before running. Two of them are counter-intuitive
 * and both appear in real code.
 */
public class Starter {

    /** What does this return? Write it down first. */
    static int copiedBeforeFinally() {
        int x = 1;
        try {
            return x;
        } finally {
            x = 2;
        }
    }

    /** And this one? Where did the exception go? */
    @SuppressWarnings("finally")
    static int swallowed() {
        try {
            throw new RuntimeException("you will never see this");
        } finally {
            return 42;
        }
    }

    public static void main(String[] args) {
        System.out.println("copiedBeforeFinally() = " + copiedBeforeFinally());
        System.out.println("swallowed()           = " + swallowed());

        try {
            throw new IllegalStateException("first");
        } catch (IllegalStateException e) {
            System.out.println("caught: " + e.getMessage());
            // TODO 1: throw a new IllegalArgumentException from here WITHOUT
            // passing e as the cause. Catch it outside and print its
            // getCause(). What do you get?
        } finally {
            System.out.println("finally ran");
        }

        // TODO 2: do it again, this time passing e as the cause:
        //     new IllegalArgumentException("second", e)
        // Print the full stack trace of the outer exception. How many
        // "Caused by:" sections do you see?

        // TODO 3: in a comment, say why swallowed() is legal Java and what a
        // linter would tell you about it.
    }
}