mapstruct · cedricschwyter · Jul 16, 2023 · filiphr · Jul 29, 2023 · filiphr
diff --git a/processor/src/main/java/org/mapstruct/ap/internal/model/AbstractBaseBuilder.java b/processor/src/main/java/org/mapstruct/ap/internal/model/AbstractBaseBuilder.java
@@ -124,7 +124,7 @@ Assignment createForgedAssignment(SourceRHS source, ForgedMethod methodRef, Mapp
     private Assignment createAssignment(SourceRHS source, ForgedMethod methodRef) {
         Assignment assignment = MethodReference.forForgedMethod(
             methodRef,
-            ParameterBinding.fromParameters( methodRef.getParameters() )
+            ParameterBinding.fromParameters( methodRef.getSourceParameters() )
         );
         assignment.setAssignment( source );
 

diff --git a/processor/src/main/java/org/mapstruct/ap/internal/model/BeanMappingMethod.java b/processor/src/main/java/org/mapstruct/ap/internal/model/BeanMappingMethod.java
@@ -467,6 +467,7 @@ private SubclassMapping createSubclassMapping(SubclassMappingOptions subclassMap
                                                sourceType,
                                                targetType,
                                                mappingReferences ) );
+
             String sourceArgument = null;
             for ( Parameter parameter : method.getSourceParameters() ) {
                 if ( ctx
@@ -479,7 +480,19 @@ private SubclassMapping createSubclassMapping(SubclassMappingOptions subclassMap
                     }
                 }
             }
-            return new SubclassMapping( sourceType, sourceArgument, targetType, assignment );
+
+            String targetArgument = null;
+            Parameter targetParameter = method.getMappingTargetParameter();
+            if ( targetParameter != null ) {
+                targetArgument = targetParameter.getName();
+                if ( assignment != null ) {
+                    assignment.setSourceLocalVarName(
+                        "(" + sourceType.createReferenceName() + ") " + sourceArgument
+                            + ", (" + targetType.createReferenceName() + ") " + targetArgument );
+                }
+            }
+
+            return new SubclassMapping( sourceType, sourceArgument, targetType, targetArgument, assignment );
         }
 
         private boolean isAbstractReturnTypeAllowed() {
@@ -1942,6 +1955,10 @@ public boolean hasSubclassMappings() {
         return !subclassMappings.isEmpty();
     }
 
+    public boolean isUpdateMethod() {
+        return Parameter.getMappingTargetParameter( getParameters() ) != null;
+    }
+
     public boolean isAbstractReturnType() {
         return getFactoryMethod() == null && returnTypeToConstruct != null
             && returnTypeToConstruct.isAbstract();

diff --git a/processor/src/main/java/org/mapstruct/ap/internal/model/ForgedMethod.java b/processor/src/main/java/org/mapstruct/ap/internal/model/ForgedMethod.java
@@ -171,6 +171,9 @@ private ForgedMethod(String name, Type sourceType, Type returnType, List<Paramet
         Parameter sourceParameter = new Parameter( sourceParamSafeName, sourceType );
         this.parameters.add( sourceParameter );
         this.parameters.addAll( additionalParameters );
+        if ( basedOn.isUpdateMethod() ) {
+            this.parameters.add( Parameter.forForgedMappingTarget( returnType ) );
+        }
         this.sourceParameters = Parameter.getSourceParameters( parameters );
         this.contextParameters = Parameter.getContextParameters( parameters );
         this.mappingTargetParameter = Parameter.getMappingTargetParameter( parameters );

diff --git a/processor/src/main/java/org/mapstruct/ap/internal/model/SubclassMapping.java b/processor/src/main/java/org/mapstruct/ap/internal/model/SubclassMapping.java
@@ -28,18 +28,24 @@ public class SubclassMapping extends ModelElement {
     private final Type targetType;
     private final Assignment assignment;
     private final String sourceArgument;
+    private final String targetArgument;
 
-    public SubclassMapping(Type sourceType, String sourceArgument, Type targetType, Assignment assignment) {
+    public SubclassMapping( Type sourceType, String sourceArgument, Type targetType, String targetArgument, Assignment assignment ) {
         this.sourceType = sourceType;
         this.sourceArgument = sourceArgument;
         this.targetType = targetType;
+        this.targetArgument = targetArgument;
         this.assignment = assignment;
     }
 
     public Type getSourceType() {
         return sourceType;
     }
 
+    public Type getTargetType() {
+        return targetType;
+    }
+
     @Override
     public Set<Type> getImportTypes() {
         return Collections.singleton( sourceType );
@@ -53,6 +59,10 @@ public String getSourceArgument() {
         return sourceArgument;
     }
 
+    public String getTargetArgument() {
+        return targetArgument;
+    }
+
     @Override
     public boolean equals(final Object other) {
         if ( !( other instanceof SubclassMapping ) ) {

diff --git a/processor/src/main/java/org/mapstruct/ap/internal/model/source/SubclassMappingOptions.java b/processor/src/main/java/org/mapstruct/ap/internal/model/source/SubclassMappingOptions.java
@@ -24,7 +24,6 @@
 
 import static org.mapstruct.ap.internal.util.Message.SUBCLASSMAPPING_ILLEGAL_SUBCLASS;
 import static org.mapstruct.ap.internal.util.Message.SUBCLASSMAPPING_NO_VALID_SUPERCLASS;
-import static org.mapstruct.ap.internal.util.Message.SUBCLASSMAPPING_UPDATE_METHODS_NOT_SUPPORTED;
 
 /**
  * Represents a subclass mapping as configured via {@code @SubclassMapping}.
@@ -58,11 +57,6 @@ private static boolean isConsistent(SubclassMappingGem gem, ExecutableElement me
                                         TypeUtils typeUtils, List<Parameter> sourceParameters, Type resultType,
                                         SubclassValidator subclassValidator) {
 
-        if ( resultType == null ) {
-            messager.printMessage( method, gem.mirror(), SUBCLASSMAPPING_UPDATE_METHODS_NOT_SUPPORTED );
-            return false;
-        }
-
         TypeMirror sourceSubclass = gem.source().getValue();
         TypeMirror targetSubclass = gem.target().getValue();
         TypeMirror targetParentType = resultType.getTypeMirror();

diff --git a/processor/src/main/java/org/mapstruct/ap/internal/processor/MethodRetrievalProcessor.java b/processor/src/main/java/org/mapstruct/ap/internal/processor/MethodRetrievalProcessor.java
@@ -312,7 +312,7 @@ private SourceMethod getMethodRequiringImplementation(ExecutableType methodType,
         SubclassValidator subclassValidator = new SubclassValidator( messager, typeUtils );
         Set<SubclassMappingOptions> subclassMappingOptions = getSubclassMappings(
             sourceParameters,
-            targetParameter != null ? null : resultType,
+            resultType,
             method,
             beanMappingOptions,
             subclassValidator

diff --git a/processor/src/main/java/org/mapstruct/ap/internal/util/Message.java b/processor/src/main/java/org/mapstruct/ap/internal/util/Message.java
@@ -123,7 +123,6 @@ public enum Message {
     SUBCLASSMAPPING_DOUBLE_SOURCE_SUBCLASS( "Subclass '%s' is already defined as a source." ),
     SUBCLASSMAPPING_ILLEGAL_SUBCLASS( "Class '%s' is not a subclass of '%s'." ),
     SUBCLASSMAPPING_NO_VALID_SUPERCLASS( "Could not find a parameter that is a superclass for '%s'." ),
-    SUBCLASSMAPPING_UPDATE_METHODS_NOT_SUPPORTED( "SubclassMapping annotation can not be used for update methods." ),
     SUBCLASSMAPPING_ILLOGICAL_ORDER( "SubclassMapping annotation for '%s' found after '%s', but all '%s' objects are also instances of '%s'.", Diagnostic.Kind.WARNING ),
 
     LIFECYCLEMETHOD_AMBIGUOUS_PARAMETERS( "Lifecycle method has multiple matching parameters (e. g. same type), in this case please ensure to name the parameters in the lifecycle and mapping method identical. This lifecycle method will not be used for the mapping method '%s'.", Diagnostic.Kind.WARNING),

diff --git a/processor/src/main/resources/org/mapstruct/ap/internal/model/BeanMappingMethod.ftl b/processor/src/main/resources/org/mapstruct/ap/internal/model/BeanMappingMethod.ftl
@@ -35,8 +35,12 @@
 
     <#if hasSubclassMappings()>
         <#list subclassMappings as subclass>
-            <#if subclass_index &gt; 0>else</#if> if (${subclass.sourceArgument} instanceof <@includeModel object=subclass.sourceType/>) {
-                <@includeModel object=subclass.assignment existingInstanceMapping=existingInstanceMapping/>
+            <#if isUpdateMethod()>
+                <#if subclass_index &gt; 0>else</#if> if (${subclass.sourceArgument} instanceof <@includeModel object=subclass.sourceType/> && ${subclass.targetArgument} instanceof <@includeModel object=subclass.targetType/>) {
+            <#else>
+                <#if subclass_index &gt; 0>else</#if> if (${subclass.sourceArgument} instanceof <@includeModel object=subclass.sourceType/>) {
+            </#if>
+            <@includeModel object=subclass.assignment existingInstanceMapping=existingInstanceMapping/>
             }
         </#list>
         else {

diff --git a/processor/src/test/java/org/mapstruct/ap/test/subclassmapping/SubclassMappingTest.java b/processor/src/test/java/org/mapstruct/ap/test/subclassmapping/SubclassMappingTest.java
@@ -227,21 +227,11 @@ void subclassMappingInheritsInverseMappingWithCompositeMapping() {
     void subclassOrderWarning() {
     }
 
+    @IssueKey( "2946" )
     @ProcessorTest
-    @WithClasses({ ErroneousSubclassUpdateMapper.class })
-    @ExpectedCompilationOutcome(value = CompilationResult.FAILED, diagnostics = {
-        @Diagnostic(type = ErroneousSubclassUpdateMapper.class,
-            kind = javax.tools.Diagnostic.Kind.ERROR,
-            line = 21,
-            message = "SubclassMapping annotation can not be used for update methods."
-        ),
-        @Diagnostic(type = ErroneousSubclassUpdateMapper.class,
-            kind = javax.tools.Diagnostic.Kind.ERROR,
-            line = 25,
-            message = "SubclassMapping annotation can not be used for update methods."
-        )
-    })
-    void unsupportedUpdateMethod() {
+    @WithClasses({ SubclassUpdateMapper.class })
+    @ExpectedCompilationOutcome(value = CompilationResult.SUCCEEDED)
+    void updateMethod() {
     }
 
     @ProcessorTest

diff --git a/...apping/ErroneousSubclassUpdateMapper.java → ...subclassmapping/SubclassUpdateMapper.java b/...apping/ErroneousSubclassUpdateMapper.java → ...subclassmapping/SubclassUpdateMapper.java
@@ -11,18 +11,15 @@
 import org.mapstruct.SubclassMapping;
 import org.mapstruct.ap.test.subclassmapping.mappables.Car;
 import org.mapstruct.ap.test.subclassmapping.mappables.CarDto;
+import org.mapstruct.ap.test.subclassmapping.mappables.Vehicle;
 import org.mapstruct.ap.test.subclassmapping.mappables.VehicleDto;
 import org.mapstruct.factory.Mappers;
 
 @Mapper
-public interface ErroneousSubclassUpdateMapper {
-    ErroneousSubclassUpdateMapper INSTANCE = Mappers.getMapper( ErroneousSubclassUpdateMapper.class );
+public interface SubclassUpdateMapper {
+    SubclassUpdateMapper INSTANCE = Mappers.getMapper( SubclassUpdateMapper.class );
 
     @SubclassMapping( source = Car.class, target = CarDto.class )
     @Mapping( source = "vehicleManufacturingCompany", target = "maker" )
-    void map(@MappingTarget VehicleDto target, Car vehicle);
-
-    @SubclassMapping( source = Car.class, target = CarDto.class )
-    @Mapping( source = "vehicleManufacturingCompany", target = "maker" )
-    VehicleDto mapWithReturnType(@MappingTarget VehicleDto target, Car vehicle);
+    VehicleDto map(@MappingTarget VehicleDto target, Vehicle vehicle);
 }