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 }