Rewrite trailing setters and field setters as mapper.rebuild() chains

[steve-aom-elliott]

Summary

MigrateMapperSettersToBuilder previously left mapper.rebuild()...build() TODO comments on any setter it couldn't fold into a Mapper.builder()...build() chain, and silently skipped setters whose receiver was a field access (this.mapper.setX(...)).

This PR rewrites those setters as receiver = receiver.rebuild().<builderName>(args).build(); when the receiver is safely reassignable:

• a non-final local declared in an enclosing block — method parameters are excluded because reassignment silently drops the caller's expected mutation
• a J.FieldAccess with an identifier target and a non-final field

A doAfterVisit post-pass coalesces consecutive per-receiver rebuild assignments into a single chained .rebuild()....build(), so a run of N setters becomes one assignment rather than N.

Before

class A {
    JsonMapper create() {
        JsonMapper mapper = new JsonMapper();
        mapper.disable(SerializationFeature.INDENT_OUTPUT);
        System.out.println(mapper);
        mapper.enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        return mapper;
    }
}

The enable(...) call was left with a TODO because it fell outside the contiguous run following new JsonMapper(). A field-scoped variant like this.mapper.setX(...) produced no rewrite and no TODO at all.

After

class A {
    JsonMapper create() {
        JsonMapper mapper = JsonMapper.builder()
                .disable(SerializationFeature.INDENT_OUTPUT)
                .build();
        System.out.println(mapper);
        mapper = mapper.rebuild()
                .enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
                .build();
        return mapper;
    }
}

And, newly covered, the this.mapper.setX(...) shape:

class A {
    private JsonMapper mapper = new JsonMapper();

    void configure() {
        this.mapper = this.mapper.rebuild()
                .disable(SerializationFeature.INDENT_OUTPUT)
                .enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
                .build();
    }
}

How

• Extend the guard in visitMethodInvocation to accept J.FieldAccess selects with a J.Identifier target, so field-shape setters are considered rather than silently dropped.
• Add rewriteAsRebuildAssignment to build a JavaTemplate producing one <lhs> = <lhs>.rebuild().<builderName>(args).build() assignment per setter, applied at the setter's own coordinate — invoked before the TODO fallback when the receiver is reassignable.
• Add coalesceRebuildAssignments as a doAfterVisit post-pass. Purely tree surgery (no template): it walks each block, parses consecutive <lhs> = <lhs>.rebuild()....build(); statements via tryParseRebuildAssignment, and if their LHSs are SemanticallyEqual, rewires the chain calls into one shared .rebuild() + .build().
• Add rebuild() to mapperStub so the JavaTemplate parser resolves it against the Jackson 2 classpath used for template stubs.

Method parameters, final fields, and receivers behind a method chain still get the existing TODO comment.

Test plan

• ./gradlew test — all tests pass, including five new cases under @Nested class RewriteAsRebuild:
  • trailingSetterAfterGapOnLocal — one straggler after a gap becomes a rebuild() assignment.
  • trailingSettersCoalesceIntoOneRebuildChain — multiple stragglers coalesce into one chain.
  • thisFieldSetterCoalescesIntoRebuild — this.mapper.setX(...) rewrites and coalesces.
  • qualifiedFieldSetterRewritten — holder.mapper.setX(...) rewrites.
  • finalFieldStillGetsTodoComment — final field left with TODO (no rewrite).
• The existing CommentFallback.mapperFromParameter still leaves the TODO comment (parameters intentionally excluded).

[sambsnyd]

I wonder if we should have a Reassignable trait or something like it. There must be quite a few recipes which must ask a variation on this question.

[steve-aom-elliott]

I can kick something off to try making one that would live in openrewrite/rewrite, as I feel that's likely a more appropriate place for it to live. Later on we could refactor this to use that trait instead?

[steve-aom-elliott]

@sambsnyd You can see the initial pass of this here:

• Add Reassignable trait rewrite#8175