Handle fake overrides of members of Any in BuiltInsReferenceResolver

idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java

@@ -176,6 +176,15 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
 
     @Nullable
     private DeclarationDescriptor findCurrentDescriptorForMember(@NotNull MemberDescriptor originalDescriptor) {
+        if (originalDescriptor instanceof CallableMemberDescriptor &&
+            ((CallableMemberDescriptor) originalDescriptor).getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+            CallableMemberDescriptor descriptor = (CallableMemberDescriptor) originalDescriptor;
+            while (descriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+                descriptor = descriptor.getOverriddenDescriptors().iterator().next();
+            }
+            return findCurrentDescriptorForMember(descriptor.getOriginal());
+        }
+
         DeclarationDescriptor containingDeclaration = findCurrentDescriptor(originalDescriptor.getContainingDeclaration());
         JetScope memberScope = getMemberScope(containingDeclaration);
         if (memberScope == null) return null;
@@ -220,10 +229,7 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
             return Collections.emptyList();
         }
 
-        DeclarationDescriptor descriptor = declarationDescriptor;
+        DeclarationDescriptor descriptor = findCurrentDescriptor(declarationDescriptor.getOriginal());
-
-        descriptor = descriptor.getOriginal();
-        descriptor = findCurrentDescriptor(descriptor);
         if (descriptor != null) {
             return BindingContextUtils.descriptorToDeclarations(bindingContext, descriptor);
         }

idea/testData/codeInsight/overrideImplement/complexMultiOverride.kt.after

@@ -9,8 +9,14 @@ class C : Base<String, C, Unit>() {
     override fun bar(value: () -> Unit): (String) -> Unit {
         return super<Base>.bar(value)
     }
+    override fun equals(other: Any?): Boolean {
+        return super<Base>.equals(other)
+    }
     override fun foo(value: C): C {
         return super<Base>.foo(value)
     }
+    override fun hashCode(): Int {
+        return super<Base>.hashCode()
+    }
     override val method: (String?) -> String = ?
 }

idea/testData/codeInsight/overrideImplement/inheritVisibilities.kt.after

@@ -12,6 +12,12 @@ trait B {
 
 class C : A(), B {
 
+    override fun equals(other: Any?): Boolean {
+        return super<A>.equals(other)
+    }
+    override fun hashCode(): Int {
+        return super<A>.hashCode()
+    }
     override fun internalFun() {
         super<A>.internalFun()
     }

idea/testData/codeInsight/overrideImplement/multiOverride.kt.after

@@ -8,7 +8,13 @@ class C : A {
     override fun bar(): String {
         return super<A>.bar()
     }
+    override fun equals(other: Any?): Boolean {
+        return super<A>.equals(other)
+    }
     override fun foo(value: String): Int {
         return super<A>.foo(value)
     }
+    override fun hashCode(): Int {
+        return super<A>.hashCode()
+    }
 }

idea/testData/codeInsight/overrideImplement/overrideRespectCaretPosition.kt.after

@@ -7,9 +7,15 @@ class C : A() {
     val constant = 42
     // Some comment
     override val bar: Int = 0
+    override fun equals(other: Any?): Boolean {
+        return super<A>.equals(other)
+    }
     override fun foo(value: Int) {
         super<A>.foo(value)
     }
+    override fun hashCode(): Int {
+        return super<A>.hashCode()
+    }
 
     /*
         Some another comment

idea/tests/org/jetbrains/jet/plugin/codeInsight/AbstractOverrideImplementTest.java

@@ -18,7 +18,6 @@ package org.jetbrains.jet.plugin.codeInsight;
 
 import com.intellij.codeInsight.generation.OverrideImplementUtil;
 import com.intellij.codeInsight.generation.PsiMethodMember;
-import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.Result;
 import com.intellij.openapi.command.WriteCommandAction;
 import com.intellij.openapi.project.Project;
@@ -29,21 +28,23 @@ import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.testFramework.LightProjectDescriptor;
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import com.intellij.util.SmartList;
+import jet.Function1;
 import junit.framework.Assert;
+import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.OverridingUtil;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.plugin.JetLightProjectDescriptor;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.Set;
 
 public abstract class AbstractOverrideImplementTest extends LightCodeInsightFixtureTestCase {
     @NotNull
@@ -128,8 +129,21 @@ public abstract class AbstractOverrideImplementTest extends LightCodeInsightFixt
 
         final CallableMemberDescriptor singleToOverride;
         if (memberToOverride == null) {
-            assertEquals("Invalid number of available descriptors for override", 1, descriptors.size());
+            // Filter out fake overrides of members of Any (equals, hashCode, toString)
-            singleToOverride = descriptors.iterator().next();
+            List<CallableMemberDescriptor> filtered = KotlinPackage.filter(descriptors, new Function1<CallableMemberDescriptor, Boolean>() {
+                @Override
+                public Boolean invoke(CallableMemberDescriptor descriptor) {
+                    ClassDescriptor any = KotlinBuiltIns.getInstance().getAny();
+                    for (CallableMemberDescriptor overridden : OverridingUtil.getOverriddenDeclarations(descriptor)) {
+                        if (overridden.getContainingDeclaration().equals(any)) {
+                            return false;
+                        }
+                    }
+                    return true;
+                }
+            });
+            assertEquals("Invalid number of available descriptors for override", 1, filtered.size());
+            singleToOverride = filtered.iterator().next();
         }
         else {
             CallableMemberDescriptor candidateToOverride = null;