Java to Kotlin converter: fixed bugs with reference conversion in secondary constructors

j2k/src/org/jetbrains/jet/j2k/ConstructorConverter.kt

@@ -40,9 +40,12 @@ class ConstructorConverter(private val converter: Converter) {
             val bodyConverter = converter.withExpressionVisitor { object : ExpressionVisitor(it, mapOf()/*TODO: see KT-5327*/) {
                 override fun visitReferenceExpression(expression: PsiReferenceExpression) {
                     if (isQualifierEmptyOrThis(expression)) {
-                        val field = expression.getReference()?.resolve() as? PsiField
-                        if (field != null && field.getContainingClass() == constructor.getContainingClass()) {
-                            val isNullable = typeConverter.variableNullability(field).isNullable(converter.settings)
+                        val member = expression.getReference()?.resolve() as? PsiMember
+                        if (member != null &&
+                                !member.isConstructor() &&
+                                member.getContainingClass() == constructor.getContainingClass() &&
+                                !member.hasModifierProperty(PsiModifier.STATIC)) {
+                            val isNullable = member is PsiField && typeConverter.variableNullability(member).isNullable(converter.settings)
                             result = QualifiedExpression(tempValIdentifier(), Identifier(expression.getReferenceName()!!, isNullable).assignNoPrototype())
                             return
                         }

j2k/src/org/jetbrains/jet/j2k/Converter.kt

@@ -153,6 +153,7 @@ public class Converter private(val project: Project, val settings: ConverterSett
     // do not convert private static methods into class object if possible
     private fun shouldGenerateClassObject(psiClass: PsiClass, convertedMembers: Map<PsiMember, Member>): Boolean {
         if (psiClass.isEnum()) return false
+        if (convertedMembers.values().any { it is FactoryFunction }) return true
         val members = convertedMembers.keySet().filter { !it.isConstructor() }
         val classObjectMembers = members.filter { it !is PsiClass && it.hasModifierProperty(PsiModifier.STATIC) }
         val nestedClasses = members.filterIsInstance(javaClass<PsiClass>()).filter { it.hasModifierProperty(PsiModifier.STATIC) }

j2k/tests/test/org/jetbrains/jet/j2k/test/JavaToKotlinConverterTestGenerated.java

@@ -861,6 +861,11 @@ public class JavaToKotlinConverterTestGenerated extends AbstractJavaToKotlinConv
             doTest("j2k/tests/testData/ast/constructors/identifier.java");
         }
         
+        @TestMetadata("methodCallInFactoryFun.java")
+        public void testMethodCallInFactoryFun() throws Exception {
+            doTest("j2k/tests/testData/ast/constructors/methodCallInFactoryFun.java");
+        }
+        
         @TestMetadata("parameterModification.java")
         public void testParameterModification() throws Exception {
             doTest("j2k/tests/testData/ast/constructors/parameterModification.java");
@@ -876,6 +881,11 @@ public class JavaToKotlinConverterTestGenerated extends AbstractJavaToKotlinConv
             doTest("j2k/tests/testData/ast/constructors/qualifiedRefInFactoryFun.java");
         }
         
+        @TestMetadata("staticFieldRefInFactoryFun.java")
+        public void testStaticFieldRefInFactoryFun() throws Exception {
+            doTest("j2k/tests/testData/ast/constructors/staticFieldRefInFactoryFun.java");
+        }
+        
         @TestMetadata("withManyDefaultParams.java")
         public void testWithManyDefaultParams() throws Exception {
             doTest("j2k/tests/testData/ast/constructors/withManyDefaultParams.java");

j2k/tests/testData/ast/constructors/methodCallInFactoryFun.java

@@ -0,0 +1,20 @@
+//file
+class C {
+    private final int arg1;
+    private final int arg2;
+    private final int arg3;
+
+    int foo(int p){ return p; }
+    private static int staticFoo(int p){ return p; }
+
+    C(int arg1, int arg2, int arg3) {
+        this.arg1 = arg1;
+        this.arg2 = arg2;
+        this.arg3 = arg3;
+    }
+
+    C(int arg1, int arg2, C other) {
+        this(arg1, arg2, 0);
+        System.out.println(foo(1) + this.foo(2) + other.foo(3) + staticFoo(4) + C.staticFoo(5));
+    }
+}

j2k/tests/testData/ast/constructors/methodCallInFactoryFun.kt

@@ -0,0 +1,18 @@
+class C(private val arg1: Int, private val arg2: Int, private val arg3: Int) {
+
+    fun foo(p: Int): Int {
+        return p
+    }
+
+    class object {
+        private fun staticFoo(p: Int): Int {
+            return p
+        }
+
+        fun create(arg1: Int, arg2: Int, other: C): C {
+            val __ = C(arg1, arg2, 0)
+            System.out.println(__.foo(1) + __.foo(2) + other.foo(3) + staticFoo(4) + C.staticFoo(5))
+            return __
+        }
+    }
+}

j2k/tests/testData/ast/constructors/staticFieldRefInFactoryFun.java

@@ -0,0 +1,13 @@
+//file
+class C {
+    private static int staticField1 = 0;
+    private static int staticField2 = 0;
+
+    C() {
+    }
+
+    C(int p) {
+        this();
+        System.out.println(staticField1 + C.staticField2);
+    }
+}

j2k/tests/testData/ast/constructors/staticFieldRefInFactoryFun.kt

@@ -0,0 +1,12 @@
+class C {
+    class object {
+        private val staticField1 = 0
+        private val staticField2 = 0
+
+        fun create(p: Int): C {
+            val __ = C()
+            System.out.println(staticField1 + C.staticField2)
+            return __
+        }
+    }
+}