Reject private declarative fallback methods (helidon-io#11602)

Author: tomas-langer

declarative/codegen/src/main/java/io/helidon/declarative/codegen/faulttolerance/FallbackHandler.java

@@ -114,6 +114,7 @@ private void fallbackMethod(ClassModel.Builder classModel,
         boolean expectsThrowable = false;
         boolean found = false;
         TypedElementInfo fallbackMethod = null;
+        TypedElementInfo privateFallbackMethod = null;
         List<BadCandidate> badCandidates = new ArrayList<>();
 
         Predicate<TypedElementInfo> withThrowable = ElementInfoPredicates.hasParams(argsWithThrowable);
@@ -122,12 +123,24 @@ private void fallbackMethod(ClassModel.Builder classModel,
             String reason;
             if (elementInfo.typeName().resolvedName().equals(returnType.resolvedName())) {
                 if (withThrowable.test(elementInfo)) {
+                    if (elementInfo.accessModifier() == AccessModifier.PRIVATE) {
+                        privateFallbackMethod = elementInfo;
+                        reason = "Method is private and cannot be called from generated interceptors";
+                        badCandidates.add(new BadCandidate(elementInfo, reason));
+                        continue;
+                    }
                     expectsThrowable = true;
                     found = true;
                     fallbackMethod = elementInfo;
                     break;
                 }
                 if (noThrowable.test(elementInfo)) {
+                    if (elementInfo.accessModifier() == AccessModifier.PRIVATE) {
+                        privateFallbackMethod = elementInfo;
+                        reason = "Method is private and cannot be called from generated interceptors";
+                        badCandidates.add(new BadCandidate(elementInfo, reason));
+                        continue;
+                    }
                     found = true;
                     fallbackMethod = elementInfo;
                     break;
@@ -140,6 +153,12 @@ private void fallbackMethod(ClassModel.Builder classModel,
             badCandidates.add(new BadCandidate(elementInfo, reason));
         }
         if (!found) {
+            if (privateFallbackMethod != null) {
+                throw new CodegenException("Fallback method " + privateFallbackMethod.signature().text()
+                                                   + " on " + typeInfo.typeName().fqName()
+                                                   + " must not be private, generated interceptors cannot call private methods.",
+                                           privateFallbackMethod.originatingElementValue());
+            }
             throw new CodegenException("Could not find matching fallback method for  "
                                                + returnType.className() + " "
                                                + fallbackMethodName

declarative/tests/codegen/src/test/java/io/helidon/declarative/codegen/faulttolerance/FallbackPrivateMethodCodegenTest.java

@@ -0,0 +1,108 @@
+/*
+ * 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.declarative.codegen.faulttolerance;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+import io.helidon.builder.api.Prototype;
+import io.helidon.codegen.apt.AptProcessor;
+import io.helidon.codegen.testing.TestCompiler;
+import io.helidon.common.Generated;
+import io.helidon.common.types.Annotation;
+import io.helidon.faulttolerance.ErrorChecker;
+import io.helidon.faulttolerance.Ft;
+import io.helidon.faulttolerance.FtSupport;
+import io.helidon.service.registry.Dependency;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.ServiceDescriptor;
+
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+class FallbackPrivateMethodCodegenTest {
+    private static final List<Class<?>> CLASSPATH = List.of(
+            Annotation.class,
+            Dependency.class,
+            ErrorChecker.class,
+            Ft.class,
+            FtSupport.class,
+            Generated.class,
+            Prototype.class,
+            Service.class,
+            ServiceDescriptor.class
+    );
+
+    @Test
+    void privateFallbackMethodIsRejectedBeforeGeneratedCompileFails() throws IOException {
+        Path workDirRoot = Path.of("target/test-compiler");
+        Files.createDirectories(workDirRoot);
+        Path workDir = Files.createTempDirectory(workDirRoot, "faulttolerance-private-fallback-");
+
+        var result = TestCompiler.builder()
+                .currentRelease()
+                .addClasspath(CLASSPATH)
+                .addProcessor(AptProcessor::new)
+                .workDir(workDir)
+                .addSource("FallbackService.java", """
+                        package com.example;
+
+                        import io.helidon.faulttolerance.Ft;
+                        import io.helidon.service.registry.Service;
+
+                        @Service.Singleton
+                        class FallbackService {
+                            @Ft.Fallback("privateFallback")
+                            String hello(String name) {
+                                throw new IllegalStateException("boom");
+                            }
+
+                            private String privateFallback(String name) {
+                                return "fallback " + name;
+                            }
+                        }
+                        """)
+                .addSource("Main.java", """
+                        package com.example;
+
+                        import io.helidon.service.registry.Service;
+
+                        @Service.GenerateBinding
+                        class Main {
+                        }
+                        """)
+                .build()
+                .compile();
+
+        String diagnostics = String.join("\n", result.diagnostics());
+        assertThat(diagnostics, result.success(), is(false));
+        assertThat(diagnostics,
+                   containsString("Fallback method privateFallback(java.lang.String) on com.example.FallbackService"
+                                          + " must not be private"));
+        assertThat(diagnostics, containsString("generated interceptors cannot call private methods"));
+        assertThat(diagnostics, not(containsString("has private access")));
+
+        var generatedFallback = result.sourceOutput().resolve("com/example/FallbackService_hello__Fallback.java");
+        assertThat(Files.exists(generatedFallback), is(false));
+    }
+}