Apply reformat code and optimize imports to kotlin code in j2k

Minor: remove Unit return types

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

@@ -66,7 +66,7 @@ public open class Converter(val project: Project) {
         return Collections.unmodifiableSet(classIdentifiersSet)
     }
 
-    public open fun clearClassIdentifiers(): Unit {
+    public open fun clearClassIdentifiers() {
         classIdentifiersSet.clear()
     }
 
@@ -611,9 +611,11 @@ public open class Converter(val project: Project) {
             return false
         }
         private fun removeEmpty(statements: List<Element>): List<Element> {
-            return statements.filterNot { it == Statement.EMPTY_STATEMENT ||
+            return statements.filterNot {
+                it == Statement.EMPTY_STATEMENT ||
                 it == Expression.EMPTY_EXPRESSION ||
-                                          it == Element.EMPTY_ELEMENT }
+                it == Element.EMPTY_ELEMENT
+            }
         }
 
         private fun isNotOpenMethod(method: PsiMethod): Boolean {
@@ -852,7 +854,7 @@ open class ReferenceCollector(): JavaRecursiveElementVisitor() {
         return myCollectedReferences
     }
 
-    public override fun visitReferenceExpression(expression: PsiReferenceExpression?): Unit {
+    public override fun visitReferenceExpression(expression: PsiReferenceExpression?) {
         super.visitReferenceExpression(expression)
         if (expression != null) {
             myCollectedReferences.add(expression)

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

@@ -86,7 +86,7 @@ object JavaToKotlinTranslator {
         return null
     }
 
-    fun setClassIdentifiers(converter: Converter, psiFile: PsiElement): Unit {
+    fun setClassIdentifiers(converter: Converter, psiFile: PsiElement) {
         val c = ClassVisitor()
         psiFile.accept(c)
         converter.clearClassIdentifiers()

j2k/src/org/jetbrains/jet/j2k/ast/ArrayInitializerExpression.kt

@@ -18,7 +18,6 @@ package org.jetbrains.jet.j2k.ast
 
 import org.jetbrains.jet.j2k.ast.types.Type
 import org.jetbrains.jet.lang.types.expressions.OperatorConventions
-import java.util.*
 import com.intellij.openapi.util.text.StringUtil
 
 public open class ArrayInitializerExpression(val `type`: Type, val initializers: List<Expression>) : Expression() {

j2k/src/org/jetbrains/jet/j2k/ast/Block.kt

@@ -16,8 +16,6 @@
 
 package org.jetbrains.jet.j2k.ast
 
-import java.util.LinkedList
-
 public open class Block(val statements: List<Element>, val notEmpty: Boolean = false) : Statement() {
     public override fun isEmpty(): Boolean {
         return !notEmpty && (statements.size() == 0 || statements.all { it == Statement.EMPTY_STATEMENT })

j2k/src/org/jetbrains/jet/j2k/ast/Class.kt

@@ -16,13 +16,11 @@
 
 package org.jetbrains.jet.j2k.ast
 
-import org.jetbrains.annotations.Nullable
 import org.jetbrains.jet.j2k.Converter
 import org.jetbrains.jet.j2k.J2KConverterFlags
 import org.jetbrains.jet.j2k.ast.types.ClassType
 import org.jetbrains.jet.j2k.ast.types.Type
 import java.util.HashSet
-import java.util.LinkedList
 import java.util.ArrayList
 
 public open class Class(converter: Converter,
@@ -150,9 +148,11 @@ public open class Class(converter : Converter,
     class object {
         open fun getMembers(members: List<Node>, converter: Converter): List<Node> {
             if (converter.hasFlag(J2KConverterFlags.SKIP_NON_PUBLIC_MEMBERS)) {
-                return members.filter { it is Comment ||
+                return members.filter {
+                    it is Comment ||
                     (it as Member).accessModifier() == Modifier.PUBLIC ||
-                                        (it as Member).accessModifier() == Modifier.PROTECTED }
+                    (it as Member).accessModifier() == Modifier.PROTECTED
+                }
             }
             return members
         }

j2k/src/org/jetbrains/jet/j2k/ast/ExpressionList.kt

@@ -16,8 +16,6 @@
 
 package org.jetbrains.jet.j2k.ast
 
-import org.jetbrains.jet.j2k.ast.types.Type
-
 public open class ExpressionList(val expressions: List<Expression>) : Expression() {
     public override fun toKotlin(): String = expressions.map { it.toKotlin() }.makeString(", ")
 }

j2k/src/org/jetbrains/jet/j2k/ast/Field.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.jet.j2k.ast
 
 import org.jetbrains.jet.j2k.ast.types.Type
-import java.util.LinkedList
 import org.jetbrains.jet.j2k.Converter
 import java.util.ArrayList
 

j2k/src/org/jetbrains/jet/j2k/ast/Function.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.j2k.ast
 
-import java.util.LinkedList
 import org.jetbrains.jet.j2k.ast.types.Type
 import java.util.ArrayList
 

j2k/src/org/jetbrains/jet/j2k/ast/Identifier.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.jet.j2k.ast
 
 
-
 public open class Identifier(val name: String,
                              val myNullable: Boolean = true,
                              val quotingNeeded: Boolean = true) : Expression() {

j2k/src/org/jetbrains/jet/j2k/ast/NewClassExpression.kt

@@ -16,8 +16,6 @@
 
 package org.jetbrains.jet.j2k.ast
 
-import org.jetbrains.annotations.Nullable
-
 public open class NewClassExpression(val name: Element,
                                      val arguments: List<Expression>,
                                      val qualifier: Expression = Expression.EMPTY_EXPRESSION,

j2k/src/org/jetbrains/jet/j2k/ast/types/ClassType.kt

@@ -18,7 +18,6 @@ package org.jetbrains.jet.j2k.ast.types
 
 import org.jetbrains.jet.j2k.ast.Element
 import org.jetbrains.jet.j2k.ast.Identifier
-import java.util.Collections
 import java.util.ArrayList
 
 public open class ClassType(val `type`: Identifier, val parameters: List<Element>, nullable: Boolean) : Type(nullable) {

j2k/src/org/jetbrains/jet/j2k/ast/types/VarArg.kt

@@ -16,8 +16,6 @@
 
 package org.jetbrains.jet.j2k.ast.types
 
-import org.jetbrains.jet.j2k.ast.types.Type
-
 public open class VarArg(val `type`: Type) : Type(false) {
     public override fun toKotlin(): String = `type`.toKotlin()
 }

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

@@ -27,7 +27,7 @@ public open class ClassVisitor(): JavaRecursiveElementVisitor() {
         return HashSet<String>(myClassIdentifiers)
     }
 
-    public override fun visitClass(aClass: PsiClass?): Unit {
+    public override fun visitClass(aClass: PsiClass?) {
         val qName = aClass?.getQualifiedName()
         if (qName != null) {
             myClassIdentifiers.add(qName)

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

@@ -34,7 +34,7 @@ public open class ElementVisitor(val myConverter : Converter) : JavaElementVisit
         return myResult
     }
 
-    public override fun visitLocalVariable(variable : PsiLocalVariable?) : Unit {
+    public override fun visitLocalVariable(variable: PsiLocalVariable?) {
         val theVariable = variable!!
         var kType = myConverter.typeToType(theVariable.getType(), isAnnotatedAsNotNull(theVariable.getModifierList()))
         if (theVariable.hasModifierProperty(PsiModifier.FINAL) && isDefinitelyNotNull(theVariable.getInitializer())) {
@@ -46,11 +46,11 @@ public open class ElementVisitor(val myConverter : Converter) : JavaElementVisit
                                  myConverter.expressionToExpression(theVariable.getInitializer(), theVariable.getType()))
     }
 
-    public override fun visitExpressionList(list : PsiExpressionList?) : Unit {
+    public override fun visitExpressionList(list: PsiExpressionList?) {
         myResult = ExpressionList(myConverter.expressionsToExpressionList(list!!.getExpressions()))
     }
 
-    public override fun visitReferenceElement(reference : PsiJavaCodeReferenceElement?) : Unit {
+    public override fun visitReferenceElement(reference: PsiJavaCodeReferenceElement?) {
         val theReference = reference!!
         val types: List<Type> = myConverter.typesToTypeList(theReference.getTypeParameters())
         if (!theReference.isQualified()) {
@@ -69,16 +69,16 @@ public open class ElementVisitor(val myConverter : Converter) : JavaElementVisit
         }
     }
 
-    public override fun visitTypeElement(`type` : PsiTypeElement?) : Unit {
+    public override fun visitTypeElement(`type`: PsiTypeElement?) {
         myResult = TypeElement(myConverter.typeToType(`type`!!.getType()))
     }
 
-    public override fun visitTypeParameter(classParameter : PsiTypeParameter?) : Unit {
+    public override fun visitTypeParameter(classParameter: PsiTypeParameter?) {
         myResult = TypeParameter(Identifier(classParameter!!.getName()!!),
                                  classParameter.getExtendsListTypes().map { myConverter.typeToType(it) })
     }
 
-    public override fun visitParameterList(list : PsiParameterList?) : Unit {
+    public override fun visitParameterList(list: PsiParameterList?) {
         myResult = ParameterList(myConverter.parametersToParameterList(list!!.getParameters()).requireNoNulls())
     }
 

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

@@ -18,10 +18,8 @@ package org.jetbrains.jet.j2k.visitors
 
 import com.intellij.psi.*
 import com.intellij.psi.tree.IElementType
-import org.jetbrains.annotations.Nullable
 import org.jetbrains.jet.j2k.Converter
 import org.jetbrains.jet.j2k.ast.*
-import org.jetbrains.jet.j2k.ast.types.EmptyType
 import org.jetbrains.jet.j2k.ast.types.Type
 import org.jetbrains.jet.lang.types.expressions.OperatorConventions
 import java.util.ArrayList
@@ -40,7 +38,7 @@ public open class ExpressionVisitor(converter: Converter): StatementVisitor(conv
         return myResult as Expression
     }
 
-    public override fun visitArrayAccessExpression(expression: PsiArrayAccessExpression?): Unit {
+    public override fun visitArrayAccessExpression(expression: PsiArrayAccessExpression?) {
         val assignment = PsiTreeUtil.getParentOfType(expression, javaClass<PsiAssignmentExpression>())
         val lvalue = assignment != null && expression == assignment.getLExpression();
         myResult = ArrayAccessExpression(getConverter().expressionToExpression(expression?.getArrayExpression()),
@@ -48,12 +46,12 @@ public open class ExpressionVisitor(converter: Converter): StatementVisitor(conv
                                          lvalue)
     }
 
-    public override fun visitArrayInitializerExpression(expression: PsiArrayInitializerExpression?): Unit {
+    public override fun visitArrayInitializerExpression(expression: PsiArrayInitializerExpression?) {
         myResult = ArrayInitializerExpression(getConverter().typeToType(expression?.getType()),
                                               getConverter().expressionsToExpressionList(expression?.getInitializers()!!))
     }
 
-    public override fun visitAssignmentExpression(expression: PsiAssignmentExpression?): Unit {
+    public override fun visitAssignmentExpression(expression: PsiAssignmentExpression?) {
         val tokenType: IElementType = expression?.getOperationSign()?.getTokenType()!!
         val secondOp: String = when(tokenType) {
             JavaTokenType.GTGTEQ -> "shr"
@@ -75,7 +73,7 @@ public open class ExpressionVisitor(converter: Converter): StatementVisitor(conv
         }
     }
 
-    public override fun visitBinaryExpression(expression: PsiBinaryExpression?): Unit {
+    public override fun visitBinaryExpression(expression: PsiBinaryExpression?) {
         val lhs = getConverter().expressionToExpression(expression?.getLOperand()!!, expression?.getType())
         val rhs = getConverter().expressionToExpression(expression?.getROperand(), expression?.getType())
         if (expression?.getOperationSign()?.getTokenType() == JavaTokenType.GTGTGT) {
@@ -87,11 +85,11 @@ public open class ExpressionVisitor(converter: Converter): StatementVisitor(conv
         }
     }
 
-    public override fun visitClassObjectAccessExpression(expression: PsiClassObjectAccessExpression?): Unit {
+    public override fun visitClassObjectAccessExpression(expression: PsiClassObjectAccessExpression?) {
         myResult = ClassObjectAccessExpression(getConverter().typeElementToTypeElement(expression?.getOperand()))
     }
 
-    public override fun visitConditionalExpression(expression: PsiConditionalExpression?): Unit {
+    public override fun visitConditionalExpression(expression: PsiConditionalExpression?) {
         val condition: PsiExpression? = expression?.getCondition()
         val `type`: PsiType? = condition?.getType()
         val e: Expression = (if (`type` != null)
@@ -103,17 +101,17 @@ public open class ExpressionVisitor(converter: Converter): StatementVisitor(conv
                                                        getConverter().expressionToExpression(expression?.getElseExpression())))
     }
 
-    public override fun visitExpressionList(list: PsiExpressionList?): Unit {
+    public override fun visitExpressionList(list: PsiExpressionList?) {
         myResult = ExpressionList(getConverter().expressionsToExpressionList(list!!.getExpressions()))
     }
 
-    public override fun visitInstanceOfExpression(expression: PsiInstanceOfExpression?): Unit {
+    public override fun visitInstanceOfExpression(expression: PsiInstanceOfExpression?) {
         val checkType: PsiTypeElement? = expression?.getCheckType()
         myResult = IsOperator(getConverter().expressionToExpression(expression?.getOperand()),
                               myConverter.typeElementToTypeElement(checkType))
     }
 
-    public override fun visitLiteralExpression(expression: PsiLiteralExpression?): Unit {
+    public override fun visitLiteralExpression(expression: PsiLiteralExpression?) {
         val value: Any? = expression?.getValue()
         var text: String = expression?.getText()!!
         val `type`: PsiType? = expression?.getType()
@@ -143,7 +141,7 @@ public open class ExpressionVisitor(converter: Converter): StatementVisitor(conv
         myResult = LiteralExpression(text)
     }
 
-    public override fun visitMethodCallExpression(expression: PsiMethodCallExpression?): Unit {
+    public override fun visitMethodCallExpression(expression: PsiMethodCallExpression?) {
         convertMethodCallExpression(expression!!)
     }
 
@@ -156,7 +154,7 @@ public open class ExpressionVisitor(converter: Converter): StatementVisitor(conv
         }
     }
 
-    public override fun visitNewExpression(expression: PsiNewExpression?): Unit {
+    public override fun visitNewExpression(expression: PsiNewExpression?) {
         if (expression?.getArrayInitializer() != null)
         {
             myResult = createNewEmptyArray(expression)
@@ -211,16 +209,16 @@ public open class ExpressionVisitor(converter: Converter): StatementVisitor(conv
         return getConverter().expressionToExpression(expression?.getArrayInitializer())
     }
 
-    public override fun visitParenthesizedExpression(expression: PsiParenthesizedExpression?): Unit {
+    public override fun visitParenthesizedExpression(expression: PsiParenthesizedExpression?) {
         myResult = ParenthesizedExpression(getConverter().expressionToExpression(expression?.getExpression()))
     }
 
-    public override fun visitPostfixExpression(expression: PsiPostfixExpression?): Unit {
+    public override fun visitPostfixExpression(expression: PsiPostfixExpression?) {
         myResult = PostfixOperator(getOperatorString(expression!!.getOperationSign().getTokenType()!!),
                                    getConverter().expressionToExpression(expression.getOperand()))
     }
 
-    public override fun visitPrefixExpression(expression: PsiPrefixExpression?): Unit {
+    public override fun visitPrefixExpression(expression: PsiPrefixExpression?) {
         val operand = getConverter().expressionToExpression(expression?.getOperand(), expression?.getOperand()!!.getType())
         val token = expression?.getOperationTokenType()!!
         if (token == JavaTokenType.TILDE) {
@@ -231,7 +229,7 @@ public open class ExpressionVisitor(converter: Converter): StatementVisitor(conv
         }
     }
 
-    public override fun visitReferenceExpression(expression: PsiReferenceExpression?): Unit {
+    public override fun visitReferenceExpression(expression: PsiReferenceExpression?) {
         val isFieldReference: Boolean = isFieldReference(expression!!, getContainingClass(expression))
         val insideSecondaryConstructor: Boolean = isInsideSecondaryConstructor(expression)
         val hasReceiver: Boolean = isFieldReference && insideSecondaryConstructor
@@ -291,7 +289,7 @@ public open class ExpressionVisitor(converter: Converter): StatementVisitor(conv
         return false;
     }
 
-    public override fun visitSuperExpression(expression: PsiSuperExpression?): Unit {
+    public override fun visitSuperExpression(expression: PsiSuperExpression?) {
         val qualifier: PsiJavaCodeReferenceElement? = expression?.getQualifier()
         myResult = SuperExpression((if (qualifier != null)
             Identifier(qualifier.getQualifiedName()!!)
@@ -299,7 +297,7 @@ public open class ExpressionVisitor(converter: Converter): StatementVisitor(conv
             Identifier.EMPTY_IDENTIFIER))
     }
 
-    public override fun visitThisExpression(expression: PsiThisExpression?): Unit {
+    public override fun visitThisExpression(expression: PsiThisExpression?) {
         val qualifier: PsiJavaCodeReferenceElement? = expression?.getQualifier()
         myResult = ThisExpression((if (qualifier != null)
             Identifier(qualifier.getQualifiedName()!!)
@@ -307,7 +305,7 @@ public open class ExpressionVisitor(converter: Converter): StatementVisitor(conv
             Identifier.EMPTY_IDENTIFIER))
     }
 
-    public override fun visitTypeCastExpression(expression: PsiTypeCastExpression?): Unit {
+    public override fun visitTypeCastExpression(expression: PsiTypeCastExpression?) {
         val castType: PsiTypeElement? = expression?.getCastType()
         if (castType != null) {
             val operand = expression?.getOperand()
@@ -324,7 +322,7 @@ public open class ExpressionVisitor(converter: Converter): StatementVisitor(conv
         }
     }
 
-    public override fun visitPolyadicExpression(expression: PsiPolyadicExpression?): Unit {
+    public override fun visitPolyadicExpression(expression: PsiPolyadicExpression?) {
         var parameters = ArrayList<Expression>()
         for (operand : PsiExpression in expression?.getOperands()!!) {
             parameters.add(getConverter().expressionToExpression(operand, expression?.getType()))

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

@@ -24,7 +24,7 @@ import com.intellij.psi.CommonClassNames.JAVA_LANG_OBJECT
 import org.jetbrains.jet.j2k.ast.MethodCallExpression
 
 public open class ExpressionVisitorForDirectObjectInheritors(converter: Converter) : ExpressionVisitor(converter) {
-    public override fun visitMethodCallExpression(expression: PsiMethodCallExpression?): Unit {
+    public override fun visitMethodCallExpression(expression: PsiMethodCallExpression?) {
         val methodExpression = expression?.getMethodExpression()!!
         if (superMethodInvocation(methodExpression, "hashCode")) {
             myResult = MethodCallExpression.build(Identifier("System", false), "identityHashCode", arrayList(Identifier("this")))

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

@@ -18,26 +18,22 @@ package org.jetbrains.jet.j2k.visitors
 
 import com.intellij.psi.*
 import com.intellij.psi.tree.IElementType
-import org.jetbrains.annotations.Nullable
 import org.jetbrains.jet.j2k.Converter
 import org.jetbrains.jet.j2k.ast.*
-import java.util.Arrays
-import java.util.Collections
-import java.util.LinkedList
 import org.jetbrains.jet.j2k.countWritingAccesses
 import java.util.ArrayList
 
 public open class StatementVisitor(converter: Converter) : ElementVisitor(converter) {
-    public override fun visitAssertStatement(statement: PsiAssertStatement?): Unit {
+    public override fun visitAssertStatement(statement: PsiAssertStatement?) {
         myResult = AssertStatement(getConverter().expressionToExpression(statement?.getAssertCondition()),
                                    getConverter().expressionToExpression(statement?.getAssertDescription()))
     }
 
-    public override fun visitBlockStatement(statement: PsiBlockStatement?): Unit {
+    public override fun visitBlockStatement(statement: PsiBlockStatement?) {
         myResult = myConverter.blockToBlock(statement?.getCodeBlock(), true)
     }
 
-    public override fun visitBreakStatement(statement: PsiBreakStatement?): Unit {
+    public override fun visitBreakStatement(statement: PsiBreakStatement?) {
         if (statement?.getLabelIdentifier() == null) {
             myResult = BreakStatement(Identifier.EMPTY_IDENTIFIER)
         }
@@ -47,7 +43,7 @@ public open class StatementVisitor(converter: Converter): ElementVisitor(convert
         }
     }
 
-    public override fun visitContinueStatement(statement: PsiContinueStatement?): Unit {
+    public override fun visitContinueStatement(statement: PsiContinueStatement?) {
         if (statement?.getLabelIdentifier() == null)
         {
             myResult = ContinueStatement(Identifier.EMPTY_IDENTIFIER)
@@ -58,11 +54,11 @@ public open class StatementVisitor(converter: Converter): ElementVisitor(convert
         }
     }
 
-    public override fun visitDeclarationStatement(statement: PsiDeclarationStatement?): Unit {
+    public override fun visitDeclarationStatement(statement: PsiDeclarationStatement?) {
         myResult = DeclarationStatement(getConverter().elementsToElementList(statement?.getDeclaredElements()!!))
     }
 
-    public override fun visitDoWhileStatement(statement: PsiDoWhileStatement?): Unit {
+    public override fun visitDoWhileStatement(statement: PsiDoWhileStatement?) {
         val condition: PsiExpression? = statement?.getCondition()
         val expression: Expression = (if (condition != null && condition.getType() != null)
             getConverter().expressionToExpression(condition, condition.getType())
@@ -71,16 +67,16 @@ public open class StatementVisitor(converter: Converter): ElementVisitor(convert
         myResult = DoWhileStatement(expression, getConverter().statementToStatement(statement?.getBody()))
     }
 
-    public override fun visitExpressionStatement(statement: PsiExpressionStatement?): Unit {
+    public override fun visitExpressionStatement(statement: PsiExpressionStatement?) {
         myResult = getConverter().expressionToExpression(statement?.getExpression())
     }
 
-    public override fun visitExpressionListStatement(statement: PsiExpressionListStatement?): Unit {
+    public override fun visitExpressionListStatement(statement: PsiExpressionListStatement?) {
         myResult = ExpressionListStatement(getConverter().expressionsToExpressionList(
                 statement?.getExpressionList()?.getExpressions()!!))
     }
 
-    public override fun visitForStatement(statement: PsiForStatement?): Unit {
+    public override fun visitForStatement(statement: PsiForStatement?) {
         val initialization: PsiStatement? = statement?.getInitialization()
         val update: PsiStatement? = statement?.getUpdate()
         val condition: PsiExpression? = statement?.getCondition()
@@ -126,7 +122,7 @@ public open class StatementVisitor(converter: Converter): ElementVisitor(convert
         }
     }
 
-    public override fun visitForeachStatement(statement: PsiForeachStatement?): Unit {
+    public override fun visitForeachStatement(statement: PsiForeachStatement?) {
         val iterator = {
             val iteratorExpr = getConverter().expressionToExpression(statement?.getIteratedValue())
             if (iteratorExpr.isNullable())
@@ -139,7 +135,7 @@ public open class StatementVisitor(converter: Converter): ElementVisitor(convert
                                     getConverter().statementToStatement(statement?.getBody()))
     }
 
-    public override fun visitIfStatement(statement: PsiIfStatement?): Unit {
+    public override fun visitIfStatement(statement: PsiIfStatement?) {
         val condition: PsiExpression? = statement?.getCondition()
         val expression: Expression = getConverter().expressionToExpression(condition, PsiType.BOOLEAN)
         myResult = IfStatement(expression,
@@ -147,19 +143,19 @@ public open class StatementVisitor(converter: Converter): ElementVisitor(convert
                                getConverter().statementToStatement(statement?.getElseBranch()))
     }
 
-    public override fun visitLabeledStatement(statement: PsiLabeledStatement?): Unit {
+    public override fun visitLabeledStatement(statement: PsiLabeledStatement?) {
         myResult = LabelStatement(Converter.identifierToIdentifier(statement?.getLabelIdentifier()),
                                   getConverter().statementToStatement(statement?.getStatement()))
     }
 
-    public override fun visitSwitchLabelStatement(statement: PsiSwitchLabelStatement?): Unit {
+    public override fun visitSwitchLabelStatement(statement: PsiSwitchLabelStatement?) {
         myResult = (if (statement?.isDefaultCase()!!)
             DefaultSwitchLabelStatement()
         else
             SwitchLabelStatement(getConverter().expressionToExpression(statement?.getCaseValue())))
     }
 
-    public override fun visitSwitchStatement(statement: PsiSwitchStatement?): Unit {
+    public override fun visitSwitchStatement(statement: PsiSwitchStatement?) {
         myResult = SwitchContainer(getConverter().expressionToExpression(statement?.getExpression()),
                                    switchBodyToCases(statement?.getBody()))
     }
@@ -207,16 +203,16 @@ public open class StatementVisitor(converter: Converter): ElementVisitor(convert
         return result
     }
 
-    public override fun visitSynchronizedStatement(statement: PsiSynchronizedStatement?): Unit {
+    public override fun visitSynchronizedStatement(statement: PsiSynchronizedStatement?) {
         myResult = SynchronizedStatement(getConverter().expressionToExpression(statement?.getLockExpression()),
                                          getConverter().blockToBlock(statement?.getBody()))
     }
 
-    public override fun visitThrowStatement(statement: PsiThrowStatement?): Unit {
+    public override fun visitThrowStatement(statement: PsiThrowStatement?) {
         myResult = ThrowStatement(getConverter().expressionToExpression(statement?.getException()))
     }
 
-    public override fun visitTryStatement(statement: PsiTryStatement?): Unit {
+    public override fun visitTryStatement(statement: PsiTryStatement?) {
         val catches = ArrayList<CatchStatement>()
         val catchBlocks = statement?.getCatchBlocks()!!
         val catchBlockParameters = statement?.getCatchBlockParameters()!!
@@ -228,7 +224,7 @@ public open class StatementVisitor(converter: Converter): ElementVisitor(convert
                                 catches, getConverter().blockToBlock(statement?.getFinallyBlock(), true))
     }
 
-    public override fun visitWhileStatement(statement: PsiWhileStatement?): Unit {
+    public override fun visitWhileStatement(statement: PsiWhileStatement?) {
         var condition: PsiExpression? = statement?.getCondition()
         val expression: Expression = (if (condition != null && condition?.getType() != null)
             this.getConverter().expressionToExpression(condition, condition?.getType())
@@ -237,7 +233,7 @@ public open class StatementVisitor(converter: Converter): ElementVisitor(convert
         myResult = WhileStatement(expression, getConverter().statementToStatement(statement?.getBody()))
     }
 
-    public override fun visitReturnStatement(statement: PsiReturnStatement?): Unit {
+    public override fun visitReturnStatement(statement: PsiReturnStatement?) {
         val returnValue: PsiExpression? = statement?.getReturnValue()
         val methodReturnType: PsiType? = getConverter().methodReturnType
         val expression: Expression = (if (returnValue != null && methodReturnType != null)

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

@@ -22,7 +22,7 @@ import java.util.HashSet
 public open class SuperVisitor() : JavaRecursiveElementVisitor() {
     public val resolvedSuperCallParameters: HashSet<PsiExpressionList> = hashSet()
 
-    public override fun visitMethodCallExpression(expression: PsiMethodCallExpression?): Unit {
+    public override fun visitMethodCallExpression(expression: PsiMethodCallExpression?) {
         if (expression != null && isSuper(expression.getMethodExpression())) {
             resolvedSuperCallParameters.add(expression.getArgumentList())
         }

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

@@ -17,13 +17,12 @@
 package org.jetbrains.jet.j2k.visitors
 
 import com.intellij.psi.*
-import org.jetbrains.annotations.Nullable
 import java.util.LinkedHashSet
 
 public open class ThisVisitor() : JavaRecursiveElementVisitor() {
     private val myResolvedConstructors = LinkedHashSet<PsiMethod>()
 
-    public override fun visitReferenceExpression(expression: PsiReferenceExpression?): Unit {
+    public override fun visitReferenceExpression(expression: PsiReferenceExpression?) {
         for (r : PsiReference? in expression?.getReferences()!!) {
             if (r?.getCanonicalText() == "this") {
                 val res: PsiElement? = r?.resolve()