From f713e664840271200ae8325715bd5cf29c793b8d Mon Sep 17 00:00:00 2001 From: Natalia Ukhorskaya Date: Tue, 28 Jul 2015 10:59:31 +0300 Subject: [PATCH] Minor: move methods --- .../kotlin/j2k/ConstructorConverter.kt | 4 +-- j2k/src/org/jetbrains/kotlin/j2k/Converter.kt | 2 +- .../jetbrains/kotlin/j2k/ReferenceSearcher.kt | 24 +++++++++++++++ j2k/src/org/jetbrains/kotlin/j2k/Utils.kt | 29 +------------------ 4 files changed, 28 insertions(+), 31 deletions(-) diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ConstructorConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/ConstructorConverter.kt index 13ada6f895f..62ac28dafef 100644 --- a/j2k/src/org/jetbrains/kotlin/j2k/ConstructorConverter.kt +++ b/j2k/src/org/jetbrains/kotlin/j2k/ConstructorConverter.kt @@ -148,7 +148,7 @@ class ConstructorConverter( val fieldCorrection = fieldCorrections[field] // we cannot specify different setter access for constructor parameter - if (fieldCorrection != null && !isVal(converter.referenceSearcher, field) && fieldCorrection.access != fieldCorrection.setterAccess) continue + if (fieldCorrection != null && !field.isVal(converter.referenceSearcher) && fieldCorrection.access != fieldCorrection.setterAccess) continue parameterToField.put(parameter, field to type) statementsToRemove.add(initializationStatement) @@ -211,7 +211,7 @@ class ConstructorConverter( converter.convertModifiers(field).filter { it in ACCESS_MODIFIERS } Parameter(name, type, - if (isVal(converter.referenceSearcher, field)) Parameter.VarValModifier.Val else Parameter.VarValModifier.Var, + if (field.isVal(converter.referenceSearcher)) Parameter.VarValModifier.Val else Parameter.VarValModifier.Var, converter.convertAnnotations(parameter) + converter.convertAnnotations(field), accessModifiers, default) diff --git a/j2k/src/org/jetbrains/kotlin/j2k/Converter.kt b/j2k/src/org/jetbrains/kotlin/j2k/Converter.kt index 1e239dfd220..94dbe968895 100644 --- a/j2k/src/org/jetbrains/kotlin/j2k/Converter.kt +++ b/j2k/src/org/jetbrains/kotlin/j2k/Converter.kt @@ -311,7 +311,7 @@ class Converter private constructor( .assignPrototype(field, CommentsAndSpacesInheritance.LINE_BREAKS) } else { - val isVal = isVal(referenceSearcher, field) + val isVal = field.isVal(referenceSearcher) val typeToDeclare = variableTypeToDeclare(field, settings.specifyFieldTypeByDefault || modifiers.isPublic || modifiers.isProtected, isVal && modifiers.isPrivate) diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ReferenceSearcher.kt b/j2k/src/org/jetbrains/kotlin/j2k/ReferenceSearcher.kt index 19b67d78620..4806973c8e6 100644 --- a/j2k/src/org/jetbrains/kotlin/j2k/ReferenceSearcher.kt +++ b/j2k/src/org/jetbrains/kotlin/j2k/ReferenceSearcher.kt @@ -42,6 +42,30 @@ public fun ReferenceSearcher.findMethodCalls(method: PsiMethod, scope: PsiElemen }.filterNotNull() } +public fun PsiField.isVal(searcher: ReferenceSearcher): Boolean { + if (hasModifierProperty(PsiModifier.FINAL)) return true + if (!hasModifierProperty(PsiModifier.PRIVATE)) return false + val containingClass = getContainingClass() ?: return false + val writes = searcher.findVariableUsages(this, containingClass).filter { PsiUtil.isAccessedForWriting(it) } + if (writes.size() == 0) return true + if (writes.size() > 1) return false + val write = writes.single() + val parent = write.getParent() + if (parent is PsiAssignmentExpression && + parent.getOperationSign().getTokenType() == JavaTokenType.EQ && + write.isQualifierEmptyOrThis()) { + val constructor = write.getContainingConstructor() + return constructor != null && + constructor.getContainingClass() == containingClass && + parent.getParent() is PsiExpressionStatement && + parent.getParent()?.getParent() == constructor.getBody() + } + return false +} + +public fun PsiVariable.hasWriteAccesses(searcher: ReferenceSearcher, scope: PsiElement?): Boolean + = if (scope != null) searcher.findVariableUsages(this, scope).any { PsiUtil.isAccessedForWriting(it) } else false + public object EmptyReferenceSearcher: ReferenceSearcher { override fun findLocalUsages(element: PsiElement, scope: PsiElement): Collection = emptyList() override fun hasInheritors(`class`: PsiClass) = false diff --git a/j2k/src/org/jetbrains/kotlin/j2k/Utils.kt b/j2k/src/org/jetbrains/kotlin/j2k/Utils.kt index 339e0a7beb2..e322c01b3c5 100644 --- a/j2k/src/org/jetbrains/kotlin/j2k/Utils.kt +++ b/j2k/src/org/jetbrains/kotlin/j2k/Utils.kt @@ -24,12 +24,6 @@ import com.intellij.psi.util.PsiMethodUtil fun quoteKeywords(packageName: String): String = packageName.split('.').map { Identifier.toKotlin(it) }.joinToString(".") -fun PsiVariable.countWriteAccesses(searcher: ReferenceSearcher, scope: PsiElement?): Int - = if (scope != null) searcher.findVariableUsages(this, scope).count { PsiUtil.isAccessedForWriting(it) } else 0 - -fun PsiVariable.hasWriteAccesses(searcher: ReferenceSearcher, scope: PsiElement?): Boolean - = if (scope != null) searcher.findVariableUsages(this, scope).any { PsiUtil.isAccessedForWriting(it) } else false - fun getDefaultInitializer(property: Property): Expression? { val t = property.type val result = if (t.isNullable) { @@ -50,29 +44,8 @@ fun getDefaultInitializer(property: Property): Expression? { return result?.assignNoPrototype() } -fun isVal(searcher: ReferenceSearcher, field: PsiField): Boolean { - if (field.hasModifierProperty(PsiModifier.FINAL)) return true - if (!field.hasModifierProperty(PsiModifier.PRIVATE)) return false - val containingClass = field.getContainingClass() ?: return false - val writes = searcher.findVariableUsages(field, containingClass).filter { PsiUtil.isAccessedForWriting(it) } - if (writes.size() == 0) return true - if (writes.size() > 1) return false - val write = writes.single() - val parent = write.getParent() - if (parent is PsiAssignmentExpression && - parent.getOperationSign().getTokenType() == JavaTokenType.EQ && - write.isQualifierEmptyOrThis()) { - val constructor = write.getContainingConstructor() - return constructor != null && - constructor.getContainingClass() == containingClass && - parent.getParent() is PsiExpressionStatement && - parent.getParent()?.getParent() == constructor.getBody() - } - return false -} - fun shouldGenerateDefaultInitializer(searcher: ReferenceSearcher, field: PsiField) - = field.getInitializer() == null && !(isVal(searcher, field) && field.hasWriteAccesses(searcher, field.getContainingClass())) + = field.getInitializer() == null && !(field.isVal(searcher) && field.hasWriteAccesses(searcher, field.getContainingClass())) fun PsiReferenceExpression.isQualifierEmptyOrThis(): Boolean { val qualifier = getQualifierExpression()