Fix Kotlin @ignored element pattern for @IgnoredList container support

The Kotlin element pattern for @ignored used `insideAnnotationParam` which
only matches standalone annotations. Changed to use
`insideRepeatableAnnotationParam` with `IGNORED_LIST_ANNOTATION_FQN` so
references and completion work when @ignored is nested inside @IgnoredList.

Also fixed `insideRepeatableAnnotationParam` in `KotlinElementPattern` to
use `withAncestor(2, ...)` instead of `withParent(...)` to support array
parameters like `targets = ["..."]` where a collection literal sits between
the string and the value argument.

Added tests for @IgnoredList in both Java and Kotlin:
- Completion with @IgnoredList container (Java and Kotlin)
- Standalone @ignored completion in Kotlin
- TargetPropertyMappedMoreThanOnce inspection with @IgnoredList

Author: filiphr

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

@@ -70,7 +70,8 @@ public static KotlinElementPattern.Capture<? extends PsiElement> beanMappingElem
     public static KotlinElementPattern.Capture<? extends PsiElement> ignoredElementPattern(String parameterName) {
         return elementPattern(
             parameterName,
-            MapstructUtil.IGNORED_ANNOTATION_FQN
+            MapstructUtil.IGNORED_ANNOTATION_FQN,
+            MapstructUtil.IGNORED_LIST_ANNOTATION_FQN
         );
     }
 

src/main/java/org/mapstruct/intellij/util/patterns/KotlinElementPattern.java

@@ -37,12 +37,14 @@ public Self insideRepeatableAnnotationParam(
 
         KtValueArgumentPattern ktValueArgumentPattern = ktValueArgument().withName( parameterName );
         return withElementType( KtStubElementTypes.STRING_TEMPLATE ).andOr(
-            withParent(
+            withAncestor(
+                2,
                 ktValueArgumentPattern
                     .withAncestor( 5, ktAnnotation().qName( annotationHolderQualifiedName ) )
             ),
 
-            withParent(
+            withAncestor(
+                2,
                 ktValueArgumentPattern
                     .withSuperParent( 2, ktAnnotation().qName( annotationQualifiedName ) )
             )

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

@@ -173,4 +173,37 @@ public void testIgnoredTargetsMultipleAnnotations() {
                 "available"
             );
     }
+
+    public void testIgnoredTargetsWithIgnoredList() {
+        configureByTestName();
+        assertThat( myItems )
+            .extracting( LookupElement::getLookupString )
+            .containsExactlyInAnyOrder(
+                "manufacturingYear",
+                "myDriver",
+                "passengers",
+                "price",
+                "category",
+                "available"
+            );
+    }
+
+    public void testIgnoredTargetsNoPrefixKotlin() {
+        configureByFile( "/" + getTestName( false ) + ".kt" );
+        assertCarDtoAutoComplete();
+    }
+
+    public void testIgnoredTargetsWithIgnoredListKotlin() {
+        configureByFile( "/" + getTestName( false ) + ".kt" );
+        assertThat( myItems )
+            .extracting( LookupElement::getLookupString )
+            .containsExactlyInAnyOrder(
+                "manufacturingYear",
+                "myDriver",
+                "passengers",
+                "price",
+                "category",
+                "available"
+            );
+    }
 }

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

@@ -28,6 +28,10 @@ public void testTargetPropertyMappedMoreThanOnceWithIgnored() {
         doTest();
     }
 
+    public void testTargetPropertyMappedMoreThanOnceWithIgnoredList() {
+        doTest();
+    }
+
     public void testTargetPropertyMappedMoreThanOnce() {
         doTest();
         String testName = getTestName( false );

testData/completion/ignored/IgnoredTargetsNoPrefixKotlin.kt

@@ -0,0 +1,18 @@
+/**
+ * Copyright MapStruct Authors.
+ *
+ * Licensed under the Apache License version 2.0, available at https://www.apache.org/licenses/LICENSE-2.0
+ */
+package org.mapstruct.ap.test.complex
+
+import org.mapstruct.Ignored
+import org.mapstruct.Mapper
+import org.example.dto.Car
+import org.example.dto.CarDtoKt
+
+@Mapper
+interface IgnoredTargetsNoPrefixKotlin {
+
+    @Ignored(targets = ["<caret>"])
+    fun carToCarDto(car: Car): CarDtoKt
+}

testData/completion/ignored/IgnoredTargetsWithIgnoredList.java

@@ -0,0 +1,22 @@
+/*
+ * Copyright MapStruct Authors.
+ *
+ * Licensed under the Apache License version 2.0, available at https://www.apache.org/licenses/LICENSE-2.0
+ */
+package org.mapstruct.ap.test.complex;
+
+import org.mapstruct.Ignored;
+import org.mapstruct.IgnoredList;
+import org.mapstruct.Mapper;
+import org.example.dto.Car;
+import org.example.dto.CarDto;
+
+@Mapper
+public interface IgnoredTargetsWithIgnoredList {
+
+    @IgnoredList({
+        @Ignored(targets = { "make", "seatCount" }),
+        @Ignored(targets = { "<caret>" })
+    })
+    CarDto carToCarDto(Car car);
+}

testData/completion/ignored/IgnoredTargetsWithIgnoredListKotlin.kt

@@ -0,0 +1,22 @@
+/**
+ * Copyright MapStruct Authors.
+ *
+ * Licensed under the Apache License version 2.0, available at https://www.apache.org/licenses/LICENSE-2.0
+ */
+package org.mapstruct.ap.test.complex
+
+import org.mapstruct.Ignored
+import org.mapstruct.IgnoredList
+import org.mapstruct.Mapper
+import org.example.dto.Car
+import org.example.dto.CarDtoKt
+
+@Mapper
+interface IgnoredTargetsWithIgnoredListKotlin {
+
+    @IgnoredList(
+        Ignored(targets = ["make", "seatCount"]),
+        Ignored(targets = ["<caret>"])
+    )
+    fun carToCarDto(car: Car): CarDtoKt
+}

testData/inspection/TargetPropertyMappedMoreThanOnceWithIgnoredList.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright MapStruct Authors.
+ *
+ * Licensed under the Apache License version 2.0, available at https://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import org.mapstruct.Ignored;
+import org.mapstruct.IgnoredList;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+
+class Source {
+    private String name;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}
+
+class Target {
+    private String testName;
+    private String moreTarget;
+
+    public String getTestName() {
+        return testName;
+    }
+
+    public void setTestName(String testName) {
+        this.testName = testName;
+    }
+
+    public String getMoreTarget() {
+        return moreTarget;
+    }
+
+    public void setMoreTarget(String moreTarget) {
+        this.moreTarget = moreTarget;
+    }
+}
+
+@Mapper
+interface MappingAndIgnoredListSameTargetMapper {
+
+    @Mapping(target = <error descr="Target property 'testName' must not be mapped more than once.">"testName"</error>, source = "name")
+    @IgnoredList({
+        @Ignored(targets = { <error descr="Target property 'testName' must not be mapped more than once.">"testName"</error> })
+    })
+    Target map(Source source);
+}
+
+@Mapper
+interface IgnoredListDuplicateTargetMapper {
+
+    @IgnoredList({
+        @Ignored(targets = { <error descr="Target property 'testName' must not be mapped more than once.">"testName"</error> }),
+        @Ignored(targets = { <error descr="Target property 'testName' must not be mapped more than once.">"testName"</error> })
+    })
+    Target map(Source source);
+}
+
+@Mapper
+interface IgnoredListNoConflictMapper {
+
+    @IgnoredList({
+        @Ignored(targets = { "testName" }),
+        @Ignored(targets = { "moreTarget" })
+    })
+    Target map(Source source);
+}