#88 Fix crash when injecting Java code for expression

This commit fixes the crash that is happening when using a constant for the target

Author: filiphr

change-notes.html

@@ -2,6 +2,7 @@
 <h2>1.3.1</h2>
 <ul>
     <li>Improve language injections, especially for generics</li>
+    <li>Bug fix: Crash in case using static constant in target field of <code>@Mapping</code> annotation</li>
 </ul>
 <h2>1.3.0</h2>
 <ul>

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

@@ -11,7 +11,7 @@
 import com.intellij.psi.PsiReferenceBase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.uast.ULiteralExpression;
+import org.jetbrains.uast.UExpression;
 import org.jetbrains.uast.UMethod;
 import org.jetbrains.uast.UastContextKt;
 import org.jetbrains.uast.UastUtils;
@@ -44,7 +44,7 @@ abstract class BaseReference extends PsiReferenceBase<PsiElement> {
     @Nullable
     PsiMethod getMappingMethod() {
         PsiElement element = getElement();
-        ULiteralExpression expression = UastContextKt.toUElement( element, ULiteralExpression.class );
+        UExpression expression = UastContextKt.toUElement( element, UExpression.class );
         if ( expression != null ) {
             UMethod parent = UastUtils.getParentOfType( expression, UMethod.class );
             if ( parent != null ) {

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

@@ -5,14 +5,19 @@
  */
 package org.mapstruct.intellij.codeinsight.references;
 
+import java.util.function.Function;
+
 import com.intellij.codeInsight.lookup.LookupElement;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.ElementManipulator;
 import com.intellij.psi.ElementManipulators;
 import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiLiteralExpression;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.PsiReference;
+import com.intellij.psi.PsiReferenceExpression;
 import com.intellij.psi.PsiType;
+import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -28,6 +33,7 @@
 abstract class MapstructBaseReference extends BaseReference {
 
     private final MapstructBaseReference previous;
+    private final String value;
 
     /**
      * Create a reference.
@@ -37,9 +43,19 @@ abstract class MapstructBaseReference extends BaseReference {
      * @param rangeInElement the range in the {@code element} for which this reference is valid
      */
     MapstructBaseReference(@NotNull PsiElement element,
-        @Nullable MapstructBaseReference previous, TextRange rangeInElement) {
+        @Nullable MapstructBaseReference previous, TextRange rangeInElement, String value) {
         super( element, rangeInElement );
         this.previous = previous;
+        this.value = value;
+    }
+
+    @Override
+    @NotNull
+    public String getValue() {
+        if ( value != null ) {
+            return value;
+        }
+        return super.getValue();
     }
 
     @Nullable
@@ -152,30 +168,74 @@ private static ElementManipulator<PsiElement> getManipulator(PsiElement psiEleme
      */
     static <T extends MapstructBaseReference> PsiReference[] create(PsiElement psiElement,
         ReferenceCreator<T> creator, boolean supportsNested) {
-        ElementManipulator<PsiElement> manipulator = getManipulator( psiElement );
-        TextRange rangeInElement = manipulator.getRangeInElement( psiElement );
-        String targetValue = rangeInElement.substring( psiElement.getText() );
+        String targetValue;
+        Function<String, TextRange> rangeCreator;
+        if ( psiElement instanceof PsiReferenceExpression ) {
+            PsiElement resolvedPsiElement = ( (PsiReferenceExpression) psiElement ).resolve();
+
+            PsiLiteralExpression expression = PsiTreeUtil.findChildOfType(
+                resolvedPsiElement,
+                PsiLiteralExpression.class
+            );
+
+            if ( expression == null ) {
+                return PsiReference.EMPTY_ARRAY;
+            }
+
+            ElementManipulator<PsiElement> manipulator = getManipulator( expression );
+            TextRange rangeInElement = manipulator.getRangeInElement( expression );
+            targetValue = rangeInElement.substring( expression.getText() );
+            rangeCreator = part -> TextRange.EMPTY_RANGE;
+
+        }
+        else {
+            ElementManipulator<PsiElement> manipulator = getManipulator( psiElement );
+            TextRange rangeInElement = manipulator.getRangeInElement( psiElement );
+            targetValue = rangeInElement.substring( psiElement.getText() );
+
+            rangeCreator = new RangeCreator( rangeInElement.getStartOffset() );
+
+        }
+
         String[] parts = supportsNested ? targetValue.split( "\\." ) : new String[] { targetValue };
         if ( parts.length == 0 ) {
             return PsiReference.EMPTY_ARRAY;
         }
-        int nextStart = rangeInElement.getStartOffset();
 
         PsiReference[] references = new PsiReference[parts.length];
         T lastReference = null;
 
         for ( int i = 0; i < parts.length; i++ ) {
             String part = parts[i];
+            lastReference = creator.create( psiElement, lastReference, rangeCreator.apply( part ), part );
+            references[i] = lastReference;
+        }
+
+        return references;
+    }
+
+    private static class RangeCreator implements Function<String, TextRange> {
+
+        private int nextStart;
+        private boolean first = true;
+
+        private RangeCreator(int nextStart) {
+            this.nextStart = nextStart;
+        }
+
+        @Override
+        public TextRange apply(String part) {
             int endOffset = nextStart + part.length();
-            if ( i != 0 ) {
+            if ( !first ) {
                 nextStart++;
                 endOffset++;
             }
-            lastReference = creator.create( psiElement, lastReference, new TextRange( nextStart, endOffset ) );
+            else {
+                first = false;
+            }
+            TextRange range = new TextRange( nextStart, endOffset );
             nextStart = endOffset;
-            references[i] = lastReference;
+            return range;
         }
-
-        return references;
     }
 }

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

@@ -41,10 +41,11 @@ class MapstructSourceReference extends MapstructBaseReference {
      * @param element the element that the reference belongs to
      * @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}
+     * @param value the matched value (useful when {@code rangeInElement} is empty)
      */
     private MapstructSourceReference(PsiElement element, MapstructSourceReference previousReference,
-        TextRange rangeInElement) {
-        super( element, previousReference, rangeInElement );
+        TextRange rangeInElement, String value) {
+        super( element, previousReference, rangeInElement, value );
     }
 
     @Override

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

@@ -50,10 +50,11 @@ class MapstructTargetReference extends MapstructBaseReference {
      * @param element the element that the reference belongs to
      * @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}
+     * @param value the matched value (useful when {@code rangeInElement} is empty)
      */
     private MapstructTargetReference(PsiElement element, MapstructTargetReference previousReference,
-        TextRange rangeInElement) {
-        super( element, previousReference, rangeInElement );
+        TextRange rangeInElement, String value) {
+        super( element, previousReference, rangeInElement, value );
         mapStructVersion = MapstructUtil.resolveMapStructProjectVersion( element.getContainingFile()
             .getOriginalFile() );
     }

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

@@ -24,8 +24,9 @@ interface ReferenceCreator<T extends MapstructBaseReference> {
      * @param psiElement the element that the reference belongs to
      * @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 psiLiteral}
+     * @param value the value that was matched
      *
      * @return a new reference created from the provided parameters
      */
-    T create(PsiElement psiElement, T previousReference, TextRange rangeInElement);
+    T create(PsiElement psiElement, T previousReference, TextRange rangeInElement, String value);
 }

src/test/java/org/mapstruct/intellij/expression/JavaExpressionInjectionTest.java

@@ -567,6 +567,41 @@ protected void withClassMapper(String attribute) {
             "}" );
     }
 
+    public void testExpressionWithTargetUsingStaticString() {
+        withTargetUsingStaticString( "expression" );
+        withTargetUsingStaticString( "defaultExpression" );
+    }
+
+    protected void withTargetUsingStaticString(String attribute) {
+        configureMapperByText(
+            "import org.mapstruct.Mapper;\n" +
+            "import org.mapstruct.Mapping;\n" +
+            "import org.example.dto.CarDto;\n" +
+            "import org.example.dto.Car;\n" +
+            "import org.example.dto.Utils;\n" +
+            "\n" +
+            "@Mapper\n" +
+            "public abstract class CarMapper {\n" +
+            "\n" +
+            "    @Mapping( target = Utils.MANUFACTURING_YEAR, " + attribute + " = \"java(car.<caret>)\")\n" +
+            "    CarDto carToCarDto(Car car);\n" +
+            "}" );
+
+        assertJavaFragment( "import CarMapper;\n" +
+            "import org.example.dto.Car;\n" +
+            "\n" +
+            "@SuppressWarnings(\"unused\")\n" +
+            "abstract class CarMapperImpl\n" +
+            "    extends CarMapper {\n" +
+            "\n" +
+            "    void __test__(\n" +
+            "        Car car\n" +
+            "    ) {\n" +
+            "        String __target__ = car.;\n" +
+            "    }\n" +
+            "}" );
+    }
+
     private PsiFile configureMapperByText(@Language("java") String text) {
         return myFixture.configureByText( JavaFileType.INSTANCE, text );
     }

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

@@ -65,6 +65,8 @@ public void testUnmappedTargetProperties() {
                 "Ignore unmapped target property: 'testName'",
                 "Add unmapped target property: 'testName'",
                 "Ignore unmapped target property: 'moreTarget'",
+                "Add unmapped target property: 'moreTarget'",
+                "Ignore unmapped target property: 'moreTarget'",
                 "Add unmapped target property: 'moreTarget'"
             );
 

testData/expression/dto/Utils.java

@@ -7,4 +7,6 @@
 
 public class Utils {
 
+    public static final String MANUFACTURING_YEAR = "manufacturingYear";
+
 }

testData/inspection/UnmappedTargetProperties.java

@@ -80,4 +80,13 @@ interface UpdateMapper {
 interface MultiSourceUpdateMapper {
 
     void <warning descr="Unmapped target property: moreTarget">update</warning>(@MappingTarget Target moreTarget, Source source, String testName, @org.mapstruct.Context String matching);
+}
+
+@Mapper
+interface SingleMappingConstantReferenceMapper {
+
+    String TEST_NAME = "testName";
+
+    @Mapping(target = TEST_NAME, source = "name")
+    Target <warning descr="Unmapped target property: moreTarget">map</warning>(Source source);
 }