Add "unused equals" warning on direct equals call #KT-21192 Fixed

idea/src/org/jetbrains/kotlin/idea/inspections/UnusedEqualsInspection.kt

@@ -20,30 +20,44 @@ import com.intellij.codeInspection.ProblemHighlightType
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.PsiElementVisitor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.intentions.conventionNameCalls.isAnyEquals
 import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.KtBlockExpression
-import org.jetbrains.kotlin.psi.KtIfExpression
-import org.jetbrains.kotlin.psi.KtVisitorVoid
 import org.jetbrains.kotlin.resolve.bindingContextUtil.isUsedAsExpression
+import org.jetbrains.kotlin.util.OperatorNameConventions
 
 class UnusedEqualsInspection : AbstractKotlinInspection() {
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
         return object : KtVisitorVoid() {
+            private fun reportIfNotUsedAsExpression(expression: KtExpression, target: KtExpression) {
+                val context = expression.analyze()
+                if (!expression.isUsedAsExpression(context)) {
+                    holder.registerProblem(target,
+                                           "Unused equals expression",
+                                           ProblemHighlightType.LIKE_UNUSED_SYMBOL)
+
+                }
+            }
+
             override fun visitBinaryExpression(expression: KtBinaryExpression) {
                 super.visitBinaryExpression(expression)
                 if (expression.operationToken == KtTokens.EQEQ &&
                     (expression.parent is KtBlockExpression || expression.parent.parent is KtIfExpression)) {
-                    val context = expression.analyze()
+                    reportIfNotUsedAsExpression(expression, expression.operationReference)
-                    if (!expression.isUsedAsExpression(context)) {
-                        holder.registerProblem(expression.operationReference,
-                                               "Unused equals expression",
-                                               ProblemHighlightType.LIKE_UNUSED_SYMBOL)
-
-                    }
                 }
             }
+
+            override fun visitDotQualifiedExpression(expression: KtDotQualifiedExpression) {
+                super.visitDotQualifiedExpression(expression)
+
+                val callExpression = expression.selectorExpression as? KtCallExpression ?: return
+                val calleeExpression = callExpression.calleeExpression as? KtSimpleNameExpression ?: return
+                if (calleeExpression.getReferencedNameAsName() != OperatorNameConventions.EQUALS) return
+
+                if (!expression.isAnyEquals()) return
+                reportIfNotUsedAsExpression(expression, calleeExpression)
+            }
         }
     }
 

idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ConventionUtils.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.intentions.conventionNameCalls
+
+import org.jetbrains.kotlin.idea.intentions.toResolvedCall
+import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
+import org.jetbrains.kotlin.resolve.findOriginalTopMostOverriddenDescriptors
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
+
+fun KtDotQualifiedExpression.isAnyEquals(): Boolean {
+    val resolvedCall = toResolvedCall(BodyResolveMode.PARTIAL) ?: return false
+    val overriddenDescriptors = resolvedCall.resultingDescriptor.findOriginalTopMostOverriddenDescriptors()
+    return overriddenDescriptors.any { it.fqNameUnsafe.asString() == "kotlin.Any.equals" }
+}

idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceCallWithBinaryOperatorIntention.kt

@@ -112,9 +112,7 @@ class ReplaceCallWithBinaryOperatorIntention : SelfTargetingRangeIntention<KtDot
         val dotQualified = calleeExpression.parent.parent as? KtDotQualifiedExpression ?: return null
         return when (identifier) {
             OperatorNameConventions.EQUALS -> {
-                val resolvedCall = dotQualified.toResolvedCall(BodyResolveMode.PARTIAL) ?: return null
+                if (!dotQualified.isAnyEquals()) return null
-                val overriddenDescriptors = resolvedCall.resultingDescriptor.findOriginalTopMostOverriddenDescriptors()
-                if (overriddenDescriptors.none { it.fqNameUnsafe.asString() == "kotlin.Any.equals" }) return null
 
                 val prefixExpression = dotQualified.getWrappingPrefixExpressionIfAny()
                 if (prefixExpression != null && prefixExpression.operationToken == KtTokens.EXCL) KtTokens.EXCLEQ

idea/testData/inspections/unusedEquals/consumer/ConsumerVoid.java

@@ -0,0 +1,5 @@
+package consumer;
+
+public interface ConsumerVoid<T> {
+    void consumer(T t);
+}

idea/testData/inspections/unusedEquals/inspectionData/expected.xml

@@ -79,4 +79,22 @@
         <problem_class severity="WARNING" attribute_key="NOT_USED_ELEMENT_ATTRIBUTES">Unused equals expression</problem_class>
         <description>Unused equals expression</description>
     </problem>
+
+    <problem>
+        <file>test.kt</file>
+        <line>71</line>
+        <module>light_idea_test_case</module>
+        <entry_point TYPE="file" FQNAME="temp:///src/test.kt" />
+        <problem_class severity="WARNING" attribute_key="NOT_USED_ELEMENT_ATTRIBUTES">Unused equals expression</problem_class>
+        <description>Unused equals expression</description>
+    </problem>
+
+    <problem>
+        <file>test.kt</file>
+        <line>75</line>
+        <module>light_idea_test_case</module>
+        <entry_point TYPE="file" FQNAME="temp:///src/test.kt" />
+        <problem_class severity="WARNING" attribute_key="NOT_USED_ELEMENT_ATTRIBUTES">Unused equals expression</problem_class>
+        <description>Unused equals expression</description>
+    </problem>
 </problems>

idea/testData/inspections/unusedEquals/test.kt

@@ -67,6 +67,14 @@ fun foo9() {
     consumer.Consumer<Any?> { it == null } // used
 }
 
+fun foo9a() {
+    consumer.ConsumerVoid<Any?> { it == null } // not used
+}
+
+fun foo9b() {
+    consumer.ConsumerVoid<Any?> { it.equals(null) } // not used
+}
+
 class Test(val successCondition: (Int) -> Boolean) {
     fun pass(num: Int): Boolean = successCondition(num)
 }