| /* |
| * Copyright (c) 2017, 2024, 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. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * 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. |
| */ |
| package build.tools.depend; |
| |
| import com.sun.source.tree.ClassTree; |
| import com.sun.source.tree.CompilationUnitTree; |
| import com.sun.source.tree.IdentifierTree; |
| import com.sun.source.tree.ImportTree; |
| import com.sun.source.tree.LiteralTree; |
| import com.sun.source.tree.MemberReferenceTree; |
| import com.sun.source.tree.MemberSelectTree; |
| import com.sun.source.tree.MethodTree; |
| import com.sun.source.tree.ModifiersTree; |
| import com.sun.source.tree.PrimitiveTypeTree; |
| import com.sun.source.tree.Tree; |
| import com.sun.source.tree.VariableTree; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.lang.annotation.Documented; |
| import java.nio.charset.Charset; |
| import java.security.MessageDigest; |
| import java.security.NoSuchAlgorithmException; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.HexFormat; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.Set; |
| import java.util.stream.Collectors; |
| |
| import javax.lang.model.element.AnnotationMirror; |
| import javax.lang.model.element.AnnotationValue; |
| import javax.lang.model.element.AnnotationValueVisitor; |
| import javax.lang.model.element.Element; |
| import javax.lang.model.element.ElementVisitor; |
| import javax.lang.model.element.ExecutableElement; |
| import javax.lang.model.element.Modifier; |
| import javax.lang.model.element.ModuleElement; |
| import javax.lang.model.element.ModuleElement.DirectiveVisitor; |
| import javax.lang.model.element.ModuleElement.ExportsDirective; |
| import javax.lang.model.element.ModuleElement.OpensDirective; |
| import javax.lang.model.element.ModuleElement.ProvidesDirective; |
| import javax.lang.model.element.ModuleElement.RequiresDirective; |
| import javax.lang.model.element.ModuleElement.UsesDirective; |
| import javax.lang.model.element.PackageElement; |
| import javax.lang.model.element.QualifiedNameable; |
| import javax.lang.model.element.RecordComponentElement; |
| import javax.lang.model.element.TypeElement; |
| import javax.lang.model.element.TypeParameterElement; |
| import javax.lang.model.element.VariableElement; |
| import javax.lang.model.type.ArrayType; |
| import javax.lang.model.type.DeclaredType; |
| import javax.lang.model.type.ErrorType; |
| import javax.lang.model.type.ExecutableType; |
| import javax.lang.model.type.IntersectionType; |
| import javax.lang.model.type.NoType; |
| import javax.lang.model.type.NullType; |
| import javax.lang.model.type.PrimitiveType; |
| import javax.lang.model.type.TypeMirror; |
| import javax.lang.model.type.TypeVariable; |
| import javax.lang.model.type.TypeVisitor; |
| import javax.lang.model.type.UnionType; |
| import javax.lang.model.type.WildcardType; |
| import javax.lang.model.util.ElementFilter; |
| import javax.tools.JavaFileObject; |
| |
| import com.sun.source.util.JavacTask; |
| import com.sun.source.util.Plugin; |
| import com.sun.source.util.TaskEvent; |
| import com.sun.source.util.TaskEvent.Kind; |
| import com.sun.source.util.TaskListener; |
| import com.sun.source.util.TreePath; |
| import com.sun.source.util.TreeScanner; |
| import com.sun.source.util.Trees; |
| import com.sun.tools.javac.api.BasicJavacTask; |
| import com.sun.tools.javac.code.Flags; |
| import com.sun.tools.javac.main.JavaCompiler; |
| import com.sun.tools.javac.tree.JCTree.JCCompilationUnit; |
| import com.sun.tools.javac.tree.JCTree.JCVariableDecl; |
| import com.sun.tools.javac.util.Context; |
| import com.sun.tools.javac.util.Context.Key; |
| import com.sun.tools.javac.util.ListBuffer; |
| import com.sun.tools.javac.util.Options; |
| import com.sun.tools.javac.util.StringUtils; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.InvocationHandler; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Proxy; |
| import java.nio.charset.StandardCharsets; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.util.ArrayList; |
| import java.util.IdentityHashMap; |
| import java.util.LinkedHashMap; |
| import java.util.concurrent.atomic.AtomicBoolean; |
| import java.util.stream.StreamSupport; |
| import javax.lang.model.element.ElementKind; |
| import javax.lang.model.element.Name; |
| import javax.tools.ForwardingJavaFileManager; |
| import javax.tools.JavaFileManager; |
| import javax.tools.StandardLocation; |
| import javax.tools.ToolProvider; |
| |
| public class Depend implements Plugin { |
| |
| @Override |
| public String getName() { |
| return "depend"; |
| } |
| |
| @Override |
| public void init(JavacTask jt, String... args) { |
| addExports(); |
| |
| Path internalAPIDigestFile; |
| Map<String, String> internalAPI = new HashMap<>(); |
| AtomicBoolean noApiChange = new AtomicBoolean(); |
| Context context = ((BasicJavacTask) jt).getContext(); |
| JavaCompiler compiler = JavaCompiler.instance(context); |
| try { |
| Options options = Options.instance(context); |
| String modifiedInputs = options.get("modifiedInputs"); |
| if (modifiedInputs == null) { |
| throw new IllegalStateException("Expected modifiedInputs to be set using -XDmodifiedInputs=<list-of-files>"); |
| } |
| String logLevel = options.get("LOG_LEVEL"); |
| boolean debug = "trace".equals(logLevel) || "debug".equals(logLevel); |
| String internalAPIPath = options.get("internalAPIPath"); |
| if (internalAPIPath == null) { |
| throw new IllegalStateException("Expected internalAPIPath to be set using -XDinternalAPIPath=<internal-API-path>"); |
| } |
| Set<Path> modified = Files.readAllLines(Paths.get(modifiedInputs)).stream() |
| .map(Paths::get) |
| .collect(Collectors.toSet()); |
| internalAPIDigestFile = Paths.get(internalAPIPath); |
| if (Files.isReadable(internalAPIDigestFile)) { |
| try { |
| Files.readAllLines(internalAPIDigestFile, StandardCharsets.UTF_8) |
| .forEach(line -> { |
| String[] keyAndValue = line.split("="); |
| internalAPI.put(keyAndValue[0], keyAndValue[1]); |
| }); |
| } catch (IOException ex) { |
| throw new IllegalStateException(ex); |
| } |
| } |
| Class<?> initialFileParserIntf = Class.forName("com.sun.tools.javac.main.JavaCompiler$InitialFileParserIntf"); |
| Class<?> initialFileParser = Class.forName("com.sun.tools.javac.main.JavaCompiler$InitialFileParser"); |
| Field initialParserKeyField = initialFileParser.getDeclaredField("initialParserKey"); |
| @SuppressWarnings("unchecked") |
| Key<Object> key = (Key<Object>) initialParserKeyField.get(null); |
| Object initialParserInstance = |
| Proxy.newProxyInstance(Depend.class.getClassLoader(), |
| new Class<?>[] {initialFileParserIntf}, |
| new FilteredInitialFileParser(compiler, |
| modified, |
| internalAPI, |
| noApiChange, |
| debug)); |
| context.<Object>put(key, initialParserInstance); |
| } catch (Exception ex) { |
| throw new IllegalStateException(ex); |
| } |
| |
| jt.addTaskListener(new TaskListener() { |
| private final Map<ModuleElement, Set<PackageElement>> apiPackages = new HashMap<>(); |
| private final MessageDigest apiHash; |
| { |
| try { |
| apiHash = MessageDigest.getInstance("SHA-256"); |
| } catch (NoSuchAlgorithmException ex) { |
| throw new IllegalStateException(ex); |
| } |
| } |
| @Override |
| public void started(TaskEvent te) { |
| } |
| |
| @Override |
| public void finished(TaskEvent te) { |
| if (te.getKind() == Kind.ANALYZE) { |
| if (te.getSourceFile().isNameCompatible("module-info", JavaFileObject.Kind.SOURCE)) { |
| ModuleElement mod = (ModuleElement) Trees.instance(jt).getElement(new TreePath(te.getCompilationUnit())); |
| new APIVisitor(apiHash).visit(mod); |
| } else if (te.getSourceFile().isNameCompatible("package-info", JavaFileObject.Kind.SOURCE)) { |
| //ignore - cannot contain important changes (?) |
| } else { |
| TypeElement clazz = te.getTypeElement(); |
| ModuleElement mod = jt.getElements().getModuleOf(clazz); |
| Set<PackageElement> thisModulePackages = apiPackages.computeIfAbsent(mod, m -> { |
| return ElementFilter.exportsIn(mod.getDirectives()) |
| .stream() |
| .map(ed -> ed.getPackage()) |
| .collect(Collectors.toSet()); |
| }); |
| if (thisModulePackages.contains(jt.getElements().getPackageOf(clazz))) { |
| new APIVisitor(apiHash).visit(clazz); |
| } |
| } |
| } |
| if (te.getKind() == Kind.COMPILATION && !noApiChange.get() && |
| compiler.errorCount() == 0) { |
| try (OutputStream out = Files.newOutputStream(internalAPIDigestFile)) { |
| String hashes = internalAPI.entrySet() |
| .stream() |
| .map(e -> e.getKey() + "=" + e.getValue()) |
| .collect(Collectors.joining("\n")); |
| out.write(hashes.getBytes(StandardCharsets.UTF_8)); |
| } catch (IOException ex) { |
| throw new IllegalStateException(ex); |
| } |
| String previousSignature = null; |
| File digestFile = new File(args[0]); |
| try (InputStream in = new FileInputStream(digestFile)) { |
| previousSignature = new String(in.readAllBytes(), "UTF-8"); |
| } catch (IOException ex) { |
| //ignore |
| } |
| String currentSignature = Depend.this.toString(apiHash.digest()); |
| if (!Objects.equals(previousSignature, currentSignature)) { |
| digestFile.getParentFile().mkdirs(); |
| try (OutputStream out = new FileOutputStream(digestFile)) { |
| out.write(currentSignature.getBytes("UTF-8")); |
| } catch (IOException ex) { |
| throw new IllegalStateException(ex); |
| } |
| } |
| } |
| } |
| }); |
| } |
| |
| private void addExports() { |
| var systemCompiler = ToolProvider.getSystemJavaCompiler(); |
| try (JavaFileManager jfm = systemCompiler.getStandardFileManager(null, null, null)) { |
| JavaFileManager fm = new ForwardingJavaFileManager<JavaFileManager>(jfm) { |
| @Override |
| public ClassLoader getClassLoader(JavaFileManager.Location location) { |
| if (location == StandardLocation.CLASS_PATH) { |
| return Depend.class.getClassLoader(); |
| } |
| return super.getClassLoader(location); |
| } |
| }; |
| ((JavacTask) systemCompiler.getTask(null, fm, null, |
| List.of("-proc:only", "-XDaccessInternalAPI=true"), |
| List.of("java.lang.Object"), null)) |
| .analyze(); |
| } catch (IOException ex) { |
| throw new IllegalStateException(ex); |
| } |
| } |
| |
| private com.sun.tools.javac.util.List<JCCompilationUnit> doFilteredParse( |
| JavaCompiler compiler, Iterable<JavaFileObject> fileObjects, Set<Path> modified, |
| Map<String, String> internalAPI, AtomicBoolean noApiChange, |
| boolean debug) { |
| Map<JavaFileObject, JCCompilationUnit> files2CUT = new IdentityHashMap<>(); |
| boolean fullRecompile = modified.stream() |
| .map(Path::toString) |
| .anyMatch(f -> !StringUtils.toLowerCase(f).endsWith(".java")); |
| ListBuffer<JCCompilationUnit> result = new ListBuffer<>(); |
| for (JavaFileObject jfo : fileObjects) { |
| if (modified.contains(Path.of(jfo.getName()))) { |
| JCCompilationUnit parsed = compiler.parse(jfo); |
| files2CUT.put(jfo, parsed); |
| String currentSignature = treeDigest(parsed); |
| if (!currentSignature.equals(internalAPI.get(jfo.getName()))) { |
| fullRecompile |= true; |
| internalAPI.put(jfo.getName(), currentSignature); |
| } |
| result.add(parsed); |
| } |
| } |
| if (fullRecompile) { |
| for (JavaFileObject jfo : fileObjects) { |
| if (!modified.contains(Path.of(jfo.getName()))) { |
| JCCompilationUnit parsed = files2CUT.get(jfo); |
| if (parsed == null) { |
| parsed = compiler.parse(jfo); |
| internalAPI.put(jfo.getName(), treeDigest(parsed)); |
| } |
| result.add(parsed); |
| } |
| } |
| } else { |
| noApiChange.set(true); |
| } |
| if (debug) { |
| long allJavaInputs = StreamSupport.stream(fileObjects.spliterator(), false).count(); |
| String module = StreamSupport.stream(fileObjects.spliterator(), false) |
| .map(fo -> fo.toUri().toString()) |
| .filter(path -> path.contains("/share/classes/")) |
| .map(path -> path.substring(0, path.indexOf("/share/classes/"))) |
| .map(path -> path.substring(path.lastIndexOf("/") + 1)) |
| .findAny() |
| .orElseGet(() -> "unknown"); |
| String nonJavaModifiedFiles = modified.stream() |
| .map(Path::toString) |
| .filter(f -> !StringUtils.toLowerCase(f) |
| .endsWith(".java")) |
| .collect(Collectors.joining(", ")); |
| System.err.println("compiling module: " + module + |
| ", all Java inputs: " + allJavaInputs + |
| ", modified files (Java or non-Java): " + modified.size() + |
| ", full recompile: " + fullRecompile + |
| ", non-Java modified files: " + nonJavaModifiedFiles); |
| } |
| return result.toList(); |
| } |
| |
| private String treeDigest(JCCompilationUnit cu) { |
| try { |
| TreeVisitor v = new TreeVisitor(MessageDigest.getInstance("MD5")); |
| v.scan(cu, null); |
| return Depend.this.toString(v.apiHash.digest()); |
| } catch (NoSuchAlgorithmException ex) { |
| throw new IllegalStateException(ex); |
| } |
| } |
| private String toString(byte[] digest) { |
| return HexFormat.of().withUpperCase().formatHex(digest); |
| } |
| |
| private static final class APIVisitor implements ElementVisitor<Void, Void>, |
| TypeVisitor<Void, Void>, |
| AnnotationValueVisitor<Void, Void>, |
| DirectiveVisitor<Void, Void> { |
| |
| private final MessageDigest apiHash; |
| private final Charset utf8; |
| |
| public APIVisitor(MessageDigest apiHash) { |
| this.apiHash = apiHash; |
| utf8 = Charset.forName("UTF-8"); |
| } |
| |
| public Void visit(Iterable<? extends Element> list, Void p) { |
| list.forEach(e -> visit(e, p)); |
| return null; |
| } |
| |
| private void update(CharSequence data) { |
| apiHash.update(data.toString().getBytes(utf8)); |
| } |
| |
| private void visit(Iterable<? extends TypeMirror> types) { |
| for (TypeMirror type : types) { |
| visit(type); |
| } |
| } |
| |
| private void updateAnnotation(AnnotationMirror am) { |
| update("@"); |
| visit(am.getAnnotationType()); |
| am.getElementValues() |
| .keySet() |
| .stream() |
| .sorted((ee1, ee2) -> ee1.getSimpleName().toString().compareTo(ee2.getSimpleName().toString())) |
| .forEach(ee -> { |
| visit(ee); |
| visit(am.getElementValues().get(ee)); |
| }); |
| } |
| |
| private void updateAnnotations(Iterable<? extends AnnotationMirror> annotations) { |
| for (AnnotationMirror am : annotations) { |
| if (am.getAnnotationType().asElement().getAnnotation(Documented.class) == null) |
| continue; |
| updateAnnotation(am); |
| } |
| } |
| |
| @Override |
| public Void visit(Element e, Void p) { |
| if (e.getKind() != ElementKind.MODULE && |
| !e.getModifiers().contains(Modifier.PUBLIC) && |
| !e.getModifiers().contains(Modifier.PROTECTED)) { |
| return null; |
| } |
| update(e.getKind().name()); |
| update(e.getModifiers().stream() |
| .map(mod -> mod.name()) |
| .collect(Collectors.joining(",", "[", "]"))); |
| update(e.getSimpleName()); |
| updateAnnotations(e.getAnnotationMirrors()); |
| return e.accept(this, p); |
| } |
| |
| @Override |
| public Void visit(Element e) { |
| return visit(e, null); |
| } |
| |
| @Override |
| public Void visitModule(ModuleElement e, Void p) { |
| update(String.valueOf(e.isOpen())); |
| update(e.getQualifiedName()); |
| e.getDirectives() |
| .stream() |
| .forEach(d -> d.accept(this, null)); |
| return null; |
| } |
| |
| @Override |
| public Void visitPackage(PackageElement e, Void p) { |
| throw new UnsupportedOperationException("Should not get here."); |
| } |
| |
| @Override |
| public Void visitType(TypeElement e, Void p) { |
| visit(e.getTypeParameters(), p); |
| visit(e.getSuperclass()); |
| visit(e.getInterfaces()); |
| visit(e.getEnclosedElements(), p); |
| return null; |
| } |
| |
| @Override |
| public Void visitRecordComponent(RecordComponentElement e, Void p) { |
| update(e.getSimpleName()); |
| visit(e.asType()); |
| return null; |
| } |
| |
| @Override |
| public Void visitVariable(VariableElement e, Void p) { |
| visit(e.asType()); |
| update(String.valueOf(e.getConstantValue())); |
| return null; |
| } |
| |
| @Override |
| public Void visitExecutable(ExecutableElement e, Void p) { |
| update("<"); |
| visit(e.getTypeParameters(), p); |
| update(">"); |
| visit(e.getReturnType()); |
| update("("); |
| visit(e.getParameters(), p); |
| update(")"); |
| visit(e.getThrownTypes()); |
| update(String.valueOf(e.getDefaultValue())); |
| update(String.valueOf(e.isVarArgs())); |
| return null; |
| } |
| |
| @Override |
| public Void visitTypeParameter(TypeParameterElement e, Void p) { |
| visit(e.getBounds()); |
| return null; |
| } |
| |
| @Override |
| public Void visitUnknown(Element e, Void p) { |
| throw new UnsupportedOperationException("Not supported."); |
| } |
| |
| @Override |
| public Void visit(TypeMirror t, Void p) { |
| if (t == null) { |
| update("null"); |
| return null; |
| } |
| update(t.getKind().name()); |
| updateAnnotations(t.getAnnotationMirrors()); |
| t.accept(this, p); |
| return null; |
| } |
| |
| @Override |
| public Void visitPrimitive(PrimitiveType t, Void p) { |
| return null; //done |
| } |
| |
| @Override |
| public Void visitNull(NullType t, Void p) { |
| return null; //done |
| } |
| |
| @Override |
| public Void visitArray(ArrayType t, Void p) { |
| visit(t.getComponentType()); |
| update("[]"); |
| return null; |
| } |
| |
| @Override |
| public Void visitDeclared(DeclaredType t, Void p) { |
| update(((QualifiedNameable) t.asElement()).getQualifiedName()); |
| update("<"); |
| visit(t.getTypeArguments()); |
| update(">"); |
| return null; |
| } |
| |
| @Override |
| public Void visitError(ErrorType t, Void p) { |
| return visitDeclared(t, p); |
| } |
| |
| private final Set<Element> seenVariables = new HashSet<>(); |
| |
| @Override |
| public Void visitTypeVariable(TypeVariable t, Void p) { |
| Element decl = t.asElement(); |
| if (!seenVariables.add(decl)) { |
| return null; |
| } |
| visit(decl, null); |
| visit(t.getLowerBound(), null); |
| visit(t.getUpperBound(), null); |
| seenVariables.remove(decl); |
| return null; |
| } |
| |
| @Override |
| public Void visitWildcard(WildcardType t, Void p) { |
| visit(t.getSuperBound()); |
| visit(t.getExtendsBound()); |
| return null; |
| } |
| |
| @Override |
| public Void visitExecutable(ExecutableType t, Void p) { |
| throw new UnsupportedOperationException("Not supported."); |
| } |
| |
| @Override |
| public Void visitNoType(NoType t, Void p) { |
| return null;//done |
| } |
| |
| @Override |
| public Void visitUnknown(TypeMirror t, Void p) { |
| throw new UnsupportedOperationException("Not supported."); |
| } |
| |
| @Override |
| public Void visitUnion(UnionType t, Void p) { |
| update("("); |
| visit(t.getAlternatives()); |
| update(")"); |
| return null; |
| } |
| |
| @Override |
| public Void visitIntersection(IntersectionType t, Void p) { |
| update("("); |
| visit(t.getBounds()); |
| update(")"); |
| return null; |
| } |
| |
| @Override |
| public Void visit(AnnotationValue av, Void p) { |
| return av.accept(this, p); |
| } |
| |
| @Override |
| public Void visitBoolean(boolean b, Void p) { |
| update(String.valueOf(b)); |
| return null; |
| } |
| |
| @Override |
| public Void visitByte(byte b, Void p) { |
| update(String.valueOf(b)); |
| return null; |
| } |
| |
| @Override |
| public Void visitChar(char c, Void p) { |
| update(String.valueOf(c)); |
| return null; |
| } |
| |
| @Override |
| public Void visitDouble(double d, Void p) { |
| update(String.valueOf(d)); |
| return null; |
| } |
| |
| @Override |
| public Void visitFloat(float f, Void p) { |
| update(String.valueOf(f)); |
| return null; |
| } |
| |
| @Override |
| public Void visitInt(int i, Void p) { |
| update(String.valueOf(i)); |
| return null; |
| } |
| |
| @Override |
| public Void visitLong(long i, Void p) { |
| update(String.valueOf(i)); |
| return null; |
| } |
| |
| @Override |
| public Void visitShort(short s, Void p) { |
| update(String.valueOf(s)); |
| return null; |
| } |
| |
| @Override |
| public Void visitString(String s, Void p) { |
| update(s); |
| return null; |
| } |
| |
| @Override |
| public Void visitType(TypeMirror t, Void p) { |
| return visit(t); |
| } |
| |
| @Override |
| public Void visitEnumConstant(VariableElement c, Void p) { |
| return visit(c); |
| } |
| |
| @Override |
| public Void visitAnnotation(AnnotationMirror a, Void p) { |
| updateAnnotation(a); |
| return null; |
| } |
| |
| @Override |
| public Void visitArray(List<? extends AnnotationValue> vals, Void p) { |
| update("("); |
| for (AnnotationValue av : vals) { |
| visit(av); |
| } |
| update(")"); |
| return null; |
| } |
| |
| @Override |
| public Void visitUnknown(AnnotationValue av, Void p) { |
| throw new UnsupportedOperationException("Not supported."); |
| } |
| |
| @Override |
| public Void visitRequires(RequiresDirective d, Void p) { |
| update("RequiresDirective"); |
| update(String.valueOf(d.isStatic())); |
| update(String.valueOf(d.isTransitive())); |
| update(d.getDependency().getQualifiedName()); |
| return null; |
| } |
| |
| @Override |
| public Void visitExports(ExportsDirective d, Void p) { |
| update("ExportsDirective"); |
| update(d.getPackage().getQualifiedName()); |
| if (d.getTargetModules() != null) { |
| for (ModuleElement me : d.getTargetModules()) { |
| update(me.getQualifiedName()); |
| } |
| } else { |
| update("<none>"); |
| } |
| return null; |
| } |
| |
| @Override |
| public Void visitOpens(OpensDirective d, Void p) { |
| update("OpensDirective"); |
| update(d.getPackage().getQualifiedName()); |
| if (d.getTargetModules() != null) { |
| for (ModuleElement me : d.getTargetModules()) { |
| update(me.getQualifiedName()); |
| } |
| } else { |
| update("<none>"); |
| } |
| return null; |
| } |
| |
| @Override |
| public Void visitUses(UsesDirective d, Void p) { |
| update("UsesDirective"); |
| update(d.getService().getQualifiedName()); |
| return null; |
| } |
| |
| @Override |
| public Void visitProvides(ProvidesDirective d, Void p) { |
| update("ProvidesDirective"); |
| update(d.getService().getQualifiedName()); |
| update("("); |
| for (TypeElement impl : d.getImplementations()) { |
| update(impl.getQualifiedName()); |
| } |
| update(")"); |
| return null; |
| } |
| |
| } |
| |
| private static final class TreeVisitor extends TreeScanner<Void, Void> { |
| |
| private final Set<Name> seenIdentifiers = new HashSet<>(); |
| private final MessageDigest apiHash; |
| private final Charset utf8; |
| |
| public TreeVisitor(MessageDigest apiHash) { |
| this.apiHash = apiHash; |
| utf8 = Charset.forName("UTF-8"); |
| } |
| |
| private void update(CharSequence data) { |
| apiHash.update(data.toString().getBytes(utf8)); |
| } |
| |
| @Override |
| public Void scan(Tree tree, Void p) { |
| update("("); |
| if (tree != null) { |
| update(tree.getKind().name()); |
| }; |
| super.scan(tree, p); |
| update(")"); |
| return null; |
| } |
| |
| @Override |
| public Void visitCompilationUnit(CompilationUnitTree node, Void p) { |
| seenIdentifiers.clear(); |
| scan(node.getPackage(), p); |
| scan(node.getTypeDecls(), p); |
| scan(((JCCompilationUnit) node).getModuleDecl(), p); |
| List<ImportTree> importantImports = new ArrayList<>(); |
| for (ImportTree imp : node.getImports()) { |
| Tree t = imp.getQualifiedIdentifier(); |
| if (t.getKind() == Tree.Kind.MEMBER_SELECT) { |
| Name member = ((MemberSelectTree) t).getIdentifier(); |
| if (member.contentEquals("*") || seenIdentifiers.contains(member)) { |
| importantImports.add(imp); |
| } |
| } else { |
| //should not happen, possibly erroneous source? |
| importantImports.add(imp); |
| } |
| } |
| importantImports.sort((imp1, imp2) -> { |
| if (imp1.isStatic() ^ imp2.isStatic()) { |
| return imp1.isStatic() ? -1 : 1; |
| } else { |
| return imp1.getQualifiedIdentifier().toString().compareTo(imp2.getQualifiedIdentifier().toString()); |
| } |
| }); |
| scan(importantImports, p); |
| return null; |
| } |
| |
| @Override |
| public Void visitIdentifier(IdentifierTree node, Void p) { |
| update(node.getName()); |
| seenIdentifiers.add(node.getName()); |
| return super.visitIdentifier(node, p); |
| } |
| |
| @Override |
| public Void visitMemberSelect(MemberSelectTree node, Void p) { |
| update(node.getIdentifier()); |
| return super.visitMemberSelect(node, p); |
| } |
| |
| @Override |
| public Void visitMemberReference(MemberReferenceTree node, Void p) { |
| update(node.getName()); |
| return super.visitMemberReference(node, p); |
| } |
| |
| @Override |
| public Void scan(Iterable<? extends Tree> nodes, Void p) { |
| update("("); |
| super.scan(nodes, p); |
| update(")"); |
| return null; |
| } |
| |
| @Override |
| public Void visitClass(ClassTree node, Void p) { |
| update(node.getSimpleName()); |
| scan(node.getModifiers(), p); |
| scan(node.getTypeParameters(), p); |
| scan(node.getExtendsClause(), p); |
| scan(node.getImplementsClause(), p); |
| scan(node.getMembers() |
| .stream() |
| .filter(this::importantMember) |
| .collect(Collectors.toList()), |
| p); |
| return null; |
| } |
| |
| private boolean importantMember(Tree m) { |
| return switch (m.getKind()) { |
| case ANNOTATION_TYPE, CLASS, ENUM, INTERFACE, RECORD -> |
| !isPrivate(((ClassTree) m).getModifiers()); |
| case METHOD -> |
| !isPrivate(((MethodTree) m).getModifiers()); |
| case VARIABLE -> |
| !isPrivate(((VariableTree) m).getModifiers()) || |
| isRecordComponent((VariableTree) m); |
| case BLOCK -> false; |
| default -> false; |
| }; |
| } |
| |
| private boolean isPrivate(ModifiersTree mt) { |
| return mt.getFlags().contains(Modifier.PRIVATE); |
| } |
| |
| private boolean isRecordComponent(VariableTree vt) { |
| return (((JCVariableDecl) vt).mods.flags & Flags.RECORD) != 0; |
| } |
| |
| @Override |
| public Void visitVariable(VariableTree node, Void p) { |
| update(node.getName()); |
| return super.visitVariable(node, p); |
| } |
| |
| @Override |
| public Void visitMethod(MethodTree node, Void p) { |
| update(node.getName()); |
| scan(node.getModifiers(), p); |
| scan(node.getReturnType(), p); |
| scan(node.getTypeParameters(), p); |
| scan(node.getParameters(), p); |
| scan(node.getReceiverParameter(), p); |
| scan(node.getThrows(), p); |
| scan(node.getDefaultValue(), p); |
| return null; |
| } |
| |
| @Override |
| public Void visitLiteral(LiteralTree node, Void p) { |
| update(String.valueOf(node.getValue())); |
| return super.visitLiteral(node, p); |
| } |
| |
| @Override |
| public Void visitModifiers(ModifiersTree node, Void p) { |
| update(node.getFlags().toString()); |
| return super.visitModifiers(node, p); |
| } |
| |
| @Override |
| public Void visitPrimitiveType(PrimitiveTypeTree node, Void p) { |
| update(node.getPrimitiveTypeKind().name()); |
| return super.visitPrimitiveType(node, p); |
| } |
| |
| } |
| |
| private class FilteredInitialFileParser implements InvocationHandler { |
| |
| private final JavaCompiler compiler; |
| private final Set<Path> modified; |
| private final Map<String, String> internalAPI; |
| private final AtomicBoolean noApiChange; |
| private final boolean debug; |
| |
| public FilteredInitialFileParser(JavaCompiler compiler, |
| Set<Path> modified, |
| Map<String, String> internalAPI, |
| AtomicBoolean noApiChange, |
| boolean debug) { |
| this.compiler = compiler; |
| this.modified = modified; |
| this.internalAPI = internalAPI; |
| this.noApiChange = noApiChange; |
| this.debug = debug; |
| } |
| |
| @Override |
| @SuppressWarnings("unchecked") |
| public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { |
| return switch (method.getName()) { |
| case "parse" -> doFilteredParse(compiler, |
| (Iterable<JavaFileObject>) args[0], |
| modified, |
| internalAPI, |
| noApiChange, |
| debug); |
| default -> throw new UnsupportedOperationException(); |
| }; |
| } |
| } |
| } |
