public class Unions {
    void foo1(MyInterface<Throwable> param) throws Throwable {
        try {
            bar();
        } catch (MyExceptionA | MyExceptionB ex) {
            typeVar(ex);
            typeVarIntersection(ex);

            typeVarWildcard(ex, param);
            typeVarWildcard2(ex, param);
        }
    }

    void foo2(MyInterface<Throwable> param) throws Throwable {
        try {
            bar();
        } catch (SubMyExceptionA | SubMyExceptionA2 ex) {
            typeVar(ex);
            typeVar2(ex, ex);

            typeVarIntersection(ex);

            typeVarWildcard(ex, param);
            typeVarWildcard2(ex, param);
        }
    }

    <T extends Cloneable & MyInterface<String>> void typeVarIntersection(T param) {}

    <T extends Throwable> void typeVar(T param) {}

    <T extends Throwable> void typeVar2(T param, T param2) {}

    <T extends Throwable> void typeVarWildcard(T param, MyInterface<? extends T> myInterface) {}

    <T extends Throwable> void typeVarWildcard2(T param, MyInterface<? super T> myInterface) {}

    void bar() throws MyExceptionA, MyExceptionB {}

    interface MyInterface<T> {}

    class MyExceptionA extends Throwable implements Cloneable, MyInterface<String> {}

    class MyExceptionB extends Throwable implements Cloneable, MyInterface<String> {}

    class SubMyExceptionA extends MyExceptionA {}

    class SubMyExceptionA2 extends MyExceptionA {}
}
