From 0f9a93ffcafad7e88e82ed7f143e09be4436e170 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Thu, 21 Nov 2013 20:35:02 +0400 Subject: [PATCH] Refactor converter: Move some of the code out of Converter.kt to newly created MethodUtils.kt Simplify and clarify that code --- j2k/src/org/jetbrains/jet/j2k/Converter.kt | 97 +------------------- j2k/src/org/jetbrains/jet/j2k/MethodUtils.kt | 78 ++++++++++++++++ 2 files changed, 80 insertions(+), 95 deletions(-) create mode 100644 j2k/src/org/jetbrains/jet/j2k/MethodUtils.kt diff --git a/j2k/src/org/jetbrains/jet/j2k/Converter.kt b/j2k/src/org/jetbrains/jet/j2k/Converter.kt index ea153be1faf..a3225b80b62 100644 --- a/j2k/src/org/jetbrains/jet/j2k/Converter.kt +++ b/j2k/src/org/jetbrains/jet/j2k/Converter.kt @@ -251,7 +251,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) { } private fun methodToFunction(method: PsiMethod, notEmpty: Boolean): Function { - if (isOverrideObjectDirect(method)) { + if (directlyOverridesMethodFromObject(method)) { dispatcher.expressionVisitor = ExpressionVisitorForDirectObjectInheritors(this) } else { @@ -266,7 +266,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) { val typeParameters = elementsToElementList(method.getTypeParameters()) val modifiers = modifiersListToModifiersSet(method.getModifierList()) val docComments = getDocComments(method) - if (isOverrideAnyMethodExceptMethodsFromObject(method)) { + if (isOverride(method)) { modifiers.add(Modifier.OVERRIDE) } @@ -298,35 +298,6 @@ public class Converter(val project: Project, val settings: ConverterSettings) { return ParameterList(result) } - private fun isOverrideAnyMethodExceptMethodsFromObject(method: PsiMethod): Boolean { - var counter: Boolean = normalCase(method) - if (counter) - { - return true - } - - if (isInheritFromObject(method)) - { - return caseForObject(method) - } - - return false - } - - private fun caseForObject(method: PsiMethod): Boolean { - val containing: PsiClass? = method.getContainingClass() - if (containing != null) { - for (s : PsiClassType? in containing.getSuperTypes()) { - val canonicalText: String? = s?.getCanonicalText() - if (canonicalText != JAVA_LANG_OBJECT && !getClassIdentifiers().contains(canonicalText)) { - return true - } - } - } - - return false - } - public fun blockToBlock(block: PsiCodeBlock?, notEmpty: Boolean): Block { if (block == null) return Block.EMPTY_BLOCK @@ -529,70 +500,6 @@ public class Converter(val project: Project, val settings: ConverterSettings) { } } - private fun isNotOpenMethod(method: PsiMethod): Boolean { - val parent = method.getParent() - if (parent is PsiClass) { - val parentModifierList = parent.getModifierList() - if ((parentModifierList != null && parentModifierList.hasExplicitModifier(PsiModifier.FINAL)) || parent.isEnum()) { - return true - } - - } - - return false - } - - private fun normalCase(method: PsiMethod): Boolean { - var counter: Int = 0 - for (s : HierarchicalMethodSignature? in method.getHierarchicalMethodSignature().getSuperSignatures()) - { - var containingClass: PsiClass? = s?.getMethod()?.getContainingClass() - var qualifiedName: String? = (if (containingClass != null) - containingClass?.getQualifiedName() - else - "") - if (qualifiedName != null && !qualifiedName.equals(JAVA_LANG_OBJECT)) - { - counter++ - } - - } - return counter > 0 - } - - private fun isInheritFromObject(method: PsiMethod): Boolean { - var superSignatures: List = method.getHierarchicalMethodSignature().getSuperSignatures() - for (s : HierarchicalMethodSignature? in superSignatures) { - var containingClass: PsiClass? = s?.getMethod()?.getContainingClass() - var qualifiedName: String? = (if (containingClass != null) - containingClass?.getQualifiedName() - else - "") - if (qualifiedName == JAVA_LANG_OBJECT) { - return true - } - - } - return false - } - - private fun isOverrideObjectDirect(method: PsiMethod): Boolean { - var superSignatures: List? = method.getHierarchicalMethodSignature().getSuperSignatures() - if (superSignatures?.size()!! == 1) - { - val containingClass: PsiClass? = superSignatures?.get(0)?.getMethod()?.getContainingClass() - val qualifiedName: String? = (if (containingClass != null) - containingClass.getQualifiedName() - else - "") - if (qualifiedName == JAVA_LANG_OBJECT) { - return true - } - - } - - return false - } private fun importsToImportList(imports: Array): List { val result = ArrayList() for (i : PsiImportStatementBase? in imports) { diff --git a/j2k/src/org/jetbrains/jet/j2k/MethodUtils.kt b/j2k/src/org/jetbrains/jet/j2k/MethodUtils.kt new file mode 100644 index 00000000000..4b883ebfdd6 --- /dev/null +++ b/j2k/src/org/jetbrains/jet/j2k/MethodUtils.kt @@ -0,0 +1,78 @@ +/* + * 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.j2k + +import com.intellij.psi.PsiMethod +import com.intellij.psi.PsiClass +import com.intellij.psi.PsiModifier +import com.intellij.psi.CommonClassNames.JAVA_LANG_OBJECT + +/* +* Overrides of methods from object should not be marked as overrides in Kotlin unless the class itself has java ancestors +* */ +fun Converter.isOverride(method: PsiMethod): Boolean { + val superSignatures = method.getHierarchicalMethodSignature().getSuperSignatures() + val overridesMethodNotFromObject = superSignatures any { + it.getMethod().getContainingClass()?.getQualifiedName() != JAVA_LANG_OBJECT + } + + if (overridesMethodNotFromObject) { + return true + } + + val overridesMethodFromObject = superSignatures any { + it.getMethod().getContainingClass()?.getQualifiedName() == JAVA_LANG_OBJECT + } + + if (overridesMethodFromObject) { + val containing = method.getContainingClass() + if (containing != null) { + val hasOtherJavaSuperclasses = containing.getSuperTypes() any { + val canonicalText = it.getCanonicalText() + //TODO: correctly check for kotlin class + canonicalText != JAVA_LANG_OBJECT && !getClassIdentifiers().contains(canonicalText) + } + if (hasOtherJavaSuperclasses) { + return true + } + } + } + + return false +} + +fun isNotOpenMethod(method: PsiMethod): Boolean { + val parent = method.getParent() + if (parent is PsiClass) { + val parentModifierList = parent.getModifierList() + if ((parentModifierList != null && parentModifierList.hasExplicitModifier(PsiModifier.FINAL)) || parent.isEnum()) { + return true + } + } + return false +} + +fun directlyOverridesMethodFromObject(method: PsiMethod): Boolean { + var superSignatures = method.getHierarchicalMethodSignature().getSuperSignatures() + if (superSignatures.size() == 1) { + val qualifiedName = superSignatures.first!!.getMethod().getContainingClass()?.getQualifiedName() + if (qualifiedName == JAVA_LANG_OBJECT) { + return true + } + } + return false +} \ No newline at end of file