azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renamed methods

Browse Source
This commit is contained in:
Valentin Kipyatkov
2015-06-26 18:56:26 +03:00
parent a02c86bac9
commit c478f1d347
15 changed files with 78 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/GenerateLambda.kt
+1 -1
View File
@@ -102,7 +102,7 @@ private fun buildTemplate(lambdaType: JetType, explicitParameterTypes: Boolean,
template.addTextSegment(", ")
}
//TODO: check for names in scope
template.addVariable(ParameterNameExpression(KotlinNameSuggester.suggestNames(parameterType, { true }, "p")), true)
template.addVariable(ParameterNameExpression(KotlinNameSuggester.suggestNamesByType(parameterType, { true }, "p")), true)
if (explicitParameterTypes) {
template.addTextSegment(": " + IdeDescriptorRenderers.SOURCE_CODE.renderType(parameterType))
}
idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinNameSuggester.kt
+56 -53
View File
@@ -38,7 +38,7 @@ public object KotlinNameSuggester {
var name = name ?: return
if ("class" == name) name = "clazz"
if (!isIdentifier(name)) return
result.add(validateName(name, validator))
result.add(suggestNameByName(name, validator))
}
/**
@@ -57,85 +57,92 @@ public object KotlinNameSuggester {
* *
* @return possible names
*/
public fun suggestNames(expression: JetExpression, validator: (String) -> Boolean, defaultName: String?): Array<String> {
public fun suggestNamesByExpressionAndType(expression: JetExpression, validator: (String) -> Boolean, defaultName: String?): Array<String> {
val result = ArrayList<String>()
val bindingContext = expression.analyze(BodyResolveMode.FULL)
val jetType = bindingContext.getType(expression)
if (jetType != null) {
addNamesForType(result, jetType, validator)
addNamesByType(result, jetType, validator)
}
addNamesByExpression(result, expression, validator)
if (result.isEmpty()) {
addName(result, defaultName, validator)
}
addNamesForExpression(result, expression, validator)
if (result.isEmpty()) addName(result, defaultName, validator)
return ArrayUtil.toStringArray(result)
}
public fun suggestNames(type: JetType, validator: (String) -> Boolean, defaultName: String?): Array<String> {
public fun suggestNamesByType(type: JetType, validator: (String) -> Boolean, defaultName: String? = null): Array<String> {
val result = ArrayList<String>()
addNamesForType(result, type, validator)
if (result.isEmpty()) addName(result, defaultName, validator)
addNamesByType(result, type, validator)
if (result.isEmpty()) {
addName(result, defaultName, validator)
}
return ArrayUtil.toStringArray(result)
}
public fun suggestNamesForType(jetType: JetType, validator: (String) -> Boolean): Array<String> {
public fun suggestNamesByExpressionOnly(expression: JetExpression, validator: (String) -> Boolean, defaultName: String? = null): Array<String> {
val result = ArrayList<String>()
addNamesForType(result, jetType, validator)
addNamesByExpression(result, expression, validator)
if (result.isEmpty()) {
addName(result, defaultName, validator)
}
return ArrayUtil.toStringArray(result)
}
jvmOverloads public fun suggestNamesForExpression(expression: JetExpression, validator: (String) -> Boolean, defaultName: String? = null): Array<String> {
val result = ArrayList<String>()
addNamesForExpression(result, expression, validator)
if (result.isEmpty()) addName(result, defaultName, validator)
return ArrayUtil.toStringArray(result)
}
private val COMMON_TYPE_PARAMETER_NAMES = arrayOf("T", "U", "V", "W", "X", "Y", "Z")
private val COMMON_TYPE_PARAMETER_NAMES = listOf("T", "U", "V", "W", "X", "Y", "Z")
public fun suggestNamesForTypeParameters(count: Int, validator: (String) -> Boolean): Array<String> {
val result = ArrayList<String>()
for (i in 0..count - 1) {
result.add(validateNameWithVariants(validator, *COMMON_TYPE_PARAMETER_NAMES))
result.add(suggestNameByMultipleNames(COMMON_TYPE_PARAMETER_NAMES, validator))
}
return ArrayUtil.toStringArray(result)
}
private fun addNamesForType(result: ArrayList<String>, jetType: JetType, validator: (String) -> Boolean) {
var jetType = jetType
private fun addNamesByType(result: ArrayList<String>, type: JetType, validator: (String) -> Boolean) {
var type = TypeUtils.makeNotNullable(type) // wipe out '?'
val builtIns = KotlinBuiltIns.getInstance()
val typeChecker = JetTypeChecker.DEFAULT
jetType = TypeUtils.makeNotNullable(jetType) // wipe out '?'
if (ErrorUtils.containsErrorType(jetType)) return
if (typeChecker.equalTypes(builtIns.getBooleanType(), jetType)) {
if (ErrorUtils.containsErrorType(type)) return
if (typeChecker.equalTypes(builtIns.getBooleanType(), type)) {
addName(result, "b", validator)
}
else if (typeChecker.equalTypes(builtIns.getIntType(), jetType)) {
else if (typeChecker.equalTypes(builtIns.getIntType(), type)) {
addName(result, "i", validator)
}
else if (typeChecker.equalTypes(builtIns.getByteType(), jetType)) {
else if (typeChecker.equalTypes(builtIns.getByteType(), type)) {
addName(result, "byte", validator)
}
else if (typeChecker.equalTypes(builtIns.getLongType(), jetType)) {
else if (typeChecker.equalTypes(builtIns.getLongType(), type)) {
addName(result, "l", validator)
}
else if (typeChecker.equalTypes(builtIns.getFloatType(), jetType)) {
else if (typeChecker.equalTypes(builtIns.getFloatType(), type)) {
addName(result, "fl", validator)
}
else if (typeChecker.equalTypes(builtIns.getDoubleType(), jetType)) {
else if (typeChecker.equalTypes(builtIns.getDoubleType(), type)) {
addName(result, "d", validator)
}
else if (typeChecker.equalTypes(builtIns.getShortType(), jetType)) {
else if (typeChecker.equalTypes(builtIns.getShortType(), type)) {
addName(result, "sh", validator)
}
else if (typeChecker.equalTypes(builtIns.getCharType(), jetType)) {
else if (typeChecker.equalTypes(builtIns.getCharType(), type)) {
addName(result, "c", validator)
}
else if (typeChecker.equalTypes(builtIns.getStringType(), jetType)) {
else if (typeChecker.equalTypes(builtIns.getStringType(), type)) {
addName(result, "s", validator)
}
else if (KotlinBuiltIns.isArray(jetType) || KotlinBuiltIns.isPrimitiveArray(jetType)) {
val elementType = KotlinBuiltIns.getInstance().getArrayElementType(jetType)
else if (KotlinBuiltIns.isArray(type) || KotlinBuiltIns.isPrimitiveArray(type)) {
val elementType = KotlinBuiltIns.getInstance().getArrayElementType(type)
if (typeChecker.equalTypes(builtIns.getBooleanType(), elementType)) {
addName(result, "booleans", validator)
}
@@ -172,16 +179,12 @@ public object KotlinNameSuggester {
}
}
else {
addForClassType(result, jetType, validator)
}
}
private fun addForClassType(result: ArrayList<String>, jetType: JetType, validator: (String) -> Boolean) {
val descriptor = jetType.getConstructor().getDeclarationDescriptor()
if (descriptor != null) {
val className = descriptor.getName()
if (!className.isSpecial()) {
addCamelNames(result, className.asString(), validator)
val descriptor = type.getConstructor().getDeclarationDescriptor()
if (descriptor != null) {
val className = descriptor.getName()
if (!className.isSpecial()) {
addCamelNames(result, className.asString(), validator)
}
}
}
}
@@ -254,13 +257,13 @@ public object KotlinNameSuggester {
return matcher.replaceAll("")
}
private fun addNamesForExpression(result: ArrayList<String>, expression: JetExpression?, validator: (String) -> Boolean) {
private fun addNamesByExpression(result: ArrayList<String>, expression: JetExpression?, validator: (String) -> Boolean) {
if (expression == null) return
expression.accept(object : JetVisitorVoid() {
override fun visitQualifiedExpression(expression: JetQualifiedExpression) {
val selectorExpression = expression.getSelectorExpression()
addNamesForExpression(result, selectorExpression, validator)
addNamesByExpression(result, selectorExpression, validator)
}
override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
@@ -274,11 +277,11 @@ public object KotlinNameSuggester {
}
override fun visitCallExpression(expression: JetCallExpression) {
addNamesForExpression(result, expression.getCalleeExpression(), validator)
addNamesByExpression(result, expression.getCalleeExpression(), validator)
}
override fun visitPostfixExpression(expression: JetPostfixExpression) {
addNamesForExpression(result, expression.getBaseExpression(), validator)
addNamesByExpression(result, expression.getBaseExpression(), validator)
}
})
}
@@ -299,10 +302,10 @@ public object KotlinNameSuggester {
* @param name to check it in scope
* @return name or nameI, where I is number
*/
public fun validateName(name: String, validator: (String) -> Boolean): String {
if (validator.invoke(name)) return name
public fun suggestNameByName(name: String, validator: (String) -> Boolean): String {
if (validator(name)) return name
var i = 1
while (!validator.invoke(name + i)) {
while (!validator(name + i)) {
++i
}
@@ -315,12 +318,12 @@ public object KotlinNameSuggester {
* @param names to check it in scope
* @return name or nameI, where name is one of variants and I is a number
*/
public fun validateNameWithVariants(validator: (String) -> Boolean, vararg names: String): String {
public fun suggestNameByMultipleNames(names: Collection<String>, validator: (String) -> Boolean): String {
var i = 0
while (true) {
for (name in names) {
val candidate = if (i > 0) name + i else name
if (validator.invoke(candidate)) return candidate
if (validator(candidate)) return candidate
}
i++
}
idea/src/org/jetbrains/kotlin/idea/intentions/IterateExpressionIntention.kt
+1 -1
View File
@@ -59,7 +59,7 @@ public class IterateExpressionIntention : JetSelfTargetingIntention<JetExpressio
val elementType = data(element)!!.elementType
//TODO: base on expression too
//TODO: name validation
val names = KotlinNameSuggester.suggestNames(elementType, { true }, "e")
val names = KotlinNameSuggester.suggestNamesByType(elementType, { true }, "e")
var forExpression = JetPsiFactory(element).createExpressionByPattern("for($0 in $1) {\nx\n}", names[0], element) as JetForExpression
forExpression = element.replaced(forExpression)
idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralSignatureFix.java
+1 -1
View File
@@ -70,7 +70,7 @@ public class ChangeFunctionLiteralSignatureFix extends ChangeFunctionSignatureFi
CollectingNameValidator validator = new CollectingNameValidator();
descriptor.clearNonReceiverParameters();
for (JetType type : parameterTypes) {
String name = KotlinNameSuggester.INSTANCE$.suggestNames(type, validator, "param")[0];
String name = KotlinNameSuggester.INSTANCE$.suggestNamesByType(type, validator, "param")[0];
descriptor.addParameter(
new JetParameterInfo(functionDescriptor, -1, name, type, null, null, JetValVar.None, null)
);
idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.java
+3 -3
View File
@@ -102,13 +102,13 @@ public abstract class ChangeFunctionSignatureFix extends JetIntentionAction<PsiE
JetExpression expression = argument.getArgumentExpression();
if (argumentName != null) {
return KotlinNameSuggester.INSTANCE$.validateName(argumentName.getAsName().asString(), validator);
return KotlinNameSuggester.INSTANCE$.suggestNameByName(argumentName.getAsName().asString(), validator);
}
else if (expression != null) {
return KotlinNameSuggester.INSTANCE$.suggestNames(expression, validator, "param")[0];
return KotlinNameSuggester.INSTANCE$.suggestNamesByExpressionAndType(expression, validator, "param")[0];
}
return KotlinNameSuggester.INSTANCE$.validateName("param", validator);
return KotlinNameSuggester.INSTANCE$.suggestNameByName("param", validator);
}
protected static JetParameterInfo getNewParameterInfo(
idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageFixBase.kt
+2 -2
View File
@@ -663,9 +663,9 @@ public abstract class DeprecatedSymbolUsageFixBase(
fun suggestName(validator: (String) -> Boolean): Name {
val name = if (nameSuggestion != null)
KotlinNameSuggester.validateName(nameSuggestion, validator)
KotlinNameSuggester.suggestNameByName(nameSuggestion, validator)
else
KotlinNameSuggester.suggestNamesForExpression(value, validator, "t").first()
KotlinNameSuggester.suggestNamesByExpressionOnly(value, validator, "t").first()
return Name.identifier(name)
}
idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt
+2 -2
View File
@@ -622,7 +622,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
}
val validator = CollectingNameValidator { scope.getClassifier(Name.identifier(it)) == null }
val typeParameterNames = allTypeParametersNotInScope.map { KotlinNameSuggester.validateName(it.getName().asString(), validator) }
val typeParameterNames = allTypeParametersNotInScope.map { KotlinNameSuggester.suggestNameByName(it.getName().asString(), validator) }
return allTypeParametersNotInScope.zip(typeParameterNames).toMap()
}
@@ -820,7 +820,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
// figure out suggested names for each type option
val parameterTypeToNamesMap = HashMap<String, Array<String>>()
typeCandidates[parameter.typeInfo]!!.forEach { typeCandidate ->
val suggestedNames = KotlinNameSuggester.suggestNamesForType(typeCandidate.theType, { true })
val suggestedNames = KotlinNameSuggester.suggestNamesByType(typeCandidate.theType, { true })
parameterTypeToNamesMap[typeCandidate.renderedType!!] = suggestedNames
}
idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableInfo.kt
+1 -1
View File
@@ -43,7 +43,7 @@ abstract class TypeInfo(val variance: Variance) {
class ByExpression(val expression: JetExpression, variance: Variance): TypeInfo(variance) {
override val possibleNamesFromExpression: Array<String> by Delegates.lazy {
KotlinNameSuggester.suggestNamesForExpression(expression, { true })
KotlinNameSuggester.suggestNamesByExpressionOnly(expression, { true })
}
override fun getPossibleTypes(builder: CallableBuilder): List<JetType> =
idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/templateExpressions.kt
+1 -1
View File
@@ -95,7 +95,7 @@ private class ParameterNameExpression(
// ensure there are no conflicts
val validator = CollectingNameValidator(parameterNames)
return names.map { LookupElementBuilder.create(KotlinNameSuggester.validateName(it, validator)) }.toTypedArray()
return names.map { LookupElementBuilder.create(KotlinNameSuggester.suggestNameByName(it, validator)) }.toTypedArray()
}
}
idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt
+1 -1
View File
@@ -82,7 +82,7 @@ public class JetChangeSignatureData(
}
} ?: CollectingNameValidator(paramNames)
val receiverType = baseDescriptor.getExtensionReceiverParameter()?.getType() ?: return null
val receiverName = KotlinNameSuggester.suggestNames(receiverType, validator, "receiver").first()
val receiverName = KotlinNameSuggester.suggestNamesByType(receiverType, validator, "receiver").first()
return JetParameterInfo(functionDescriptor = baseDescriptor, name = receiverName, type = receiverType)
}
idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt
+4 -4
View File
@@ -756,9 +756,9 @@ private fun ExtractionData.inferParametersInfo(
with (parameter) {
if (currentName == null) {
currentName = KotlinNameSuggester.suggestNames(getParameterType(options.allowSpecialClassNames), varNameValidator, "p").first()
currentName = KotlinNameSuggester.suggestNamesByType(getParameterType(options.allowSpecialClassNames), varNameValidator, "p").first()
}
mirrorVarName = if (descriptorToExtract in modifiedVarDescriptors) KotlinNameSuggester.validateName(name, varNameValidator) else null
mirrorVarName = if (descriptorToExtract in modifiedVarDescriptors) KotlinNameSuggester.suggestNameByName(name, varNameValidator) else null
info.parameters.add(this)
}
}
@@ -915,13 +915,13 @@ private fun ExtractionData.suggestFunctionNames(returnType: JetType): List<Strin
if (options.extractAsProperty) NameValidatorImpl.Target.PROPERTIES else NameValidatorImpl.Target.FUNCTIONS_AND_CLASSES
)
if (!returnType.isDefault()) {
functionNames.addAll(KotlinNameSuggester.suggestNamesForType(returnType, validator))
functionNames.addAll(KotlinNameSuggester.suggestNamesByType(returnType, validator))
}
getExpressions().singleOrNull()?.let { expr ->
val property = expr.getStrictParentOfType<JetProperty>()
if (property?.getInitializer() == expr) {
property?.getName()?.let { functionNames.add(KotlinNameSuggester.validateName("get" + it.capitalize(), validator)) }
property?.getName()?.let { functionNames.add(KotlinNameSuggester.suggestNameByName("get" + it.capitalize(), validator)) }
}
}
idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt
+2 -2
View File
@@ -279,7 +279,7 @@ private fun makeCall(
}
else {
val varNameValidator = NameValidatorImpl(block, anchorInBlock, NameValidatorImpl.Target.PROPERTIES)
val resultVal = KotlinNameSuggester.suggestNames(extractableDescriptor.returnType, varNameValidator, null).first()
val resultVal = KotlinNameSuggester.suggestNamesByType(extractableDescriptor.returnType, varNameValidator, null).first()
block.addBefore(psiFactory.createDeclaration("val $resultVal = $callText"), anchorInBlock)
block.addBefore(newLine, anchorInBlock)
controlFlow.outputValueBoxer.getUnboxingExpressions(resultVal)
@@ -513,7 +513,7 @@ fun ExtractionGeneratorConfiguration.generateDeclaration(
val (defaultExpression, expressionToUnifyWith) =
if (!generatorOptions.inTempFile && defaultValue != null && descriptor.controlFlow.outputValueBoxer.boxingRequired && lastExpression!!.isMultiLine()) {
val varNameValidator = NameValidatorImpl(body, lastExpression, NameValidatorImpl.Target.PROPERTIES)
val resultVal = KotlinNameSuggester.suggestNames(defaultValue.valueType, varNameValidator, null).first()
val resultVal = KotlinNameSuggester.suggestNamesByType(defaultValue.valueType, varNameValidator, null).first()
val newDecl = body.addBefore(psiFactory.createDeclaration("val $resultVal = ${lastExpression!!.getText()}"), lastExpression) as JetProperty
body.addBefore(psiFactory.createNewLine(), lastExpression)
psiFactory.createExpression(resultVal) to newDecl.getInitializer()!!
idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt
+1 -1
View File
@@ -235,7 +235,7 @@ public open class KotlinIntroduceParameterHandler(
else -> null
} ?: throw AssertionError("Body element is not found: ${targetParent.getElementTextWithContext()}")
val nameValidator = NameValidatorImpl(body, null, NameValidatorImpl.Target.PROPERTIES)
val suggestedNames = linkedSetOf(*KotlinNameSuggester.suggestNames(replacementType, nameValidator, "p"))
val suggestedNames = linkedSetOf(*KotlinNameSuggester.suggestNamesByType(replacementType, nameValidator, "p"))
val parametersUsages = findInternalUsagesOfParametersAndReceiver(targetParent, functionDescriptor)
idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java
+1 -1
View File
@@ -197,7 +197,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
calculateAnchor(commonParent, commonContainer, allReplaces),
NameValidatorImpl.Target.PROPERTIES
);
final String[] suggestedNames = KotlinNameSuggester.INSTANCE$.suggestNames(expression, validator, "value");
final String[] suggestedNames = KotlinNameSuggester.INSTANCE$.suggestNamesByExpressionAndType(expression, validator, "value");
final Ref<JetProperty> propertyRef = new Ref<JetProperty>();
final ArrayList<JetExpression> references = new ArrayList<JetExpression>();
final Ref<JetExpression> reference = new Ref<JetExpression>();
idea/tests/org/jetbrains/kotlin/idea/refactoring/nameSuggester/JetNameSuggesterTest.kt
+1 -1
View File
@@ -69,7 +69,7 @@ public class JetNameSuggesterTest : LightCodeInsightFixtureTestCase() {
try {
JetRefactoringUtil.selectExpression(myFixture.getEditor(), file, object : JetRefactoringUtil.SelectExpressionCallback {
override fun run(expression: JetExpression) {
val names = KotlinNameSuggester.suggestNames(expression, { true }, "value")
val names = KotlinNameSuggester.suggestNamesByExpressionAndType(expression, { true }, "value")
Arrays.sort(names)
val result = StringUtil.join(names, "\n").trim()
assertEquals(expectedResultText, result)