jdk8-mips64-public/langtools: test/tools/javac/treeannotests/TestProcessor.java@7909abb85562

     1 /*

     2  * Copyright (c) 2010, 2013, 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  */

    24 import java.io.*;

    25 import java.util.*;

    26 import javax.annotation.processing.*;

    27 import javax.lang.model.*;

    28 import javax.lang.model.element.*;

    29 import javax.lang.model.util.*;

    30 import javax.tools.*;

    32 import com.sun.source.util.*;

    33 import com.sun.tools.javac.code.BoundKind;

    34 import com.sun.tools.javac.tree.JCTree.*;

    35 import com.sun.tools.javac.tree.TreeScanner;

    36 import com.sun.tools.javac.tree.*;

    37 import com.sun.tools.javac.util.List;

    39 /**

    40  * Test processor used to check test programs using the @Test, @DA, and @TA

    41  * annotations.

    42  *

    43  * The processor looks for elements annotated with @Test, and analyzes the

    44  * syntax trees for those elements. Within such trees, the processor looks

    45  * for the DA annotations on decls and TA annotations on types.

    46  * The value of these annotations should be a simple string rendition of

    47  * the tree node to which it is attached.

    48  * The expected number of annotations is given by the parameter to the

    49  * @Test annotation itself.

    50  */

    51 @SupportedAnnotationTypes({"Test"})

    52 public class TestProcessor extends AbstractProcessor {

    53     public SourceVersion getSupportedSourceVersion() {

    54         return SourceVersion.latest();

    55     }

    57     /** Process trees for elements annotated with the @Test(n) annotation. */

    58     public boolean process(Set<? extends TypeElement> annos, RoundEnvironment renv) {

    59         if (renv.processingOver())

    60             return true;

    62         Elements elements = processingEnv.getElementUtils();

    63         Trees trees = Trees.instance(processingEnv);

    65         TypeElement testAnno = elements.getTypeElement("Test");

    66         for (Element elem: renv.getElementsAnnotatedWith(testAnno)) {

    67             System.err.println("ELEM: " + elem);

    68             int count = getValue(getAnnoMirror(elem, testAnno), Integer.class);

    69             System.err.println("count: " + count);

    70             TreePath p = trees.getPath(elem);

    71             JavaFileObject file = p.getCompilationUnit().getSourceFile();

    72             JCTree tree = (JCTree) p.getLeaf();

    73             System.err.println("tree: " + tree);

    74             new TestScanner(file).check(tree, count);

    75         }

    76         return true;

    77     }

    79     /** Get the AnnotationMirror on an element for a given annotation. */

    80     AnnotationMirror getAnnoMirror(Element e, TypeElement anno) {

    81         Types types = processingEnv.getTypeUtils();

    82         for (AnnotationMirror m: e.getAnnotationMirrors()) {

    83             if (types.isSameType(m.getAnnotationType(), anno.asType()))

    84                 return m;

    85         }

    86         return null;

    87     }

    89     /** Get the value of the value element of an annotation mirror. */

    90     <T> T getValue(AnnotationMirror m, Class<T> type) {

    91         for (Map.Entry<? extends ExecutableElement,? extends AnnotationValue> e: m.getElementValues().entrySet()) {

    92             ExecutableElement ee = e.getKey();

    93             if (ee.getSimpleName().contentEquals("value")) {

    94                 AnnotationValue av = e.getValue();

    95                 return type.cast(av.getValue());

    96             }

    97         }

    98         return null;

    99     }

   101     /** Report an error to the annotation processing system. */

   102     void error(String msg) {

   103         Messager messager = processingEnv.getMessager();

   104         messager.printMessage(Diagnostic.Kind.ERROR, msg);

   105     }

   107     /** Report an error to the annotation processing system. */

   108     void error(JavaFileObject file, JCTree tree, String msg) {

   109         // need better API for reporting tree position errors to the messager

   110         Messager messager = processingEnv.getMessager();

   111         String text = file.getName() + ":" + getLine(file, tree) + ": " + msg;

   112         messager.printMessage(Diagnostic.Kind.ERROR, text);

   113     }

   115     /** Get the line number for the primary position for a tree.

   116      * The code is intended to be simple, although not necessarily efficient.

   117      * However, note that a file manager such as JavacFileManager is likely

   118      * to cache the results of file.getCharContent, avoiding the need to read

   119      * the bits from disk each time this method is called.

   120      */

   121     int getLine(JavaFileObject file, JCTree tree) {

   122         try {

   123             CharSequence cs = file.getCharContent(true);

   124             int line = 1;

   125             for (int i = 0; i < tree.pos; i++) {

   126                 if (cs.charAt(i) == '\n') // jtreg tests always use Unix line endings

   127                     line++;

   128             }

   129             return line;

   130         } catch (IOException e) {

   131             return -1;

   132         }

   133     }

   135     /** Scan a tree, looking for @DA and @TA annotations, and verifying that such

   136      * annotations are attached to the expected tree node matching the string

   137      * parameter of the annotation.

   138      */

   139     class TestScanner extends TreeScanner {

   140         /** Create a scanner for a given file. */

   141         TestScanner(JavaFileObject file) {

   142             this.file = file;

   143         }

   145         /** Check the annotations in a given tree. */

   146         void check(JCTree tree, int expectCount) {

   147             foundCount = 0;

   148             scan(tree);

   149             if (foundCount != expectCount)

   150                 error(file, tree, "Wrong number of annotations found: " + foundCount + ", expected: " + expectCount);

   151         }

   153         /** Check @DA annotations on a class declaration. */

   154         @Override

   155         public void visitClassDef(JCClassDecl tree) {

   156             super.visitClassDef(tree);

   157             check(tree.mods.annotations, "DA", tree);

   158         }

   160         /** Check @DA annotations on a method declaration. */

   161         @Override

   162         public void visitMethodDef(JCMethodDecl tree) {

   163             super.visitMethodDef(tree);

   164             check(tree.mods.annotations, "DA", tree);

   165         }

   167         /** Check @DA annotations on a field, parameter or local variable declaration. */

   168         @Override

   169         public void visitVarDef(JCVariableDecl tree) {

   170             super.visitVarDef(tree);

   171             check(tree.mods.annotations, "DA", tree);

   172         }

   174         /** Check @TA annotations on a type. */

   175         public void visitAnnotatedType(JCAnnotatedType tree) {

   176             super.visitAnnotatedType(tree);

   177             check(tree.annotations, "TA", tree);

   178         }

   180         /** Check to see if a list of annotations contains a named annotation, and

   181          * if so, verify the annotation is expected by comparing the value of the

   182          * annotation's argument against the string rendition of the reference tree

   183          * node.

   184          * @param annos the list of annotations to be checked

   185          * @param name  the name of the annotation to be checked

   186          * @param tree  the tree against which to compare the annotations's argument

   187          */

   188         void check(List<? extends JCAnnotation> annos, String name, JCTree tree) {

   189             for (List<? extends JCAnnotation> l = annos; l.nonEmpty(); l = l.tail) {

   190                 JCAnnotation anno = l.head;

   191                 if (anno.annotationType.toString().equals(name) && (anno.args.size() == 1)) {

   192                     String expect = getStringValue(anno.args.head);

   193                     foundCount++;

   194                     System.err.println("found: " + name + " " + expect);

   195                     String found = new TypePrinter().print(tree);

   196                     if (!found.equals(expect))

   197                         error(file, anno, "Unexpected result: expected: \"" + expect + "\", found: \"" + found + "\"");

   198                 }

   199             }

   200         }

   202         /** Get the string value of an annotation argument, which is given by the

   203          * expression <i>name</i>=<i>value</i>.

   204          */

   205         String getStringValue(JCExpression e) {

   206             if (e.hasTag(JCTree.Tag.ASSIGN)) {

   207                 JCAssign a = (JCAssign) e;

   208                 JCExpression rhs = a.rhs;

   209                 if (rhs.hasTag(JCTree.Tag.LITERAL)) {

   210                     JCLiteral l = (JCLiteral) rhs;

   211                     return (String) l.value;

   212                 }

   213             } else if (e.hasTag(JCTree.Tag.LITERAL)) {

   214                 JCLiteral l = (JCLiteral) e;

   215                 return (String) l.value;

   216             }

   217             throw new IllegalArgumentException(e.toString());

   218         }

   220         /** The file for the tree. Used to locate errors. */

   221         JavaFileObject file;

   222         /** The number of annotations that have been found. @see #check */

   223         int foundCount;

   224     }

   226     /** Convert a type or decl tree to a reference string used by the @DA and @TA annotations. */

   227     class TypePrinter extends Visitor {

   228         /** Convert a type or decl tree to a string. */

   229         String print(JCTree tree) {

   230             if (tree == null)

   231                 return null;

   232             tree.accept(this);

   233             return result;

   234         }

   236         String print(List<? extends JCTree> list) {

   237             return print(list, ", ");

   238         }

   240         String print(List<? extends JCTree> list, String sep) {

   241             StringBuilder sb = new StringBuilder();

   242             if (list.nonEmpty()) {

   243                 sb.append(print(list.head));

   244                 for (List<? extends JCTree> l = list.tail; l.nonEmpty(); l = l.tail) {

   245                     sb.append(sep);

   246                     sb.append(print(l.head));

   247                 }

   248             }

   249             return sb.toString();

   250         }

   252         @Override

   253         public void visitClassDef(JCClassDecl tree) {

   254             result = tree.name.toString();

   255         }

   257         @Override

   258         public void visitMethodDef(JCMethodDecl tree) {

   259             result = tree.name.toString();

   260         }

   262         @Override

   263         public void visitVarDef(JCVariableDecl tree) {

   264             tree.vartype.accept(this);

   265         }

   267         @Override

   268         public void visitAnnotatedType(JCAnnotatedType tree) {

   269             tree.underlyingType.accept(this);

   270         }

   272         @Override

   273         public void visitTypeIdent(JCPrimitiveTypeTree tree) {

   274             result = tree.toString();

   275         }

   277         @Override

   278         public void visitTypeArray(JCArrayTypeTree tree) {

   279             result = print(tree.elemtype) + "[]";

   280         }

   282         @Override

   283         public void visitTypeApply(JCTypeApply tree) {

   284             result = print(tree.clazz) + "<" + print(tree.arguments) + ">";

   285         }

   287         @Override

   288         public void visitTypeParameter(JCTypeParameter tree) {

   289             if (tree.bounds.isEmpty())

   290                 result = tree.name.toString();

   291             else

   292                 result = tree.name + " extends " + print(tree.bounds, "&");

   293         }

   295         @Override

   296         public void visitWildcard(JCWildcard tree) {

   297             if (tree.kind.kind == BoundKind.UNBOUND)

   298                 result = tree.kind.toString();

   299             else

   300                 result = tree.kind + " " + print(tree.inner);

   301         }

   303         private String result;

   304     }

   305 }

Mercurial > jdk8-mips64-public > langtools / file revision

test/tools/javac/treeannotests/TestProcessor.java@7909abb85562

test/tools/javac/treeannotests/TestProcessor.java