Merge branch '4.7.x' into 4.8.x

Author: graemerocher

Diff for: aop/src/main/java/io/micronaut/aop/chain/AdapterIntroduction.java

@@ -19,6 +19,7 @@
 import io.micronaut.aop.MethodInterceptor;
 import io.micronaut.aop.MethodInvocationContext;
 import io.micronaut.context.BeanContext;
+import io.micronaut.core.annotation.AnnotationValue;
 import io.micronaut.core.annotation.Internal;
 import io.micronaut.core.annotation.Nullable;
 import io.micronaut.core.util.StringUtils;
@@ -49,19 +50,22 @@ final class AdapterIntroduction implements MethodInterceptor<Object, Object> {
      * @param method The target method
      */
     AdapterIntroduction(BeanContext beanContext, ExecutableMethod<?, ?> method) {
-        Class<?> beanType = method.classValue(Adapter.class, ADAPTED_BEAN).orElse(null);
-
+        AnnotationValue<Adapter> adapterAnnotationValue = method.getAnnotation(Adapter.class);
+        if (adapterAnnotationValue == null) {
+            throw new IllegalStateException("Adapter method must have @Adapter annotation");
+        }
+        Class<?> beanType = adapterAnnotationValue.classValue(ADAPTED_BEAN).orElse(null);
         if (beanType == null) {
             throw new IllegalStateException("No bean type to adapt found in Adapter configuration for method: " + method);
         }
 
-        String beanMethod = method.stringValue(Adapter.class, ADAPTED_METHOD).orElse(null);
+        String beanMethod = adapterAnnotationValue.stringValue(ADAPTED_METHOD).orElse(null);
         if (StringUtils.isEmpty(beanMethod)) {
             throw new IllegalStateException("No bean method to adapt found in Adapter configuration for method: " + method);
         }
 
-        String beanQualifier = method.stringValue(Adapter.class, ADAPTED_QUALIFIER).orElse(null);
-        Class<?>[] argumentTypes = method.classValues(Adapter.class, ADAPTED_ARGUMENT_TYPES);
+        String beanQualifier = adapterAnnotationValue.stringValue(ADAPTED_QUALIFIER).orElse(null);
+        Class<?>[] argumentTypes = adapterAnnotationValue.classValues(ADAPTED_ARGUMENT_TYPES);
         Class<?>[] methodArgumentTypes = method.getArgumentTypes();
         Class<?>[] arguments = argumentTypes.length == methodArgumentTypes.length ? argumentTypes : methodArgumentTypes;
         if (StringUtils.isNotEmpty(beanQualifier)) {

Diff for: core/src/main/java/io/micronaut/core/annotation/AnnotationClassValue.java

@@ -95,7 +95,7 @@ public AnnotationClassValue(@NonNull T instance) {
         this.theClass = (Class<T>) instance.getClass();
         this.name = theClass.getName();
         this.instance = instance;
-        this.instantiated = true;
+        this.instantiated = !(instance instanceof AnnotationClassValue.UnresolvedClass);
     }
 
     /**
@@ -120,8 +120,7 @@ public AnnotationClassValue(@NonNull T instance) {
      * @since 1.1
      */
     public boolean isInstantiated() {
-        return instantiated ||
-            (getInstance().isPresent() && !(getInstance().get() instanceof AnnotationClassValue.UnresolvedClass));
+        return instantiated;
     }
 
     /**

Diff for: inject-kotlin/src/main/kotlin/io/micronaut/kotlin/processing/visitor/KotlinClassElement.kt

@@ -151,6 +151,12 @@ internal open class KotlinClassElement(
             // We need to aggregate all the hierarchy properties because
             // getAllProperties doesn't return correct parent of the property
             properties.addAll(clazz.getDeclaredSyntheticBeanProperties())
+            clazz.interfaces.forEach {
+                if (it is KotlinClassElement) {
+                    properties.addAll(it.getDeclaredSyntheticBeanProperties())
+                }
+            }
+
             clazz = clazz.superType.orElse(null) as KotlinClassElement?
         }
         properties

Diff for: inject-kotlin/src/test/groovy/io/micronaut/kotlin/processing/inject/ast/ClassElementSpec.groovy

@@ -26,6 +26,8 @@ import io.micronaut.runtime.context.env.ConfigurationAdvice
 import jakarta.validation.Valid
 import spock.lang.PendingFeature
 
+import static io.micronaut.annotation.processing.test.KotlinCompiler.buildContext
+
 class ClassElementSpec extends AbstractKotlinCompilerSpec {
 
     void "test Java Record compile"() {
@@ -171,6 +173,29 @@ class MyBean {}
         } != null
     }
 
+    void "test interface native properties"() {
+
+        when:
+        def nativeProps = buildClassElementMapped('test.BaseConfiguration', '''
+package test
+
+import io.micronaut.context.annotation.ConfigurationProperties
+
+@ConfigurationProperties("base")
+interface BaseConfiguration : Other {
+    val port: Int
+}
+
+interface Other {
+    val host: String
+}
+''', ce -> ce.syntheticBeanProperties)
+
+        then:
+            nativeProps.size() == 2
+            nativeProps.collect { it.name } == ["port", "host"]
+    }
+
     void "test visitGeneratedFile"() {
         given:
         AllElementsVisitor.VISITED_CLASS_ELEMENTS.clear()

Diff for: test-suite/src/test/java/io/micronaut/test/lombok/Bar.java

@@ -0,0 +1,15 @@
+package io.micronaut.test.lombok;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import io.micronaut.core.annotation.Introspected;
+
+@Introspected
+@JsonIgnoreProperties(ignoreUnknown = true)
+@JsonDeserialize(builder = Foo.FooBuilder.class)
+public interface Bar {
+
+    String getName();
+
+}
+

Diff for: test-suite/src/test/java/io/micronaut/test/lombok/Foo.java

@@ -0,0 +1,26 @@
+package io.micronaut.test.lombok;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.micronaut.core.annotation.Introspected;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.ToString;
+import lombok.experimental.FieldNameConstants;
+import lombok.extern.jackson.Jacksonized;
+
+@Getter
+@Builder(toBuilder = true)
+@ToString
+@Jacksonized
+@JsonIgnoreProperties(ignoreUnknown = true)
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+@EqualsAndHashCode
+@FieldNameConstants(innerTypeName = "UserField", asEnum = true)
+@Introspected
+public class Foo implements Bar {
+
+    private String name;
+
+}

Diff for: test-suite/src/test/java/io/micronaut/test/lombok/LombokIntrospectedBuilderTest.java

@@ -15,6 +15,15 @@
 
 public class LombokIntrospectedBuilderTest {
 
+    @Test
+    void testLombokInheritance() {
+        Foo foo = Foo.builder().name("Name").build();
+        final BeanIntrospection<Foo> introspection = BeanIntrospection.getIntrospection(Foo.class);
+
+        Assertions.assertEquals("Name", foo.getName());
+        Assertions.assertNotNull(introspection);
+    }
+
     @Test
     void testNoArgsAndAllArgsConstructor() {
         BeanIntrospection<BarCommand> introspection = BeanIntrospection.getIntrospection(BarCommand.class);