Name Validator: Translate JetNameValidator to Kotlin

idea/src/org/jetbrains/jet/plugin/completion/handlers/GenerateLambda.kt

@@ -42,6 +42,7 @@ import org.jetbrains.jet.plugin.completion.ExpectedInfos
 import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
 import org.jetbrains.jet.plugin.refactoring.runWriteAction
+import org.jetbrains.jet.plugin.refactoring.EmptyValidator
 
 fun insertLambdaTemplate(context: InsertionContext, placeholderRange: TextRange, lambdaType: JetType) {
     val explicitParameterTypes = needExplicitParameterTypes(context, placeholderRange, lambdaType)
@@ -98,8 +99,6 @@ private fun needExplicitParameterTypes(context: InsertionContext, placeholderRan
 private fun buildTemplate(lambdaType: JetType, explicitParameterTypes: Boolean, project: Project): Template {
     val parameterTypes = functionParameterTypes(lambdaType)
 
-    val nameValidator = JetNameValidator.getEmptyValidator() //TODO: check for names in scope
-
     val useParenthesis = explicitParameterTypes || parameterTypes.size != 1
 
     val manager = TemplateManager.getInstance(project)
@@ -116,7 +115,8 @@ private fun buildTemplate(lambdaType: JetType, explicitParameterTypes: Boolean,
         if (i > 0) {
             template.addTextSegment(", ")
         }
-        template.addVariable(ParameterNameExpression(JetNameSuggester.suggestNames(parameterType, nameValidator, "p")), true)
+        //TODO: check for names in scope
+        template.addVariable(ParameterNameExpression(JetNameSuggester.suggestNames(parameterType, EmptyValidator, "p")), true)
         if (explicitParameterTypes) {
             template.addTextSegment(": " + DescriptorRenderer.SOURCE_CODE.renderType(parameterType))
         }

idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionParametersFix.java

@@ -36,6 +36,7 @@ import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.plugin.JetBundle;
 import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
+import org.jetbrains.jet.plugin.refactoring.CollectingValidator;
 import org.jetbrains.jet.plugin.refactoring.JetNameValidator;
 import org.jetbrains.jet.plugin.refactoring.changeSignature.JetChangeSignatureConfiguration;
 import org.jetbrains.jet.plugin.refactoring.changeSignature.JetChangeSignatureData;
@@ -116,7 +117,7 @@ public class AddFunctionParametersFix extends ChangeFunctionSignatureFix {
             public void configure(@NotNull JetChangeSignatureData changeSignatureData, @NotNull BindingContext bindingContext) {
                 List<ValueParameterDescriptor> parameters = functionDescriptor.getValueParameters();
                 List<? extends ValueArgument> arguments = callElement.getValueArguments();
-                JetNameValidator validator = JetNameValidator.createCollectingValidator();
+                JetNameValidator validator = new CollectingValidator();
 
                 for (int i = 0; i < arguments.size(); i ++) {
                     ValueArgument argument = arguments.get(i);

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralSignatureFix.java

@@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.plugin.JetBundle;
 import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
+import org.jetbrains.jet.plugin.refactoring.CollectingValidator;
 import org.jetbrains.jet.plugin.refactoring.JetNameSuggester;
 import org.jetbrains.jet.plugin.refactoring.JetNameValidator;
 import org.jetbrains.jet.plugin.refactoring.changeSignature.JetChangeSignatureConfiguration;
@@ -61,7 +62,7 @@ public class ChangeFunctionLiteralSignatureFix extends ChangeFunctionSignatureFi
         runChangeSignature(project, functionDescriptor, new JetChangeSignatureConfiguration() {
             @Override
             public void configure(@NotNull JetChangeSignatureData changeSignatureData, @NotNull BindingContext bindingContext) {
-                JetNameValidator validator = JetNameValidator.createCollectingValidator();
+                JetNameValidator validator = new CollectingValidator();
                 changeSignatureData.clearParameters();
                 for (JetType type : parameterTypes) {
                     String name = JetNameSuggester.suggestNames(type, validator, "param")[0];

idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createFunction/CreateFunctionFromUsageFix.kt

@@ -66,6 +66,7 @@ import org.jetbrains.jet.plugin.caches.resolve.getAnalysisResults
 import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils
 import org.jetbrains.jet.plugin.quickfix.QuickFixUtil
 import org.jetbrains.jet.plugin.quickfix.createFromUsage.CreateFromUsageFixBase
+import org.jetbrains.jet.plugin.refactoring.EmptyValidator
 
 private val TYPE_PARAMETER_LIST_VARIABLE_NAME = "typeParameterList"
 private val TEMPLATE_FROM_USAGE_FUNCTION_BODY = "New Kotlin Function Body.kt"
@@ -126,10 +127,7 @@ private class TypeOrExpressionThereof(private val variance: Variance,
             ArrayUtil.EMPTY_STRING_ARRAY
         }
         else {
-            JetNameSuggester.suggestNamesForExpression(
-                    expressionOfType!!,
-                    JetNameValidator.getEmptyValidator()
-            )
+            JetNameSuggester.suggestNamesForExpression(expressionOfType!!, EmptyValidator)
         }
     }
 
@@ -665,7 +663,6 @@ public class CreateFunctionFromUsageFix internal (
     private fun setupParameterTypeTemplates(builder: TemplateBuilder, parameterList: JetParameterList): List<TypeExpression> {
         val jetParameters = parameterList.getParameters()
         assert(jetParameters.size == parameters.size)
-        val dummyValidator = JetNameValidator.getEmptyValidator()
 
         val typeParameters = ArrayList<TypeExpression>()
         for ((parameter, jetParameter) in parameters.zip(jetParameters)) {
@@ -686,7 +683,7 @@ public class CreateFunctionFromUsageFix internal (
             // figure out suggested names for each type option
             val parameterTypeToNamesMap = HashMap<String, Array<String>>()
             parameter.theType.typeCandidates!!.forEach { typeCandidate ->
-                val suggestedNames = JetNameSuggester.suggestNamesForType(typeCandidate.theType, dummyValidator)
+                val suggestedNames = JetNameSuggester.suggestNamesForType(typeCandidate.theType, EmptyValidator)
                 parameterTypeToNamesMap[typeCandidate.renderedType!!] = suggestedNames
             }
 

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

@@ -1,72 +0,0 @@
-/*
- * Copyright 2010-2013 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.jet.plugin.refactoring;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashSet;
-import java.util.Set;
-
-public abstract class JetNameValidator {
-    private static final JetNameValidator EMPTY_VALIDATOR = new JetNameValidator() {
-        @Override
-        protected boolean validateInner(String name) {
-            return true;
-        }
-    };
-
-    @NotNull
-    public static JetNameValidator getEmptyValidator() {
-        return EMPTY_VALIDATOR;
-    }
-
-    @NotNull
-    public static JetNameValidator createCollectingValidator() {
-        return new JetNameValidator() {
-            private final Set<String> suggestedSet = new HashSet<String>();
-
-            @Override
-            protected boolean validateInner(String name) {
-                return !suggestedSet.contains(name);
-            }
-
-            @Override
-            public String validateName(String name) {
-                String validatedName = super.validateName(name);
-                suggestedSet.add(validatedName);
-                return validatedName;
-            }
-        };
-    }
-
-    /**
-     * Validates name, and slightly improves it by adding number to name in case of conflicts
-     * @param name to check it in scope
-     * @return name or nameI, where I is number
-     */
-    public String validateName(String name) {
-        if (validateInner(name)) return name;
-        int i = 1;
-        while (!validateInner(name + i)) {
-            ++i;
-        }
-
-        return name + i;
-    }
-
-    protected abstract boolean validateInner(String name);
-}

idea/src/org/jetbrains/jet/plugin/refactoring/JetNameValidator.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.plugin.refactoring
+
+import java.util.HashSet
+
+public abstract class JetNameValidator {
+    /**
+     * Validates name, and slightly improves it by adding number to name in case of conflicts
+     * @param name to check it in scope
+     * @return name or nameI, where I is number
+     */
+    public open fun validateName(name: String): String {
+        if (validateInner(name)) return name
+        var i = 1
+        while (!validateInner(name + i)) {
+            ++i
+        }
+
+        return name + i
+    }
+
+    protected abstract fun validateInner(name: String): Boolean
+}
+
+public object EmptyValidator : JetNameValidator() {
+    override fun validateInner(name: String): Boolean = true
+}
+
+public class CollectingValidator: JetNameValidator() {
+    private val suggestedSet = HashSet<String>()
+
+    override fun validateInner(name: String): Boolean = !suggestedSet.contains(name)
+
+    override fun validateName(name: String): String {
+        val validatedName = super.validateName(name)
+        suggestedSet.add(validatedName)
+        return validatedName
+    }
+}

idea/tests/org/jetbrains/jet/plugin/refactoring/nameSuggester/JetNameSuggesterTest.java

@@ -23,6 +23,7 @@ import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
+import org.jetbrains.jet.plugin.refactoring.EmptyValidator;
 import org.jetbrains.jet.plugin.refactoring.JetNameSuggester;
 import org.jetbrains.jet.plugin.refactoring.JetNameValidator;
 import org.jetbrains.jet.plugin.refactoring.JetRefactoringUtil;
@@ -92,7 +93,7 @@ public class JetNameSuggesterTest extends LightCodeInsightFixtureTestCase {
             JetRefactoringUtil.selectExpression(myFixture.getEditor(), file, new JetRefactoringUtil.SelectExpressionCallback() {
                 @Override
                 public void run(@Nullable JetExpression expression) {
-                    String[] names = JetNameSuggester.suggestNames(expression, JetNameValidator.getEmptyValidator(), "value");
+                    String[] names = JetNameSuggester.suggestNames(expression, EmptyValidator.INSTANCE$, "value");
                     Arrays.sort(names);
                     String result = StringUtil.join(names, "\n").trim();
                     assertEquals(expectedResultText, result);