1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
// Test case for issue #577 with expected errors:
// Also see test case in framework/tests/all-systems/Issue577.java
// https://github.com/typetools/checker-framework/issues/577
import org.checkerframework.checker.nullness.qual.*;
class Banana<T extends Number> extends Apple<int[]> {
@Override
void fooOuter(int[] array) {}
class InnerBanana extends InnerApple<long[]> {
@Override
// :: error: (override.param.invalid)
<F2 extends Object> void foo(int[] array, long[] array2, F2 param3) {}
}
}
class Apple<T> {
void fooOuter(T param) {}
class InnerApple<E> {
<F> void foo(T param, E param2, F param3) {}
}
}
class Pineapple<E extends Object> extends Apple<E> {
@Override
void fooOuter(E array) {}
class InnerPineapple extends InnerApple<@Nullable String> {
@Override
// :: error: (override.param.invalid)
<F3> void foo(E array, String array2, F3 param3) {}
}
}
class IntersectionAsMemberOf {
interface MyGenericInterface<F> {
F getF();
}
<T extends Object & MyGenericInterface<@NonNull String>> void foo(T param) {
@NonNull String s = param.getF();
}
}
class UnionAsMemberOf {
interface MyInterface<T> {
T getT();
}
class MyExceptionA extends Throwable implements Cloneable, MyInterface<@NonNull String> {
public String getT() {
return "t";
}
}
class MyExceptionB extends Throwable implements Cloneable, MyInterface<String> {
public String getT() {
return "t";
}
}
void bar() throws MyExceptionA, MyExceptionB {}
void foo1(MyInterface<Throwable> param) throws Throwable {
try {
bar();
} catch (MyExceptionA | MyExceptionB ex1) {
@NonNull String s = ex1.getT();
}
}
}
|
