#20 Kotlin support for target / source in Mapping and ValueMapping

Author: ifrankwang

build.gradle

@@ -1,7 +1,11 @@
+import com.hierynomus.gradle.license.tasks.LicenseCheck
+import com.hierynomus.gradle.license.tasks.LicenseFormat
+
 plugins {
-    id "org.jetbrains.intellij" version "0.4.18"
+    id "org.jetbrains.intellij" version "0.4.21"
     id "com.github.hierynomus.license" version "0.14.0"
     id "de.undercouch.download" version "4.0.4"
+    id 'org.jetbrains.kotlin.jvm' version '1.3.71'
 }
 
 
@@ -14,6 +18,7 @@ apply plugin: 'org.jetbrains.intellij'
 apply plugin: 'license'
 apply plugin: 'checkstyle'
 apply plugin: 'jacoco'
+apply plugin: 'kotlin'
 
 sourceCompatibility = 1.8
 targetCompatibility = 1.8
@@ -27,15 +32,29 @@ repositories {
 }
 
 intellij {
-    version System.getenv().getOrDefault('IDEA_VERSION', ideaVersion)
+    version System.getenv().getOrDefault('IDEA_VERSION', '2020.1.4')
     type ideaType
     downloadSources Boolean.valueOf(sources)
     sameSinceUntilBuild Boolean.valueOf(isEAP)
     alternativeIdePath idePath
     updateSinceUntilBuild false
     pluginName 'MapStruct-Intellij-Plugin'
     if ( !(version.startsWith('2018') || version.startsWith('2019.1'))) {
-        plugins 'java'
+        plugins = ['java', 'Kotlin', 'properties']
+    } else {
+        plugins = ['Kotlin', 'properties']
+    }
+}
+
+compileKotlin {
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}
+
+compileTestKotlin {
+    kotlinOptions {
+        jvmTarget = "1.8"
     }
 }
 
@@ -47,10 +66,14 @@ patchPluginXml {
     pluginDescription = htmlFixer('description.html')
 }
 
-task licenseTestData(type: com.hierynomus.gradle.license.tasks.LicenseCheck) {
+task licenseTestData(type: LicenseCheck) {
     source = fileTree(dir: "testData").include("**/*")
 }
 
+task licenseFormatForKotlin(type: LicenseFormat) {
+    source = fileTree(dir: "src/main").include("**/*.kt").include("**/*.xml")
+}
+
 license {
     header rootProject.file('etc/license.txt')
     strictCheck true
@@ -64,6 +87,7 @@ license {
     ])
 }
 
+licenseFormat.dependsOn licenseFormatForKotlin
 licenseTest.dependsOn licenseTestData
 
 checkstyle {
@@ -82,6 +106,7 @@ jacocoTestReport {
 }
 
 dependencies {
+    compile 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
     compile group: 'org.mapstruct', name: 'mapstruct', version: '1.4.0.Beta1'
     testCompile group: 'junit', name: 'junit', version: '4.12'
     testCompile group: 'org.assertj', name: 'assertj-core', version: '3.11.1'

src/main/java/org/mapstruct/intellij/codeinsight/references/BaseReference.java

@@ -6,32 +6,32 @@
 package org.mapstruct.intellij.codeinsight.references;
 
 import com.intellij.openapi.util.TextRange;
-import com.intellij.psi.PsiLiteral;
+import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.PsiReferenceBase;
-import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.mapstruct.intellij.util.MapstructUtilKt;
 
 /**
  * Base Reference for MapStruct.
  *
  * @author Filip Hrisafov
  */
-abstract class BaseReference extends PsiReferenceBase<PsiLiteral> {
+abstract class BaseReference extends PsiReferenceBase<PsiElement> {
 
     /**
      * @param element the element for which a reference should be found
      */
-    BaseReference(@NotNull PsiLiteral element) {
+    BaseReference(@NotNull PsiElement element) {
         super( element );
     }
 
     /**
      * @param element the element for which a reference should be found
      * @param rangeInElement the range in the element
      */
-    BaseReference(PsiLiteral element, TextRange rangeInElement) {
+    BaseReference(PsiElement element, TextRange rangeInElement) {
         super( element, rangeInElement );
     }
 
@@ -40,6 +40,6 @@ abstract class BaseReference extends PsiReferenceBase<PsiLiteral> {
      */
     @Nullable
     PsiMethod getMappingMethod() {
-        return PsiTreeUtil.getParentOfType( getElement(), PsiMethod.class );
+      return MapstructUtilKt.getPsiMethod( getElement() );
     }
 }

src/main/java/org/mapstruct/intellij/codeinsight/references/BaseValueMappingReference.java

@@ -7,7 +7,6 @@
 
 import com.intellij.codeInsight.lookup.LookupElement;
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiLiteral;
 import com.intellij.psi.PsiMethod;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -22,7 +21,7 @@ abstract class BaseValueMappingReference extends BaseReference {
     /**
      * @param element the element for which a reference should be found
      */
-    BaseValueMappingReference(@NotNull PsiLiteral element) {
+    BaseValueMappingReference(@NotNull PsiElement element) {
         super( element );
     }
 

src/main/java/org/mapstruct/intellij/codeinsight/references/KtMapstructReferenceContributor.kt

@@ -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.codeinsight.references
+
+import com.intellij.psi.PsiReferenceContributor
+import com.intellij.psi.PsiReferenceRegistrar
+import org.mapstruct.intellij.util.toMappingElementPattern
+import org.mapstruct.intellij.util.toMappingsElementPattern
+import org.mapstruct.intellij.util.toValueMappingPattern
+import org.mapstruct.intellij.util.toValueMappingsPattern
+
+
+/**
+ * @author Frank Wang
+ */
+class KtMapstructReferenceContributor : PsiReferenceContributor() {
+
+    override fun registerReferenceProviders(registrar: PsiReferenceRegistrar) {
+        registrar.registerReferenceProvider(
+            "target".toMappingElementPattern(),
+            MappingTargetReferenceProvider(MapstructTargetReference::create)
+        )
+        registrar.registerReferenceProvider(
+            "source".toMappingElementPattern(),
+            MappingTargetReferenceProvider(MapstructSourceReference::create)
+        )
+        registrar.registerReferenceProvider(
+            "target".toMappingsElementPattern(),
+            MappingTargetReferenceProvider(MapstructTargetReference::create)
+        )
+        registrar.registerReferenceProvider(
+            "source".toMappingsElementPattern(),
+            MappingTargetReferenceProvider(MapstructSourceReference::create)
+        )
+
+        registrar.registerReferenceProvider(
+            "target".toValueMappingPattern(),
+            MappingTargetReferenceProvider(ValueMappingSourceReference::create)
+        )
+        registrar.registerReferenceProvider(
+            "source".toValueMappingPattern(),
+            MappingTargetReferenceProvider(ValueMappingTargetReference::create)
+        )
+        registrar.registerReferenceProvider(
+            "target".toValueMappingsPattern(),
+            MappingTargetReferenceProvider(ValueMappingSourceReference::create)
+        )
+        registrar.registerReferenceProvider(
+            "source".toValueMappingsPattern(),
+            MappingTargetReferenceProvider(ValueMappingTargetReference::create)
+        )
+    }
+}

src/main/java/org/mapstruct/intellij/codeinsight/references/MappingTargetReferenceProvider.java

@@ -5,34 +5,33 @@
  */
 package org.mapstruct.intellij.codeinsight.references;
 
-import java.util.function.Function;
-
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiLiteral;
 import com.intellij.psi.PsiReference;
 import com.intellij.psi.PsiReferenceProvider;
 import com.intellij.util.ProcessingContext;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.function.Function;
+
 /**
  * {@link PsiReferenceProvider} for references in target / source properties of {@link org.mapstruct.Mapping}.
  *
  * @author Filip Hrisafov
  */
 class MappingTargetReferenceProvider extends PsiReferenceProvider {
 
-    private final Function<PsiLiteral, PsiReference[]> reference;
+    private final Function<PsiElement, PsiReference[]> reference;
 
     /**
      * @param reference the function that can be used to create the references array
      */
-    MappingTargetReferenceProvider(Function<PsiLiteral, PsiReference[]> reference) {
+    MappingTargetReferenceProvider(Function<PsiElement, PsiReference[]> reference) {
         this.reference = reference;
     }
 
     @NotNull
     @Override
     public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext context) {
-        return reference.apply( (PsiLiteral) element );
+        return reference.apply( element );
     }
 }

src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructBaseReference.java

@@ -10,7 +10,6 @@
 import com.intellij.psi.ElementManipulator;
 import com.intellij.psi.ElementManipulators;
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiLiteral;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.PsiReference;
 import com.intellij.psi.PsiType;
@@ -37,7 +36,7 @@ abstract class MapstructBaseReference extends BaseReference {
      * @param previous the previous reference ({@code null} if there is no previous reference)
      * @param rangeInElement the range in the {@code element} for which this reference is valid
      */
-    MapstructBaseReference(@NotNull PsiLiteral element,
+    MapstructBaseReference(@NotNull PsiElement element,
         @Nullable MapstructBaseReference previous, TextRange rangeInElement) {
         super( element, rangeInElement );
         this.previous = previous;
@@ -127,7 +126,7 @@ public final Object[] getVariants() {
     abstract PsiType resolvedType();
 
     @Override
-    public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException {
+    public PsiElement handleElementRename(@NotNull String newElementName) throws IncorrectOperationException {
         PsiElement reference = resolve();
         if ( reference instanceof PsiMethod ) {
             return super.handleElementRename( MapstructUtil.getPropertyName( newElementName ) );
@@ -137,24 +136,24 @@ public PsiElement handleElementRename(String newElementName) throws IncorrectOpe
         }
     }
 
-    private static ElementManipulator<PsiLiteral> getManipulator(PsiLiteral psiLiteral) {
-        return ElementManipulators.getNotNullManipulator( psiLiteral );
+    private static ElementManipulator<PsiElement> getManipulator(PsiElement psiElement) {
+        return ElementManipulators.getNotNullManipulator( psiElement );
     }
 
     /**
      * Create all the references for the provided {@code psiLiteral}.
      *
-     * @param psiLiteral the literal that contain
+     * @param psiElement the literal that contain
      * @param creator The creator that should be used to create new references
      * @param <T> the type of the reference that needs to be created
      *
      * @return the array of all the references
      */
-    static <T extends MapstructBaseReference> PsiReference[] create(PsiLiteral psiLiteral,
+    static <T extends MapstructBaseReference> PsiReference[] create(PsiElement psiElement,
         ReferenceCreator<T> creator) {
-        ElementManipulator<PsiLiteral> manipulator = getManipulator( psiLiteral );
-        TextRange rangeInElement = manipulator.getRangeInElement( psiLiteral );
-        String targetValue = rangeInElement.substring( psiLiteral.getText() );
+        ElementManipulator<PsiElement> manipulator = getManipulator( psiElement );
+        TextRange rangeInElement = manipulator.getRangeInElement( psiElement );
+        String targetValue = rangeInElement.substring( psiElement.getText() );
         String[] parts = targetValue.split( "\\." );
         if ( parts.length == 0 ) {
             return PsiReference.EMPTY_ARRAY;
@@ -171,7 +170,7 @@ static <T extends MapstructBaseReference> PsiReference[] create(PsiLiteral psiLi
                 nextStart++;
                 endOffset++;
             }
-            lastReference = creator.create( psiLiteral, lastReference, new TextRange( nextStart, endOffset ) );
+            lastReference = creator.create( psiElement, lastReference, new TextRange( nextStart, endOffset ) );
             nextStart = endOffset;
             references[i] = lastReference;
         }

src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructSourceReference.java

@@ -5,15 +5,11 @@
  */
 package org.mapstruct.intellij.codeinsight.references;
 
-import java.util.Objects;
-import java.util.stream.Stream;
-
 import com.intellij.codeInsight.lookup.LookupElement;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiField;
-import com.intellij.psi.PsiLiteral;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.PsiParameter;
 import com.intellij.psi.PsiReference;
@@ -24,6 +20,9 @@
 import org.jetbrains.annotations.Nullable;
 import org.mapstruct.intellij.util.MapstructUtil;
 
+import java.util.Objects;
+import java.util.stream.Stream;
+
 import static org.mapstruct.intellij.util.MapstructUtil.asLookup;
 import static org.mapstruct.intellij.util.MapstructUtil.isPublicNonStatic;
 import static org.mapstruct.intellij.util.SourceUtils.getParameterType;
@@ -43,7 +42,7 @@ class MapstructSourceReference extends MapstructBaseReference {
      * @param previousReference the previous reference if there is one (in nested properties for example)
      * @param rangeInElement the range that the reference represent in the {@code element}
      */
-    private MapstructSourceReference(PsiLiteral element, MapstructSourceReference previousReference,
+    private MapstructSourceReference(PsiElement element, MapstructSourceReference previousReference,
         TextRange rangeInElement) {
         super( element, previousReference, rangeInElement );
     }
@@ -125,12 +124,12 @@ else if ( element instanceof PsiParameter ) {
     }
 
     /**
-     * @param psiLiteral the literal for which references need to be created
+     * @param psiElement the literal for which references need to be created
      *
      * @return the references for the given {@code psiLiteral}
      */
-    static PsiReference[] create(PsiLiteral psiLiteral) {
-        return MapstructBaseReference.create( psiLiteral, MapstructSourceReference::new );
+    static PsiReference[] create(PsiElement psiElement) {
+        return MapstructBaseReference.create( psiElement, MapstructSourceReference::new );
     }
 
     private static PsiType memberPsiType(PsiElement psiMember) {

src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructTargetReference.java

@@ -14,7 +14,6 @@
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiField;
-import com.intellij.psi.PsiLiteral;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.PsiParameter;
 import com.intellij.psi.PsiReference;
@@ -50,7 +49,7 @@ class MapstructTargetReference extends MapstructBaseReference {
      * @param previousReference the previous reference if there is one (in nested properties for example)
      * @param rangeInElement the range that the reference represent in the {@code element}
      */
-    private MapstructTargetReference(PsiLiteral element, MapstructTargetReference previousReference,
+    private MapstructTargetReference(PsiElement element, MapstructTargetReference previousReference,
         TextRange rangeInElement) {
         super( element, previousReference, rangeInElement );
         mapStructVersion = MapstructUtil.resolveMapStructProjectVersion( element.getContainingFile()
@@ -154,12 +153,12 @@ else if ( element instanceof PsiParameter ) {
     }
 
     /**
-     * @param psiLiteral the literal for which references need to be created
+     * @param psiElement the literal for which references need to be created
      *
      * @return the references for the given {@code psiLiteral}
      */
-    static PsiReference[] create(PsiLiteral psiLiteral) {
-        return MapstructBaseReference.create( psiLiteral, MapstructTargetReference::new );
+    static PsiReference[] create(PsiElement psiElement) {
+        return MapstructBaseReference.create( psiElement, MapstructTargetReference::new );
     }
 
     private static PsiType memberPsiType(PsiElement psiMember) {