Support reproducible builds.

Author: raphw

byte-buddy-dep/src/main/java/net/bytebuddy/description/annotation/AnnotationDescription.java

@@ -1188,7 +1188,7 @@ public Builder defineEnumerationArray(String property, TypeDescription enumerati
         public <T extends Annotation> Builder defineAnnotationArray(String property, Class<T> annotationType, T... annotation) {
             return defineAnnotationArray(property,
                     TypeDescription.ForLoadedType.of(annotationType),
-                    new AnnotationList.ForLoadedAnnotations(annotation).toArray(new AnnotationDescription[0]));
+                    new AnnotationList.ForLoadedAnnotations(Arrays.asList(annotation)).toArray(new AnnotationDescription[0]));
         }
 
         /**

byte-buddy-dep/src/main/java/net/bytebuddy/description/annotation/AnnotationList.java

@@ -19,6 +19,8 @@
 import net.bytebuddy.description.type.TypeList;
 import net.bytebuddy.matcher.ElementMatcher;
 import net.bytebuddy.matcher.FilterableList;
+import net.bytebuddy.utility.AnnotationComparator;
+import net.bytebuddy.utility.GraalImageCode;
 import net.bytebuddy.utility.nullability.AlwaysNull;
 import net.bytebuddy.utility.nullability.MaybeNull;
 
@@ -227,7 +229,7 @@ class ForLoadedAnnotations extends AbstractBase {
          * @param annotation The represented annotations.
          */
         public ForLoadedAnnotations(Annotation... annotation) {
-            this(Arrays.asList(annotation));
+            this(Arrays.asList(GraalImageCode.getCurrent().sorted(annotation, AnnotationComparator.INSTANCE)));
         }
 
         /**

byte-buddy-dep/src/main/java/net/bytebuddy/description/type/TypeDescription.java

@@ -36,10 +36,7 @@
 import net.bytebuddy.dynamic.TargetType;
 import net.bytebuddy.implementation.bytecode.StackSize;
 import net.bytebuddy.matcher.ElementMatcher;
-import net.bytebuddy.utility.CompoundList;
-import net.bytebuddy.utility.FieldComparator;
-import net.bytebuddy.utility.GraalImageCode;
-import net.bytebuddy.utility.JavaType;
+import net.bytebuddy.utility.*;
 import net.bytebuddy.utility.dispatcher.JavaDispatcher;
 import net.bytebuddy.utility.nullability.AlwaysNull;
 import net.bytebuddy.utility.nullability.MaybeNull;
@@ -9028,7 +9025,7 @@ public TypeDescription getEnclosingType() {
          * {@inheritDoc}
          */
         public TypeList getDeclaredTypes() {
-            return new TypeList.ForLoadedTypes(type.getDeclaredClasses());
+            return new TypeList.ForLoadedTypes(GraalImageCode.getCurrent().sorted(type.getDeclaredClasses(), TypeComparator.INSTANCE));
         }
 
         /**

byte-buddy-dep/src/main/java/net/bytebuddy/utility/AnnotationComparator.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2014 - Present Rafael Winterhalter
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.bytebuddy.utility;
+
+import java.lang.annotation.Annotation;
+import java.util.Comparator;
+
+/**
+ * A comparator for guaranteeing a stable order for declared {@link Annotation}s.
+ */
+public enum AnnotationComparator implements Comparator<Annotation> {
+
+    /**
+     * The singleton instance.
+     */
+    INSTANCE;
+
+    /**
+     * {@inheritDoc}
+     */
+    public int compare(Annotation left, Annotation right) {
+        if (left == right) {
+            return 0;
+        }
+        return left.annotationType().getName().compareTo(right.annotationType().getName());
+    }
+}

byte-buddy-dep/src/main/java/net/bytebuddy/utility/GraalImageCode.java

@@ -57,6 +57,16 @@ public enum GraalImageCode {
      */
     NONE(false, false);
 
+    /**
+     * Indicates that member properties and annotations should be sorted when being read.
+     */
+    public static final String REPRODUCIBLE_PROPERTIES = "net.bytebuddy.reproducible";
+
+    /**
+     * Resolves if properties should always be sorted at the cost of some runtime overhead.
+     */
+    private static final boolean SORTED = Boolean.parseBoolean(doPrivileged(new GetSystemPropertyAction(REPRODUCIBLE_PROPERTIES)));
+
     /**
      * The current image code or {@code null} if the image code was not yet resolved. The image code must be
      * initialized lazily to avoid that it's bound to a value during native compilation.
@@ -102,7 +112,7 @@ public static GraalImageCode getCurrent() {
      * @return The supplied array, potentially sorted.
      */
     public <T> T[] sorted(T[] value, Comparator<? super T> comparator) {
-        if (defined) {
+        if (SORTED || defined) {
             Arrays.sort(value, comparator);
         }
         return value;

byte-buddy-dep/src/main/java/net/bytebuddy/utility/TypeComparator.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2014 - Present Rafael Winterhalter
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.bytebuddy.utility;
+
+import java.util.Comparator;
+
+/**
+ * A comparator for guaranteeing a stable order for declared {@link Class}s.
+ */
+public enum TypeComparator implements Comparator<Class<?>> {
+
+    /**
+     * The singleton instance.
+     */
+    INSTANCE;
+
+    /**
+     * {@inheritDoc}
+     */
+    public int compare(Class<?> left, Class<?> right) {
+        if (left == right) {
+            return 0;
+        }
+        return left.getName().compareTo(right.getName());
+    }
+}

byte-buddy-dep/src/test/java/net/bytebuddy/utility/AnnotationComparatorTest.java

@@ -0,0 +1,32 @@
+package net.bytebuddy.utility;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+import java.lang.annotation.Annotation;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.mockito.Mockito.when;
+
+public class AnnotationComparatorTest {
+
+    @Rule
+    public MockitoRule mockitoRule = MockitoJUnit.rule();
+
+    @Mock
+    private Annotation left, right;
+
+    @Test
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public void testTypeComparison() {
+        when(left.annotationType()).thenReturn((Class) Object.class);
+        when(right.annotationType()).thenReturn((Class) String.class);
+        assertThat(AnnotationComparator.INSTANCE.compare(left, left) == 0, is(true));
+        assertThat(AnnotationComparator.INSTANCE.compare(left, right) < 0, is(true));
+        assertThat(AnnotationComparator.INSTANCE.compare(left, right) > 0, is(true));
+    }
+}

byte-buddy-dep/src/test/java/net/bytebuddy/utility/TypeComparatorTest.java

@@ -0,0 +1,16 @@
+package net.bytebuddy.utility;
+
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class TypeComparatorTest {
+
+    @Test
+    public void testTypeComparison() {
+        assertThat(TypeComparator.INSTANCE.compare(Object.class, Object.class) == 0, is(true));
+        assertThat(TypeComparator.INSTANCE.compare(Object.class, String.class) < 0, is(true));
+        assertThat(TypeComparator.INSTANCE.compare(String.class, Object.class) > 0, is(true));
+    }
+}