A default method on blueprint is now also default on prototype and calls the method on blueprint (helidon-io#11061)

Author: tomas-langer

builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandlerBasic.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, 2025 Oracle and/or its affiliates.
+ * Copyright (c) 2023, 2026 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -35,6 +35,7 @@
 import io.helidon.common.types.Annotation;
 import io.helidon.common.types.Annotations;
 import io.helidon.common.types.ElementKind;
+import io.helidon.common.types.Modifier;
 import io.helidon.common.types.TypeInfo;
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypeNames;
@@ -905,6 +906,25 @@ private Optional<GeneratedMethod> preparePrototypeGetter(Javadoc javadoc) {
             }
         }
 
+        boolean callSuper = false;
+        TypeName declaringType;
+        if (override) {
+            TypeName tmpDeclaringType = null;
+            if (option().interfaceMethod().isPresent()) {
+                var interfaceMethod = option().interfaceMethod().get();
+                if (interfaceMethod.elementModifiers().contains(Modifier.DEFAULT)) {
+                    // in case we do not have a declaring type, we cannot call the super method
+                    // as default methods on interfaces may inherit from more than one super interface, and the
+                    // invocation is SuperType.super.methodName()
+                    tmpDeclaringType = interfaceMethod.enclosingType().orElse(null);
+                    callSuper = tmpDeclaringType != null;
+                }
+            }
+            declaringType = tmpDeclaringType;
+        } else {
+            declaringType = null;
+        }
+
         var method = TypedElementInfo.builder()
                 .kind(ElementKind.METHOD)
                 .accessModifier(AccessModifier.PUBLIC)
@@ -917,11 +937,23 @@ private Optional<GeneratedMethod> preparePrototypeGetter(Javadoc javadoc) {
             method.addAnnotation(Annotations.OVERRIDE);
         }
 
+        Consumer<ContentBuilder<?>> contentConsumer;
+        if (callSuper) {
+            method.addElementModifier(Modifier.DEFAULT);
+            contentConsumer = it -> it.addContent("return ")
+                    .addContent(declaringType)
+                    .addContent(".super.")
+                    .addContent(option().getterName())
+                    .addContentLine("();");
+        } else {
+            // interface method
+            contentConsumer = it -> {};
+        }
+
         return Optional.of(GeneratedMethod.builder()
                                    .method(method.build())
                                    .javadoc(javadoc)
-                                   .contentBuilder(it -> {
-                                   }) // always an interface method
+                                   .contentBuilder(contentConsumer)
                                    .build());
     }
 

builder/tests/builder/src/test/java/io/helidon/builder/test/BackwardCompatibilityTest.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2026 Oracle and/or its affiliates.
+ *
+ * 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 io.helidon.builder.test;
+
+import java.util.Optional;
+
+import io.helidon.builder.test.testsubjects.A;
+
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+/*
+Make sure the A from ABlueprint can be extended without implementing the default method
+ */
+class BackwardCompatibilityTest {
+    @Test
+    void testDefaultMethodValue() {
+        A a = A.builder()
+                .a("hello")
+                .build();
+
+        assertThat(a.a(), is("hello"));
+        assertThat(a.aNewProperty(), is(Optional.empty()));
+    }
+
+    @Test
+    void testFoo() {
+        // make sure the class compiles and the default method on `A` is truly default
+        Foo foo = new Foo();
+
+        assertThat(foo.a(), is(""));
+    }
+
+    // this class must compile, as a() should be the only non-default method
+    static class Foo implements A {
+        @Override
+        public String a() {
+            return "";
+        }
+    }
+}