#220: Support multi level inheritance generic builders as fluent builder (like lomboks @SuperBuilder)

Author: thunderhook

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

@@ -10,6 +10,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.function.Function;
 import java.util.stream.Stream;
 import javax.swing.Icon;
@@ -39,6 +40,7 @@
 import com.intellij.psi.PsiRecordComponent;
 import com.intellij.psi.PsiSubstitutor;
 import com.intellij.psi.PsiType;
+import com.intellij.psi.PsiTypeParameter;
 import com.intellij.psi.impl.PsiClassImplUtil;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.util.CachedValueProvider;
@@ -229,10 +231,12 @@ public boolean isFluentSetter(@NotNull PsiMethod method, PsiType psiType) {
         return !psiType.getCanonicalText().startsWith( "java.lang" ) &&
             method.getReturnType() != null &&
             !isAdderWithUpperCase4thCharacter( method ) &&
-            isAssignableFromReturnTypeOrSuperTypes( psiType, method.getReturnType() );
+            isAssignableFromReturnTypeOrSuperTypesOrGenericBuilder( psiType, method );
     }
 
-    private static boolean isAssignableFromReturnTypeOrSuperTypes(PsiType psiType, PsiType returnType) {
+    private static boolean isAssignableFromReturnTypeOrSuperTypesOrGenericBuilder(PsiType psiType, PsiMethod method) {
+
+        PsiType returnType = method.getReturnType();
 
         if ( isAssignableFrom( psiType, returnType ) ) {
             return true;
@@ -243,8 +247,43 @@ private static boolean isAssignableFromReturnTypeOrSuperTypes(PsiType psiType, P
                 return true;
             }
         }
+
+        return isAssignableFromGenericBuilder( returnType, method.getContainingClass() );
+    }
+
+    private static boolean isAssignableFromGenericBuilder(PsiType returnType, PsiClass containingClass) {
+
+        if ( returnType == null || containingClass == null ) {
+            return false;
+        }
+
+        // Generic types (FooBuilder<C, B>)
+        PsiTypeParameter[] typeParameters = containingClass.getTypeParameters();
+        if ( typeParameters.length < 2 ) {
+            return false;
+        }
+
+        for ( PsiTypeParameter typeParameter : typeParameters ) {
+            PsiClassType[] superTypes = typeParameter.getExtendsListTypes();
+            for ( PsiClassType superType : superTypes ) {
+                // Check if the return value is derivable from a builder type
+                if ( classNameEndsWithBuilder( superType )
+                    && superType.isAssignableFrom( returnType ) ) {
+                    return true;
+                }
+            }
+        }
+
         return false;
     }
+    
+    private static boolean classNameEndsWithBuilder(PsiClassType psiClassType) {
+
+        return Optional.ofNullable( psiClassType.resolve() )
+            .map( PsiClass::getQualifiedName )
+            .map( name -> name.endsWith( "Builder" ) )
+            .orElse( false );
+    }
 
     private static boolean isAssignableFrom(PsiType psiType, @Nullable PsiType returnType) {
         return TypeConversionUtil.isAssignable(

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

@@ -0,0 +1,52 @@
+/*
+ * 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 java.util.List;
+
+import com.intellij.codeInsight.intention.IntentionAction;
+import org.jetbrains.annotations.NotNull;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Oliver Erhart
+ */
+public class UnmappedSuperBuilderMultiLevelTargetPropertiesInspectionTest extends BaseInspectionTest {
+
+    @NotNull
+    @Override
+    protected Class<UnmappedTargetPropertiesInspection> getInspection() {
+        return UnmappedTargetPropertiesInspection.class;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        myFixture.copyFileToProject(
+            "UnmappedSuperBuilderMultiLevelTargetPropertiesData.java",
+            "org/example/data/UnmappedSuperBuilderMultiLevelTargetPropertiesData.java"
+        );
+    }
+
+    public void testUnmappedSuperBuilderMultiLevelTargetProperties() {
+        doTest();
+        List<IntentionAction> allQuickFixes = myFixture.getAllQuickFixes();
+
+        assertThat( allQuickFixes )
+            .extracting( IntentionAction::getText )
+            .as( "Intent Text" )
+            .containsExactly(
+                "Ignore unmapped target property: 'age'",
+                "Add unmapped target property: 'age'",
+                "Ignore unmapped target property: 'id'",
+                "Add unmapped target property: 'id'",
+                "Ignore unmapped target property: 'name'",
+                "Add unmapped target property: 'name'",
+                "Ignore all unmapped target properties"
+            );
+    }
+}

testData/inspection/UnmappedSuperBuilderMultiLevelTargetProperties.java

@@ -0,0 +1,15 @@
+/*
+ * Copyright MapStruct Authors.
+ *
+ * Licensed under the Apache License version 2.0, available at https://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import org.mapstruct.Mapper;
+import org.example.data.UnmappedSuperBuilderMultiLevelTargetPropertiesData.PersonEntity;
+
+@Mapper
+interface MultiLevelMapper {
+
+    PersonEntity <warning descr="Unmapped target properties: age, id, name">map</warning>(String input);
+
+}

testData/inspection/UnmappedSuperBuilderMultiLevelTargetPropertiesData.java

@@ -0,0 +1,145 @@
+/*
+ * 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;
+
+public class UnmappedSuperBuilderMultiLevelTargetPropertiesData {
+
+    public static class BaseEntity {
+        Long id;
+
+        protected BaseEntity(BaseEntityBuilder<?, ?> b) {
+            this.id = b.id;
+        }
+
+        public static BaseEntityBuilder<?, ?> builder() {
+            return new BaseEntityBuilderImpl();
+        }
+
+        public static abstract class BaseEntityBuilder<C extends BaseEntity, B extends BaseEntityBuilder<C, B>> {
+            private Long id;
+
+            public B id(Long id) {
+                this.id = id;
+                return self();
+            }
+
+            protected abstract B self();
+
+            public abstract C build();
+
+            public String toString() {
+                return "BaseEntity.BaseEntityBuilder(id=" + this.id + ")";
+            }
+        }
+
+        private static final class BaseEntityBuilderImpl extends BaseEntityBuilder<BaseEntity, BaseEntityBuilderImpl> {
+            private BaseEntityBuilderImpl() {
+            }
+
+            protected BaseEntityBuilderImpl self() {
+                return this;
+            }
+
+            public BaseEntity build() {
+                return new BaseEntity( this );
+            }
+        }
+    }
+
+    public static class NamedEntity extends BaseEntity {
+        String name;
+
+        protected NamedEntity(NamedEntityBuilder<?, ?> b) {
+            super( b );
+            this.name = b.name;
+        }
+
+        public static NamedEntityBuilder<?, ?> builder() {
+            return new NamedEntityBuilderImpl();
+        }
+
+        public static abstract class NamedEntityBuilder<C extends NamedEntity, B extends NamedEntityBuilder<C, B>>
+            extends BaseEntityBuilder<C, B> {
+            private String name;
+
+            public B name(String name) {
+                this.name = name;
+                return self();
+            }
+
+            protected abstract B self();
+
+            public abstract C build();
+
+            public String toString() {
+                return "NamedEntity.NamedEntityBuilder(super=" + super.toString() + ", name=" + this.name + ")";
+            }
+        }
+
+        private static final class NamedEntityBuilderImpl extends NamedEntityBuilder<NamedEntity, NamedEntityBuilderImpl> {
+            private NamedEntityBuilderImpl() {
+            }
+
+            protected NamedEntityBuilderImpl self() {
+                return this;
+            }
+
+            public NamedEntity build() {
+                return new NamedEntity( this );
+            }
+        }
+    }
+
+    public static class PersonEntity extends NamedEntity {
+        int age;
+
+        protected PersonEntity(PersonEntityBuilder<?, ?> b) {
+            super( b );
+            this.age = b.age;
+        }
+
+        public static PersonEntityBuilder<?, ?> builder() {
+            return new PersonEntityBuilderImpl();
+        }
+
+        public static abstract class PersonEntityBuilder<C extends PersonEntity, B extends PersonEntityBuilder<C, B>>
+            extends NamedEntityBuilder<C, B> {
+            private int age;
+
+            public B age(int age) {
+                this.age = age;
+                return self();
+            }
+
+            public C someIrrelevantMethod(int someParameter) {
+                return null;
+            }
+
+            protected abstract B self();
+
+            public abstract C build();
+
+            public String toString() {
+                return "PersonEntity.PersonEntityBuilder(super=" + super.toString() + ", age=" + this.age + ")";
+            }
+        }
+
+        private static final class PersonEntityBuilderImpl
+            extends PersonEntityBuilder<PersonEntity, PersonEntityBuilderImpl> {
+            private PersonEntityBuilderImpl() {
+            }
+
+            protected PersonEntityBuilderImpl self() {
+                return this;
+            }
+
+            public PersonEntity build() {
+                return new PersonEntity( this );
+            }
+        }
+    }
+
+}