More correct operator treatment

idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt

@@ -82,7 +82,7 @@ class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, ReferencesSearc
         val specialSymbols = runReadAction { unwrappedElement.getSpecialNamesToSearch(kotlinOptions) }
         val words = runReadAction {
             val classNameForCompanionObject = unwrappedElement.getClassNameForCompanionObject()
-            specialSymbols.first +
+            (specialSymbols?.first ?: emptyList()) +
             (if (classNameForCompanionObject != null) listOf(classNameForCompanionObject) else emptyList())
         }
 
@@ -93,7 +93,7 @@ class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, ReferencesSearc
 
         val refFilter: (PsiReference) -> Boolean = when {
             unwrappedElement is KtParameter -> ({ ref: PsiReference -> !ref.isNamedArgumentReference()/* they are processed later*/ })
-            specialSymbols.second != null -> { ref -> ref.javaClass == specialSymbols.second }
+            specialSymbols != null -> { ref -> ref.javaClass == specialSymbols.second }
             else -> ({true})
         }
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/ExpressionsOfTypeProcessor.kt

@@ -28,8 +28,10 @@ import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.util.Processor
 import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
+import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
@@ -44,7 +46,9 @@ import org.jetbrains.kotlin.idea.search.restrictToKotlinSources
 import org.jetbrains.kotlin.idea.util.FuzzyType
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocName
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.java.sam.SingleAbstractMethodUtils
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.types.KotlinType
@@ -584,13 +588,12 @@ class ExpressionsOfTypeProcessor(
     }
 
     private fun PsiElement.isOperatorExpensiveToSearch(): Boolean {
-        return false //TODO
-/*
         when (this) {
             is KtFunction -> {
-                if (name?.startsWith("component") == true || name == OperatorNameConventions.INVOKE.asString()) return false
-                return  hasModifier(KtTokens.OPERATOR_KEYWORD)
-                        || hasModifier(KtTokens.OVERRIDE_KEYWORD) && (resolveToDescriptorIfAny() as? FunctionDescriptor)?.isOperator == true
+                val isOperator = hasModifier(KtTokens.OPERATOR_KEYWORD)
+                                  || hasModifier(KtTokens.OVERRIDE_KEYWORD) && (resolveToDescriptorIfAny() as? FunctionDescriptor)?.isOperator == true
+                val name = name
+                return isOperator && name != null && Name.isValidIdentifier(name) && Name.identifier(name).getOperationSymbolsToSearch() != null
             }
 
             is KtLightMethod -> {
@@ -601,7 +604,6 @@ class ExpressionsOfTypeProcessor(
                 return false
             }
         }
-*/
     }
 
     private fun KotlinType.containsTypeOrDerivedInside(type: FuzzyType): Boolean {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/conventions.kt

@@ -48,7 +48,7 @@ val IN_OPERATIONS_TO_SEARCH = setOf(KtTokens.IN_KEYWORD)
 
 val COMPARISON_OPERATIONS_TO_SEARCH = setOf(KtTokens.LT, KtTokens.GT)
 
-fun Name.getOperationSymbolsToSearch(): Pair<Set<KtToken>, Class<*>?> {
+fun Name.getOperationSymbolsToSearch(): Pair<Set<KtToken>, Class<*>>? {
     when (this) {
         OperatorNameConventions.COMPARE_TO -> return COMPARISON_OPERATIONS_TO_SEARCH to KtSimpleNameReference::class.java
         OperatorNameConventions.EQUALS -> return EQUALS_OPERATIONS to KtSimpleNameReference::class.java
@@ -59,19 +59,11 @@ fun Name.getOperationSymbolsToSearch(): Pair<Set<KtToken>, Class<*>?> {
         DelegatedPropertyResolver.PROPERTY_DELEGATED_FUNCTION_NAME -> return setOf(KtTokens.BY_KEYWORD) to KtPropertyDelegationMethodsReference::class.java
     }
 
-    val unaryOp = UNARY_OPERATION_NAMES_WITH_DEPRECATED_INVERTED[this]
+    val unaryOp = UNARY_OPERATION_NAMES.inverse()[this]
     if (unaryOp != null) return setOf(unaryOp) to KtSimpleNameReference::class.java
 
-/*
-    val binaryOp = BINARY_OPERATION_NAMES.inverse()[this]
-    if (binaryOp != null) {
-        val assignmentOp = ASSIGNMENT_OPERATION_COUNTERPARTS.inverse()[binaryOp]
-        return (if (assignmentOp != null) setOf(binaryOp, assignmentOp) else setOf(binaryOp)) to KtSimpleNameReference::class.java
-    }
-*/
-
     val assignmentOp = ASSIGNMENT_OPERATIONS.inverse()[this]
     if (assignmentOp != null) return setOf(assignmentOp) to KtSimpleNameReference::class.java
 
-    return emptySet<KtToken>() to null
+    return null
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/searchHelpers.kt

@@ -63,14 +63,14 @@ fun PsiNamedElement.getClassNameForCompanionObject(): String? {
     }
 }
 
-fun PsiNamedElement.getSpecialNamesToSearch(options: KotlinReferencesSearchOptions): Pair<List<String>, Class<*>?> {
+fun PsiNamedElement.getSpecialNamesToSearch(options: KotlinReferencesSearchOptions): Pair<List<String>, Class<*>>? {
     val name = name
-    return when {
-        name == null || !Name.isValidIdentifier(name) -> Collections.emptyList<String>() to null
+    when {
+        name == null || !Name.isValidIdentifier(name) -> return null
 
         else -> {
-            val operationSymbolsToSearch = Name.identifier(name).getOperationSymbolsToSearch()
-            operationSymbolsToSearch.first.map { (it as KtSingleValueToken).value } to operationSymbolsToSearch.second
+            val operationSymbolsToSearch = Name.identifier(name).getOperationSymbolsToSearch() ?: return null
+            return operationSymbolsToSearch.first.map { (it as KtSingleValueToken).value } to operationSymbolsToSearch.second
         }
     }
 }