Is It Possible to Provide an Interface for the `...Builder.With` Interface to Extend?

[adrian-tavve]

I don't believe this is the same ask as #211

I have a base interface for a group of record classes. One of the things this accomplishes is providing a type for specific with*() methods that should be common to every subclass:

interface CommonWithers {

  public CommonWithers withId(int id);
}

@RecordBuilder
record Foo(int id, Foo foo) implements CommonWithers, FooBuilder.With {}

However, this doesn't compile. The FooBuilder.With.withId(int) method doesn't satisfy the CommonWithers.withId(int) requirement - even though copy+pasting that generated method into Foo does satisfy it.

What I'm looking for is a way to make FooBuilder.With extend CommonWithers, so its default method can satisfy the interface. Something similar to:

@RecordBuilder
@RecordBuilder.Options( withExtendsInterface = CommonWithers.class )
record Foo(int id, Foo foo) implements FooBuilder.With {}

which would generate a With interface like

public class FooBuilder {

  //  . . .

  public interface With extends CommonWithers {

    default Foo withId(int id) {
      //  . . .

[Randgalt]

CommonWithers has a base return type though. What's the purpose of this? You would have a set of methods that take CommonWithers? I can't think of a reason why that's useful. Can you give a larger example?

[adrian-tavve]

all of these records will have common component(s), and yes, i need an interface to type against that allows me to with() those components. declaring the accessor method (e.g., int id()) on the interface works fine, but the return type is covariant (i.e., the interface type vs. the concrete record type).

using one interface (that extends the other) instead of using both interfaces does solve this, but I can't find a way to make the annotation processor do that.

[Randgalt]

This seems like a very specific case for you and is not general enough for a library. This library is already very complex with a lot of options. If we get other requests for this, then we could consider it. So, try to get others to request this. I'll leave the issue open.

[adrian-tavve]

This seems like a very specific case

I disagree - without some solution to this issue, the With interfaces are useful only for their defaults. there's no way to operate on "any type with with{something}()." you're forced to write code that accounts for every possible concrete type instead, which is the problem interfaces are actually meant to deal with.

I realize the library is already complex, but adding an option to define an interface to extend is minimally complex and easily solves a significant issue.

[Randgalt]

Just to explore doing this with code... it can be done with Java's Dynamic proxy mechanism with some minor changes. The CommonWithers need to have an alternate name. Something like:

interface CommonWithers {
  CommonWithers withCommonId(int id);

  CommonWithers withCommonName(String name);
}

Then, you create a factory:

public class CommonBuilder {
    private static final Map<Method, Method> methodCache = new ConcurrentHashMap<>();

    private CommonBuilder() {}

    public static <T>T of(Class<T> iface, Object instance) {
        return of(CommonBuilder.class.getClassLoader(), iface, instance);
    }

    @SuppressWarnings("unchecked")
    public static <T> T of(ClassLoader classLoader, Class<T> iface, Object instance) {
        InvocationHandler invocationHandler = (proxy, method, args) -> {
            Method instanceMethod = methodCache.computeIfAbsent(method, ignore -> findMethodOnInstance(method, instance));
            return instanceMethod.invoke(instance, args);
        };
        return (T) Proxy.newProxyInstance(classLoader, new Class[] { iface }, invocationHandler);
    }

    // find the corresponding method in the Wither interface
    private static Method findMethodOnInstance(Method method, Object instance) {
        try {
             // this needs some fine tuning
            return instance.getClass().getMethod(method.getName().replace("withCommon", "with"), method.getParameterTypes());
        } catch (NoSuchMethodException e) {
            // TODO
            throw new RuntimeException(e);
        }
    }
}

CommonWithers gets re-written as:

interface CommonWithers {
  default CommonWithers withCommonId(int id) {
        // the "withCommonId()" gets handled by the proxy which calls the Wither `withId` instead
        return CommonBuilder.of(CommonWithers.class, this). withCommonId(id);
  }

  default CommonWithers withCommonName(String name) {
        // the "withCommonId()" gets handled by the proxy which calls the Wither `withName` instead
        return CommonBuilder.of(CommonWithers.class, this). withCommonName(name);
  }
}

Then, you can have a record:

@RecordBuilder
public record MyRecord(int id, String name) implements MyRecord.With, CommonWithers
{
}

Now, you can do what you need:

MyRecord myRecord = new  MyRecord(1, "one");
CommonWithers asCommon = myRecord;
MyRecord changedRecord = (MyRecord) asCommon.withCommonId(2).withCommonName("two);

You could cache the proxy too as an optimization.

[adrian-tavve]

thanks for the idea 👍

[j-bernard]

I think a solution to #211 would also solve your issue.
You need an interface for the with*() methods. An interface on the Builder class would provide you the same capability through object.with(). Rather than object.withId(myId) you'd do object.with().id(myId) and your interface would contain the id(int id) method.