1 /*
2 * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @bug 6338064 6346249 6340951 6392177
27 * @summary Tree API: can't determine kind of operator
28 * @author Peter von der Ah\u00e9
29 * @compile TestOperators.java
30 * @compile -processor TestOperators -proc:only TestOperators.java
31 */
32
33 import java.util.Set;
34 import javax.annotation.processing.*;
35 import javax.lang.model.element.*;
36 import javax.lang.model.util.*;
37 import static javax.tools.Diagnostic.Kind.*;
38
39 import com.sun.source.tree.*;
40 import com.sun.source.util.Trees;
41
42 import static com.sun.source.tree.Tree.Kind.*;
43
44 @interface TestMe {
45 Tree.Kind value();
46 }
47
48 @SupportedAnnotationTypes("TestMe")
49 public class TestOperators extends AbstractProcessor {
50
51 @TestMe(POSTFIX_INCREMENT)
52 public int test_POSTFIX_INCREMENT(int i) {
53 return i++;
54 }
55
56 @TestMe(POSTFIX_DECREMENT)
57 public int test_POSTFIX_DECREMENT(int i) {
58 return i--;
59 }
60
61 @TestMe(PREFIX_INCREMENT)
62 public int test_PREFIX_INCREMENT(int i) {
63 return ++i;
64 }
65
66 @TestMe(PREFIX_DECREMENT)
67 public int test_PREFIX_DECREMENT(int i) {
68 return --i;
69 }
70
71 @TestMe(UNARY_PLUS)
72 public int test_UNARY_PLUS(int i) {
73 return +i;
74 }
75
76 @TestMe(UNARY_MINUS)
77 public int test_UNARY_MINUS(int i) {
78 return -i;
79 }
80
81 @TestMe(BITWISE_COMPLEMENT)
82 public int test_BITWISE_COMPLEMENT(int i) {
83 return ~i;
84 }
85
86 @TestMe(LOGICAL_COMPLEMENT)
87 public boolean test_LOGICAL_COMPLEMENT(boolean b) {
88 return !b;
89 }
90
91 @TestMe(MULTIPLY)
92 public int test_MULTIPLY(int i, int j) {
93 return i * j;
94 }
95
96 @TestMe(DIVIDE)
97 public int test_DIVIDE(int i, int j) {
98 return i / j;
99 }
100
101 @TestMe(REMAINDER)
102 public int test_REMAINDER(int i, int j) {
103 return i % j;
104 }
105
106 @TestMe(PLUS)
107 public int test_PLUS(int i, int j) {
108 return i + j;
109 }
110
111 @TestMe(MINUS)
112 public int test_MINUS(int i, int j) {
113 return i - j;
114 }
115
116 @TestMe(LEFT_SHIFT)
117 public int test_LEFT_SHIFT(int i, int j) {
118 return i << j;
119 }
120
121 @TestMe(RIGHT_SHIFT)
122 public int test_RIGHT_SHIFT(int i, int j) {
123 return i >> j;
124 }
125
126 @TestMe(UNSIGNED_RIGHT_SHIFT)
127 public int test_UNSIGNED_RIGHT_SHIFT(int i, int j) {
128 return i >>> j;
129 }
130
131 @TestMe(LESS_THAN)
132 public boolean test_LESS_THAN(int i, int j) {
133 return i < j;
134 }
135
136 @TestMe(GREATER_THAN)
137 public boolean test_GREATER_THAN(int i, int j) {
138 return i > j;
139 }
140
141 @TestMe(LESS_THAN_EQUAL)
142 public boolean test_LESS_THAN_EQUAL(int i, int j) {
143 return i <= j;
144 }
145
146 @TestMe(GREATER_THAN_EQUAL)
147 public boolean test_GREATER_THAN_EQUAL(int i, int j) {
148 return i >= j;
149 }
150
151 @TestMe(EQUAL_TO)
152 public boolean test_EQUAL_TO(int i, int j) {
153 return i == j;
154 }
155
156 @TestMe(NOT_EQUAL_TO)
157 public boolean test_NOT_EQUAL_TO(int i, int j) {
158 return i != j;
159 }
160
161 @TestMe(AND)
162 public boolean test_AND(boolean a, boolean b) {
163 return a & b;
164 }
165
166 @TestMe(XOR)
167 public boolean test_XOR(boolean a, boolean b) {
168 return a ^ b;
169 }
170
171 @TestMe(OR)
172 public boolean test_OR(boolean a, boolean b) {
173 return a | b;
174 }
175
176 @TestMe(CONDITIONAL_AND)
177 public boolean test_CONDITIONAL_AND(boolean a, boolean b) {
178 return a && b;
179 }
180
181 @TestMe(CONDITIONAL_OR)
182 public boolean test_CONDITIONAL_OR(boolean a, boolean b) {
183 return a || b;
184 }
185
186 @TestMe(MULTIPLY_ASSIGNMENT)
187 public int test_MULTIPLY_ASSIGNMENT(int i, int j) {
188 return i *= j;
189 }
190
191 @TestMe(DIVIDE_ASSIGNMENT)
192 public int test_DIVIDE_ASSIGNMENT(int i, int j) {
193 return i /= j;
194 }
195
196 @TestMe(REMAINDER_ASSIGNMENT)
197 public int test_REMAINDER_ASSIGNMENT(int i, int j) {
198 return i %= j;
199 }
200
201 @TestMe(PLUS_ASSIGNMENT)
202 public int test_PLUS_ASSIGNMENT(int i, int j) {
203 return i += j;
204 }
205
206 @TestMe(MINUS_ASSIGNMENT)
207 public int test_MINUS_ASSIGNMENT(int i, int j) {
208 return i -= j;
209 }
210
211 @TestMe(LEFT_SHIFT_ASSIGNMENT)
212 public int test_LEFT_SHIFT_ASSIGNMENT(int i, int j) {
213 return i <<= j;
214 }
215
216 @TestMe(RIGHT_SHIFT_ASSIGNMENT)
217 public int test_RIGHT_SHIFT_ASSIGNMENT(int i, int j) {
218 return i >>= j;
219 }
220
221 @TestMe(UNSIGNED_RIGHT_SHIFT_ASSIGNMENT)
222 public int test_UNSIGNED_RIGHT_SHIFT_ASSIGNMENT(int i, int j) {
223 return i >>>= j;
224 }
225
226 @TestMe(AND_ASSIGNMENT)
227 public boolean test_AND_ASSIGNMENT(boolean a, boolean b) {
228 return a &= b;
229 }
230
231 @TestMe(XOR_ASSIGNMENT)
232 public boolean test_XOR_ASSIGNMENT(boolean a, boolean b) {
233 return a ^= b;
234 }
235
236 @TestMe(OR_ASSIGNMENT)
237 public boolean test_OR_ASSIGNMENT(boolean a, boolean b) {
238 return a |= b;
239 }
240
241 @TestMe(INT_LITERAL)
242 public Object test_INT_LITERAL() {
243 return 0;
244 }
245
246 @TestMe(LONG_LITERAL)
247 public Object test_LONG_LITERAL() {
248 return 0L;
249 }
250
251 @TestMe(FLOAT_LITERAL)
252 public Object test_FLOAT_LITERAL() {
253 return 0.0F;
254 }
255
256 @TestMe(DOUBLE_LITERAL)
257 public Object test_DOUBLE_LITERAL() {
258 return 0.0;
259 }
260
261 @TestMe(BOOLEAN_LITERAL)
262 public Object test_BOOLEAN_LITERAL() {
263 return true;
264 }
265
266 @TestMe(CHAR_LITERAL)
267 public Object test_CHAR_LITERAL() {
268 return 'a';
269 }
270
271 @TestMe(STRING_LITERAL)
272 public Object test_STRING_LITERAL() {
273 return "a";
274 }
275
276 @TestMe(NULL_LITERAL)
277 public Object test_NULL_LITERAL() {
278 return null;
279 }
280
281 @TestMe(UNBOUNDED_WILDCARD)
282 public Set<?> test_UNBOUNDED_WILDCARD() {
283 return null;
284 }
285
286 @TestMe(EXTENDS_WILDCARD)
287 public Set<? extends Number> test_EXTENDS_WILDCARD() {
288 return null;
289 }
290
291 @TestMe(SUPER_WILDCARD)
292 public Set<? super Number> test_SUPER_WILDCARD() {
293 return null;
294 }
295
296 public boolean process(Set<? extends TypeElement> annotations,
297 RoundEnvironment roundEnvironment)
298 {
299 final Trees trees = Trees.instance(processingEnv);
300 final Messager log = processingEnv.getMessager();
301 final Elements elements = processingEnv.getElementUtils();
302 class Scan extends ElementScanner7<Void,Void> {
303 @Override
304 public Void visitExecutable(ExecutableElement e, Void p) {
305 Object debug = e; // info for exception handler
306 try {
307 TestMe info = e.getAnnotation(TestMe.class);
308 if (info == null)
309 return null;
310
311 Tree.Kind kind = info.value();
312 MethodTree node = trees.getTree(e);
313 debug = node;
314 Tree testNode;
315 switch (kind) {
316 case UNBOUNDED_WILDCARD:
317 case EXTENDS_WILDCARD:
318 case SUPER_WILDCARD:
319 ParameterizedTypeTree typeTree;
320 typeTree = (ParameterizedTypeTree) node.getReturnType();
321 testNode = typeTree.getTypeArguments().get(0);
322 break;
323 default:
324 ReturnTree returnNode;
325 returnNode = (ReturnTree) node.getBody().getStatements().get(0);
326 testNode = returnNode.getExpression();
327 }
328 if (testNode.getKind() != kind) {
329 log.printMessage(ERROR, testNode.getKind() + " != " + kind, e);
330 throw new AssertionError(testNode);
331 }
332 System.err.format("OK: %32s %s%n", kind, testNode);
333 } catch (Error ex) {
334 System.err.println("Error while looking at " + debug);
335 throw ex;
336 }
337 return null;
338 }
339 }
340 Scan scan = new Scan();
341 for (Element e : roundEnvironment.getRootElements()) {
342 scan.scan(e);
343 }
344 return true;
345 }
346
347 }