4.x: Set all contracts when calling Services.set (helidon-io#10816)

* Added a new method to descriptor to analyze types at runtime, no change to codegen.
* Added a test
* Services.set() now uses all contracts associated with the used type
* Support for add method and set with qualiers to use all interfaces
* Update documentation of services.

Author: tomas-langer

codegen/class-model/src/main/java/io/helidon/codegen/classmodel/ClassBase.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ * Copyright (c) 2023, 2025 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.
@@ -223,9 +223,14 @@ void writeComponent(ModelWriter writer, Set<String> declaredTokens, ImportOrgani
         }
         writer.write("{");
         writer.writeSeparatorLine();
+
         if (!staticFields.isEmpty()) {
             writeClassFields(staticFields, writer, combinedTokens, imports);
         }
+
+        // support for static initializers
+        writePostConstantDeclaration(writer, declaredTokens, imports, classType);
+
         if (!fields.isEmpty()) {
             writeClassFields(fields, writer, combinedTokens, imports);
         }
@@ -245,6 +250,11 @@ void writeComponent(ModelWriter writer, Set<String> declaredTokens, ImportOrgani
         writer.write("}");
     }
 
+    void writePostConstantDeclaration(ModelWriter writer,  Set<String> declaredTokens, ImportOrganizer imports, ClassType classType)
+            throws IOException {
+        // default impl does nothing, as interfaces do not support this
+    }
+
     @Override
     void addImports(ImportOrganizer.Builder imports) {
         super.addImports(imports);

codegen/class-model/src/main/java/io/helidon/codegen/classmodel/ClassModel.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ * Copyright (c) 2023, 2025 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.
@@ -21,6 +21,7 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.function.Consumer;
 
 import io.helidon.common.types.AccessModifier;
 import io.helidon.common.types.TypeName;
@@ -49,12 +50,15 @@ public final class ClassModel extends ClassBase {
     public static final String DEFAULT_PADDING = "    ";
     private final String packageName;
     private final String copyright;
+    private final Content staticInitializer;
+
     private ImportOrganizer imports;
 
     private ClassModel(Builder builder) {
         super(builder);
         this.copyright = builder.copyright;
         this.packageName = builder.packageName;
+        this.staticInitializer = builder.staticInitializer == null ? null : builder.staticInitializer.build();
     }
 
     /**
@@ -128,6 +132,23 @@ void writeComponent(ModelWriter writer,
         writer.writeSeparatorLine();
     }
 
+    @Override
+    void writePostConstantDeclaration(ModelWriter writer, Set<String> declaredTokens, ImportOrganizer imports, ClassType classType)
+            throws IOException {
+        if (staticInitializer == null) {
+            return;
+        }
+        writer.increasePaddingLevel();
+        writer.write("\n");
+        writer.increasePaddingLevel();
+        writer.writeLine("static {");
+        staticInitializer.writeBody(writer, imports);
+        writer.decreasePaddingLevel();
+        writer.write("\n");
+        writer.writeLine("}");
+        writer.decreasePaddingLevel();
+    }
+
     /**
      * Type name of this class.
      *
@@ -145,11 +166,19 @@ public String toString() {
                 + '}';
     }
 
+    @Override
+    void addImports(ImportOrganizer.Builder builder) {
+        super.addImports(builder);
+        if (staticInitializer != null) {
+            staticInitializer.addImports(builder);
+        }
+    }
+
     /**
      * Fluent API builder for {@link ClassModel}.
      */
     public static final class Builder extends ClassBase.Builder<Builder, ClassModel> {
-
+        private Content.Builder staticInitializer;
         private String packageName = "";
         private String copyright;
 
@@ -212,6 +241,20 @@ public Builder type(TypeName type) {
             return this;
         }
 
+        /**
+         * Update the static initializer of this class.
+         *
+         * @param contentBuilder content builder consumer to update the static initializer
+         * @return updated builder instance
+         */
+        public Builder staticInitializer(Consumer<ContentBuilder<?>> contentBuilder) {
+            this.staticInitializer = (this.staticInitializer == null)
+                    ? Content.builder()
+                    : this.staticInitializer;
+            contentBuilder.accept(staticInitializer);
+            return this;
+        }
+
         /**
          * Find if the provided type name is handled as part of this generated class.
          *

service/codegen/src/main/java/io/helidon/service/codegen/DescribedService.java

@@ -185,6 +185,16 @@ static DescribedService create(RegistryCodegenContext ctx,
                                                                                   processedDirectContracts,
                                                                                   it));
 
+        Map<ResolvedType, Set<ResolvedType>> contractMap = new HashMap<>();
+        directContracts.forEach(directContract -> addContractToMap(roundContext,
+                                                                   serviceContracts,
+                                                                   contractMap,
+                                                                   directContract));
+        providedContracts.forEach(providedContract -> addContractToMap(roundContext,
+                                                                       serviceContracts,
+                                                                       contractMap,
+                                                                       providedContract));
+
         DescribedType serviceDescriptor;
         DescribedType providedDescriptor;
 
@@ -193,6 +203,7 @@ static DescribedService create(RegistryCodegenContext ctx,
             serviceDescriptor = new DescribedType(serviceInfo,
                                                   serviceInfo.typeName(),
                                                   directContracts,
+                                                  contractMap,
                                                   serviceElements);
 
             providedDescriptor = null;
@@ -201,12 +212,14 @@ static DescribedService create(RegistryCodegenContext ctx,
             serviceDescriptor = new DescribedType(serviceInfo,
                                                   serviceInfo.typeName(),
                                                   directContracts,
+                                                  contractMap,
                                                   serviceElements);
             DescribedElements providedElements = DescribedElements.create(ctx, interception, providedContracts, providedTypeInfo);
 
             providedDescriptor = new DescribedType(providedTypeInfo,
                                                    providedTypeName,
                                                    providedContracts,
+                                                   contractMap,
                                                    providedElements);
         }
 
@@ -222,6 +235,24 @@ static DescribedService create(RegistryCodegenContext ctx,
         );
     }
 
+    private static void addContractToMap(RegistryRoundContext ctx,
+                                         ServiceContracts serviceContracts,
+                                         Map<ResolvedType, Set<ResolvedType>> contractMap,
+                                         ResolvedType contract) {
+
+        var transitiveContracts = contractMap.computeIfAbsent(contract, k -> new HashSet<>());
+        transitiveContracts.add(contract);
+
+        // contract may have type arguments that are using real types, whereas the typeInfo may have generics - we need to
+        // remember the correct generic types
+        var maybeTypeInfo = ctx.typeInfo(contract.type());
+        if (maybeTypeInfo.isEmpty()) {
+            // we cannot add, as not on classpath
+            return;
+        }
+        serviceContracts.addContracts(transitiveContracts, new HashSet<>(), maybeTypeInfo.get());
+    }
+
     @Override
     public String toString() {
         return serviceType.typeName().fqName();

service/codegen/src/main/java/io/helidon/service/codegen/DescribedType.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Oracle and/or its affiliates.
+ * Copyright (c) 2024, 2025 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.
@@ -16,6 +16,7 @@
 
 package io.helidon.service.codegen;
 
+import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 
@@ -29,27 +30,43 @@
  * A described type (class, interface).
  * User service can have up to two types - one is the service itself, another one is a provided contract,
  * if the service is a provider.
+ *
+ * @deprecated this class is not part of public API and does not have any public elements, it will be package private in
+ *      a future release
  */
+@Deprecated(forRemoval = true, since = "4.4.0")
 public class DescribedType {
     private final TypeInfo typeInfo;
     private final boolean isAbstract;
     private final TypeName typeName;
     private final Set<ResolvedType> contracts;
     private final DescribedElements elements;
+    private final Map<ResolvedType, Set<ResolvedType>> contractTypes;
+
+    DescribedType(TypeInfo typeInfo,
+                  TypeName typeName,
+                  Set<ResolvedType> contracts,
+                  Map<ResolvedType, Set<ResolvedType>> contractMap,
+                  DescribedElements elements) {
 
-    DescribedType(TypeInfo typeInfo, TypeName typeName, Set<ResolvedType> contracts, DescribedElements elements) {
         Objects.requireNonNull(typeInfo);
         Objects.requireNonNull(typeName);
         Objects.requireNonNull(contracts);
+        Objects.requireNonNull(contractMap);
         Objects.requireNonNull(elements);
 
         this.typeInfo = typeInfo;
         this.isAbstract = isAbstract(typeInfo);
         this.typeName = typeName;
         this.contracts = contracts;
+        this.contractTypes = contractMap;
         this.elements = elements;
     }
 
+    Map<ResolvedType, Set<ResolvedType>> contractTypeSets() {
+        return contractTypes;
+    }
+
     boolean isAbstract() {
         return isAbstract;
     }

service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenTypes.java

@@ -368,6 +368,14 @@ public final class ServiceCodegenTypes {
     public static final TypeName SET_OF_RESOLVED_TYPES = TypeName.builder(TypeNames.SET)
             .addTypeArgument(TypeNames.RESOLVED_TYPE_NAME)
             .build();
+
+    /**
+     * A map of resolved types to a set of resolved types.
+     */
+    public static final TypeName MAP_RESOLVED_TO_SET_OF_RESOLVED = TypeName.builder(TypeNames.MAP)
+            .addTypeArgument(TypeNames.RESOLVED_TYPE_NAME)
+            .addTypeArgument(SET_OF_RESOLVED_TYPES)
+            .build();
     /**
      * A set of String.
      */
@@ -402,5 +410,3 @@ public final class ServiceCodegenTypes {
     private ServiceCodegenTypes() {
     }
 }
-
-