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