third_codes/mapstruct
1
0
Fork 0
mirror of https://github.com/mapstruct/mapstruct.git synced 2025-07-12 00:00:08 +08:00
Code Issues Packages Projects Releases Wiki Activity

Feature/2663 (#3007)

Browse Source 
#2663 Fix for 2-step mapping with generics.

---------

Co-authored-by: Ben Zegveld <Ben.Zegveld@gmail.com>
This commit is contained in:
Zegveld 2023-08-04 10:14:53 +02:00 committed by GitHub
parent 812faeef51
commit 721288140a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 390 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
processor/src/main/java/org/mapstruct/ap/internal/model/common/Type.java
View File

@ -605,6 +605,21 @@ public class Type extends ModelElement implements Comparable<Type> {
);
}
private Type replaceGeneric(Type oldGenericType, Type newType) {
if ( !typeParameters.contains( oldGenericType ) || newType == null ) {
return this;
}
newType = newType.getBoxedEquivalent();
TypeMirror[] replacedTypeMirrors = new TypeMirror[typeParameters.size()];
for ( int i = 0; i < typeParameters.size(); i++ ) {
Type typeParameter = typeParameters.get( i );
replacedTypeMirrors[i] =
typeParameter.equals( oldGenericType ) ? newType.typeMirror : typeParameter.typeMirror;
}
return typeFactory.getType( typeUtils.getDeclaredType( typeElement, replacedTypeMirrors ) );
}
/**
* Whether this type is assignable to the given other type, considering the "extends / upper bounds"
* as well.
@ -1377,9 +1392,9 @@ public class Type extends ModelElement implements Comparable<Type> {
/**
* Steps through the declaredType in order to find a match for this typeVar Type. It aligns with
* the provided parameterized type where this typeVar type is used.
*
* For example:
* the provided parameterized type where this typeVar type is used.<br>
* <br>
* For example:<pre>
* {@code
* this: T
* declaredType: JAXBElement<String>
@ -1392,12 +1407,13 @@ public class Type extends ModelElement implements Comparable<Type> {
* parameterizedType: Callable<BigDecimal>
* return: BigDecimal
* }
* </pre>
*
* @param declared the type
* @param parameterized the parameterized type
*
* @return - the same type when this is not a type var in the broadest sense (T, T[], or ? extends T)
* - the matching parameter in the parameterized type when this is a type var when found
* @return - the same type when this is not a type var in the broadest sense (T, T[], or ? extends T)<br>
* - the matching parameter in the parameterized type when this is a type var when found<br>
* - null in all other cases
*/
public ResolvedPair resolveParameterToType(Type declared, Type parameterized) {
@ -1408,6 +1424,96 @@ public class Type extends ModelElement implements Comparable<Type> {
return new ResolvedPair( this, this );
}
/**
* Resolves generic types using the declared and parameterized types as input.<br>
* <br>
* For example:
* <pre>
* {@code
* this: T
* declaredType: JAXBElement<T>
* parameterizedType: JAXBElement<Integer>
* result: Integer
*
* this: List<T>
* declaredType: JAXBElement<T>
* parameterizedType: JAXBElement<Integer>
* result: List<Integer>
*
* this: List<? extends T>
* declaredType: JAXBElement<? extends T>
* parameterizedType: JAXBElement<BigDecimal>
* result: List<BigDecimal>
*
* this: List<Optional<T>>
* declaredType: JAXBElement<T>
* parameterizedType: JAXBElement<BigDecimal>
* result: List<Optional<BigDecimal>>
* }
* </pre>
* It also works for partial matching.<br>
* <br>
* For example:
* <pre>
* {@code
* this: Map<K, V>
* declaredType: JAXBElement<K>
* parameterizedType: JAXBElement<BigDecimal>
* result: Map<BigDecimal, V>
* }
* </pre>
* It also works with multiple parameters at both sides.<br>
* <br>
* For example when reversing Key/Value for a Map:
* <pre>
* {@code
* this: Map<KEY, VALUE>
* declaredType: HashMap<VALUE, KEY>
* parameterizedType: HashMap<BigDecimal, String>
* result: Map<String, BigDecimal>
* }
* </pre>
*
* Mismatch result examples:
* <pre>
* {@code
* this: T
* declaredType: JAXBElement<Y>
* parameterizedType: JAXBElement<Integer>
* result: null
*
* this: List<T>
* declaredType: JAXBElement<Y>
* parameterizedType: JAXBElement<Integer>
* result: List<T>
* }
* </pre>
*
* @param declared the type
* @param parameterized the parameterized type
*
* @return - the result of {@link #resolveParameterToType(Type, Type)} when this type itself is a type var.<br>
* - the type but then with the matching type parameters replaced.<br>
* - the same type when this type does not contain matching type parameters.
*/
public Type resolveGenericTypeParameters(Type declared, Type parameterized) {
if ( isTypeVar() || isArrayTypeVar() || isWildCardBoundByTypeVar() ) {
return resolveParameterToType( declared, parameterized ).getMatch();
}
Type resultType = this;
for ( Type generic : getTypeParameters() ) {
if ( generic.isTypeVar() || generic.isArrayTypeVar() || generic.isWildCardBoundByTypeVar() ) {
ResolvedPair resolveParameterToType = generic.resolveParameterToType( declared, parameterized );
resultType = resultType.replaceGeneric( generic, resolveParameterToType.getMatch() );
}
else {
Type replacementType = generic.resolveParameterToType( declared, parameterized ).getMatch();
resultType = resultType.replaceGeneric( generic, replacementType );
}
}
return resultType;
}
public boolean isWildCardBoundByTypeVar() {
return ( hasExtendsBound() || hasSuperBound() ) && getTypeBound().isTypeVar();
}

2
processor/src/main/java/org/mapstruct/ap/internal/processor/creation/MappingResolverImpl.java
View File

@ -825,7 +825,7 @@ public class MappingResolverImpl implements MappingResolver {
for ( T2 yCandidate : yMethods ) {
Type ySourceType = yCandidate.getMappingSourceType();
ySourceType = ySourceType.resolveParameterToType( targetType, yCandidate.getResultType() ).getMatch();
ySourceType = ySourceType.resolveGenericTypeParameters( targetType, yCandidate.getResultType() );
Type yTargetType = yCandidate.getResultType();
if ( ySourceType == null
|| !yTargetType.isRawAssignableTo( targetType )

31
processor/src/test/java/org/mapstruct/ap/test/bugs/_2663/Issue2663Mapper.java Normal file
View File

@ -0,0 +1,31 @@
/*
* Copyright MapStruct Authors.
*
* Licensed under the Apache License version 2.0, available at http://www.apache.org/licenses/LICENSE-2.0
*/
package org.mapstruct.ap.test.bugs._2663;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
/**
* @author Filip Hrisafov
*/
@Mapper( uses = NullableHelper.class )
public interface Issue2663Mapper {
Issue2663Mapper INSTANCE = Mappers.getMapper( Issue2663Mapper.class );
Request map(RequestDto dto);
default JsonNullable<Request.ChildRequest> mapJsonNullableChildren(JsonNullable<RequestDto.ChildRequestDto> dtos) {
if ( dtos.isPresent() ) {
return JsonNullable.of( mapChild( dtos.get() ) );
}
else {
return JsonNullable.undefined();
}
}
Request.ChildRequest mapChild(RequestDto.ChildRequestDto dto);
}

47
processor/src/test/java/org/mapstruct/ap/test/bugs/_2663/Issue2663Test.java Normal file
View File

@ -0,0 +1,47 @@
/*
* Copyright MapStruct Authors.
*
* Licensed under the Apache License version 2.0, available at http://www.apache.org/licenses/LICENSE-2.0
*/
package org.mapstruct.ap.test.bugs._2663;
import org.mapstruct.ap.testutil.IssueKey;
import org.mapstruct.ap.testutil.ProcessorTest;
import org.mapstruct.ap.testutil.WithClasses;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Filip Hrisafov
*/
@IssueKey( "2663" )
@WithClasses({
Issue2663Mapper.class,
JsonNullable.class,
Nullable.class,
NullableHelper.class,
Request.class,
RequestDto.class
})
public class Issue2663Test {
@ProcessorTest
public void shouldUnpackGenericsCorrectly() {
RequestDto dto = new RequestDto();
dto.setName( JsonNullable.of( "Tester" ) );
Request request = Issue2663Mapper.INSTANCE.map( dto );
assertThat( request.getName() )
.extracting( Nullable::get )
.isEqualTo( "Tester" );
dto.setName( JsonNullable.undefined() );
request = Issue2663Mapper.INSTANCE.map( dto );
assertThat( request.getName() )
.extracting( Nullable::isPresent )
.isEqualTo( false );
}
}

44
processor/src/test/java/org/mapstruct/ap/test/bugs/_2663/JsonNullable.java Normal file
View File

@ -0,0 +1,44 @@
/*
* Copyright MapStruct Authors.
*
* Licensed under the Apache License version 2.0, available at http://www.apache.org/licenses/LICENSE-2.0
*/
package org.mapstruct.ap.test.bugs._2663;
import java.util.NoSuchElementException;
/**
* @author Filip Hrisafov
*/
public class JsonNullable<T> {
private static final JsonNullable<?> UNDEFINED = new JsonNullable<>( null, false );
private final T value;
private final boolean present;
private JsonNullable(T value, boolean present) {
this.value = value;
this.present = present;
}
public T get() {
if (!present) {
throw new NoSuchElementException("Value is undefined");
}
return value;
}
public boolean isPresent() {
return present;
}
@SuppressWarnings("unchecked")
public static <T> JsonNullable<T> undefined() {
return (JsonNullable<T>) UNDEFINED;
}
public static <T> JsonNullable<T> of(T value) {
return new JsonNullable<>( value, true );
}
}

45
processor/src/test/java/org/mapstruct/ap/test/bugs/_2663/Nullable.java Normal file
View File

@ -0,0 +1,45 @@
/*
* Copyright MapStruct Authors.
*
* Licensed under the Apache License version 2.0, available at http://www.apache.org/licenses/LICENSE-2.0
*/
package org.mapstruct.ap.test.bugs._2663;
import java.util.NoSuchElementException;
/**
* @author Filip Hrisafov
*/
public class Nullable<T> {
@SuppressWarnings("rawtypes")
private static final Nullable UNDEFINED = new Nullable<>( null, false );
private final T value;
private final boolean present;
private Nullable(T value, boolean present) {
this.value = value;
this.present = present;
}
public T get() {
if (!present) {
throw new NoSuchElementException("Value is undefined");
}
return value;
}
public boolean isPresent() {
return present;
}
public static <T> Nullable<T> of(T value) {
return new Nullable<>( value, true );
}
@SuppressWarnings("unchecked")
public static <T> Nullable<T> undefined() {
return (Nullable<T>) UNDEFINED;
}
}

23
processor/src/test/java/org/mapstruct/ap/test/bugs/_2663/NullableHelper.java Normal file
View File

@ -0,0 +1,23 @@
/*
* Copyright MapStruct Authors.
*
* Licensed under the Apache License version 2.0, available at http://www.apache.org/licenses/LICENSE-2.0
*/
package org.mapstruct.ap.test.bugs._2663;
/**
* @author Filip Hrisafov
*/
public class NullableHelper {
private NullableHelper() {
// Helper class
}
public static <T> Nullable<T> jsonNullableToNullable(JsonNullable<T> jsonNullable) {
if ( jsonNullable.isPresent() ) {
return Nullable.of( jsonNullable.get() );
}
return Nullable.undefined();
}
}

44
processor/src/test/java/org/mapstruct/ap/test/bugs/_2663/Request.java Normal file
View File

@ -0,0 +1,44 @@
/*
* Copyright MapStruct Authors.
*
* Licensed under the Apache License version 2.0, available at http://www.apache.org/licenses/LICENSE-2.0
*/
package org.mapstruct.ap.test.bugs._2663;
/**
* @author Filip Hrisafov
*/
public class Request {
private Nullable<String> name = Nullable.undefined();
private Nullable<ChildRequest> child = Nullable.undefined();
public Nullable<String> getName() {
return name;
}
public void setName(Nullable<String> name) {
this.name = name;
}
public Nullable<ChildRequest> getChild() {
return child;
}
public void setChild(Nullable<ChildRequest> child) {
this.child = child;
}
public static class ChildRequest {
private Nullable<String> name = Nullable.undefined();
public Nullable<String> getName() {
return name;
}
public void setName(Nullable<String> name) {
this.name = name;
}
}
}

44
processor/src/test/java/org/mapstruct/ap/test/bugs/_2663/RequestDto.java Normal file
View File

@ -0,0 +1,44 @@
/*
* Copyright MapStruct Authors.
*
* Licensed under the Apache License version 2.0, available at http://www.apache.org/licenses/LICENSE-2.0
*/
package org.mapstruct.ap.test.bugs._2663;
/**
* @author Filip Hrisafov
*/
public class RequestDto {
private JsonNullable<String> name = JsonNullable.undefined();
private JsonNullable<ChildRequestDto> child = JsonNullable.undefined();
public JsonNullable<String> getName() {
return name;
}
public void setName(JsonNullable<String> name) {
this.name = name;
}
public JsonNullable<ChildRequestDto> getChild() {
return child;
}
public void setChild(JsonNullable<ChildRequestDto> child) {
this.child = child;
}
public static class ChildRequestDto {
private JsonNullable<String> name = JsonNullable.undefined();
public JsonNullable<String> getName() {
return name;
}
public void setName(JsonNullable<String> name) {
this.name = name;
}
}
}