Add diagnostic for calling ConcurrentHashMap::contains by convention

^KT-18053 Fixed

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InconsistentOperatorFromJavaCallChecker.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.resolve.jvm.checkers
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
+import org.jetbrains.kotlin.resolve.calls.checkers.CallCheckerContext
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameOrNull
+import org.jetbrains.kotlin.resolve.descriptorUtil.overriddenTreeUniqueAsSequence
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
+import org.jetbrains.kotlin.types.typeUtil.isAnyOrNullableAny
+import org.jetbrains.kotlin.util.OperatorNameConventions
+
+/**
+ * This checker detects if call by operator convention to a Java method violates some expected contract:
+ * - "key in map" commonly resolves to an stdlib extension that calls Map.containsKey(),
+ *   but there's a member in ConcurrentHashMap with acceptable signature that delegates to `containsValue` instead
+ */
+object InconsistentOperatorFromJavaCallChecker : CallChecker {
+    private val CONCURRENT_HASH_MAP_FQ_NAME = FqName("java.util.concurrent.ConcurrentHashMap")
+
+    override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) {
+        val candidateDescriptor = resolvedCall.candidateDescriptor
+        if (candidateDescriptor.name != OperatorNameConventions.CONTAINS) return
+        if (candidateDescriptor.valueParameters.singleOrNull()?.type?.isAnyOrNullableAny() != true) return
+        if (resolvedCall.call.callElement !is KtBinaryExpression || !resolvedCall.status.possibleTransformToSuccess()) return
+
+        for (callableDescriptor in candidateDescriptor.overriddenTreeUniqueAsSequence(useOriginal = false)) {
+            val containingClass = callableDescriptor.containingDeclaration as? ClassDescriptor ?: continue
+            if (containingClass.fqNameOrNull() != CONCURRENT_HASH_MAP_FQ_NAME) continue
+
+            val diagnosticFactory =
+                if (context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitConcurrentHashMapContains))
+                    ErrorsJvm.CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR
+                else
+                    ErrorsJvm.CONCURRENT_HASH_MAP_CONTAINS_OPERATOR
+
+            context.trace.report(diagnosticFactory.on(reportOn))
+            break
+        }
+    }
+}

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java

@@ -138,6 +138,13 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension {
         MAP.put(EXPLICIT_METADATA_IS_DISALLOWED, "Explicit @Metadata is disallowed");
         MAP.put(SUSPENSION_POINT_INSIDE_MONITOR, "A suspension point at {0} is inside a critical section", STRING);
         MAP.put(SUSPENSION_POINT_INSIDE_SYNCHRONIZED, "The ''{0}'' suspension point is inside a synchronized block", NAME);
+
+        String MESSAGE_FOR_CONCURRENT_HASH_MAP_CONTAINS =
+                "Method 'contains' from ConcurrentHashMap may have unexpected semantics: it calls 'containsValue' instead of 'containsKey'. " +
+                "Use explicit form of the call to 'containsKey'/'containsValue'/'contains' or cast the value to kotlin.collections.Map instead. " +
+                "See https://youtrack.jetbrains.com/issue/KT-18053 for more details";
+        MAP.put(CONCURRENT_HASH_MAP_CONTAINS_OPERATOR, MESSAGE_FOR_CONCURRENT_HASH_MAP_CONTAINS);
+        MAP.put(CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR, MESSAGE_FOR_CONCURRENT_HASH_MAP_CONTAINS);
     }
 
     @NotNull

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java

@@ -125,6 +125,9 @@ public interface ErrorsJvm {
     DiagnosticFactory1<PsiElement, String> SUSPENSION_POINT_INSIDE_MONITOR = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory1<PsiElement, CallableDescriptor> SUSPENSION_POINT_INSIDE_SYNCHRONIZED = DiagnosticFactory1.create(ERROR);
 
+    DiagnosticFactory0<PsiElement> CONCURRENT_HASH_MAP_CONTAINS_OPERATOR = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory0<PsiElement> CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR = DiagnosticFactory0.create(ERROR);
+
     @SuppressWarnings("UnusedDeclaration")
     Object _initializer = new Object() {
         {

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt

@@ -50,7 +50,8 @@ object JvmPlatformConfigurator : PlatformConfiguratorBase(
         ProtectedSyntheticExtensionCallChecker,
         ReifiedTypeParameterSubstitutionChecker(),
         RuntimeAssertionsOnExtensionReceiverCallChecker,
-        ApiVersionIsAtLeastArgumentsChecker
+        ApiVersionIsAtLeastArgumentsChecker,
+        InconsistentOperatorFromJavaCallChecker
     ),
 
     additionalTypeCheckers = listOf(