Properly support Optional as a header param for REST Client

Fixes: #47366
(cherry picked from commit 2422ae6)

Author: geoand

extensions/resteasy-reactive/rest-client-jaxrs/deployment/src/main/java/io/quarkus/jaxrs/client/reactive/deployment/JaxrsClientReactiveProcessor.java

@@ -1138,6 +1138,19 @@ A more full example of generated client (with sub-resource) can is at the bottom
                             // just store the index of parameter used to create the body, we'll use it later
                             bodyParameterIdx = paramIdx;
                         } else if (param.parameterType == ParameterType.HEADER) {
+                            Type paramType = jandexMethod.parameterType(paramIdx);
+                            String effectiveParamTypeStr = paramType.name().toString();
+                            boolean isOptional = isOptional(paramType, index);
+                            if (isOptional) {
+                                effectiveParamTypeStr = DotNames.OBJECT.toString();
+                                if (paramType.kind() == PARAMETERIZED_TYPE) {
+                                    Type objectType = paramType.asParameterizedType().arguments().get(0);
+                                    if ((objectType.kind() == CLASS) || (objectType.kind() == PARAMETERIZED_TYPE)) {
+                                        effectiveParamTypeStr = objectType.name().toString();
+                                    }
+                                }
+                            }
+
                             // headers are added at the invocation builder level
                             MethodDescriptor handleHeaderDescriptor = MethodDescriptor.ofMethod(name,
                                     method.getName() + "$$" + methodIndex + "$$handleHeader$$" + paramIdx,
@@ -1149,8 +1162,15 @@ A more full example of generated client (with sub-resource) can is at the bottom
                             AssignableResultHandle invocationBuilderRef = handleHeaderMethod
                                     .createVariable(Invocation.Builder.class);
                             handleHeaderMethod.assign(invocationBuilderRef, handleHeaderMethod.getMethodParam(0));
+                            ResultHandle headerValue = handleHeaderMethod.getMethodParam(1);
                             addHeaderParam(handleHeaderMethod, invocationBuilderRef, param.name,
-                                    handleHeaderMethod.getMethodParam(1), param.type,
+                                    isOptional
+                                            ? handleHeaderMethod.invokeVirtualMethod(
+                                                    MethodDescriptor.ofMethod(Optional.class, "orElse", Object.class,
+                                                            Object.class),
+                                                    headerValue, handleHeaderMethod.loadNull())
+                                            : headerValue,
+                                    effectiveParamTypeStr,
                                     handleHeaderMethod.getThis(),
                                     getGenericTypeFromArray(handleHeaderMethod, methodGenericParametersField, paramIdx),
                                     getAnnotationsFromArray(handleHeaderMethod, methodParamAnnotationsField, paramIdx));
@@ -3123,22 +3143,22 @@ private boolean isOptional(Type type, IndexView index) {
     }
 
     private void addHeaderParam(BytecodeCreator invoBuilderEnricher, AssignableResultHandle invocationBuilder,
-            String paramName, ResultHandle headerParamHandle, String paramType, ResultHandle client,
+            String headerName, ResultHandle headerValueHandle, String paramType, ResultHandle client,
             ResultHandle genericType, ResultHandle annotations) {
 
-        BytecodeCreator notNullValue = invoBuilderEnricher.ifNull(headerParamHandle).falseBranch();
+        BytecodeCreator notNullValue = invoBuilderEnricher.ifNull(headerValueHandle).falseBranch();
 
-        headerParamHandle = notNullValue.invokeVirtualMethod(
+        headerValueHandle = notNullValue.invokeVirtualMethod(
                 MethodDescriptor.ofMethod(RestClientBase.class, "convertParam", Object.class,
                         Object.class, Class.class, java.lang.reflect.Type.class, Annotation[].class),
-                client, headerParamHandle,
+                client, headerValueHandle,
                 notNullValue.loadClassFromTCCL(paramType), genericType, annotations);
 
         notNullValue.assign(invocationBuilder,
                 notNullValue.invokeInterfaceMethod(
                         MethodDescriptor.ofMethod(Invocation.Builder.class, "header", Invocation.Builder.class,
                                 String.class, Object.class),
-                        invocationBuilder, notNullValue.load(paramName), headerParamHandle));
+                        invocationBuilder, notNullValue.load(headerName), headerValueHandle));
     }
 
     private void addPathParam(BytecodeCreator methodCreator, AssignableResultHandle methodTarget,

extensions/resteasy-reactive/rest-client/deployment/src/test/java/io/quarkus/rest/client/reactive/headers/OptionalHeaderTest.java

@@ -0,0 +1,75 @@
+package io.quarkus.rest.client.reactive.headers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.net.URI;
+import java.util.Optional;
+
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.HeaderParam;
+import jakarta.ws.rs.Path;
+
+import org.jboss.resteasy.reactive.RestHeader;
+import org.jboss.resteasy.reactive.RestQuery;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.rest.client.reactive.QuarkusRestClientBuilder;
+import io.quarkus.test.QuarkusUnitTest;
+import io.quarkus.test.common.http.TestHTTPResource;
+
+public class OptionalHeaderTest {
+
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest()
+            .withApplicationRoot((jar) -> jar.addClasses(Resource.class, Client.class));
+
+    @TestHTTPResource
+    URI baseUri;
+
+    @Test
+    void test() {
+        Client client = QuarkusRestClientBuilder.newBuilder().baseUri(baseUri).build(Client.class);
+        String result = client.send(Optional.empty(), "q", Optional.of("h2"), Optional.of(3));
+        assertThat(result).isEqualTo("query=q/Header2=h2,Header3=3");
+    }
+
+    @Path("test")
+    public interface Client {
+
+        @GET
+        String send(@HeaderParam("header1") Optional<String> header1, @RestQuery String query,
+                @RestHeader Optional<String> header2, @RestHeader Optional<Integer> header3);
+    }
+
+    @Path("test")
+    public static class Resource {
+
+        @GET
+        public String test(@RestQuery String query, @RestHeader String header1,
+                @RestHeader String header2,
+                @RestHeader Integer header3) {
+            StringBuilder result = new StringBuilder("query=");
+            result.append(query);
+            result.append("/");
+            if (header1 != null) {
+                result.append("Header1");
+                result.append("=");
+                result.append(header1);
+                result.append(",");
+            }
+            if (header2 != null) {
+                result.append("Header2");
+                result.append("=");
+                result.append(header2);
+                result.append(",");
+            }
+            if (header3 != null) {
+                result.append("Header3");
+                result.append("=");
+                result.append(header3);
+            }
+            return result.toString();
+        }
+    }
+}