feature: inspection on redundant dropReturn call

src/main/kotlin/de/sirywell/handlehints/inspection/ProblemEmitter.kt

@@ -92,7 +92,7 @@ abstract class ProblemEmitter(protected val typeData: TypeData) {
 
     protected fun emitRedundant(element: PsiElement, message: String, vararg quickFixes: LocalQuickFix) {
         typeData.reportProblem(element) {
-            it.registerProblem(element, message, ProblemHighlightType.LIKE_UNUSED_SYMBOL, *quickFixes)
+            it.registerProblem(element, message, ProblemHighlightType.GENERIC_ERROR_OR_WARNING, *quickFixes)
         }
 
     }

src/main/kotlin/de/sirywell/handlehints/inspection/RedundantInvocationFix.kt

@@ -2,12 +2,17 @@
 
 import com.intellij.codeInspection.LocalQuickFix
 import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.lang.jvm.JvmModifier
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiMethodCallExpression
 import com.siyeh.ig.PsiReplacementUtil
 import com.siyeh.ig.psiutils.CommentTracker
 import de.sirywell.handlehints.MethodHandleBundle
 
+/**
+ * Convert calls of the form Class.method(p0, ..., pn) into p0,
+ * and calls of the form object.method(p0, ..., pn) into object
+ */
 class RedundantInvocationFix : LocalQuickFix {
     override fun getFamilyName(): String {
         return MethodHandleBundle.message("problem.general.invocation.redundant.remove")
@@ -17,9 +22,14 @@
         val commentTracker = CommentTracker()
         when (val psiElement = descriptor.psiElement) {
             is PsiMethodCallExpression -> {
+                val replacement = if (psiElement.resolveMethod()?.hasModifier(JvmModifier.STATIC) ?: return) {
+                    psiElement.argumentList.expressions.first()
+                } else {
+                    psiElement.methodExpression.qualifierExpression
+                }
                 PsiReplacementUtil.replaceExpression(
                     psiElement,
-                    psiElement.methodExpression.qualifierExpression?.text!!,
+                    replacement?.text!!,
                     commentTracker
                 )
             }

src/main/kotlin/de/sirywell/handlehints/mhtype/MethodHandlesMerger.kt

@@ -1,12 +1,15 @@
 package de.sirywell.handlehints.mhtype
 
 import com.intellij.psi.PsiExpression
+import com.intellij.psi.PsiMethodCallExpression
 import com.intellij.psi.PsiTypes
+import com.intellij.psi.util.parentOfType
 import de.sirywell.handlehints.*
 import de.sirywell.handlehints.MethodHandleBundle.message
 import de.sirywell.handlehints.dfa.SsaAnalyzer
 import de.sirywell.handlehints.dfa.SsaConstruction
 import de.sirywell.handlehints.inspection.ProblemEmitter
+import de.sirywell.handlehints.inspection.RedundantInvocationFix
 import de.sirywell.handlehints.type.*
 
 /**
@@ -224,7 +227,7 @@
     ): MethodHandleType {
         val types = valueTypes.mapToTypes()
         val target = ssaAnalyzer.methodHandleType(targetExpr, block) ?: bottomType
         val signature = target
         if (signature.parameterTypes.compareSize(pos) == PartialOrder.LT) {
             return emitOutOfBounds(signature.parameterTypes.sizeOrNull()?.toLong(), targetExpr, pos.toLong(), false)
         }
@@ -237,11 +240,15 @@
     // fun dropCoordinates() no VarHandle support, preview
 
     fun dropReturn(targetExpr: PsiExpression, block: SsaConstruction.Block): MethodHandleType {
-        val target = ssaAnalyzer.methodHandleType(targetExpr, block) ?: bottomType
-        if (target is CompleteMethodHandleType) {
-            return target.withReturnType(ExactType.voidType)
+        val target = ssaAnalyzer.methodHandleType(targetExpr, block) ?: topType
+        if (target.returnType == ExactType.voidType) {
+            emitRedundant(
+                targetExpr.parentOfType<PsiMethodCallExpression>()!!,
+                message("problem.transforming.dropReturn.redundant"),
+                RedundantInvocationFix()
+            )
         }
-        return target
+        return target.withReturnType(ExactType.voidType)
     }
 
     fun explicitCastArguments(
@@ -264,7 +271,7 @@
         // TODO proper handling of bottom/top
         if (target !is CompleteMethodHandleType) return target
         if (filters.any { it !is CompleteMethodHandleType }) return topType
         val targetSignature = target
         val targetParameterList = targetSignature.parameterTypes
         if (targetParameterList.sizeMatches { pos + filters.size > it } == TriState.YES) return topType
         val filtersCast = filters.map { it as CompleteMethodHandleType }
@@ -374,10 +381,10 @@
         return target.withParameterTypes(new)
     }
 
     fun iteratedLoop(iterator: MethodHandleType, init: MethodHandleType, body: MethodHandleType): MethodHandleType =
         TODO()
 
     fun loop(clauses: List<List<MethodHandleType>>): MethodHandleType =
         TODO() // not sure if we can do anything about this
 
     fun permuteArguments(
@@ -493,14 +500,14 @@
         return target
     }
 
     fun whileLoop(
         initExpr: PsiExpression,
         bodyExpr: PsiExpression,
         predExpr: PsiExpression,
         block: SsaConstruction.Block
     ) = doWhileLoop(initExpr, bodyExpr, predExpr, block) // same type behavior
 
     fun PsiExpression.nonNegativeInt(): Int? {
         return this.getConstantOfType<Int>()?.let {
             if (it < 0) {
                 emitProblem<MethodHandleType>(this, message("problem.general.position.invalidIndexNegative", it))

src/main/resources/messages/MethodHandleMessages.properties

@@ -34,11 +34,12 @@ problem.merging.tableSwitch.leadingInt=The passed MethodHandle requires a leadin
 problem.merging.tableSwitch.notIdentical=The passed MethodHandle type is not compatible with the previous handle(s).
 problem.merging.withVarargs.arrayTypeExpected=Last parameter type must be an array but was {0}.
 problem.merging.withVarargs.noParameters=MethodHandle does not have any parameters.
+problem.transforming.dropReturn.redundant=MethodHandle to drop return from already has return type 'void'.
 problem.invocation.returnType.mustBeVoid=MethodHandle returns void but is called in a non-void context.
 problem.general.argument.notAPowerOfTwo=Argument must be a power of 2 but was {0}.
 problem.general.argument.numericConditionMismatch=Argument must be {0} but is {1}.
 problem.general.invocation.redundant=Redundant method invocation.
-problem.general.invocation.redundant.remove=Remove redundant method invocation.
+problem.general.invocation.redundant.remove=Remove redundant method invocation
 problem.foreign.memory.layoutSizeOverflow=Resulting layout byte size overflows.
 problem.foreign.memory.layoutMismatch=Layout requires a byte alignment of {0} but is inserted at an offset of {1}.
 problem.foreign.memory.alignmentMismatch=Layout must be {0} byte aligned but is {1} byte aligned.

src/test/kotlin/de/sirywell/handlehints/mhtype/MethodHandleInspectionsTest.kt

@@ -48,7 +48,7 @@ class MethodHandleInspectionsTest : TypeAnalysisTestBase() {
 
     fun testMethodHandlesDropArguments() = doTypeCheckingTest()
 
-    fun testMethodHandlesDropReturn() = doTypeCheckingTest()
+    fun testMethodHandlesDropReturn() = doInspectionAndTypeCheckingTest()
 
     fun testMethodHandlesEmpty() = doTypeCheckingTest()
 

src/test/testData/MethodHandlesDropReturn.java

@@ -3,9 +3,13 @@
 import java.lang.invoke.MethodType;
 
 class MethodHandlesDropReturn {
-  static {
-    try {
-      <info descr="(int)void">MethodHandle mh = <info descr="(int)void">MethodHandles.dropReturn(<info descr="(int)int">MethodHandles.identity(int.class)</info>)</info>;</info>
-    } catch (Throwable ignored) {}
+  void droppingReturn(MethodHandle mh10) {
+    <info descr="(int)int">MethodHandle mh00 = <info descr="(int)int">MethodHandles.identity(int.class)</info>;</info>
+    // dropping makes sense
+    <info descr="(int)void">MethodHandle mh01 = <info descr="(int)void">MethodHandles.dropReturn(mh00)</info>;</info>
+    // dropping doesn't make sense, but type stays!
+    <info descr="(int)void">MethodHandle mh02 = <warning descr="MethodHandle to drop return from already has return type 'void'."><info descr="(int)void">MethodHandles.dropReturn(mh01)</info></warning>;</info>
+    // we don't know if dropping makes sense - assume it does
+    <info descr="⊤">MethodHandle mh11 = <info descr="⊤">MethodHandles.dropReturn(mh10)</info>;</info>
   }
 }