regarding

Always assume that optionals are not null, i.e. we can always call isPresent() / isEmpty() on an Optional

this looks like a breaking change
see case with jackson + Optional deserialization #3183 (comment)
In this case it is possible that Optional is null and probably could break existing users after update to a new version. Or at least this feature will be unusable for such case.

Is it possible to add config option for mapping like this

i.e. null maps to null always for objects
?

this looks like a breaking change

Breaking change compare to what? Currently we do not have support for optional at all.
Can you provide certain things that work in the moment, but won't keep working?

I personally really dislike using Optional as input parameter and / or a field, IntelliJ even constantly complains about that and in addition to that the Optional javadoc itself says

Optional is primarily intended for use as a method return type where there is a clear need to represent "no result," and where using null is likely to cause errors. A variable whose type is Optional should never itself be null; it should always point to an Optional instance.

see case with jackson + Optional deserialization

This is not because Jackson does that, it's more because Jackson will not invoke the setter if there is nothing in the json.

breaking in terms that mapstruct usually checks source for null. But breaking was a wrong word maybe unexpected/surprising because null check is a boilerplate code and using mapstruct is the main use case for null safe boilerplate mapping code generation.
And I am not sure how it would work with generic mappers for Optional like

@Mapper
public interface OptionalMapper {

    default <E> E unwrapFromOptional(Optional<E> optional) {
        return optional == null
            ? null
            : optional.orElse(null);
    }

    default <E> Optional<E> wrapToOptional(E value) {
        return value == null
            ? null
            : Optional.of(value);
    }
}

I personally really dislike using Optional as input parameter and / or a field

I don't like it either, but ther are a lot of code that used it this way and at least part of the mapstruct users use is it this way and cannot change it due to their API contracts.

This is not because Jackson does that, it's more because Jackson will not invoke the setter if there is nothing in the json.

This is just implementaion detail and the main point is that Optional is used as a container for patch requests. Because Optional is part of the jdk and does not require additional dependencies and because jackson supports such case with Optional out of the box.

An additional use case is cloning objects using mappers that map to the same type, and you want this to be symmetrical, but this is not possible with the null -> Optional.empty() asymmetric approach.

I don't like it either, but ther are a lot of code that used it this way and at least part of the mapstruct users use is it this way and cannot change it due to their API contracts.

If MapStruct users are using this right now it means that they have custom methods where this is being done, this means that this will keep working like that. User defined methods always have a precedence over MapStruct internals.

An additional use case is cloning objects using mappers that map to the same type, and you want this to be symmetrical, but this is not possible with the null -> Optional.empty() asymmetric approach.

That stays the same. Have a look at the OptionalSameTypeMapperImpl in the PR. I generates:

constructorOptionalToOptional = source.getConstructorOptionalToOptional();

When the optional can be directly assigned, it is assigned without a presence check.

And I am not sure how it would work with generic mappers for Optional like

I added some tests like that.

I am not super keen on adding something that only small number of users is going to use, especially if it can be achieved with custom methods. I would actually prefer to try to keep it simple and in the spirit of how optional is supposed to be used without any warnings from the IDE. If I treat Optional as null then IntelliJ gives me a warning about it, same when I use it as a method parameter.

Good job!!!!!