fix SimpleAnnotation equals and hashCode

h908714124 · h908714124 · commit 63160cce7a5f · 2023-02-26T17:28:31.000+01:00
diff --git a/compiler/src/main/java/io/jbock/simple/processor/ContextComponent.java b/compiler/src/main/java/io/jbock/simple/processor/ContextComponent.java
@@ -5,6 +5,7 @@
 import io.jbock.simple.processor.binding.InjectBindingFactory;
 import io.jbock.simple.processor.binding.KeyFactory;
 import io.jbock.simple.processor.graph.TopologicalSorter;
+import io.jbock.simple.processor.util.SafeElements;
 import io.jbock.simple.processor.util.TypeTool;
 import io.jbock.simple.processor.writing.Generator;
 
@@ -16,18 +17,21 @@ interface Factory {
         ContextComponent create(
                 ComponentElement component,
                 TypeTool tool,
+                SafeElements elements,
                 InjectBindingFactory injectBindingFactory,
                 KeyFactory keyFactory);
     }
 
     static ContextComponent create(
             ComponentElement component,
             TypeTool tool,
+            SafeElements elements,
             InjectBindingFactory injectBindingFactory,
             KeyFactory keyFactory) {
         return ContextComponent_Impl.factory().create(
                 component,
                 tool,
+                elements,
                 injectBindingFactory,
                 keyFactory);
     }
diff --git a/compiler/src/main/java/io/jbock/simple/processor/binding/KeyFactory.java b/compiler/src/main/java/io/jbock/simple/processor/binding/KeyFactory.java
@@ -35,7 +35,7 @@ public KeyFactory(TypeTool tool) {
     private Optional<SimpleAnnotation> getQualifier(Element element) {
         List<SimpleAnnotation> qualifiers = element.getAnnotationMirrors().stream()
                 .filter(this::hasQualifierAnnotation)
-                .map(mirror -> SimpleAnnotation.create(mirror, tool.elements()))
+                .map(mirror -> SimpleAnnotation.create(mirror, tool.elements(), tool.types()))
                 .collect(Collectors.toList());
         if (qualifiers.isEmpty()) {
             return Optional.empty();
diff --git a/compiler/src/main/java/io/jbock/simple/processor/graph/GraphFactory.java b/compiler/src/main/java/io/jbock/simple/processor/graph/GraphFactory.java
@@ -45,8 +45,8 @@ private Optional<Binding> getBinding(DependencyRequest request) {
             return result;
         }
         result = component.parameterBinding(key)
-                .or(() -> injectBindingFactory.binding(key))
                 .or(() -> Optional.ofNullable(component.providesBindings().get(key)))
+                .or(() -> injectBindingFactory.binding(key))
                 .or(() -> providerBinding(key));
         if (result.isPresent()) {
             bindingCache.put(key, result);
@@ -62,8 +62,8 @@ private Optional<Binding> providerBinding(Key key) {
         ProviderType provider = providerType.orElseThrow();
         Key innerKey = key.changeType(provider.innerType());
         return component.parameterBinding(innerKey)
-                .or(() -> injectBindingFactory.binding(innerKey))
                 .or(() -> Optional.ofNullable(component.providesBindings().get(innerKey)))
+                .or(() -> injectBindingFactory.binding(innerKey))
                 .map(b -> new ProviderBinding(key, b, provider));
     }
 
diff --git a/compiler/src/main/java/io/jbock/simple/processor/step/ComponentStep.java b/compiler/src/main/java/io/jbock/simple/processor/step/ComponentStep.java
@@ -89,7 +89,7 @@ private void process(TypeElement typeElement) {
             }
         }
         ContextComponent componentComponent = ContextComponent.create(
-                component, tool, injectBindingFactory, keyFactory);
+                component, tool, tool.elements(), injectBindingFactory, keyFactory);
         Generator generator = componentComponent.generator();
         List<Binding> sorted = componentComponent.topologicalSorter().sortedBindings();
         TypeSpec typeSpec = generator.generate(sorted);
diff --git a/compiler/src/main/java/io/jbock/simple/processor/util/SimpleAnnotation.java b/compiler/src/main/java/io/jbock/simple/processor/util/SimpleAnnotation.java
@@ -1,5 +1,7 @@
 package io.jbock.simple.processor.util;
 
+import io.jbock.javapoet.TypeName;
+
 import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.element.AnnotationValue;
 import javax.lang.model.type.DeclaredType;
@@ -12,27 +14,35 @@
 public final class SimpleAnnotation {
 
     private final DeclaredType annotationType;
+    private final TypeName typeName;
     private final List<AnnotationValue> values;
+    private final SafeTypes types;
 
     private SimpleAnnotation(
             DeclaredType annotationType,
-            List<AnnotationValue> values) {
+            List<AnnotationValue> values,
+            SafeTypes types) {
         this.annotationType = annotationType;
         this.values = values;
+        this.types = types;
+        this.typeName = TypeName.get(annotationType);
     }
 
-    public static SimpleAnnotation create(AnnotationMirror mirror, SafeElements elements) {
+    public static SimpleAnnotation create(
+            AnnotationMirror mirror,
+            SafeElements elements,
+            SafeTypes types) {
         DeclaredType annotationType = mirror.getAnnotationType();
         List<AnnotationValue> values = new ArrayList<>(elements.getElementValuesWithDefaults(mirror).values());
-        return new SimpleAnnotation(annotationType, values);
+        return new SimpleAnnotation(annotationType, values, types);
     }
 
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         SimpleAnnotation that = (SimpleAnnotation) o;
-        if (!annotationType.equals(that.annotationType)) {
+        if (!types.isSameType(annotationType, that.annotationType)) {
             return false;
         }
         if (values.size() != that.values.size()) {
@@ -49,7 +59,7 @@ public boolean equals(Object o) {
     @Override
     public int hashCode() {
         int[] result = new int[values.size() + 1];
-        result[0] = Objects.hashCode(annotationType);
+        result[0] = Objects.hashCode(typeName); //avoid TypeMirror hashCode
         for (int i = 0; i < values.size(); i++) {
             result[i + 1] = Objects.hashCode(values.get(i).getValue());
         }
diff --git a/simple-component/src/main/java/io/jbock/simple/Component.java b/simple-component/src/main/java/io/jbock/simple/Component.java
@@ -1,11 +1,10 @@
 package io.jbock.simple;
 
-import java.lang.annotation.Documented;
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
 
 import static java.lang.annotation.ElementType.TYPE;
-import static java.lang.annotation.RetentionPolicy.SOURCE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
  * Annotates an interface for which a dependency-injected
@@ -28,7 +27,7 @@
  * </ul>
  */
 @Target(TYPE)
-@Retention(SOURCE)
+@Retention(RUNTIME)
 public @interface Component {
 
     /**
@@ -47,9 +46,8 @@
      *   <li>The method parameters bind the instance passed for that parameter within the component.
      * </ul>
      */
-    @Retention(SOURCE)
     @Target(TYPE)
-    @Documented
+    @Retention(RUNTIME)
     @interface Factory {
     }
 }
diff --git a/simple-component/src/main/java/io/jbock/simple/Inject.java b/simple-component/src/main/java/io/jbock/simple/Inject.java
@@ -5,12 +5,12 @@
 
 import static java.lang.annotation.ElementType.CONSTRUCTOR;
 import static java.lang.annotation.ElementType.METHOD;
-import static java.lang.annotation.RetentionPolicy.SOURCE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
  * Identifies injectable constructors and <em>static</em> methods.
  */
 @Target({METHOD, CONSTRUCTOR})
-@Retention(SOURCE)
+@Retention(RUNTIME)
 public @interface Inject {
 }
diff --git a/simple-component/src/main/java/io/jbock/simple/Named.java b/simple-component/src/main/java/io/jbock/simple/Named.java
@@ -21,14 +21,14 @@
 
 import static java.lang.annotation.ElementType.METHOD;
 import static java.lang.annotation.ElementType.PARAMETER;
-import static java.lang.annotation.RetentionPolicy.SOURCE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
  * String-based qualifier.
  */
 @Qualifier
 @Target({METHOD, PARAMETER})
-@Retention(SOURCE)
+@Retention(RUNTIME)
 public @interface Named {
 
     String value();
diff --git a/simple-component/src/main/java/io/jbock/simple/Provides.java b/simple-component/src/main/java/io/jbock/simple/Provides.java
@@ -4,7 +4,7 @@
 import java.lang.annotation.Target;
 
 import static java.lang.annotation.ElementType.METHOD;
-import static java.lang.annotation.RetentionPolicy.SOURCE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
  * Annotates <em>static</em> methods of a {@linkplain Component component}
@@ -16,6 +16,6 @@
  * implementation will pass dependencies to the method as parameters.
  */
 @Target(METHOD)
-@Retention(SOURCE)
+@Retention(RUNTIME)
 public @interface Provides {
 }

Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ private void process(TypeElement typeElement) {`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`	`ContextComponent componentComponent = ContextComponent.create(`
`92`		`- component, tool, injectBindingFactory, keyFactory);`
	`92`	`+ component, tool, tool.elements(), injectBindingFactory, keyFactory);`
`93`	`93`	`Generator generator = componentComponent.generator();`
`94`	`94`	`List<Binding> sorted = componentComponent.topologicalSorter().sortedBindings();`
`95`	`95`	`TypeSpec typeSpec = generator.generate(sorted);`