Sat, 22 Dec 2018 13:10:38 -0800
Added tag jdk8u202-b25 for changeset 15d8c732039b
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 }