1import java.lang.annotation.ElementType;
2import java.lang.annotation.Target;
3import java.util.ArrayList;
4import java.util.Collection;
5import java.util.Collections;
6import java.util.Iterator;
7import java.util.List;
8import java.util.Map;
9//import java.util.function.Consumer;
10import java.util.function.Function;
11import java.util.function.IntFunction;
12import java.util.function.IntSupplier;
13import java.util.function.LongSupplier;
14import java.util.function.Supplier;
15import java.util.function.ToIntFunction;
16import java.util.function.UnaryOperator;
17
18@Target(ElementType.TYPE_USE) @interface A {}
19@Target(ElementType.TYPE_USE) @interface B {}
20@Target(ElementType.TYPE_USE) @interface C {}
21@Target(ElementType.TYPE_USE) @interface D {}
22
23@skip-test
24public class MemberReference<T> {
25  class Inner<U> implements Map.Entry<T, U> {
26    @Override
27    public T getKey() { return null; }
28    @Override
29    public U getValue() { return null; }
30    @Override
31    public U setValue(U u) { throw new UnsupportedOperationException(); }
32  }
33
34  boolean test = false;
35  List list = new ArrayList<T>();
36  Collection<T>[] foo;
37
38  <U extends T> MemberReference(U bar) {
39    foo = new ArrayList[1];
40    foo[0] = new ArrayList<T>(1);
41    foo[0].add(bar);
42  }
43
44  // instance method
45  ToIntFunction<String> o1 = @A String::length;
46
47  // static method
48  LongSupplier o2 = @A System::currentTimeMillis;
49
50  // explicit type args
51  ToIntFunction<List<String>> o3 = @A List<@B String>::size;
52
53  // inferred type args
54  ToIntFunction<List<String>> o4 = @A List::size;
55
56  UnaryOperator<Integer[]> o5 = @A Integer @B []::clone;
57
58  Function<T, String> o6 = @A T::toString;
59
60  //IntSupplier o7 = ((String) "abc")::length;
61  //IntSupplier o8 = ((List<String>) foo[0])::size;
62
63  Supplier<Iterator<T>> o9 =
64      (test ? list : Collections.<@A T>emptyList()) :: iterator;
65
66  // constructor for parameterized type
67  Supplier<ArrayList<String>> o10 =
68      @A ArrayList<@B String>::new;
69
70  // inferred type arguments for generic class
71  Supplier<ArrayList<String>> o11 =
72      @A ArrayList::new;
73
74  // explicit type arguments for generic constructor
75  IntFunction<List<Integer>> o12 =
76      @A ArrayList<@B Integer>::<@C Integer>new;
77
78  // generic class + constructor
79  Function<String, MemberReference<CharSequence>> o13 =
80      @A MemberReference<@B CharSequence>::<@C String>new;
81
82  // inner class constructor
83  Supplier<MemberReference<Object>.Inner<Long>> o14 =
84      @A MemberReference<@B Object>.Inner<@C Long>::<@D String>new;
85
86  // array creation
87  Function<Integer, Integer[]> o15 =
88      @A Integer @B []::new;
89
90  //Consumer<String> o16 = System.out::println;
91  //Supplier<String> o17 = ((Object) super)::toString;
92  //Supplier<String> o18 = ((Object) MemberReference.super)::toString;
93
94  public static void main(String[] args) {
95    String[] ss = {"a", "b"};
96    System.out.println(java.util.Arrays.asList(ss).stream()
97        .map(@A String::toUpperCase)
98        .collect(java.util.stream.Collectors.joining(" ")));
99  }
100}
101
102