fix reproducibility in case type annotations are used

Author: Ladicek

core/src/main/java/org/jboss/jandex/Indexer.java

@@ -396,14 +396,21 @@ void returnConstantAnnoAttributes(byte[] attributes) {
     private int[] constantPoolOffsets;
     private byte[] constantPoolAnnoAttrributes;
 
+    // note that for reproducibility, we have to establish a predictable iteration order for all `Map`s
+    // below that we iterate upon (fortunately, that's not too many)
+    // this is either by using keys with predictable `equals`/`hashCode` (such as `DotName`),
+    // or by storing the keys on the side in a list and iterate on that (needed for `IdentityHashMap`s)
+
     private ClassInfo currentClass;
     private HashMap<DotName, List<AnnotationInstance>> classAnnotations;
     private ArrayList<AnnotationInstance> elementAnnotations;
     private IdentityHashMap<AnnotationTarget, Object> signaturePresent;
     private List<Object> signatures;
     private int classSignatureIndex = -1;
     private Map<DotName, InnerClassInfo> innerClasses;
+    // iteration: `typeAnnotationsKeys` is used for predictable iteration order, we never iterate on `typeAnnotations`
     private IdentityHashMap<AnnotationTarget, List<TypeAnnotationState>> typeAnnotations;
+    private List<AnnotationTarget> typeAnnotationsKeys;
     private List<MethodInfo> methods;
     private List<FieldInfo> fields;
     private List<RecordComponentInfo> recordComponents;
@@ -416,9 +423,12 @@ void returnConstantAnnoAttributes(byte[] attributes) {
     private Map<DotName, List<ClassInfo>> subclasses;
     private Map<DotName, List<ClassInfo>> subinterfaces;
     private Map<DotName, List<ClassInfo>> implementors;
+    // iteration: `DotName` has predictable `equals`/`hashCode`, which implies predictable iteration order
     private Map<DotName, ClassInfo> classes;
     private Map<DotName, ModuleInfo> modules;
-    private Map<DotName, Set<ClassInfo>> users; // must be a linked set for reproducibility
+    // iteration: `DotName` has predictable `equals`/`hashCode`, which implies predictable iteration order
+    // iteration: the `Set`s in map values must be linked sets for predictable iteration order
+    private Map<DotName, Set<ClassInfo>> users;
     private NameTable names;
     private GenericSignatureParser signatureParser;
     private final TmpObjects tmpObjects = new TmpObjects();
@@ -459,6 +469,7 @@ private void initClassFields() {
         signaturePresent = new IdentityHashMap<AnnotationTarget, Object>();
         signatures = new ArrayList<Object>();
         typeAnnotations = new IdentityHashMap<AnnotationTarget, List<TypeAnnotationState>>();
+        typeAnnotationsKeys = new ArrayList<>();
 
         // in bytecode, record components are stored as class attributes,
         // and if the attribute is missing, processRecordComponents isn't called at all
@@ -903,6 +914,7 @@ private void processTypeAnnotations(DataInputStream data, AnnotationTarget targe
             typeAnnotations.get(target).addAll(annotations);
         } else {
             typeAnnotations.put(target, annotations);
+            typeAnnotationsKeys.add(target);
         }
     }
 
@@ -1104,9 +1116,8 @@ private static boolean isEnumConstructor(MethodInfo method) {
     }
 
     private void resolveTypeAnnotations() {
-        for (Map.Entry<AnnotationTarget, List<TypeAnnotationState>> entry : typeAnnotations.entrySet()) {
-            AnnotationTarget key = entry.getKey();
-            List<TypeAnnotationState> annotations = entry.getValue();
+        for (AnnotationTarget key : typeAnnotationsKeys) {
+            List<TypeAnnotationState> annotations = typeAnnotations.get(key);
 
             for (TypeAnnotationState annotation : annotations) {
                 resolveTypeAnnotation(key, annotation);
@@ -1202,9 +1213,8 @@ private void recordUsedClass(DotName usedClass) {
     }
 
     private void updateTypeTargets() {
-        for (Map.Entry<AnnotationTarget, List<TypeAnnotationState>> entry : typeAnnotations.entrySet()) {
-            AnnotationTarget key = entry.getKey();
-            List<TypeAnnotationState> annotations = entry.getValue();
+        for (AnnotationTarget key : typeAnnotationsKeys) {
+            List<TypeAnnotationState> annotations = typeAnnotations.get(key);
 
             for (TypeAnnotationState annotation : annotations) {
                 updateTypeTarget(key, annotation);
@@ -2686,6 +2696,7 @@ public ClassSummary indexWithSummary(InputStream stream) throws IOException {
             classSignatureIndex = -1;
             innerClasses = null;
             typeAnnotations = null;
+            typeAnnotationsKeys = null;
             methods = null;
             fields = null;
             recordComponents = null;

core/src/test/java/org/jboss/jandex/test/ReproducibilityTest.java

@@ -0,0 +1,89 @@
+package org.jboss.jandex.test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+
+import org.jboss.jandex.Index;
+import org.jboss.jandex.IndexWriter;
+import org.jboss.jandex.Indexer;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.RepeatedTest;
+
+// asserts that the indexing process is reproducible (that is, always produces the same output)
+// on the same JVM version with the same sequence of input files, using the test classes from
+// packages `org.jboss.jandex.test` (the `core` module) and `test` (the `test-data` module)
+//
+// there's also a reproducibility integration test in the `maven-plugin` module, which uses
+// a different set of inputs
+public class ReproducibilityTest {
+    static byte[] firstIndex;
+
+    static byte[] index() throws IOException, URISyntaxException {
+        Indexer indexer = new Indexer();
+        ClassLoader cl = ReproducibilityTest.class.getClassLoader();
+        for (String pkg : Arrays.asList("org/jboss/jandex/test/", "test/")) {
+            URI uri = cl.getResources(pkg).nextElement().toURI();
+            String scheme = uri.getScheme();
+            if ("file".equals(scheme)) {
+                try (Stream<Path> stream = Files.walk(Paths.get(uri))) {
+                    List<Path> classes = stream
+                            .filter(it -> Files.isRegularFile(it) && it.getFileName().toString().endsWith(".class"))
+                            .sorted()
+                            .collect(Collectors.toList());
+                    for (Path path : classes) {
+                        try (InputStream in = Files.newInputStream(path)) {
+                            indexer.index(in);
+                        }
+                    }
+                }
+            }
+            if ("jar".equals(scheme)) {
+                // opaque URI of the form `jar:<file URI>!/pkg/`
+                String part = uri.getSchemeSpecificPart();
+                uri = new URI(part.substring(0, part.indexOf("!")));
+                try (JarFile jar = new JarFile(new File(uri))) {
+                    List<JarEntry> classes = jar.stream()
+                            .filter(it -> it.getName().endsWith(".class"))
+                            .sorted(Comparator.comparing(ZipEntry::getName))
+                            .collect(Collectors.toList());
+                    for (JarEntry entry : classes) {
+                        try (InputStream in = jar.getInputStream(entry)) {
+                            indexer.index(in);
+                        }
+                    }
+                }
+            }
+        }
+        Index index = indexer.complete();
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        new IndexWriter(out).write(index);
+        return out.toByteArray();
+    }
+
+    @BeforeAll
+    public static void setup() throws IOException, URISyntaxException {
+        firstIndex = index();
+    }
+
+    @RepeatedTest(50)
+    public void test() throws IOException, URISyntaxException {
+        assertArrayEquals(firstIndex, index());
+    }
+}