J2K: processing usages of get/set methods in the code being converted when converting them into property

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

@@ -35,6 +35,7 @@ import com.intellij.psi.PsiExpressionStatement
 import com.intellij.psi.PsiAssignmentExpression
 import com.intellij.psi.PsiExpression
 import com.intellij.psi.JavaTokenType
+import org.jetbrains.jet.j2k.usageProcessing.AccessorToPropertyProcessing
 
 class FieldCorrectionInfo(val name: String, val access: Modifier?, val setterAccess: Modifier?) {
     val identifier = Identifier(name).assignNoPrototype()
@@ -156,9 +157,10 @@ class ClassBodyConverter(private val psiClass: PsiClass,
         }
 
         for ((field, getterInfo) in fieldToGetterInfo) {
+            val propertyName = getterInfo.propertyName
             val setterInfo = run {
                 val info = fieldToSetterInfo[field]
-                if (info?.propertyName == getterInfo.propertyName) info else null
+                if (info?.propertyName == propertyName) info else null
             }
 
             membersToRemove.add(getterInfo.method)
@@ -172,7 +174,12 @@ class ClassBodyConverter(private val psiClass: PsiClass,
             else
                 converter.convertModifiers(field).accessModifier()
             //TODO: check that setter access is not bigger
-            fieldCorrections[field] = FieldCorrectionInfo(getterInfo.propertyName, getterAccess, setterAccess)
+            fieldCorrections[field] = FieldCorrectionInfo(propertyName, getterAccess, setterAccess)
+
+            converter.addUsageProcessing(AccessorToPropertyProcessing(getterInfo.method, AccessorKind.GETTER, propertyName))
+            if (setterInfo != null) {
+                converter.addUsageProcessing(AccessorToPropertyProcessing(setterInfo.method, AccessorKind.SETTER, propertyName))
+            }
         }
     }
 

j2k/src/org/jetbrains/jet/j2k/usageProcessing/UsageProcessing.kt

@@ -44,14 +44,20 @@ class UsageProcessingExpressionConverter(processings: Collection<UsageProcessing
     override fun convertExpression(expression: PsiExpression, codeConverter: CodeConverter): Expression? {
         if (targetToProcessing.isEmpty()) return null
 
-        //TODO: method usages
+        when (expression) {
+            is PsiReferenceExpression -> {
+                val target = expression.resolve() as? PsiVariable ?: return null
+                val processor = targetToProcessing[target]?.convertedCodeProcessor ?: return null
+                return processor.convertVariableUsage(expression, codeConverter)
+            }
 
-        if (expression is PsiReferenceExpression) {
+            is PsiMethodCallExpression -> {
-            val target = expression.resolve() ?: return null
+                val target = expression.getMethodExpression().resolve() as? PsiMethod ?: return null
-            val processor = targetToProcessing[target]?.convertedCodeProcessor ?: return null
+                val processor = targetToProcessing[target]?.convertedCodeProcessor ?: return null
-            return processor.convertVariableUsage(expression, codeConverter)
+                return processor.convertMethodUsage(expression, codeConverter)
+            }
+
+            else -> return null
         }
-
-        return null
     }
 }

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

@@ -37,8 +37,8 @@ public class User {
     class object {
         public fun main() {
             val customer = CustomerBuilder().WithFirstName("Homer").WithLastName("Simpson").Build()
-            System.out.println(customer.getFirstName())
+            System.out.println(customer.firstName)
-            System.out.println(customer.getLastName())
+            System.out.println(customer.lastName)
         }
     }
 }

j2k/tests/testData/ast/dropAccessors/GetterSetterUsages.java

@@ -17,3 +17,9 @@ public class AAA {
         other.setX(other.getX() + 1);
     }
 }
+
+class B {
+    void foo(AAA a) {
+        a.setX(a.getX() + 1);
+    }
+}

j2k/tests/testData/ast/dropAccessors/GetterSetterUsages.kt

@@ -9,3 +9,9 @@ public class AAA {
         other.x = other.x + 1
     }
 }
+
+class B {
+    fun foo(a: AAA) {
+        a.x = a.x + 1
+    }
+}