Add "Find usage with options" dialog for Kotlin classes

idea/src/org/jetbrains/jet/plugin/JetBundle.properties

@@ -270,5 +270,9 @@ super.methods.action.key.find.usages=find usages of
 find.what.implementing.methods.checkbox=&Implementing functions
 find.what.overriding.methods.checkbox=Over&riding functions
 find.options.include.overloaded.methods.checkbox=Include o&verloaded functions and extensions
+find.what.functions.usages.checkbox=Usages of &functions
+find.what.properties.usages.checkbox=Usages of &properties
+find.what.derived.traits.checkbox=&Derived traits
+find.what.derived.classes.checkbox=&Derived classes
 
 convert.to.extension=Convert to extension

idea/src/org/jetbrains/jet/plugin/findUsages/KotlinFindUsagesHandlerFactory.java

@@ -23,6 +23,7 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetClass;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
+import org.jetbrains.jet.plugin.findUsages.options.KotlinClassFindUsagesOptions;
 import org.jetbrains.jet.plugin.findUsages.options.KotlinMethodFindUsagesOptions;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.plugin.findUsages.handlers.KotlinFindClassUsagesHandler;
@@ -33,15 +34,21 @@ import java.util.Collection;
 
 public class KotlinFindUsagesHandlerFactory extends FindUsagesHandlerFactory {
     private final KotlinMethodFindUsagesOptions findMethodOptions;
+    private final KotlinClassFindUsagesOptions findClassOptions;
 
     public KotlinFindUsagesHandlerFactory(@NotNull Project project) {
         findMethodOptions = new KotlinMethodFindUsagesOptions(project);
+        findClassOptions = new KotlinClassFindUsagesOptions(project);
     }
 
     public final KotlinMethodFindUsagesOptions getFindMethodOptions() {
         return findMethodOptions;
     }
 
+    public KotlinClassFindUsagesOptions getFindClassOptions() {
+        return findClassOptions;
+    }
+
     @Override
     public boolean canFindUsages(@NotNull PsiElement element) {
         return element instanceof JetClass || element instanceof JetNamedFunction;

idea/src/org/jetbrains/jet/plugin/findUsages/dialogs/KotlinFindClassUsagesDialog.java

@@ -0,0 +1,78 @@
+package org.jetbrains.jet.plugin.findUsages.dialogs;
+
+import com.intellij.find.FindBundle;
+import com.intellij.find.findUsages.FindClassUsagesDialog;
+import com.intellij.find.findUsages.FindUsagesHandler;
+import com.intellij.find.findUsages.FindUsagesOptions;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiClass;
+import com.intellij.ui.SimpleColoredComponent;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.asJava.KotlinLightClassForExplicitDeclaration;
+import org.jetbrains.jet.lang.psi.JetClass;
+import org.jetbrains.jet.plugin.JetBundle;
+import org.jetbrains.jet.plugin.findUsages.options.KotlinClassFindUsagesOptions;
+import org.jetbrains.jet.plugin.refactoring.JetRefactoringUtil;
+
+import javax.swing.*;
+
+public class KotlinFindClassUsagesDialog extends FindClassUsagesDialog {
+    public KotlinFindClassUsagesDialog(
+            PsiClass klass,
+            Project project,
+            FindUsagesOptions findUsagesOptions,
+            boolean toShowInNewTab,
+            boolean mustOpenInNewTab,
+            boolean isSingleFile,
+            FindUsagesHandler handler
+    ) {
+        super(klass, project, findUsagesOptions, toShowInNewTab, mustOpenInNewTab, isSingleFile, handler);
+    }
+
+    @Override
+    protected JPanel createFindWhatPanel() {
+        JPanel findWhatPanel = super.createFindWhatPanel();
+        assert findWhatPanel != null;
+
+        Utils.renameCheckbox(
+                findWhatPanel,
+                FindBundle.message("find.what.methods.usages.checkbox"),
+                JetBundle.message("find.what.functions.usages.checkbox")
+        );
+        Utils.renameCheckbox(
+                findWhatPanel,
+                FindBundle.message("find.what.fields.usages.checkbox"),
+                JetBundle.message("find.what.properties.usages.checkbox")
+        );
+        Utils.renameCheckbox(
+                findWhatPanel,
+                FindBundle.message("find.what.implementing.classes.checkbox"),
+                JetBundle.message("find.what.implementing.classes.checkbox")
+        );
+        Utils.renameCheckbox(
+                findWhatPanel,
+                FindBundle.message("find.what.derived.interfaces.checkbox"),
+                JetBundle.message("find.what.derived.traits.checkbox")
+        );
+        Utils.renameCheckbox(
+                findWhatPanel,
+                FindBundle.message("find.what.derived.classes.checkbox"),
+                JetBundle.message("find.what.derived.classes.checkbox")
+        );
+
+        return findWhatPanel;
+    }
+
+    @Override
+    protected KotlinClassFindUsagesOptions getFindUsagesOptions() {
+        return (KotlinClassFindUsagesOptions) super.getFindUsagesOptions();
+    }
+
+    @Override
+    public void configureLabelComponent(@NotNull SimpleColoredComponent coloredComponent) {
+        PsiClass klass = (PsiClass) getPsiElement();
+        if (klass instanceof KotlinLightClassForExplicitDeclaration) {
+            coloredComponent.append(JetRefactoringUtil.formatClass(((KotlinLightClassForExplicitDeclaration) klass).getJetClassOrObject()));
+        }
+    }
+}

idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindClassUsagesHandler.java

@@ -16,12 +16,44 @@
 
 package org.jetbrains.jet.plugin.findUsages.handlers;
 
+import com.intellij.find.findUsages.AbstractFindUsagesDialog;
+import com.intellij.find.findUsages.FindUsagesOptions;
+import com.intellij.openapi.actionSystem.DataContext;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.asJava.LightClassUtil;
 import org.jetbrains.jet.lang.psi.JetClass;
 import org.jetbrains.jet.plugin.findUsages.KotlinFindUsagesHandlerFactory;
+import org.jetbrains.jet.plugin.findUsages.dialogs.KotlinFindClassUsagesDialog;
 
 public class KotlinFindClassUsagesHandler extends KotlinFindUsagesHandler<JetClass> {
     public KotlinFindClassUsagesHandler(@NotNull JetClass jetClass, @NotNull KotlinFindUsagesHandlerFactory factory) {
         super(jetClass, factory);
     }
+
+    @NotNull
+    @Override
+    public AbstractFindUsagesDialog getFindUsagesDialog(boolean isSingleFile, boolean toShowInNewTab, boolean mustOpenInNewTab) {
+        PsiClass lightClass = LightClassUtil.getPsiClass(getElement());
+        if (lightClass != null) {
+            return new KotlinFindClassUsagesDialog(
+                    lightClass, getProject(), getFactory().getFindClassOptions(), toShowInNewTab, mustOpenInNewTab, isSingleFile, this
+            );
+        }
+        return super.getFindUsagesDialog(isSingleFile, toShowInNewTab, mustOpenInNewTab);
+    }
+
+    @Override
+    protected boolean isSearchForTextOccurencesAvailable(@NotNull PsiElement psiElement, boolean isSingleFile) {
+        if (isSingleFile) return false;
+        return psiElement instanceof JetClass;
+    }
+
+    @NotNull
+    @Override
+    public FindUsagesOptions getFindUsagesOptions(@Nullable DataContext dataContext) {
+        return getFactory().getFindClassOptions();
+    }
 }

idea/src/org/jetbrains/jet/plugin/findUsages/options/KotlinClassFindUsagesOptions.java

@@ -0,0 +1,11 @@
+package org.jetbrains.jet.plugin.findUsages.options;
+
+import com.intellij.find.findUsages.JavaClassFindUsagesOptions;
+import com.intellij.openapi.project.Project;
+import org.jetbrains.annotations.NotNull;
+
+public class KotlinClassFindUsagesOptions extends JavaClassFindUsagesOptions {
+    public KotlinClassFindUsagesOptions(@NotNull Project project) {
+        super(project);
+    }
+}

idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java

@@ -32,10 +32,7 @@ import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.Visibilities;
-import org.jetbrains.jet.lang.descriptors.Visibility;
+import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
@@ -271,9 +268,20 @@ public class JetRefactoringUtil {
                     AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) declaration.getContainingFile()).getBindingContext();
             DeclarationDescriptor descriptor =
                     bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration);
-            if (descriptor != null) return JetRefactoringUtil.formatFunctionDescriptor(descriptor);
+            if (descriptor != null) return formatFunctionDescriptor(descriptor);
         }
-        return JetRefactoringUtil.formatPsiMethod(method, false, false);
+        return formatPsiMethod(method, false, false);
+    }
+
+    @NotNull
+    public static String formatClass(@NotNull JetClassOrObject classOrObject) {
+        BindingContext bindingContext =
+                AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) classOrObject.getContainingFile()).getBindingContext();
+        DeclarationDescriptor descriptor =
+                bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, classOrObject);
+
+        if (descriptor instanceof ClassDescriptor) return formatClassDescriptor(descriptor);
+        return "class " + classOrObject.getName();
     }
 
     public interface SelectExpressionCallback {