Fix handling of primitive arrays in annotation metadata. Fixes micronaut-projects#1087

graemerocher · graemerocher · commit c93b6bfdc013 · 2019-01-07T13:54:28.000+01:00
diff --git a/core/src/main/java/io/micronaut/core/convert/DefaultConversionService.java b/core/src/main/java/io/micronaut/core/convert/DefaultConversionService.java
@@ -167,6 +167,28 @@ public <S, T> DefaultConversionService addConverter(Class<S> sourceType, Class<T
     @SuppressWarnings({"OptionalIsPresent", "unchecked"})
     protected void registerDefaultConverters() {
 
+        // wrapper to primitive array converters
+        addConverter(Double[].class, double[].class, (object, targetType, context) -> {
+            double[] doubles = new double[object.length];
+            for (int i = 0; i < object.length; i++) {
+                Double aDouble = object[i];
+                if (aDouble != null) {
+                    doubles[i] = aDouble;
+                }
+            }
+            return Optional.of(doubles);
+        });
+        addConverter(Integer[].class, int[].class, (object, targetType, context) -> {
+            int[] integers = new int[object.length];
+            for (int i = 0; i < object.length; i++) {
+                Integer o = object[i];
+                if (o != null) {
+                    integers[i] = o;
+                }
+            }
+            return Optional.of(integers);
+        });
+
         // Object -> List
         addConverter(Object.class, List.class, (object, targetType, context) -> {
             Optional<Argument<?>> firstTypeVariable = context.getFirstTypeVariable();
diff --git a/inject-groovy/src/main/groovy/io/micronaut/ast/groovy/InjectTransform.groovy b/inject-groovy/src/main/groovy/io/micronaut/ast/groovy/InjectTransform.groovy
@@ -242,9 +242,7 @@ class InjectTransform implements ASTTransformation, CompilationUnitAware {
 
             } catch (Throwable e) {
                 AstMessageUtils.error(source, beanClassNode, "Error generating bean definition class for dependency injection of class [${beanTypeName}]: $e.message")
-                if (e.message == null) {
-                    e.printStackTrace(System.err)
-                }
+                e.printStackTrace(System.err)
             }
         }
         if (!beanDefinitionWriters.isEmpty()) {
diff --git a/inject-groovy/src/test/groovy/io/micronaut/AbstractBeanDefinitionSpec.groovy b/inject-groovy/src/test/groovy/io/micronaut/AbstractBeanDefinitionSpec.groovy
@@ -83,7 +83,7 @@ abstract class AbstractBeanDefinitionSpec extends Specification {
 
     protected AnnotationMetadata writeAndLoadMetadata(String className, AnnotationMetadata toWrite) {
         def stream = new ByteArrayOutputStream()
-        new AnnotationMetadataWriter(className, toWrite)
+        new AnnotationMetadataWriter(className, toWrite, true)
                 .writeTo(stream)
         className = className + AnnotationMetadata.CLASS_NAME_SUFFIX
         ClassLoader classLoader = new ClassLoader() {
diff --git a/inject-groovy/src/test/groovy/io/micronaut/inject/annotation/AnnotationMetadataWriterSpec.groovy b/inject-groovy/src/test/groovy/io/micronaut/inject/annotation/AnnotationMetadataWriterSpec.groovy
@@ -34,6 +34,46 @@ import java.lang.annotation.Retention
  */
 class AnnotationMetadataWriterSpec extends AbstractBeanDefinitionSpec {
 
+    void "test annotation metadata with primitive arrays"() {
+        given:
+        AnnotationMetadata toWrite = buildTypeAnnotationMetadata('test.Test','''\
+package test;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import io.micronaut.inject.annotation.*;
+
+@MyAnn(doubleArray=[1.1d])
+class Test {
+}
+
+
+@Documented
+@Retention(RUNTIME)
+@Target([ElementType.TYPE])
+@interface MyAnn {
+    double[] doubleArray() default [];
+    int[] intArray() default [];
+    short[] shortArray() default [];
+    boolean[] booleanArray() default [];
+}
+
+''')
+        when:
+        def className = "test"
+        AnnotationMetadata metadata = writeAndLoadMetadata(className, toWrite)
+
+        then:
+        metadata != null
+        metadata.getValue("test.MyAnn","doubleArray", Double[].class).get() == [1.1d] as Double[]
+        metadata.getValue("test.MyAnn","doubleArray", double[].class).get() == [1.1d] as double[]
+    }
+
     void "test read annotation with annotation value"() {
         given:
         AnnotationMetadata toWrite = buildTypeAnnotationMetadata("test.Test",'''\
diff --git a/inject-java/build.gradle b/inject-java/build.gradle
@@ -44,6 +44,7 @@ dependencies {
     testCompile dependencyModuleVersion("groovy", "groovy-json")
     testCompile files(org.gradle.internal.jvm.Jvm.current().toolsJar)
     testRuntime 'org.glassfish:javax.el:3.0.1-b08'
+    testCompile dependencyVersion("micrometer")
 }
 
 
diff --git a/inject-java/src/test/groovy/io/micronaut/inject/AbstractTypeElementSpec.groovy b/inject-java/src/test/groovy/io/micronaut/inject/AbstractTypeElementSpec.groovy
@@ -119,7 +119,7 @@ abstract class AbstractTypeElementSpec extends Specification {
 
     protected AnnotationMetadata writeAndLoadMetadata(String className, AnnotationMetadata toWrite) {
         def stream = new ByteArrayOutputStream()
-        new AnnotationMetadataWriter(className, toWrite)
+        new AnnotationMetadataWriter(className, toWrite, true)
                 .writeTo(stream)
         className = className + AnnotationMetadata.CLASS_NAME_SUFFIX
         ClassLoader classLoader = new ClassLoader() {
diff --git a/inject-java/src/test/groovy/io/micronaut/inject/annotation/AnnotationMetadataWriterSpec.groovy b/inject-java/src/test/groovy/io/micronaut/inject/annotation/AnnotationMetadataWriterSpec.groovy
@@ -15,6 +15,7 @@
  */
 package io.micronaut.inject.annotation
 
+import io.micrometer.core.annotation.Timed
 import io.micronaut.aop.Around
 import io.micronaut.aop.introduction.StubIntroducer
 import io.micronaut.context.annotation.Primary
@@ -38,6 +39,72 @@ import java.lang.annotation.Retention
  */
 class AnnotationMetadataWriterSpec extends AbstractTypeElementSpec {
 
+    void "test write annotation metadata with primitive arrays"() {
+        given:
+        AnnotationMetadata toWrite = new DefaultAnnotationMetadata(
+                [
+                        "io.micrometer.core.annotation.Timed": [
+                                percentiles: [1.1d] as double[]
+                        ]
+
+                ], null, null, [
+                "io.micrometer.core.annotation.Timed": [
+                        percentiles: [1.1d] as double[]
+                ]
+
+        ], null
+        )
+        when:
+        def className = "test"
+        AnnotationMetadata metadata = writeAndLoadMetadata(className, toWrite)
+
+        then:
+        metadata != null
+        metadata.getValue(Timed.name, "percentiles", double[].class).get() == [1.1d] as double[]
+    }
+
+
+    void "test annotation metadata with primitive arrays"() {
+        given:
+        AnnotationMetadata toWrite = buildTypeAnnotationMetadata('''\
+package test;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import io.micronaut.inject.annotation.*;
+
+@MyAnn(doubleArray={1.1d})
+@io.micrometer.core.annotation.Timed(percentiles={1.1d})
+class Test {
+}
+
+
+@Documented
+@Retention(RUNTIME)
+@Target({ElementType.TYPE})
+@interface MyAnn {
+    double[] doubleArray() default {};
+    int[] intArray() default {};
+    short[] shortArray() default {};
+    boolean[] booleanArray() default {};
+}
+
+''')
+        when:
+        def className = "test"
+        AnnotationMetadata metadata = writeAndLoadMetadata(className, toWrite)
+
+        then:
+        metadata != null
+        metadata.getValue(Timed, "percentiles", double[].class).get() == [1.1d] as double[]
+        metadata.getValue("test.MyAnn", "doubleArray", double[].class).get() == [1.1d] as double[]
+    }
+
     void "test annotation metadata inherited stereotypes"() {
         given:
         AnnotationMetadata toWrite = buildTypeAnnotationMetadata('''\
diff --git a/inject/src/main/java/io/micronaut/inject/annotation/AnnotationMetadataWriter.java b/inject/src/main/java/io/micronaut/inject/annotation/AnnotationMetadataWriter.java
@@ -20,6 +20,7 @@
 import io.micronaut.core.annotation.AnnotationUtil;
 import io.micronaut.core.annotation.AnnotationClassValue;
 import io.micronaut.core.annotation.Internal;
+import io.micronaut.core.reflect.ClassUtils;
 import io.micronaut.core.reflect.ReflectionUtils;
 import io.micronaut.core.util.CollectionUtils;
 import io.micronaut.inject.writer.AbstractClassFileWriter;
@@ -30,10 +31,8 @@
 
 import java.io.IOException;
 import java.io.OutputStream;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.lang.reflect.Array;
+import java.util.*;
 
 /**
  * Responsible for writing class files that are instances of {@link AnnotationMetadata}.
@@ -130,8 +129,8 @@ public class AnnotationMetadataWriter extends AbstractClassFileWriter {
     /**
      * Constructs a new writer for the given class name and metadata.
      *
-     * @param className          The class name for which the metadata relates
-     * @param annotationMetadata The annotation metadata
+     * @param className               The class name for which the metadata relates
+     * @param annotationMetadata      The annotation metadata
      * @param writeAnnotationDefaults Whether annotations defaults should be written
      */
     public AnnotationMetadataWriter(String className, AnnotationMetadata annotationMetadata, boolean writeAnnotationDefaults) {
@@ -408,13 +407,13 @@ private static void pushValue(Type declaringType, ClassVisitor declaringClassWri
             Type t = Type.getType(declaringClass);
             methodVisitor.getStatic(t, value.toString(), t);
         } else if (value.getClass().isArray()) {
-            Object[] array = (Object[]) value;
-            int len = array.length;
-            pushNewArray(methodVisitor, ((Object[]) value).getClass().getComponentType(), len);
-            for (int i = 0; i < array.length; i++) {
-                int index = i;
+            final Class<?> componentType = ReflectionUtils.getWrapperType(value.getClass().getComponentType());
+            int len = Array.getLength(value);
+            pushNewArray(methodVisitor, componentType, len);
+            for (int i = 0; i < len; i++) {
+                final Object v = Array.get(value, i);
                 pushStoreInArray(methodVisitor, i, len, () ->
-                        pushValue(declaringType, declaringClassWriter, methodVisitor, array[index], loadTypeMethods)
+                        pushValue(declaringType, declaringClassWriter, methodVisitor, v, loadTypeMethods)
                 );
             }
         } else if (value instanceof List) {

Original file line number	Diff line number	Diff line change
`@@ -242,9 +242,7 @@ class InjectTransform implements ASTTransformation, CompilationUnitAware {`
`242`	`242`
`243`	`243`	`} catch (Throwable e) {`
`244`	`244`	`AstMessageUtils.error(source, beanClassNode, "Error generating bean definition class for dependency injection of class [${beanTypeName}]: $e.message")`
`245`		`- if (e.message == null) {`
`246`		`- e.printStackTrace(System.err)`
`247`		`- }`
	`245`	`+ e.printStackTrace(System.err)`
`248`	`246`	`}`
`249`	`247`	`}`
`250`	`248`	`if (!beanDefinitionWriters.isEmpty()) {`
Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,7 @@ dependencies {`
`44`	`44`	`testCompile dependencyModuleVersion("groovy", "groovy-json")`
`45`	`45`	`testCompile files(org.gradle.internal.jvm.Jvm.current().toolsJar)`
`46`	`46`	`testRuntime 'org.glassfish:javax.el:3.0.1-b08'`
	`47`	`+ testCompile dependencyVersion("micrometer")`
`47`	`48`	`}`
`48`	`49`
`49`	`50`