Refactored StatementVisitor to StatementConverter (similar to ExpressionConverter before) + renamed ExpressionVisitor

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

@@ -52,7 +52,7 @@ public class Converter private(val project: Project,
                                private val state: Converter.State) {
     private class State(val methodReturnType: PsiType?,
                         val expressionConverter: ExpressionConverter,
-                        val statementVisitorFactory: (Converter) -> StatementVisitor,
+                        val statementConverter: StatementConverter,
                         val specialContext: PsiElement?,
                         val importList: ImportList?,
                         val importsToAdd: MutableCollection<String>?)
@@ -64,8 +64,6 @@ public class Converter private(val project: Project,
     val importNames: Set<String> = state.importList?.imports?.mapTo(HashSet<String>()) { it.name } ?: setOf()
     val importsToAdd: MutableCollection<String>? = state.importsToAdd
 
-    private val statementVisitor = state.statementVisitorFactory(this)
-
     val annotationConverter = AnnotationConverter(this)
 
     class object {
@@ -73,34 +71,34 @@ public class Converter private(val project: Project,
 
         public fun create(project: Project, settings: ConverterSettings, conversionScope: ConversionScope,
                           referenceSearcher: ReferenceSearcher, postProcessor: PostProcessor?): Converter {
-            val state = State(null, ExpressionVisitor(), { StatementVisitor(it) }, null, null, null)
+            val state = State(null, DefaultExpressionConverter(), DefaultStatementConverter(), null, null, null)
             return Converter(project, settings, conversionScope, referenceSearcher, postProcessor, state)
         }
     }
 
     fun withMethodReturnType(methodReturnType: PsiType?): Converter
             = Converter(project, settings, conversionScope, referenceSearcher, postProcessor,
-                        State(methodReturnType, state.expressionConverter, state.statementVisitorFactory, state.specialContext, state.importList, state.importsToAdd))
+                        State(methodReturnType, state.expressionConverter, state.statementConverter, state.specialContext, state.importList, state.importsToAdd))
 
     fun withExpressionConverter(factory: (prevConverter: ExpressionConverter) -> ExpressionConverter): Converter
             = Converter(project, settings, conversionScope, referenceSearcher, postProcessor,
-                        State(state.methodReturnType, factory(state.expressionConverter), state.statementVisitorFactory, state.specialContext, state.importList, state.importsToAdd))
+                        State(state.methodReturnType, factory(state.expressionConverter), state.statementConverter, state.specialContext, state.importList, state.importsToAdd))
 
-    fun withStatementVisitor(factory: (Converter) -> StatementVisitor): Converter
+    fun withStatementConverter(factory: (prevConverter: StatementConverter) -> StatementConverter): Converter
             = Converter(project, settings, conversionScope, referenceSearcher, postProcessor,
-                        State(state.methodReturnType, state.expressionConverter, factory, state.specialContext, state.importList, state.importsToAdd))
+                        State(state.methodReturnType, state.expressionConverter, factory(state.statementConverter), state.specialContext, state.importList, state.importsToAdd))
 
     fun withSpecialContext(context: PsiElement): Converter
             = Converter(project, settings, conversionScope, referenceSearcher, postProcessor,
-                        State(state.methodReturnType, state.expressionConverter, state.statementVisitorFactory, context, state.importList, state.importsToAdd))
+                        State(state.methodReturnType, state.expressionConverter, state.statementConverter, context, state.importList, state.importsToAdd))
 
     private fun withImportList(importList: ImportList): Converter
             = Converter(project, settings, conversionScope, referenceSearcher, postProcessor,
-                        State(state.methodReturnType, state.expressionConverter, state.statementVisitorFactory, state.specialContext, importList, state.importsToAdd))
+                        State(state.methodReturnType, state.expressionConverter, state.statementConverter, state.specialContext, importList, state.importsToAdd))
 
     private fun withImportsToAdd(importsToAdd: MutableCollection<String>): Converter
             = Converter(project, settings, conversionScope, referenceSearcher, postProcessor,
-                        State(state.methodReturnType, state.expressionConverter, state.statementVisitorFactory, state.specialContext, state.importList, importsToAdd))
+                        State(state.methodReturnType, state.expressionConverter, state.statementConverter, state.specialContext, state.importList, importsToAdd))
 
     public fun elementToKotlin(element: PsiElement): String {
         try {
@@ -422,9 +420,7 @@ public class Converter private(val project: Project,
     fun convertStatement(statement: PsiStatement?): Statement {
         if (statement == null) return Statement.Empty
 
-        statementVisitor.reset()
+        return state.statementConverter.convertStatement(statement, this).assignPrototype(statement)
-        statement.accept(statementVisitor)
-        return statementVisitor.result.assignPrototype(statement)
     }
 
     fun convertExpressions(expressions: Array<PsiExpression>): List<Expression>

j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionConverter.kt

@@ -42,7 +42,7 @@ trait ExpressionConverter {
     fun convertExpression(expression: PsiExpression, converter: Converter): Expression
 }
 
-class ExpressionVisitor : JavaElementVisitor(), ExpressionConverter {
+class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
     private var _converter: Converter? = null
     private var result: Expression = Expression.Empty
 

j2k/src/org/jetbrains/jet/j2k/visitors/StatementConverter.kt

@@ -22,12 +22,24 @@ import org.jetbrains.jet.j2k.ast.*
 import java.util.ArrayList
 import org.jetbrains.jet.j2k.isInSingleLine
 
-open class StatementVisitor(public val converter: Converter) : JavaElementVisitor() {
+trait StatementConverter {
-    public var result: Statement = Statement.Empty
+    fun convertStatement(statement: PsiStatement, converter: Converter): Statement
-        protected set
+}
 
-    public fun reset() {
+class DefaultStatementConverter : JavaElementVisitor(), StatementConverter {
+    private var _converter: Converter? = null
+    private var result: Statement = Statement.Empty
+
+    private val converter: Converter get()  {
+        return _converter!!
+    }
+
+    override fun convertStatement(statement: PsiStatement, converter: Converter): Statement {
+        this._converter = converter
         result = Statement.Empty
+
+        statement.accept(this)
+        return result
     }
 
     override fun visitAssertStatement(statement: PsiAssertStatement) {