Find disabled builder in @MapperConfig

closes #97

Author: thunderhook

change-notes.html

@@ -3,6 +3,7 @@ <h2>1.4.0</h2>
 <ul>
     <li>Suppress redundant default parameter value assignment warning for <code>Mapping#constant</code> and <code>Mapping#defaultValue</code></li>
     <li>Support for Java records</li>
+    <li>Support MapStruct explicit <code>Builder#disableBuilder</code> through <code>@MapperConfig</code></li>
     <li>Bug fix: language injections inside expressions when target is field</li>
 </ul>
 <h2>1.3.1</h2>

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

@@ -24,9 +24,12 @@
 import com.intellij.psi.PsiAnnotation;
 import com.intellij.psi.PsiAnnotationMemberValue;
 import com.intellij.psi.PsiArrayInitializerMemberValue;
+import com.intellij.psi.PsiClassObjectAccessExpression;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiJavaCodeReferenceElement;
 import com.intellij.psi.PsiMethod;
+import com.intellij.psi.PsiModifierListOwner;
 import com.intellij.psi.PsiNameValuePair;
 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
 import com.intellij.util.IncorrectOperationException;
@@ -286,4 +289,37 @@ private static boolean isMappingPsiAnnotation(PsiAnnotationMemberValue memberVal
     private static boolean isMappingAnnotation(PsiAnnotation psiAnnotation) {
         return Objects.equals( psiAnnotation.getQualifiedName(), MAPPING_ANNOTATION_FQN );
     }
+
+    /**
+     * Find the mapper config reference class or interface defined in the {@code mapperAnnotation}
+     *
+     * @param mapperAnnotation the mapper annotation in which the mapper config is defined
+     *
+     * @return the class / interface that is defined in the mapper config,
+     * or {@code null} if there isn't anything defined
+     */
+    public static PsiModifierListOwner findMapperConfigReference(PsiAnnotation mapperAnnotation) {
+        PsiNameValuePair configAttribute = findDeclaredAttribute( mapperAnnotation, "config" );
+        if ( configAttribute == null ) {
+            return null;
+        }
+
+        PsiAnnotationMemberValue configValue = configAttribute.getValue();
+        if ( !( configValue instanceof PsiClassObjectAccessExpression ) ) {
+            return null;
+        }
+
+        PsiJavaCodeReferenceElement referenceElement = ( (PsiClassObjectAccessExpression) configValue ).getOperand()
+            .getInnermostComponentReferenceElement();
+        if ( referenceElement == null ) {
+            return null;
+        }
+
+        PsiElement resolvedElement = referenceElement.resolve();
+        if ( !( resolvedElement instanceof PsiModifierListOwner ) ) {
+            return null;
+        }
+
+        return (PsiModifierListOwner) resolvedElement;
+    }
 }

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

@@ -42,6 +42,7 @@
 import static com.intellij.codeInsight.AnnotationUtil.findAnnotation;
 import static com.intellij.codeInsight.AnnotationUtil.getBooleanAttributeValue;
 import static org.mapstruct.intellij.util.MapstructAnnotationUtils.findAllDefinedMappingAnnotations;
+import static org.mapstruct.intellij.util.MapstructAnnotationUtils.findMapperConfigReference;
 import static org.mapstruct.intellij.util.MapstructUtil.canDescendIntoType;
 import static org.mapstruct.intellij.util.MapstructUtil.isFluentSetter;
 import static org.mapstruct.intellij.util.MapstructUtil.publicFields;
@@ -148,10 +149,18 @@ public static boolean isBuilderEnabled(@Nullable PsiMethod mappingMethod) {
         Optional<Boolean> disableBuilder = findDisableBuilder( mappingMethod, MapstructUtil.BEAN_MAPPING_FQN );
 
         if ( !disableBuilder.isPresent() && mappingMethod != null ) {
-            disableBuilder = findDisableBuilder(
+            PsiAnnotation mapperAnnotation = findAnnotation(
                 mappingMethod.getContainingClass(),
                 MapstructUtil.MAPPER_ANNOTATION_FQN
             );
+            disableBuilder = findDisabledBuilder( mapperAnnotation );
+
+            if ( disableBuilder.isEmpty() && mapperAnnotation != null ) {
+                disableBuilder = findDisableBuilder(
+                    findMapperConfigReference( mapperAnnotation ),
+                    MapstructUtil.MAPPER_CONFIG_ANNOTATION_FQN
+                );
+            }
         }
 
         return !disableBuilder.orElse( false );
@@ -160,6 +169,10 @@ public static boolean isBuilderEnabled(@Nullable PsiMethod mappingMethod) {
     private static Optional<Boolean> findDisableBuilder(@Nullable PsiModifierListOwner listOwner,
                                                         String annotationName) {
         PsiAnnotation requestedAnnotation = findAnnotation( listOwner, true, annotationName );
+        return findDisabledBuilder( requestedAnnotation );
+    }
+
+    private static Optional<Boolean> findDisabledBuilder(@Nullable PsiAnnotation requestedAnnotation) {
         if ( requestedAnnotation != null ) {
             PsiNameValuePair builderAttribute = AnnotationUtil.findDeclaredAttribute( requestedAnnotation, "builder" );
             if ( builderAttribute != null ) {

src/test/java/org/mapstruct/intellij/MapstructCompletionTestCase.java

@@ -992,4 +992,24 @@ public void testMapperWithBuilderAndMapperDisabledBuilderAndBeanMappingOther() {
             );
     }
 
+    public void testMapperWithBuilderAndMapperConfigDisabledBuilder() {
+        configureByTestName();
+
+        assertThat( myItems )
+            .extracting( LookupElement::getLookupString )
+            .containsExactlyInAnyOrder(
+                "targetValue"
+            );
+    }
+
+    public void testMapperWithBuilderAndMapperConfigDisabledBuilderAndMapperEnable() {
+        configureByTestName();
+
+        assertThat( myItems )
+            .extracting( LookupElement::getLookupString )
+            .containsExactlyInAnyOrder(
+                "builderValue"
+            );
+    }
+
 }

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

@@ -51,7 +51,10 @@ public void testUnmappedTargetPropertiesWithBuilder() {
                 "Add unmapped target property: 'targetTestName'",
 
                 "Ignore unmapped target property: 'builderTestName'",
-                "Add unmapped target property: 'builderTestName'"
+                "Add unmapped target property: 'builderTestName'",
+
+                "Ignore unmapped target property: 'targetTestName'",
+                "Add unmapped target property: 'targetTestName'"
             );
 
         allQuickFixes.forEach( myFixture::launchAction );

testData/inspection/UnmappedTargetPropertiesWithBuilder.java

@@ -7,6 +7,7 @@
 import org.mapstruct.BeanMapping;
 import org.mapstruct.Builder;
 import org.mapstruct.Mapper;
+import org.mapstruct.MapperConfig;
 import org.mapstruct.Mapping;
 import org.example.data.UnmappedTargetPropertiesData.Target;
 
@@ -35,3 +36,14 @@ interface MapperDisabledBuilderBeanMappingEnabledBuilder {
     @BeanMapping(builder = @Builder(disableBuilder = false))
     Target <warning descr="Unmapped target property: builderTestName">map</warning>(String source);
 }
+
+@MapperConfig(builder = @Builder(disableBuilder = true))
+class DoNotUseBuilderMapperConfig {
+
+}
+
+@Mapper(config = DoNotUseBuilderMapperConfig.class)
+interface MapperConfigDisabledBuilder {
+
+    Target <warning descr="Unmapped target property: targetTestName">map</warning>(String source);
+}

testData/inspection/UnmappedTargetPropertiesWithBuilder_after.java

@@ -7,6 +7,7 @@
 import org.mapstruct.BeanMapping;
 import org.mapstruct.Builder;
 import org.mapstruct.Mapper;
+import org.mapstruct.MapperConfig;
 import org.mapstruct.Mapping;
 import org.example.data.UnmappedTargetPropertiesData.Target;
 
@@ -43,3 +44,16 @@ interface MapperDisabledBuilderBeanMappingEnabledBuilder {
     @BeanMapping(builder = @Builder(disableBuilder = false))
     Target map(String source);
 }
+
+@MapperConfig(builder = @Builder(disableBuilder = true))
+class DoNotUseBuilderMapperConfig {
+
+}
+
+@Mapper(config = DoNotUseBuilderMapperConfig.class)
+interface MapperConfigDisabledBuilder {
+
+    @Mapping(target = "targetTestName", source = "")
+    @Mapping(target = "targetTestName", ignore = true)
+    Target map(String source);
+}

testData/mapping/MapperWithBuilderAndMapperConfigDisabledBuilder.java

@@ -0,0 +1,52 @@
+/*
+ * 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 java.util.List;
+
+import org.mapstruct.Builder;
+import org.mapstruct.Mapper;
+import org.mapstruct.MapperConfig;
+import org.mapstruct.Mapping;
+
+@Mapper(config = CarMapper.MapperConfigDisabledBuilder.class)
+public interface CarMapper {
+
+    @Mapping(target = "<caret>")
+    Target map(String source);
+
+    class Target {
+
+        private String targetValue;
+
+        public String getTargetValue() {
+            return targetValue;
+        }
+
+        public void setTargetValue(String targetValue) {
+            this.targetValue = targetValue;
+        }
+
+        public static Builder builder() {
+            return null;
+        }
+
+        public static class Builder {
+
+            public Builder builderValue(String address) {
+
+            }
+
+            public Target build() {
+                return null;
+            }
+        }
+    }
+
+    @MapperConfig(builder = @Builder(disableBuilder = true))
+    interface MapperConfigDisabledBuilder {}
+
+}

testData/mapping/MapperWithBuilderAndMapperConfigDisabledBuilderAndMapperEnable.java

@@ -0,0 +1,52 @@
+/*
+ * 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 java.util.List;
+
+import org.mapstruct.Builder;
+import org.mapstruct.Mapper;
+import org.mapstruct.MapperConfig;
+import org.mapstruct.Mapping;
+
+@Mapper(config = CarMapper.MapperConfigDisabledBuilder.class, builder = @Builder(disableBuilder = false))
+public interface CarMapper {
+
+    @Mapping(target = "<caret>")
+    Target map(String source);
+
+    class Target {
+
+        private String targetValue;
+
+        public String getTargetValue() {
+            return targetValue;
+        }
+
+        public void setTargetValue(String targetValue) {
+            this.targetValue = targetValue;
+        }
+
+        public static Builder builder() {
+            return null;
+        }
+
+        public static class Builder {
+
+            public Builder builderValue(String address) {
+
+            }
+
+            public Target build() {
+                return null;
+            }
+        }
+    }
+
+    @MapperConfig(builder = @Builder(disableBuilder = true))
+    interface MapperConfigDisabledBuilder {}
+
+}