Determine the builder class for a FreeBuilder type without the need of a static method in the type

[lionel-bartel]

Expected behavior

When I use a FreeBuilder interface/abstract class as a target of a mapper, I expect mapstruct to use the builder to construct the instance of that interface/abstract class.

Actual behavior

At compilation, I get the message

Ambiguous factory methods found for creating Target: Target Builder.build(), Target Builder.buildPartial(). See https://mapstruct.org/faq/#ambiguous for more info.

even though I use @Builder to specify the build method in @Mapper or in @BeanMapping.

Steps to reproduce the problem

I define my source and target class

public class Source {

    private String value1;

    private int value2;

    public String getValue1() {
        return value1;
    }
    public void setValue1(String value1) {
        this.value1 = value1;
    }
    public int getValue2() {
        return value2;
    }
    public void setValue2(int value2) {
        this.value2 = value2;
    }
}

@FreeBuilder
public interface Target {

    String getValue1();

    int getValue2();

    class Builder extends Target_Builder {
    }

}

and the mapper

import org.mapstruct.Mapper;

//@Mapper(uses = Target.Builder.class, builder = @Builder(buildMethod = "buildPartial"))
//@Mapper(uses = Target.Builder.class, builder = @Builder(buildMethod = "build"))
//@Mapper(uses = Target.Builder.class, builder = @Builder)
@Mapper(uses = Target.Builder.class)
public interface ExampleMapper {

    //    @BeanMapping(builder = @Builder(buildMethod = "buildPartial"))
//    @BeanMapping(builder = @Builder(buildMethod = "build"))
//    @BeanMapping(builder = @Builder)
    Target apply(Source source);

}

with POM containing

    <properties>
        <freebuilder.version>2.8.0</freebuilder.version>
        <mapstruct.version>1.5.5.Final</mapstruct.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
            <version>${mapstruct.version}</version>
        </dependency>
        <dependency>
            <groupId>org.inferred</groupId>
            <artifactId>freebuilder</artifactId>
            <version>${freebuilder.version}</version>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.mapstruct</groupId>
                            <artifactId>mapstruct-processor</artifactId>
                            <version>${mapstruct.version}</version>
                        </path>
                        <path>
                            <groupId>org.inferred</groupId>
                            <artifactId>freebuilder</artifactId>
                            <version>${freebuilder.version}</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
        </plugins>
    </build>

Then run maven compile.

I attached a minimal project:
mapstruct-freebuilder.zip

MapStruct Version

MapStruct 1.5.5.Final

[filiphr]

@lionel-bartel is this buildPartial something new from FreeBuilder? We have some integration tests with FreeBuilder 1.14.6

[thunderhook]

Seems like a new feature that comes with 2.3: https://github.com/inferred/FreeBuilder#23from-method-testability

[filiphr]

Thanks @thunderhook. I had a deeper look and it seems like the buildPartial is there in the version we are using for testing as well. The problem is actually in the use of Mapper#uses. When the builder is given in that class then we are going to look for an implicit object factory method and use that to create an instance that we then need to map.

If I copy the FreeBuilder implementation, remove FreeBuilder and remove the buildPartial then I get code like:

public class ExampleMapperImpl implements ExampleMapper {

    private final Target.Builder builder = new Target.Builder();

    @Override
    public Target apply(Source source) {
        if ( source == null ) {
            return null;
        }

        Target target = builder.build();

        return target;
    }
}

Which of course is not valid. If we also look at the error we would see that it complains about ambiguous factory method, I missed that earlier.

In order to make this work we need to provide a static method in the type that would give us an instance of the builder. So if our Target looks like:

@FreeBuilder
public interface Target {

    String getValue1();

    int getValue2();

    static Builder builder() {
        return new Builder();
    }

    class Builder extends Target_Builder {
    }

}

The mapper will then look like:

@Mapper
public interface ExampleMapper {

    Target apply(Source source);

}

and the implementation then looks like:

public class ExampleMapperImpl implements ExampleMapper {

    @Override
    public Target apply(Source source) {
        if ( source == null ) {
            return null;
        }

        Target.Builder target = Target.builder();

        target.setValue1( source.getValue1() );
        target.setValue2( source.getValue2() );

        return target.build();
    }
}

What we can do is to enhance our FreeBuilder support to be similar to the immutables and look up the right builder class and the implementation of it, e.g. by looking up the enclosing (childen) elements of the type that should be build and try to determine the builder method (the constructor of it) through there. However, this would be something that I am going to leave to the community in case someone is interested in providing a contribution for it

[lionel-bartel]

Hello, thank you for looking into it, and thanks to @thunderhook who answered the question :)