#136 Provide references for Mapping#qualifiedByName for used mappers inside @MapperConfig

Author: thunderhook

src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructMappingQualifiedByNameReference.java

@@ -7,6 +7,7 @@
 
 import java.util.Arrays;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -27,6 +28,9 @@
 import static com.intellij.codeInsight.AnnotationUtil.findAnnotation;
 import static com.intellij.codeInsight.AnnotationUtil.getStringAttributeValue;
 import static org.mapstruct.intellij.util.MapstructAnnotationUtils.findReferencedMapperClasses;
+import static org.mapstruct.intellij.util.MapstructUtil.NAMED_ANNOTATION_FQN;
+import static org.mapstruct.intellij.util.MapstructUtil.MAPPER_ANNOTATION_FQN;
+import static org.mapstruct.intellij.util.MapstructUtil.MAPPER_CONFIG_ANNOTATION_FQN;
 import static org.mapstruct.intellij.util.MapstructUtil.asLookupWithRepresentableText;
 
 /**
@@ -67,13 +71,13 @@ PsiElement resolveInternal(@NotNull String value, @NotNull PsiMethod mappingMeth
     @Nullable
     private String getNamedValue(PsiMethod method) {
 
-        PsiAnnotation annotation = findAnnotation( method, true, MapstructUtil.NAMED_ANNOTATION_FQN );
+        PsiAnnotation namedAnnotation = findAnnotation( method, true, NAMED_ANNOTATION_FQN );
 
-        if ( annotation == null ) {
+        if ( namedAnnotation == null ) {
             return null;
         }
 
-        return getStringAttributeValue( annotation, "value" );
+        return getStringAttributeValue( namedAnnotation, "value" );
     }
 
     @NotNull
@@ -116,16 +120,15 @@ private Stream<PsiMethod> findAllNamedMethodsFromThisAndReferencedMappers(@NotNu
     @NotNull
     private Stream<PsiMethod> findNamedMethodsInUsedMappers(@Nullable PsiClass containingClass) {
 
-        PsiAnnotation mapperAnnotation = findAnnotation(
-            containingClass,
-            MapstructUtil.MAPPER_ANNOTATION_FQN
-        );
+        PsiAnnotation mapperOrMapperConfigAnnotation =
+            Optional.ofNullable( findAnnotation( containingClass, MAPPER_ANNOTATION_FQN ) )
+                .orElseGet( () -> findAnnotation( containingClass, MAPPER_CONFIG_ANNOTATION_FQN ) );
 
-        if ( mapperAnnotation == null ) {
+        if ( mapperOrMapperConfigAnnotation == null ) {
             return Stream.empty();
         }
 
-        return findReferencedMapperClasses( mapperAnnotation )
+        return findReferencedMapperClasses( mapperOrMapperConfigAnnotation )
             .flatMap( psiClass -> Arrays.stream( psiClass.getMethods() ) )
             .filter( MapstructUtil::isNamedMethod );
     }

src/test/java/org/mapstruct/intellij/completion/MappingQualifiedByNameCompletionTestCase.java

@@ -70,4 +70,23 @@ private void assertQualifiedByNameLocalAndExternalReferenceAutoComplete() {
             );
     }
 
+    public void testMappingQualifiedByNameInsideMapperConfigCompletion() {
+        configureByTestName();
+        assertQualifiedByNameInsideMapperConfigAutoComplete();
+    }
+
+    private void assertQualifiedByNameInsideMapperConfigAutoComplete() {
+        assertThat( myItems )
+            .extracting( LookupElement::getLookupString )
+            .containsOnly( "unwrapOptional" );
+
+        assertThat( myItems )
+            .extracting( LookupElementPresentation::renderElement )
+            .usingRecursiveFieldByFieldElementComparator()
+            .containsOnly(
+                // methods of mappers from @MapperConfig(uses = ...)
+                createMethod( "unwrapOptional", "T", " OptionalMapper#unwrapOptional(Optional<T>)" )
+            );
+    }
+
 }

testData/completion/qualifiedbyname/MappingQualifiedByNameInsideMapperConfigCompletion.java

@@ -0,0 +1,49 @@
+/*
+ * 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.complex;
+
+import org.example.dto.Car;
+import org.example.dto.CarDto;
+import org.mapstruct.Mapper;
+import org.mapstruct.MapperConfig;
+import org.mapstruct.InheritConfiguration;
+import org.mapstruct.Mapping;
+import org.mapstruct.Named;
+import org.mapstruct.helper.qualifiedbyname.StringMapper;
+import org.mapstruct.helper.qualifiedbyname.OptionalMapper;
+
+@Mapper(config = MapperConfigUsingOptionalMapper.class, uses = StringMapper.class)
+public interface CarMapper {
+
+    @InheritConfiguration
+    CarDto carToCarDto(Car car);
+
+    @Named("doubleSeatCount")
+    default int multiplyByFactor(Double input, int factor) {
+        return (int) (input * 2);
+    }
+
+    @Named("numberToZero")
+    default Long setToZero(int ignore) {
+        return 0L;
+    }
+
+    @Named("someNamedAfterMapping")
+    @AfterMapping
+    default void someNamedAfterMapping(CarDto target) {
+        target.setMake("...");
+    }
+
+}
+
+@MapperConfig(uses = OptionalMapper.class)
+public class MapperConfigUsingOptionalMapper {
+
+    @Mapping(source = "numberOfSeats", target = "seatCount", qualifiedByName = "<caret>")
+    @Mapping(source = "manufacturingDate", target = "manufacturingYear")
+    CarDto carToCarDto(Car car);
+
+}