Intellij warning: Return value of the method is never used

Question

I have some code that seems OK, but Intellij IDEA warns about many of its methods that return values that

Return value of the method is never used

---

Here is the actual code below, a builder class.

public static class StreamParserBuilder{
    //optional - have defaults:
    private long spanLimit1 = 2000L;
    private long spanLimit2 = 100000L;
    private long spanLimit3 = 3000000L;
    private String[] coordinates = {"L1", "R2"};
    private String outputDirectory = System.getProperty("user.dir");
    private boolean isLastSteam = false;

    //required from the builder.
    private String[] args;
    private String inputFile;
    private String streamData;
    private boolean isPaired;

    public StreamParserBuilder(String[] args, String inputFile, String streamData, boolean isPaired){
        this.args = args;
        this.inputFile = inputFile;
        this.streamData = streamData;
        this.isPaired = isPaired;
    }

    public StreamParserBuilder withSpanLimit1(long spanLimit1){
        this.spanLimit1 = spanLimit1;
        return this;
    }

    public StreamParserBuilder withSpanLimit2(long spanLimit2){
        this.spanLimit2 = spanLimit2;
        return this;
    }

    public StreamParserBuilder withSpanLimit3(long spanLimit3){
        this.spanLimit3 = spanLimit3;
        return this;
    }

    public StreamParserBuilder withCoordinates(String[] coordinates){
        this.coordinates = coordinates;
        return this;
    }

    public StreamParserBuilder withOutputDirectory(String outputDirectory){
        this.outputDirectory = outputDirectory;
        return this;
    }

    public StreamParserBuilder isLastStream(boolean isLastSteam){
        this.isLastSteam = isLastSteam;
        return this;
    }

    public StreamParser build(){
        return new StreamParser(this);
    }

Is there an issue with the code, maybe i've instantiated the .build() method incorrectly? The code for my StreamParser constructor:

private StreamParser(StreamParserBuilder streamParserBuilder){
    this.args = streamParserBuilder.args;
    this.inputFile = streamParserBuilder.inputFile;
    this.streamData = streamParserBuilder.streamData;
    this.spanLimit1 = streamParserBuilder.spanLimit1;
    this.spanLimit2 = streamParserBuilder.spanLimit2;
    this.spanLimit3 = streamParserBuilder.spanLimit3;
    this.coordinates = streamParserBuilder.coordinates;
    this.outputDirectory = streamParserBuilder.outputDirectory;
    this.isLastStream = streamParserBuilder.isLastSteam;
    this.isPaired = streamParserBuilder.isPaired;
}

Is there a better way to implement this? If the code is okay, what causes this warning?

Edit: Usage of the StreamParserBuilder, calling the withX functions:

 StreamParserBuilder streamBuilder = new StreamParserBuilder(args, inputFile, stream, isPaired);
        if (isSpanOneReplaced) streamBuilder.withSpanLimit1(spanLimit1);
        if (isSpanTwoReplaced) streamBuilder.withSpanLimit2(spanLimit2);
        if (isSpanThreeReplaced) streamBuilder.withSpanLimit3(spanLimit3);
        if (areCoordinatesReplaced) streamBuilder.withCoordinates(coordinates);
        if (isOutputDirectoryReplaced) streamBuilder.withOutputDirectory(outputDirectory);
        if (streamCount == streamData.size()) streamBuilder.isLastStream(true);
        StreamParser streamParser = streamBuilder.build();

Answer 1

"Return value of the method is never used" is a warning from the Java | Declaration redundancy | Method can be void inspection. This warning is generated because the value returned by this method is never used at the call site. It's possible to ignore the warning by annotating the class with @SuppressWarnings("UnusedReturnValue") or disabling the inspection in Settings | Editor | Inspections.

Answer 2

In your example, you don't really benefit from the builder pattern. If it's rare use case, I'd just let it be, and ignore the warnings. But if it's frequent, it might be beneficial to include conditional assignment directly to your builder. So you may write either:

streamBuilder.conditionallyWithSpanLimit1(isSpanOneReplaced, spanLimit1)
    .conditionallyWithSpanLimit2(isSpanTwoReplaced, spanLimit2)
    // etc.

That would mean to duplicate all builder methods.

Or you can introduce fluent preposition:

streamBuilder.when(isSpanOneReplaced).setSpanLimit1(spanLimit1)

Implementation of this would be extremely simple, if your builder is interface.

public interface Builder {
    Builder setSpanLimit1(int value);
    Builder when(boolean condition);
    Object build();
}

Your when() method can return a proxy bypasing following method call, if it's not build() and returning back the oeiginal builder.

Answer 3

The reason the with methods of a builder return this; is so method calls can be chained:

StreamParserBuilder streamBuilder = new StreamParserBuilder(args, inputFile, stream, isPaired)
    .withSpanLimit1(spanLimit1)
    .withSpanLimit2(spanLimit2)
    .withSpanLimit3(spanLimit3);

In your case, you're ignoring the returned value in your calling code:

// returns StreamBuilderParses, which you're ignoring
if (isSpanOneReplaced) streamBuilder.withSpanLimit1(spanLimit1);

Answer 4

As I have found, Intellij IDEA gives this warning for public methods, which is questionable, because a public (or protected) method could be called from other packages that Intellij IDEA has not included in its analysis, and that is the likely case if you are writing a library (JAR) for use by other projects.

Fortunately, configuring Settings > Editor > Inspections to disable the Java > Declaration redundancy > Method can be void inspection is not the only fix. That inspection can alternatively be configured with an option of Maximal reported method visibility changed from Public to Package-private.