| /* | |
| * Copyright (c) 2014, 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 7101822 | |
| * @summary Verify that the processing of classes in TypeEnter runs in the correct order. | |
| * @library /tools/lib | |
| * @modules jdk.compiler/com.sun.tools.javac.api | |
| * jdk.compiler/com.sun.tools.javac.code | |
| * jdk.compiler/com.sun.tools.javac.file | |
| * jdk.compiler/com.sun.tools.javac.tree | |
| * jdk.compiler/com.sun.tools.javac.util | |
| * @build annotations.TriggersComplete annotations.TriggersCompleteRepeat annotations.Phase | |
| * @build DependenciesTest | |
| * @run main DependenciesTest | |
| */ | |
| import java.io.IOException; | |
| import java.net.URI; | |
| import java.nio.file.Files; | |
| import java.nio.file.Path; | |
| import java.nio.file.Paths; | |
| import java.util.ArrayList; | |
| import java.util.Arrays; | |
| import java.util.Collection; | |
| import java.util.Collections; | |
| import java.util.HashMap; | |
| import java.util.HashSet; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.Map.Entry; | |
| import java.util.Objects; | |
| import java.util.Set; | |
| import java.util.Stack; | |
| import java.util.stream.Stream; | |
| import javax.lang.model.element.AnnotationMirror; | |
| import javax.lang.model.element.AnnotationValue; | |
| import javax.lang.model.element.Element; | |
| import javax.lang.model.element.ExecutableElement; | |
| import javax.lang.model.element.Name; | |
| import javax.lang.model.element.TypeElement; | |
| import javax.lang.model.type.DeclaredType; | |
| import javax.lang.model.type.TypeMirror; | |
| import javax.lang.model.util.Elements; | |
| import javax.tools.JavaFileObject; | |
| import javax.tools.SimpleJavaFileObject; | |
| import annotations.*; | |
| import com.sun.source.tree.AnnotationTree; | |
| import com.sun.source.tree.ClassTree; | |
| import com.sun.source.tree.CompilationUnitTree; | |
| import com.sun.source.tree.ImportTree; | |
| import com.sun.source.tree.Tree; | |
| import com.sun.source.util.JavacTask; | |
| import com.sun.source.util.SourcePositions; | |
| import com.sun.source.util.TreePathScanner; | |
| import com.sun.source.util.Trees; | |
| import com.sun.tools.javac.api.JavacTool; | |
| import com.sun.tools.javac.api.JavacTrees; | |
| import com.sun.tools.javac.code.Symbol.ClassSymbol; | |
| import com.sun.tools.javac.file.JavacFileManager; | |
| import com.sun.tools.javac.tree.JCTree; | |
| import com.sun.tools.javac.util.Context; | |
| import com.sun.tools.javac.util.Context.Factory; | |
| import com.sun.tools.javac.util.Dependencies; | |
| public class DependenciesTest { | |
| public static void main(String... args) throws IOException { | |
| new DependenciesTest().run(); | |
| } | |
| void run() throws IOException { | |
| Path src = Paths.get(System.getProperty("test.src"), "tests"); | |
| try (Stream<Path> tests = Files.list(src)) { | |
| tests.map(p -> Files.isRegularFile(p) ? Stream.of(p) : silentWalk(p)) | |
| .forEach(this :: runTest); | |
| } | |
| } | |
| Stream<Path> silentWalk(Path src) { | |
| try { | |
| return Files.walk(src).filter(Files :: isRegularFile); | |
| } catch (IOException ex) { | |
| throw new IllegalStateException(ex); | |
| } | |
| } | |
| void runTest(Stream<Path> inputs) { | |
| JavacTool tool = JavacTool.create(); | |
| try (JavacFileManager fm = tool.getStandardFileManager(null, null, null)) { | |
| Path classes = Paths.get(System.getProperty("test.classes")); | |
| Iterable<? extends JavaFileObject> reconFiles = | |
| fm.getJavaFileObjectsFromFiles(inputs.sorted().map(p -> p.toFile()) :: iterator); | |
| List<String> options = Arrays.asList("-classpath", classes.toAbsolutePath().toString()); | |
| JavacTask reconTask = tool.getTask(null, fm, null, options, null, reconFiles); | |
| Iterable<? extends CompilationUnitTree> reconUnits = reconTask.parse(); | |
| JavacTrees reconTrees = JavacTrees.instance(reconTask); | |
| SearchAnnotations scanner = new SearchAnnotations(reconTrees, | |
| reconTask.getElements()); | |
| List<JavaFileObject> validateFiles = new ArrayList<>(); | |
| reconTask.analyze(); | |
| scanner.scan(reconUnits, null); | |
| for (CompilationUnitTree cut : reconUnits) { | |
| validateFiles.add(ClearAnnotations.clearAnnotations(reconTrees, cut)); | |
| } | |
| Context validateContext = new Context(); | |
| TestDependencies.preRegister(validateContext); | |
| JavacTask validateTask = | |
| tool.getTask(null, fm, null, options, null, validateFiles, validateContext); | |
| validateTask.analyze(); | |
| TestDependencies deps = (TestDependencies) Dependencies.instance(validateContext); | |
| if (!scanner.topLevel2Expected.equals(deps.topLevel2Completing)) { | |
| throw new IllegalStateException( "expected=" + scanner.topLevel2Expected + | |
| "; actual=" + deps.topLevel2Completing); | |
| } | |
| } catch (IOException ex) { | |
| throw new IllegalStateException(ex); | |
| } finally { | |
| inputs.close(); | |
| } | |
| } | |
| static final class TestDependencies extends Dependencies { | |
| public static void preRegister(Context context) { | |
| context.put(dependenciesKey, (Factory<Dependencies>) TestDependencies :: new); | |
| } | |
| public TestDependencies(Context context) { | |
| super(context); | |
| } | |
| final Stack<PhaseDescription> inProcess = new Stack<>(); | |
| String topLevelMemberEnter; | |
| Map<String, Set<PhaseDescription>> topLevel2Completing = new HashMap<>(); | |
| @Override | |
| public void push(ClassSymbol s, CompletionCause phase) { | |
| String flatname = s.flatName().toString(); | |
| for (Phase p : Phase.values()) { | |
| if (phase == p.cause) { | |
| inProcess.push(new PhaseDescription(flatname, p)); | |
| return ; | |
| } | |
| } | |
| if (phase == CompletionCause.MEMBER_ENTER) { | |
| if (inProcess.isEmpty()) { | |
| topLevelMemberEnter = flatname; | |
| } else { | |
| for (PhaseDescription running : inProcess) { | |
| if (running == null) | |
| continue; | |
| Set<PhaseDescription> completing = | |
| topLevel2Completing.computeIfAbsent(running.flatname, $ -> new HashSet<>()); | |
| completing.add(new PhaseDescription(flatname, running.phase)); | |
| } | |
| } | |
| } | |
| inProcess.push(null); | |
| } | |
| @Override | |
| public void pop() { | |
| inProcess.pop(); | |
| } | |
| } | |
| static final class SearchAnnotations extends TreePathScanner<Void, Void> { | |
| final Trees trees; | |
| final Elements elements; | |
| final TypeElement triggersCompleteAnnotation; | |
| final TypeElement triggersCompleteRepeatAnnotation; | |
| final Map<String, Set<PhaseDescription>> topLevel2Expected = | |
| new HashMap<>(); | |
| public SearchAnnotations(Trees trees, Elements elements) { | |
| this.trees = trees; | |
| this.elements = elements; | |
| this.triggersCompleteAnnotation = | |
| elements.getTypeElement(TriggersComplete.class.getName()); | |
| this.triggersCompleteRepeatAnnotation = | |
| elements.getTypeElement(TriggersCompleteRepeat.class.getName()); | |
| } | |
| @Override | |
| public Void visitClass(ClassTree node, Void p) { | |
| TypeElement te = (TypeElement) trees.getElement(getCurrentPath()); | |
| Set<PhaseDescription> expected = new HashSet<>(); | |
| for (AnnotationMirror am : getTriggersCompleteAnnotation(te)) { | |
| TypeMirror of = (TypeMirror) findAttribute(am, "of").getValue(); | |
| Name ofName = elements.getBinaryName((TypeElement) ((DeclaredType) of).asElement()); | |
| Element at = (Element) findAttribute(am, "at").getValue(); | |
| Phase phase = Phase.valueOf(at.getSimpleName().toString()); | |
| expected.add(new PhaseDescription(ofName.toString(), phase)); | |
| } | |
| if (!expected.isEmpty()) | |
| topLevel2Expected.put(elements.getBinaryName(te).toString(), expected); | |
| return super.visitClass(node, p); | |
| } | |
| Collection<AnnotationMirror> getTriggersCompleteAnnotation(TypeElement te) { | |
| for (AnnotationMirror am : te.getAnnotationMirrors()) { | |
| if (triggersCompleteAnnotation.equals(am.getAnnotationType().asElement())) { | |
| return Collections.singletonList(am); | |
| } | |
| if (triggersCompleteRepeatAnnotation.equals(am.getAnnotationType().asElement())) { | |
| return (Collection<AnnotationMirror>) findAttribute(am, "value").getValue(); | |
| } | |
| } | |
| return Collections.emptyList(); | |
| } | |
| AnnotationValue findAttribute(AnnotationMirror mirror, String name) { | |
| for (Entry<? extends ExecutableElement, ? extends AnnotationValue> e : | |
| mirror.getElementValues().entrySet()) { | |
| if (e.getKey().getSimpleName().contentEquals(name)) { | |
| return e.getValue(); | |
| } | |
| } | |
| throw new IllegalStateException("Could not find " + name + " in " + mirror); | |
| } | |
| } | |
| static final class ClearAnnotations extends TreePathScanner<Void, Void> { | |
| final SourcePositions positions; | |
| final List<int[]> spans2Clear = new ArrayList<>(); | |
| ClearAnnotations(Trees trees) { | |
| this.positions = trees.getSourcePositions(); | |
| } | |
| @Override | |
| public Void visitAnnotation(AnnotationTree node, Void p) { | |
| removeCurrentNode(); | |
| return null; | |
| } | |
| @Override | |
| public Void visitImport(ImportTree node, Void p) { | |
| if (node.getQualifiedIdentifier().toString().startsWith("annotations.")) { | |
| removeCurrentNode(); | |
| return null; | |
| } | |
| return super.visitImport(node, p); | |
| } | |
| void removeCurrentNode() { | |
| CompilationUnitTree topLevel = getCurrentPath().getCompilationUnit(); | |
| Tree node = getCurrentPath().getLeaf(); | |
| spans2Clear.add(new int[] {(int) positions.getStartPosition(topLevel, node), | |
| (int) positions.getEndPosition(topLevel, node)}); | |
| } | |
| static JavaFileObject clearAnnotations(Trees trees, CompilationUnitTree cut) | |
| throws IOException { | |
| ClearAnnotations a = new ClearAnnotations(trees); | |
| a.scan(cut, null); | |
| Collections.sort(a.spans2Clear, (s1, s2) -> s2[0] - s1[0]); | |
| StringBuilder result = new StringBuilder(cut.getSourceFile().getCharContent(true)); | |
| for (int[] toClear : a.spans2Clear) { | |
| result.delete(toClear[0], toClear[1]); | |
| } | |
| return new TestJavaFileObject(cut.getSourceFile().toUri(), result.toString()); | |
| } | |
| } | |
| static final class PhaseDescription { | |
| final String flatname; | |
| final Phase phase; | |
| public PhaseDescription(String flatname, Phase phase) { | |
| this.flatname = flatname; | |
| this.phase = phase; | |
| } | |
| @Override | |
| public String toString() { | |
| return "@annotations.TriggersComplete(of=" + flatname + ".class," + | |
| "at=annotations.Phase." + phase + ')'; | |
| } | |
| @Override | |
| public int hashCode() { | |
| int hash = 7; | |
| hash = 89 * hash + Objects.hashCode(this.flatname); | |
| hash = 89 * hash + Objects.hashCode(this.phase); | |
| return hash; | |
| } | |
| @Override | |
| public boolean equals(Object obj) { | |
| if (obj == null) { | |
| return false; | |
| } | |
| if (getClass() != obj.getClass()) { | |
| return false; | |
| } | |
| final PhaseDescription other = (PhaseDescription) obj; | |
| if (!Objects.equals(this.flatname, other.flatname)) { | |
| return false; | |
| } | |
| if (this.phase != other.phase) { | |
| return false; | |
| } | |
| return true; | |
| } | |
| } | |
| static final class TestJavaFileObject extends SimpleJavaFileObject { | |
| private final String content; | |
| public TestJavaFileObject(URI uri, String content) { | |
| super(uri, Kind.SOURCE); | |
| this.content = content; | |
| } | |
| @Override | |
| public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException { | |
| return content; | |
| } | |
| } | |
| } | |