| /* |
| * Copyright (c) 2010, 2015, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * @test |
| * @bug 6985205 6986246 |
| * @summary access to tree positions and doc comments may be lost across annotation processing rounds |
| * @modules jdk.compiler |
| * @build TreePosRoundsTest |
| * @compile -proc:only -processor TreePosRoundsTest TreePosRoundsTest.java |
| * @run main TreePosRoundsTest |
| */ |
| |
| import java.io.*; |
| import java.util.*; |
| import javax.annotation.processing.*; |
| import javax.lang.model.*; |
| import javax.lang.model.element.*; |
| import javax.tools.*; |
| |
| import com.sun.source.tree.*; |
| import com.sun.source.util.*; |
| import javax.tools.JavaCompiler.CompilationTask; |
| |
| // This test is an annotation processor that performs multiple rounds of |
| // processing, and on each round, it checks that source positions are |
| // available and correct. |
| // |
| // The test can be run directly as a processor from the javac command line |
| // or via JSR 199 by invoking the main program. |
| |
| @SupportedAnnotationTypes("*") |
| public class TreePosRoundsTest extends AbstractProcessor { |
| public static void main(String... args) throws Exception { |
| String testSrc = System.getProperty("test.src"); |
| String testClasses = System.getProperty("test.classes"); |
| JavaCompiler c = ToolProvider.getSystemJavaCompiler(); |
| try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) { |
| String thisName = TreePosRoundsTest.class.getName(); |
| File thisFile = new File(testSrc, thisName + ".java"); |
| Iterable<? extends JavaFileObject> files = fm.getJavaFileObjects(thisFile); |
| List<String> options = Arrays.asList( |
| "-proc:only", |
| "-processor", thisName, |
| "-processorpath", testClasses); |
| CompilationTask t = c.getTask(null, fm, null, options, null, files); |
| boolean ok = t.call(); |
| if (!ok) |
| throw new Exception("processing failed"); |
| } |
| } |
| |
| Filer filer; |
| Messager messager; |
| Trees trees; |
| |
| @Override |
| public SourceVersion getSupportedSourceVersion() { |
| return SourceVersion.latest(); |
| } |
| |
| @Override |
| public void init(ProcessingEnvironment pEnv) { |
| super.init(pEnv); |
| filer = pEnv.getFiler(); |
| messager = pEnv.getMessager(); |
| trees = Trees.instance(pEnv); |
| } |
| |
| int round = 0; |
| |
| @Override |
| public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { |
| round++; |
| |
| // Scan trees for elements, verifying source tree positions |
| for (Element e: roundEnv.getRootElements()) { |
| try { |
| TreePath p = trees.getPath(e); |
| new TestTreeScanner(p.getCompilationUnit(), trees).scan(trees.getPath(e), null); |
| } catch (IOException ex) { |
| messager.printMessage(Diagnostic.Kind.ERROR, |
| "Cannot get source: " + ex, e); |
| } |
| } |
| |
| final int MAXROUNDS = 3; |
| if (round < MAXROUNDS) |
| generateSource("Gen" + round); |
| |
| return true; |
| } |
| |
| void generateSource(String name) { |
| StringBuilder text = new StringBuilder(); |
| text.append("class ").append(name).append("{\n"); |
| text.append(" int one = 1;\n"); |
| text.append(" int two = 2;\n"); |
| text.append(" int three = one + two;\n"); |
| text.append("}\n"); |
| |
| try { |
| JavaFileObject fo = filer.createSourceFile(name); |
| Writer out = fo.openWriter(); |
| try { |
| out.write(text.toString()); |
| } finally { |
| out.close(); |
| } |
| } catch (IOException e) { |
| throw new Error(e); |
| } |
| } |
| |
| class TestTreeScanner extends TreePathScanner<Void,Void> { |
| TestTreeScanner(CompilationUnitTree unit, Trees trees) throws IOException { |
| this.unit = unit; |
| JavaFileObject sf = unit.getSourceFile(); |
| source = sf.getCharContent(true).toString(); |
| sourcePositions = trees.getSourcePositions(); |
| } |
| |
| @Override |
| public Void visitVariable(VariableTree tree, Void p) { |
| check(getCurrentPath()); |
| return super.visitVariable(tree, p); |
| } |
| |
| void check(TreePath tp) { |
| Tree tree = tp.getLeaf(); |
| |
| String expect = tree.toString(); |
| if (tree.getKind() == Tree.Kind.VARIABLE) { |
| // tree.toString() does not know enough context to add ";", |
| // so deal with that manually... |
| Tree.Kind enclKind = tp.getParentPath().getLeaf().getKind(); |
| //System.err.println(" encl: " +enclKind); |
| if (enclKind == Tree.Kind.CLASS || enclKind == Tree.Kind.BLOCK) |
| expect += ";"; |
| // t-w-r- adds implicit final: remove it |
| if (enclKind == Tree.Kind.TRY && expect.startsWith("final ")) |
| expect = expect.substring(6); |
| } |
| //System.err.println("expect: " + expect); |
| |
| int start = (int)sourcePositions.getStartPosition(unit, tree); |
| if (start == Diagnostic.NOPOS) { |
| messager.printMessage(Diagnostic.Kind.ERROR, "start pos not set for " + trim(tree)); |
| return; |
| } |
| |
| int end = (int)sourcePositions.getEndPosition(unit, tree); |
| if (end == Diagnostic.NOPOS) { |
| messager.printMessage(Diagnostic.Kind.ERROR, "end pos not set for " + trim(tree)); |
| return; |
| } |
| |
| String found = source.substring(start, end); |
| //System.err.println(" found: " + found); |
| |
| // allow for long lines, in which case just compare beginning and |
| // end of the strings |
| boolean equal; |
| if (found.contains("\n")) { |
| String head = found.substring(0, found.indexOf("\n")); |
| String tail = found.substring(found.lastIndexOf("\n")).trim(); |
| equal = expect.startsWith(head) && expect.endsWith(tail); |
| } else { |
| equal = expect.equals(found); |
| } |
| |
| if (!equal) { |
| messager.printMessage(Diagnostic.Kind.ERROR, |
| "unexpected value found: '" + found + "'; expected: '" + expect + "'"); |
| } |
| } |
| |
| String trim(Tree tree) { |
| final int MAXLEN = 32; |
| String s = tree.toString().replaceAll("\\s+", " ").trim(); |
| return (s.length() < MAXLEN) ? s : s.substring(0, MAXLEN); |
| |
| } |
| |
| CompilationUnitTree unit; |
| SourcePositions sourcePositions; |
| String source; |
| } |
| |
| } |