duke@1: /*
duke@1:  * Copyright 2005-2006 Sun Microsystems, Inc.  All Rights Reserved.
duke@1:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@1:  *
duke@1:  * This code is free software; you can redistribute it and/or modify it
duke@1:  * under the terms of the GNU General Public License version 2 only, as
duke@1:  * published by the Free Software Foundation.
duke@1:  *
duke@1:  * This code is distributed in the hope that it will be useful, but WITHOUT
duke@1:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@1:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
duke@1:  * version 2 for more details (a copy is included in the LICENSE file that
duke@1:  * accompanied this code).
duke@1:  *
duke@1:  * You should have received a copy of the GNU General Public License version
duke@1:  * 2 along with this work; if not, write to the Free Software Foundation,
duke@1:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@1:  *
duke@1:  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@1:  * CA 95054 USA or visit www.sun.com if you need additional information or
duke@1:  * have any questions.
duke@1:  */
duke@1: 
duke@1: /*
duke@1:  * @test
duke@1:  * @bug     6338064 6346249 6340951 6392177
duke@1:  * @summary Tree API: can't determine kind of operator
duke@1:  * @author  Peter von der Ah\u00e9
duke@1:  * @compile TestOperators.java
duke@1:  * @compile -processor TestOperators -proc:only TestOperators.java
duke@1:  */
duke@1: 
duke@1: import java.util.Set;
duke@1: import javax.annotation.processing.*;
duke@1: import javax.lang.model.element.*;
duke@1: import javax.lang.model.util.*;
duke@1: import static javax.tools.Diagnostic.Kind.*;
duke@1: 
duke@1: import com.sun.source.tree.*;
duke@1: import com.sun.source.util.Trees;
duke@1: 
duke@1: import static com.sun.source.tree.Tree.Kind.*;
duke@1: 
duke@1: @interface TestMe {
duke@1:     Tree.Kind value();
duke@1: }
duke@1: 
duke@1: @SupportedAnnotationTypes("TestMe")
duke@1: public class TestOperators extends AbstractProcessor {
duke@1: 
duke@1:     @TestMe(POSTFIX_INCREMENT)
duke@1:     public int test_POSTFIX_INCREMENT(int i) {
duke@1:         return i++;
duke@1:     }
duke@1: 
duke@1:     @TestMe(POSTFIX_DECREMENT)
duke@1:     public int test_POSTFIX_DECREMENT(int i) {
duke@1:         return i--;
duke@1:     }
duke@1: 
duke@1:     @TestMe(PREFIX_INCREMENT)
duke@1:     public int test_PREFIX_INCREMENT(int i) {
duke@1:         return ++i;
duke@1:     }
duke@1: 
duke@1:     @TestMe(PREFIX_DECREMENT)
duke@1:     public int test_PREFIX_DECREMENT(int i) {
duke@1:         return --i;
duke@1:     }
duke@1: 
duke@1:     @TestMe(UNARY_PLUS)
duke@1:     public int test_UNARY_PLUS(int i) {
duke@1:         return +i;
duke@1:     }
duke@1: 
duke@1:     @TestMe(UNARY_MINUS)
duke@1:     public int test_UNARY_MINUS(int i) {
duke@1:         return -i;
duke@1:     }
duke@1: 
duke@1:     @TestMe(BITWISE_COMPLEMENT)
duke@1:     public int test_BITWISE_COMPLEMENT(int i) {
duke@1:         return ~i;
duke@1:     }
duke@1: 
duke@1:     @TestMe(LOGICAL_COMPLEMENT)
duke@1:     public boolean test_LOGICAL_COMPLEMENT(boolean b) {
duke@1:         return !b;
duke@1:     }
duke@1: 
duke@1:     @TestMe(MULTIPLY)
duke@1:     public int test_MULTIPLY(int i, int j) {
duke@1:         return i * j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(DIVIDE)
duke@1:     public int test_DIVIDE(int i, int j) {
duke@1:         return i / j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(REMAINDER)
duke@1:     public int test_REMAINDER(int i, int j) {
duke@1:         return i % j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(PLUS)
duke@1:     public int test_PLUS(int i, int j) {
duke@1:         return i + j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(MINUS)
duke@1:     public int test_MINUS(int i, int j) {
duke@1:         return i - j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(LEFT_SHIFT)
duke@1:     public int test_LEFT_SHIFT(int i, int j) {
duke@1:         return i << j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(RIGHT_SHIFT)
duke@1:     public int test_RIGHT_SHIFT(int i, int j) {
duke@1:         return i >> j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(UNSIGNED_RIGHT_SHIFT)
duke@1:     public int test_UNSIGNED_RIGHT_SHIFT(int i, int j) {
duke@1:         return i >>> j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(LESS_THAN)
duke@1:     public boolean test_LESS_THAN(int i, int j) {
duke@1:         return i < j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(GREATER_THAN)
duke@1:     public boolean test_GREATER_THAN(int i, int j) {
duke@1:         return i > j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(LESS_THAN_EQUAL)
duke@1:     public boolean test_LESS_THAN_EQUAL(int i, int j) {
duke@1:         return i <= j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(GREATER_THAN_EQUAL)
duke@1:     public boolean test_GREATER_THAN_EQUAL(int i, int j) {
duke@1:         return i >= j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(EQUAL_TO)
duke@1:     public boolean test_EQUAL_TO(int i, int j) {
duke@1:         return i == j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(NOT_EQUAL_TO)
duke@1:     public boolean test_NOT_EQUAL_TO(int i, int j) {
duke@1:         return i != j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(AND)
duke@1:     public boolean test_AND(boolean a, boolean b) {
duke@1:         return a & b;
duke@1:     }
duke@1: 
duke@1:     @TestMe(XOR)
duke@1:     public boolean test_XOR(boolean a, boolean b) {
duke@1:         return a ^ b;
duke@1:     }
duke@1: 
duke@1:     @TestMe(OR)
duke@1:     public boolean test_OR(boolean a, boolean b) {
duke@1:         return a | b;
duke@1:     }
duke@1: 
duke@1:     @TestMe(CONDITIONAL_AND)
duke@1:     public boolean test_CONDITIONAL_AND(boolean a, boolean b) {
duke@1:         return a && b;
duke@1:     }
duke@1: 
duke@1:     @TestMe(CONDITIONAL_OR)
duke@1:     public boolean test_CONDITIONAL_OR(boolean a, boolean b) {
duke@1:         return a || b;
duke@1:     }
duke@1: 
duke@1:     @TestMe(MULTIPLY_ASSIGNMENT)
duke@1:     public int test_MULTIPLY_ASSIGNMENT(int i, int j) {
duke@1:         return i *= j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(DIVIDE_ASSIGNMENT)
duke@1:     public int test_DIVIDE_ASSIGNMENT(int i, int j) {
duke@1:         return i /= j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(REMAINDER_ASSIGNMENT)
duke@1:     public int test_REMAINDER_ASSIGNMENT(int i, int j) {
duke@1:         return i %= j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(PLUS_ASSIGNMENT)
duke@1:     public int test_PLUS_ASSIGNMENT(int i, int j) {
duke@1:         return i += j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(MINUS_ASSIGNMENT)
duke@1:     public int test_MINUS_ASSIGNMENT(int i, int j) {
duke@1:         return i -= j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(LEFT_SHIFT_ASSIGNMENT)
duke@1:     public int test_LEFT_SHIFT_ASSIGNMENT(int i, int j) {
duke@1:         return i <<= j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(RIGHT_SHIFT_ASSIGNMENT)
duke@1:     public int test_RIGHT_SHIFT_ASSIGNMENT(int i, int j) {
duke@1:         return i >>= j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(UNSIGNED_RIGHT_SHIFT_ASSIGNMENT)
duke@1:     public int test_UNSIGNED_RIGHT_SHIFT_ASSIGNMENT(int i, int j) {
duke@1:         return i >>>= j;
duke@1:     }
duke@1: 
duke@1:     @TestMe(AND_ASSIGNMENT)
duke@1:     public boolean test_AND_ASSIGNMENT(boolean a, boolean b) {
duke@1:         return a &= b;
duke@1:     }
duke@1: 
duke@1:     @TestMe(XOR_ASSIGNMENT)
duke@1:     public boolean test_XOR_ASSIGNMENT(boolean a, boolean b) {
duke@1:         return a ^= b;
duke@1:     }
duke@1: 
duke@1:     @TestMe(OR_ASSIGNMENT)
duke@1:     public boolean test_OR_ASSIGNMENT(boolean a, boolean b) {
duke@1:         return a |= b;
duke@1:     }
duke@1: 
duke@1:     @TestMe(INT_LITERAL)
duke@1:     public Object test_INT_LITERAL() {
duke@1:         return 0;
duke@1:     }
duke@1: 
duke@1:     @TestMe(LONG_LITERAL)
duke@1:     public Object test_LONG_LITERAL() {
duke@1:         return 0L;
duke@1:     }
duke@1: 
duke@1:     @TestMe(FLOAT_LITERAL)
duke@1:     public Object test_FLOAT_LITERAL() {
duke@1:         return 0.0F;
duke@1:     }
duke@1: 
duke@1:     @TestMe(DOUBLE_LITERAL)
duke@1:     public Object test_DOUBLE_LITERAL() {
duke@1:         return 0.0;
duke@1:     }
duke@1: 
duke@1:     @TestMe(BOOLEAN_LITERAL)
duke@1:     public Object test_BOOLEAN_LITERAL() {
duke@1:         return true;
duke@1:     }
duke@1: 
duke@1:     @TestMe(CHAR_LITERAL)
duke@1:     public Object test_CHAR_LITERAL() {
duke@1:         return 'a';
duke@1:     }
duke@1: 
duke@1:     @TestMe(STRING_LITERAL)
duke@1:     public Object test_STRING_LITERAL() {
duke@1:         return "a";
duke@1:     }
duke@1: 
duke@1:     @TestMe(NULL_LITERAL)
duke@1:     public Object test_NULL_LITERAL() {
duke@1:         return null;
duke@1:     }
duke@1: 
duke@1:     @TestMe(UNBOUNDED_WILDCARD)
duke@1:     public Set<?> test_UNBOUNDED_WILDCARD() {
duke@1:         return null;
duke@1:     }
duke@1: 
duke@1:     @TestMe(EXTENDS_WILDCARD)
duke@1:     public Set<? extends Number> test_EXTENDS_WILDCARD() {
duke@1:         return null;
duke@1:     }
duke@1: 
duke@1:     @TestMe(SUPER_WILDCARD)
duke@1:     public Set<? super Number> test_SUPER_WILDCARD() {
duke@1:         return null;
duke@1:     }
duke@1: 
duke@1:     public boolean process(Set<? extends TypeElement> annotations,
duke@1:                            RoundEnvironment roundEnvironment)
duke@1:     {
duke@1:         final Trees trees = Trees.instance(processingEnv);
duke@1:         final Messager log = processingEnv.getMessager();
duke@1:         final Elements elements = processingEnv.getElementUtils();
duke@1:         class Scan extends ElementScanner6<Void,Void> {
duke@1:             @Override
duke@1:             public Void visitExecutable(ExecutableElement e, Void p) {
duke@1:                 Object debug = e; // info for exception handler
duke@1:                 try {
duke@1:                     TestMe info = e.getAnnotation(TestMe.class);
duke@1:                     if (info == null)
duke@1:                         return null;
duke@1: 
duke@1:                     Tree.Kind kind = info.value();
duke@1:                     MethodTree node = trees.getTree(e);
duke@1:                     debug = node;
duke@1:                     Tree testNode;
duke@1:                     switch (kind) {
duke@1:                     case UNBOUNDED_WILDCARD:
duke@1:                     case EXTENDS_WILDCARD:
duke@1:                     case SUPER_WILDCARD:
duke@1:                         ParameterizedTypeTree typeTree;
duke@1:                         typeTree = (ParameterizedTypeTree) node.getReturnType();
duke@1:                         testNode = typeTree.getTypeArguments().get(0);
duke@1:                         break;
duke@1:                     default:
duke@1:                         ReturnTree returnNode;
duke@1:                         returnNode = (ReturnTree) node.getBody().getStatements().get(0);
duke@1:                         testNode = returnNode.getExpression();
duke@1:                     }
duke@1:                     if (testNode.getKind() != kind) {
duke@1:                         log.printMessage(ERROR, testNode.getKind() + " != " + kind, e);
duke@1:                         throw new AssertionError(testNode);
duke@1:                     }
duke@1:                     System.err.format("OK: %32s %s%n", kind, testNode);
duke@1:                 } catch (Error ex) {
duke@1:                     System.err.println("Error while looking at " + debug);
duke@1:                     throw ex;
duke@1:                 }
duke@1:                 return null;
duke@1:             }
duke@1:         }
duke@1:         Scan scan = new Scan();
duke@1:         for (Element e : roundEnvironment.getRootElements()) {
duke@1:             scan.scan(e);
duke@1:         }
duke@1:         return true;
duke@1:     }
duke@1: 
duke@1: }