Explicit predicate passed to JetNameValidatorImpl

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

@@ -18,9 +18,9 @@ package org.jetbrains.jet.plugin.refactoring;
 
 import com.intellij.openapi.util.Ref;
 import com.intellij.psi.PsiElement;
+import kotlin.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetVisitorVoid;
@@ -33,17 +33,13 @@ import java.util.Collection;
 public class JetNameValidatorImpl extends JetNameValidator {
     private final PsiElement myContainer;
     private final PsiElement myAnchor;
-    private final boolean myOnlyVariables;
+    private final Function1<DeclarationDescriptor, Boolean> myFilter;
 
-    public JetNameValidatorImpl(PsiElement container, PsiElement anchor, boolean onlyVariables) {
+    public JetNameValidatorImpl(PsiElement container, PsiElement anchor, Function1<DeclarationDescriptor, Boolean> filter) {
         super(container.getProject());
         myContainer = container;
         myAnchor = anchor;
-        myOnlyVariables = onlyVariables;
+        myFilter = filter;
-    }
-
-    public JetNameValidatorImpl(PsiElement container, PsiElement anchor) {
-        this(container, anchor, true);
     }
 
     @Override
@@ -85,7 +81,7 @@ public class JetNameValidatorImpl extends JetNameValidator {
             public void visitExpression(@NotNull JetExpression expression) {
                 Collection<DeclarationDescriptor> variants = TipsManager.getVariantsNoReceiver(expression, bindingContext);
                 for (DeclarationDescriptor variant : variants) {
-                    if (variant.getName().asString().equals(name) && (!myOnlyVariables || variant instanceof VariableDescriptor)) {
+                    if (variant.getName().asString().equals(name) && myFilter.invoke(variant)) {
                         result.set(false);
                         return;
                     }

idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/extractFunctionUtils.kt

@@ -89,6 +89,7 @@ import org.jetbrains.jet.lang.types.ErrorUtils
 import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
 import org.jetbrains.jet.lang.diagnostics.Errors
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
 
 private val DEFAULT_FUNCTION_NAME = "myFun"
 private val DEFAULT_RETURN_TYPE = KotlinBuiltIns.getInstance().getUnitType()
@@ -234,7 +235,11 @@ private fun ExtractionData.inferParametersInfo(
         replacementMap: MutableMap<Int, Replacement>,
         parameters: MutableSet<Parameter>
 ): MaybeError<ExtractionDescriptor, String>? {
-    val varNameValidator = JetNameValidatorImpl(commonParent.getParentByType(javaClass<JetExpression>()), originalElements.first, true)
+    val varNameValidator = JetNameValidatorImpl(
+            commonParent.getParentByType(javaClass<JetExpression>()),
+            originalElements.first,
+            { it is VariableDescriptor }
+    )
     val modifiedVarDescriptors = localInstructions.getModifiedVarDescriptors(bindingContext)
 
     val extractedDescriptorToParameter = HashMap<DeclarationDescriptor, Parameter>()
@@ -448,7 +453,11 @@ fun ExtractionData.performAnalysis(): Maybe<ExtractionDescriptor, String> {
     val outOfScopeError = checkDeclarationsMovingOutOfScope(controlFlow)
     if (outOfScopeError != null) return outOfScopeError
 
-    val functionNameValidator = JetNameValidatorImpl(nextSibling.getParent(), nextSibling, false)
+    val functionNameValidator = JetNameValidatorImpl(
+            nextSibling.getParent(),
+            nextSibling,
+            {it is FunctionDescriptor || it is ClassDescriptor}
+    )
     val functionName = JetNameSuggester.suggestNames(controlFlow.returnType, functionNameValidator, DEFAULT_FUNCTION_NAME).first()
 
     val receiverCandidates = parameters.filterTo(HashSet<Parameter>()) { it.receiverCandidate }

idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java

@@ -31,9 +31,12 @@ import com.intellij.psi.PsiWhiteSpace;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.refactoring.HelpID;
 import com.intellij.refactoring.introduce.inplace.OccurrencesChooser;
+import kotlin.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.di.InjectorForMacros;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
@@ -187,10 +190,17 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
 
                 PsiElement commonParent = PsiTreeUtil.findCommonParent(allReplaces);
                 PsiElement commonContainer = getContainer(commonParent);
-                JetNameValidatorImpl validator = new JetNameValidatorImpl(commonContainer,
+                JetNameValidatorImpl validator = new JetNameValidatorImpl(
-                                                                          calculateAnchor(commonParent,
+                        commonContainer,
-                                                                                          commonContainer,
+                        calculateAnchor(commonParent, commonContainer, allReplaces),
-                                                                                          allReplaces));
+                        new Function1<DeclarationDescriptor, Boolean>() {
+                            @Override
+                            public Boolean invoke(DeclarationDescriptor descriptor) {
+                                return descriptor instanceof VariableDescriptor;
+                            }
+                        }
+
+                );
                 String[] suggestedNames = JetNameSuggester.suggestNames(expression, validator, "value");
                 final LinkedHashSet<String> suggestedNamesSet = new LinkedHashSet<String>();
                 Collections.addAll(suggestedNamesSet, suggestedNames);