Use target properties from meta annotations when looking for unmapped target properties

Fixes #49

Author: filiphr

change-notes.html

@@ -2,6 +2,7 @@
 <h2>1.2.1</h2>
 <ul>
     <li>Support code completion in Mapping#expression and Mapping#defaultExpression</li>
+    <li>Support meta annotations for when looking for unmapped target properties</li>
     <li>Bug fix: public static fields / methods should not be considered as unmapped properties or resolved in auto completion</li>
 </ul>
 <h2>1.2.0</h2>

src/main/java/org/mapstruct/intellij/inspection/UnmappedTargetPropertiesInspection.java

@@ -77,7 +77,7 @@ public void visitMethod(PsiMethod method) {
             Set<String> allTargetProperties = findAllTargetProperties( targetType, mapStructVersion );
 
             // find and remove all defined mapping targets
-            Set<String> definedTargets = TargetUtils.findAllDefinedMappingTargets( method )
+            Set<String> definedTargets = TargetUtils.findAllDefinedMappingTargets( method, mapStructVersion )
                 .collect( Collectors.toSet() );
             allTargetProperties.removeAll( definedTargets );
 

src/main/java/org/mapstruct/intellij/util/TargetUtils.java

@@ -18,9 +18,10 @@
 import java.util.Set;
 import java.util.stream.Stream;
 
+import com.intellij.codeInsight.AnnotationUtil;
+import com.intellij.codeInsight.MetaAnnotationUtil;
 import com.intellij.lang.jvm.JvmModifier;
 import com.intellij.openapi.util.Pair;
-import com.intellij.psi.ElementManipulators;
 import com.intellij.psi.PsiAnnotation;
 import com.intellij.psi.PsiAnnotationMemberValue;
 import com.intellij.psi.PsiArrayInitializerMemberValue;
@@ -311,18 +312,16 @@ private static boolean hasBuildMethod(@Nullable PsiType builderType, @NotNull Ps
      * Find all defined {@link org.mapstruct.Mapping#target()} for the given method
      *
      * @param method that needs to be checked
+     * @param mapStructVersion the MapStruct project version
      *
      * @return see description
      */
-    public static Stream<String> findAllDefinedMappingTargets(@NotNull PsiMethod method) {
+    public static Stream<String> findAllDefinedMappingTargets(@NotNull PsiMethod method,
+        MapStructVersion mapStructVersion) {
         //TODO cache
         PsiAnnotation mappings = findAnnotation( method, true, MapstructUtil.MAPPINGS_ANNOTATION_FQN );
-        Stream<PsiAnnotation> mappingsAnnotations;
-        if ( mappings == null ) {
-            mappingsAnnotations = Stream.of( method.getModifierList().getAnnotations() )
-                .filter( TargetUtils::isMappingAnnotation );
-        }
-        else {
+        Stream<PsiAnnotation> mappingsAnnotations = Stream.empty();
+        if ( mappings != null ) {
             //TODO maybe there is a better way to do this, but currently I don't have that much knowledge
             PsiNameValuePair mappingsValue = findDeclaredAttribute( mappings, null );
             if ( mappingsValue != null && mappingsValue.getValue() instanceof PsiArrayInitializerMemberValue ) {
@@ -334,18 +333,26 @@ public static Stream<String> findAllDefinedMappingTargets(@NotNull PsiMethod met
             else if ( mappingsValue != null && mappingsValue.getValue() instanceof PsiAnnotation ) {
                 mappingsAnnotations = Stream.of( (PsiAnnotation) mappingsValue.getValue() );
             }
-            else {
-                mappingsAnnotations = Stream.empty();
-            }
         }
 
-        return mappingsAnnotations
-            .map( psiAnnotation -> psiAnnotation.findDeclaredAttributeValue( "target" ) )
+        Stream<PsiAnnotation> mappingAnnotations = findMappingAnnotations( method, mapStructVersion );
+
+        return Stream.concat( mappingAnnotations, mappingsAnnotations )
+            .map( psiAnnotation -> AnnotationUtil.getDeclaredStringAttributeValue( psiAnnotation, "target" ) )
             .filter( Objects::nonNull )
-            .map( ElementManipulators::getValueText )
             .filter( s -> !s.isEmpty() );
     }
 
+    private static Stream<PsiAnnotation> findMappingAnnotations(@NotNull PsiMethod method,
+        MapStructVersion mapStructVersion) {
+        if ( mapStructVersion.isConstructorSupported() ) {
+            // Meta annotations support was added when constructor support was added
+            return MetaAnnotationUtil.findMetaAnnotations( method, Collections.singleton( MAPPING_ANNOTATION_FQN ) );
+        }
+        return Stream.of( method.getModifierList().getAnnotations() )
+            .filter( TargetUtils::isMappingAnnotation );
+    }
+
     /**
      * @param memberValue that needs to be checked
      *

src/test/java/org/mapstruct/intellij/inspection/UnmappedTargetPropertiesWithMetaAnnotationInspectionTest.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright MapStruct Authors.
+ *
+ * Licensed under the Apache License version 2.0, available at http://www.apache.org/licenses/LICENSE-2.0
+ */
+package org.mapstruct.intellij.inspection;
+
+import java.util.List;
+
+import com.intellij.codeInsight.intention.IntentionAction;
+import org.jetbrains.annotations.NotNull;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Filip Hrisafov
+ */
+public class UnmappedTargetPropertiesWithMetaAnnotationInspectionTest extends BaseInspectionTest {
+
+    @NotNull
+    @Override
+    protected Class<UnmappedTargetPropertiesInspection> getInspection() {
+        return UnmappedTargetPropertiesInspection.class;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        myFixture.copyFileToProject(
+            "UnmappedTargetPropertiesData.java",
+            "org/example/data/UnmappedConstructorTargetPropertiesData.java"
+        );
+
+        myFixture.copyFileToProject(
+            "MetaMappingIgnoreTestName.java",
+            "org/example/data/IgnoreTestName.java"
+        );
+    }
+
+    public void testUnmappedTargetPropertiesWithMetaAnnotation() {
+        doTest();
+        String testName = getTestName( false );
+        List<IntentionAction> allQuickFixes = myFixture.getAllQuickFixes();
+
+        assertThat( allQuickFixes )
+            .extracting( IntentionAction::getText )
+            .as( "Intent Text" )
+            .containsExactly(
+                "Ignore unmapped target property: 'moreTarget'",
+                "Add unmapped target property: 'moreTarget'"
+            );
+
+        allQuickFixes.forEach( myFixture::launchAction );
+        myFixture.checkResultByFile( testName + "_after.java" );
+    }
+}

testData/inspection/MetaMappingIgnoreTestName.java

@@ -0,0 +1,17 @@
+/*
+ * Copyright MapStruct Authors.
+ *
+ * Licensed under the Apache License version 2.0, available at http://www.apache.org/licenses/LICENSE-2.0
+ */
+package org.example.data;
+
+import org.mapstruct.Mapping;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Mapping(target = "testName", ignore = true)
+@Retention(RetentionPolicy.SOURCE)
+@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
+public @interface IgnoreTestName { }

testData/inspection/UnmappedTargetPropertiesWithMetaAnnotation.java

@@ -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
+ */
+
+import org.mapstruct.Context;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.MappingTarget;
+import org.mapstruct.Mappings;
+import org.example.data.IgnoreTestName;
+import org.example.data.UnmappedTargetPropertiesData.Target;
+import org.example.data.UnmappedTargetPropertiesData.Source;
+
+@Mapper
+interface SingleMappingsMapper {
+
+    @Mappings({
+        @Mapping(target = "moreTarget", source = "moreSource")
+    })
+    @IgnoreTestName
+    Target map(Source source);
+}
+
+@Mapper
+interface SingleMappingMapper {
+
+    @IgnoreTestName
+    Target <warning descr="Unmapped target property: moreTarget">map</warning>(Source source);
+}
+
+@Mapper
+interface AllMappingMapper {
+
+    @Mapping(target = "moreTarget", source = "moreSource")
+    @IgnoreTestName
+    Target mapWithAllMapping(Source source);
+}
+
+@Mapper
+interface UpdateMapper {
+
+    @Mapping(target = "moreTarget", source = "moreSource")
+    @IgnoreTestName
+    void update(@MappingTarget Target target, Source source);
+}

testData/inspection/UnmappedTargetPropertiesWithMetaAnnotation_after.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
+ */
+
+import org.mapstruct.Context;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.MappingTarget;
+import org.mapstruct.Mappings;
+import org.example.data.IgnoreTestName;
+import org.example.data.UnmappedTargetPropertiesData.Target;
+import org.example.data.UnmappedTargetPropertiesData.Source;
+
+@Mapper
+interface SingleMappingsMapper {
+
+    @Mappings({
+        @Mapping(target = "moreTarget", source = "moreSource")
+    })
+    @IgnoreTestName
+    Target map(Source source);
+}
+
+@Mapper
+interface SingleMappingMapper {
+
+    @Mapping(target = "moreTarget", source = "")
+    @Mapping(target = "moreTarget", ignore = true)
+    @IgnoreTestName
+    Target map(Source source);
+}
+
+@Mapper
+interface AllMappingMapper {
+
+    @Mapping(target = "moreTarget", source = "moreSource")
+    @IgnoreTestName
+    Target mapWithAllMapping(Source source);
+}
+
+@Mapper
+interface UpdateMapper {
+
+    @Mapping(target = "moreTarget", source = "moreSource")
+    @IgnoreTestName
+    void update(@MappingTarget Target target, Source source);
+}