mapstruct · filiphr · Aug 13, 2023 · Aug 9, 2023
diff --git a/src/main/java/org/mapstruct/intellij/util/TargetUtils.java b/src/main/java/org/mapstruct/intellij/util/TargetUtils.java
@@ -291,38 +291,37 @@ private static Map<String, Pair<? extends PsiMember, PsiSubstitutor>> publicSett
     @Nullable
     private static String extractPublicSetterPropertyName(PsiMethod method, @NotNull PsiType typeToUse,
         boolean builderSupportPresent) {
-        if ( method.getParameterList().getParametersCount() != 1 || !MapstructUtil.isPublicNonStatic( method ) ) {
-            // If the method does not have 1 parameter or is not public then there is no property
+        if (!MapstructUtil.isPublicNonStatic( method )) {
+            // If the method is not public then there is no property
+            return null;
+        }
+        String methodName = method.getName();
+        int parametersCount = method.getParameterList().getParametersCount();
+        PsiType returnType = method.getReturnType();
+        if (parametersCount == 0 && methodName.startsWith( "get" ) && returnType != null &&
+                returnType.isConvertibleFrom( PsiType.getTypeByName( "java.util.Collection",
+                        method.getProject(), method.getResolveScope() ) )) {
+            // If the methode returns a collection
+            return Introspector.decapitalize( methodName.substring( 3 ) );
+        }
+        if (parametersCount != 1) {
+            // If the method does not have 1 parameter
             return null;
         }
 
         // This logic is aligned with the DefaultAccessorNamingStrategy
-        String methodName = method.getName();
-        if ( builderSupportPresent ) {
-            if ( isFluentSetter( method, typeToUse ) ) {
-                if ( methodName.startsWith( "set" )
-                    && methodName.length() > 3
-                    && Character.isUpperCase( methodName.charAt( 3 ) ) ) {
-                    return Introspector.decapitalize( methodName.substring( 3 ) );
-                }
-                else {
-                    return methodName;
-                }
-            }
-            else if ( methodName.startsWith( "set" ) ) {
+        if ( builderSupportPresent && isFluentSetter( method, typeToUse )) {
+            if ( methodName.startsWith( "set" )
+                && methodName.length() > 3
+                && Character.isUpperCase( methodName.charAt( 3 ) ) ) {
                 return Introspector.decapitalize( methodName.substring( 3 ) );
             }
-            else {
-                return null;
-            }
+            return methodName;
         }
-        else if ( methodName.startsWith( "set" ) ) {
+        if ( methodName.startsWith( "set" ) ) {
             return Introspector.decapitalize( methodName.substring( 3 ) );
         }
-        else {
-            return null;
-        }
-
+        return null;
     }
 
     /**

diff --git a/...a/org/mapstruct/intellij/inspection/UnmappedCollectionGetterPropertiesInspectionTest.java b/...a/org/mapstruct/intellij/inspection/UnmappedCollectionGetterPropertiesInspectionTest.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright MapStruct Authors.
+ *
+ * Licensed under the Apache License version 2.0, available at https://www.apache.org/licenses/LICENSE-2.0
+ */
+package org.mapstruct.intellij.inspection;
+
+import com.intellij.codeInsight.intention.IntentionAction;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Filip Hrisafov
+ */
+public class UnmappedCollectionGetterPropertiesInspectionTest extends BaseInspectionTest {
+
+    @NotNull
+    @Override
+    protected Class<UnmappedTargetPropertiesInspection> getInspection() {
+        return UnmappedTargetPropertiesInspection.class;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        myFixture.copyFileToProject(
+            "UnmappedCollectionGetterPropertiesData.java",
+            "org/example/data/UnmappedCollectionGetterPropertiesData.java"
+        );
+    }
+
+    public void testUnmappedCollectionGetterProperties() {
+        doTest();
+        List<IntentionAction> allQuickFixes = myFixture.getAllQuickFixes();
+
+        assertThat( allQuickFixes )
+            .extracting( IntentionAction::getText )
+            .as( "Intent Text" )
+                .containsExactlyInAnyOrder(
+                        "Ignore unmapped target property: 'listTarget'",
+                        "Add unmapped target property: 'listTarget'",
+                        "Ignore unmapped target property: 'setTarget'",
+                        "Add unmapped target property: 'setTarget'",
+                        "Ignore unmapped target property: 'mapTarget'",
+                        "Add unmapped target property: 'mapTarget'",
+                        "Ignore all unmapped target properties"
+            );
+
+        allQuickFixes.forEach( myFixture::launchAction );
+    }
+}
diff --git a/testData/inspection/UnmappedCollectionGetterProperties.java b/testData/inspection/UnmappedCollectionGetterProperties.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright MapStruct Authors.
+ *
+ * Licensed under the Apache License version 2.0, available at https://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.UnmappedCollectionGetterPropertiesData.Target;
+import org.example.data.UnmappedCollectionGetterPropertiesData.Source;
+
+interface NotMapStructMapper {
+
+    Target map(Source source);
+}
+
+@Mapper
+interface NoMappingMapper {
+
+    Target <warning descr="Unmapped target properties: listTarget, mapTarget, setTarget">map</warning>(Source source);
+
+    @org.mapstruct.InheritInverseConfiguration
+    Source reverse(Target target);
+}
+
+@Mapper
+interface AllMappingMapper {
+
+    @Mapping(target = "listTarget", source = "listSource")
+    @Mapping(target = "setTarget", source = "setSource")
+    @Mapping(target = "mapTarget", source = "mapSource")
+    Target mapWithAllMapping(Source source);
+}
diff --git a/testData/inspection/UnmappedCollectionGetterPropertiesData.java b/testData/inspection/UnmappedCollectionGetterPropertiesData.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright MapStruct Authors.
+ *
+ * Licensed under the Apache License version 2.0, available at https://www.apache.org/licenses/LICENSE-2.0
+ */
+package org.example.data;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class UnmappedCollectionGetterPropertiesData {
+    public static class Source {
+
+        private List<String> listSource;
+        private Set<Strinf> setSource;
+        private Map<String, String> mapSource;
+
+        public List<String> getListSource() {
+            return listSource;
+        }
+
+        public Set<Strinf> getSetSource() {
+            return setSource;
+        }
+
+        public Map<String, String> getMapSource() {
+            return mapSource;
+        }
+    }
+
+    public static class Target {
+
+        private List<String> listTarget;
+        private Set<Strinf> setTarget;
+        private Map<String, String> mapTarget;
+        private String stringTarget;
+
+        public List<String> getListTarget() {
+            return listTarget;
+        }
+
+        public Set<Strinf> getSetTarget() {
+            return setTarget;
+        }
+
+        public Map<String, String> getMapTarget() {
+            return mapTarget;
+        }
+
+        public String getStringTarget() {
+            return stringTarget;
+        }
+    }
+
+}