Use immutables:datatype to remove the need for modifiable parameter type duplicates

Implement initial POC for hooking Plexus into immutable builder classes

Use fix from paul-hammant/qdox#271 temporarily to work around apache/maven-plugin-tools#944

Fix test compilation failure

Fix ImmutablesDataPlexusConverter to handle stdlib/primitive types correctly

Start writing unit tests for plexus converter for Immutables types

Update logic in plexus converters

Use Datatypes rather than Data for immutables

Ran into immutables/immutables#1608 when initialising the data type descriptors.

Add missing test case for immutables/immutables#1608

Update Plexus converter to use weak references to class types

Move test data to subpackage

Fix issues with nested type handling, add new test cases

Suppress testdata in Checkstyle

Author: ascopes

.mvn/checkstyle/suppressions.xml

@@ -20,4 +20,5 @@
   "-//Checkstyle//DTD SuppressionFilter Configuration 1.2//EN"
   "https://checkstyle.org/dtds/suppressions_1_2.dtd">
 <suppressions>
-</suppressions>
+  <suppress files="Datatypes_SomeBrokenModel.java" checks=".+"/>
+</suppressions>

protobuf-maven-plugin/pom.xml

@@ -82,6 +82,12 @@
       <scope>provided</scope>
     </dependency>
 
+    <dependency>
+      <groupId>org.immutables</groupId>
+      <artifactId>datatype</artifactId>
+      <scope>compile</scope>
+    </dependency>
+
     <dependency>
       <groupId>org.immutables</groupId>
       <artifactId>value</artifactId>

protobuf-maven-plugin/src/main/java/io/github/ascopes/protobufmavenplugin/dependencies/MavenDependency.java

@@ -16,8 +16,8 @@
 package io.github.ascopes.protobufmavenplugin.dependencies;
 
 import java.util.Set;
+import org.immutables.datatype.Data;
 import org.immutables.value.Value.Immutable;
-import org.immutables.value.Value.Modifiable;
 import org.jspecify.annotations.Nullable;
 
 
@@ -27,13 +27,13 @@
  * @author Ashley Scopes
  * @since 3.3.1
  */
+@Data
 @Immutable
-@Modifiable
 public abstract class MavenDependency extends MavenArtifact {
 
   public abstract @Nullable DependencyResolutionDepth getDependencyResolutionDepth();
 
-  public abstract Set<MavenExclusionBean> getExclusions();
+  public abstract Set<MavenExclusion> getExclusions();
 
   // Must be overridden to keep immutables happy.
   @Override

protobuf-maven-plugin/src/main/java/io/github/ascopes/protobufmavenplugin/dependencies/MavenExclusion.java

@@ -15,7 +15,8 @@
  */
 package io.github.ascopes.protobufmavenplugin.dependencies;
 
-import org.immutables.value.Value.Modifiable;
+import org.immutables.datatype.Data;
+import org.immutables.value.Value.Immutable;
 
 /**
  * Marker to exclude a specific transitive dependency.
@@ -26,7 +27,8 @@
  * @author Ashley Scopes
  * @since 2.12.0
  */
-@Modifiable
+@Data
+@Immutable
 public interface MavenExclusion {
 
   /**

protobuf-maven-plugin/src/main/java/io/github/ascopes/protobufmavenplugin/mojo/AbstractGenerateMojo.java

@@ -20,19 +20,19 @@
 import static java.util.function.Predicate.not;
 
 import io.github.ascopes.protobufmavenplugin.dependencies.DependencyResolutionDepth;
-import io.github.ascopes.protobufmavenplugin.dependencies.MavenDependencyBean;
+import io.github.ascopes.protobufmavenplugin.dependencies.MavenDependency;
 import io.github.ascopes.protobufmavenplugin.digests.Digest;
 import io.github.ascopes.protobufmavenplugin.generation.GenerationResult;
 import io.github.ascopes.protobufmavenplugin.generation.ImmutableGenerationRequest;
 import io.github.ascopes.protobufmavenplugin.generation.Language;
 import io.github.ascopes.protobufmavenplugin.generation.OutputDescriptorAttachmentRegistrar;
 import io.github.ascopes.protobufmavenplugin.generation.ProtobufBuildOrchestrator;
 import io.github.ascopes.protobufmavenplugin.generation.SourceRootRegistrar;
-import io.github.ascopes.protobufmavenplugin.plugins.BinaryMavenProtocPluginBean;
-import io.github.ascopes.protobufmavenplugin.plugins.JvmMavenProtocPluginBean;
-import io.github.ascopes.protobufmavenplugin.plugins.PathProtocPluginBean;
+import io.github.ascopes.protobufmavenplugin.plugins.BinaryMavenProtocPlugin;
+import io.github.ascopes.protobufmavenplugin.plugins.JvmMavenProtocPlugin;
+import io.github.ascopes.protobufmavenplugin.plugins.PathProtocPlugin;
 import io.github.ascopes.protobufmavenplugin.plugins.ProtocPlugin;
-import io.github.ascopes.protobufmavenplugin.plugins.UriProtocPluginBean;
+import io.github.ascopes.protobufmavenplugin.plugins.UriProtocPlugin;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
@@ -312,7 +312,7 @@ public AbstractGenerateMojo() {
    * @since 1.2.0
    */
   @Parameter
-  @Nullable List<MavenDependencyBean> importDependencies;
+  @Nullable List<MavenDependency> importDependencies;
 
   /**
    * Specify additional paths to import protobuf sources from on the local file system.
@@ -701,7 +701,7 @@ public AbstractGenerateMojo() {
    * @since 1.2.0
    */
   @Parameter
-  @Nullable List<MavenDependencyBean> sourceDependencies;
+  @Nullable List<MavenDependency> sourceDependencies;
 
   /**
    * Protobuf Descriptor files to compile.
@@ -735,7 +735,7 @@ public AbstractGenerateMojo() {
    * @since 3.1.0
    */
   @Parameter
-  @Nullable List<MavenDependencyBean> sourceDescriptorDependencies;
+  @Nullable List<MavenDependency> sourceDescriptorDependencies;
 
   /**
    * The source directories to compile protobuf sources from.
@@ -787,7 +787,7 @@ public AbstractGenerateMojo() {
    */
   @Deprecated(forRemoval = true)
   @Parameter
-  @Nullable List<BinaryMavenProtocPluginBean> binaryMavenPlugins;
+  @Nullable List<BinaryMavenProtocPlugin> binaryMavenPlugins;
 
   /**
    * Binary plugins to use with the protobuf compiler, sourced from the system {@code PATH}.
@@ -804,7 +804,7 @@ public AbstractGenerateMojo() {
    */
   @Deprecated(forRemoval = true)
   @Parameter
-  @Nullable List<PathProtocPluginBean> binaryPathPlugins;
+  @Nullable List<PathProtocPlugin> binaryPathPlugins;
 
   /**
    * Binary plugins to use with the protobuf compiler, specified as a valid URL.
@@ -821,7 +821,7 @@ public AbstractGenerateMojo() {
    */
   @Deprecated(forRemoval = true)
   @Parameter
-  @Nullable List<UriProtocPluginBean> binaryUrlPlugins;
+  @Nullable List<UriProtocPlugin> binaryUrlPlugins;
 
   /**
    * Additional <strong>pure-Java</strong> plugins to use with the protobuf compiler.
@@ -838,7 +838,7 @@ public AbstractGenerateMojo() {
    */
   @Deprecated(forRemoval = true)
   @Parameter
-  @Nullable List<JvmMavenProtocPluginBean> jvmMavenPlugins;
+  @Nullable List<JvmMavenProtocPlugin> jvmMavenPlugins;
 
   /*
    * Implementation-specific details.

protobuf-maven-plugin/src/main/java/io/github/ascopes/protobufmavenplugin/package-info.java

@@ -20,16 +20,10 @@
  */
 @NullMarked
 @Style(
-    beanFriendlyModifiables = true,
-    create = "new",
     defaults = @Immutable(copy = false),
     defaultAsDefault = true,
-    deferCollectionAllocation = true,
     get = {"get*", "is*"},
-    headerComments = true,
     jacksonIntegration = false,
-    // Eventually may be true when Maven upgrades.
-    jakarta = false,
     jdkOnly = true,
     jdk9Collections = true,
     nullableAnnotation = "org.jspecify.annotations.Nullable",

protobuf-maven-plugin/src/main/java/io/github/ascopes/protobufmavenplugin/plexus/ImmutablesDataPlexusConverter.java

@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2023 - 2025, Ashley Scopes.
+ *
+ * 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.github.ascopes.protobufmavenplugin.plexus;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Optional;
+import java.util.WeakHashMap;
+import javax.inject.Named;
+import javax.inject.Singleton;
+import org.codehaus.plexus.component.configurator.ComponentConfigurationException;
+import org.codehaus.plexus.component.configurator.ConfigurationListener;
+import org.codehaus.plexus.component.configurator.converters.ParameterizedConfigurationConverter;
+import org.codehaus.plexus.component.configurator.converters.basic.AbstractBasicConverter;
+import org.codehaus.plexus.component.configurator.converters.lookup.ConverterLookup;
+import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator;
+import org.codehaus.plexus.configuration.PlexusConfiguration;
+import org.immutables.datatype.Datatype;
+import org.jspecify.annotations.Nullable;
+
+/**
+ * Converter for Plexus components that can build a generated "immutables" value type, based
+ * on the interface it was derived from.
+ *
+ * <p>Note that all objects must be annotated with both {@link org.immutables.value.Value}
+ * <strong>and</strong> {@link org.immutables.datatype.Data}, otherwise deserialization will fail at
+ * runtime.
+ *
+ * @author Ashley Scopes
+ * @since TBC
+ */
+@Named
+@Singleton
+final class ImmutablesDataPlexusConverter extends AbstractBasicConverter {
+  private final Map<Class<Object>, Datatype<Object>> knownDatatypes;
+
+  ImmutablesDataPlexusConverter() {
+    // Weak hashmap keys will be deregistered upon classloader destruction safely.
+    knownDatatypes = Collections.synchronizedMap(new WeakHashMap<>());
+  }
+
+  @Override
+  public boolean canConvert(Class<?> cls) {
+    return datatypeFor(cls).isPresent();
+  }
+
+  @Override
+  public Object fromConfiguration(
+      ConverterLookup lookup,
+      PlexusConfiguration configuration,
+      Class<?> type,
+      @Nullable Class<?> enclosingType,
+      @Nullable ClassLoader loader,
+      ExpressionEvaluator evaluator,
+      @Nullable ConfigurationListener listener
+  ) throws ComponentConfigurationException {
+    var datatype = datatypeFor(type)
+        .orElseThrow(() -> new NoSuchElementException("No datatype converter " + type.getName()));
+
+    var builder = datatype.builder();
+    for (var child : configuration.getChildren()) {
+      consumeChild(builder, child, lookup, datatype, loader, evaluator, listener);
+    }
+
+    return builder.build();
+  }
+
+  private void consumeChild(
+      Datatype.Builder<Object> builder,
+      PlexusConfiguration child,
+      ConverterLookup lookup,
+      Datatype<?> datatype,
+      @Nullable ClassLoader loader,
+      ExpressionEvaluator evaluator,
+      @Nullable ConfigurationListener listener
+  ) throws ComponentConfigurationException {
+    try {
+      @SuppressWarnings("unchecked")
+      var feature = (Datatype.Feature<Object, Object>) datatype.feature(child.getName());
+      var valueType = feature.type();
+      var rawType = rawTypeOf(valueType);
+
+      var converter = lookup.lookupConverterForType(rawType);
+
+      Object value;
+
+      if (converter instanceof ParameterizedConfigurationConverter parameterizedConverter) {
+        var parameterizedType = (ParameterizedType) valueType;
+        value = parameterizedConverter.fromConfiguration(
+            lookup,
+            child,
+            rawType,
+            parameterizedType.getActualTypeArguments(),
+            rawType.getEnclosingClass(),
+            loader,
+            evaluator,
+            listener
+        );
+      } else {
+        value = converter.fromConfiguration(
+            lookup,
+            child,
+            rawType,
+            rawType.getEnclosingClass(),
+            loader,
+            evaluator,
+            listener
+        );
+      }
+
+      builder.set(feature, value);
+
+    } catch (NoSuchElementException ex) {
+      throw new ComponentConfigurationException(
+          "No attribute " + child.getName() + " exists for " + datatype.name(),
+          ex
+      );
+    }
+  }
+
+  private Optional<Datatype<Object>> datatypeFor(Class<?> cls) {
+    if (cls.isPrimitive() || cls.getClassLoader() == null) {
+      return Optional.empty();
+    }
+
+    // Horrible generic voodoo that probably is not safe, but the APIs have conflicting types
+    // and the compiler is not smart enough to help us.
+    @SuppressWarnings("unchecked")
+    var castCls = (Class<Object>) cls;
+
+    var datatype = knownDatatypes.computeIfAbsent(castCls, ignored -> {
+      var loader = cls.getClassLoader();
+      var outerClsName = cls.getPackageName() + ".Datatypes_" + cls.getSimpleName();
+
+      try {
+        var outerCls = loader.loadClass(outerClsName);
+        var method = outerCls.getMethod("_" + cls.getSimpleName());
+
+        @SuppressWarnings("unchecked")
+        var result = (Datatype<Object>) method.invoke(null);
+
+        return result;
+      } catch (ClassNotFoundException ex) {
+        return null;
+      } catch (ReflectiveOperationException ex) {
+        throw new IllegalStateException(
+            "Failed to find datatype for " + cls.getName() + ": " + ex,
+            ex
+        );
+      }
+    });
+
+    return Optional.ofNullable(datatype);
+  }
+
+  private static Class<?> rawTypeOf(Type type) {
+    return type instanceof ParameterizedType parameterizedType
+        ? rawTypeOf(parameterizedType.getRawType())
+        // Assumption: this cannot ever be a wildcard or union type.
+        : (Class<?>) type;
+  }
+}

protobuf-maven-plugin/src/main/java/io/github/ascopes/protobufmavenplugin/plexus/KindHint.java

@@ -25,6 +25,9 @@
 /**
  * Marker to advise the "kind" of the implementation when used with a sealed-type hierarchy.
  *
+ * <p>When this marker is spotted, the {@code ConverterLookup} will be consulted to produce
+ * an instance of that type.
+ *
  * @author Ashley Scopes
  * @since 4.1.0
  */
@@ -38,20 +41,5 @@
    *
    * @return the kind.
    */
-  String kind();
-
-  /**
-   * The implementation that the kind should point to.
-   *
-   * <p>This is needed until
-   * <a href="https://github.com/ascopes/protobuf-maven-plugin/pull/880">GH-880</a>
-   * can be merged, as we cannot easily infer the immutable implementation class from the base
-   * when working with the Immutables library. GH-880 will enable better integration with that
-   * library based on compile-time metadata that avoids this issue. We may just need to include
-   * this annotation in {@link Style#passAnnotations()} to achieve this correctly closer to the
-   * time.
-   *
-   * @return the implementation type.
-   */
-  Class<?> implementation();
+  String value();
 }

protobuf-maven-plugin/src/main/java/io/github/ascopes/protobufmavenplugin/plexus/SealedTypePlexusConverter.java

@@ -162,11 +162,11 @@ private static Map<String, Class<?>> computeKindMappingFor(Class<?> base) {
           log.trace(
               "Found concrete kind for base \"{}\": \"{}\" will map to \"{}\"",
               base.getName(),
-              kind.kind(),
-              kind.implementation().getName()
+              kind.value(),
+              next.getName()
           );
 
-          mapping.put(kind.kind(), kind.implementation());
+          mapping.put(kind.value(), next);
         }
       }
     }