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

@@ -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<HierarchicalMethodSignature?> = 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<HierarchicalMethodSignature?>? = 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<PsiImportStatementBase>): List<Import> {
         val result = ArrayList<Import>()
         for (i : PsiImportStatementBase? in imports) {

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
+}