From a25ced9aa09fb355624ce1786513440e1d69bf29 Mon Sep 17 00:00:00 2001
From: "Pavel V. Talanov" <talanov.pavel@gmail.com>
Date: Wed, 18 Dec 2013 20:32:47 +0400
Subject: [PATCH] Refactor Converter: Minor: remove redundant public modifiers
 and fix formatting issues

---
 .../org/jetbrains/jet/j2k/ConstructorUtils.kt |   7 +-
 j2k/src/org/jetbrains/jet/j2k/Converter.kt    |  64 +++++------
 .../jetbrains/jet/j2k/ConverterSettings.kt    |   3 +-
 .../jet/j2k/JavaToKotlinTranslator.kt         |   8 +-
 .../org/jetbrains/jet/j2k/MainMethodUtils.kt  |   5 +-
 .../jetbrains/jet/j2k/ast/AnonymousClass.kt   |   4 +-
 .../jet/j2k/ast/ArrayInitializerExpression.kt |   6 +-
 .../ArrayWithoutInitializationExpression.kt   |   4 +-
 .../jetbrains/jet/j2k/ast/AssertStatement.kt  |   4 +-
 j2k/src/org/jetbrains/jet/j2k/ast/Block.kt    |  12 +-
 .../jet/j2k/ast/CallChainExpression.kt        |   6 +-
 j2k/src/org/jetbrains/jet/j2k/ast/Class.kt    |  20 ++--
 .../org/jetbrains/jet/j2k/ast/Constructor.kt  |  26 +++--
 .../jet/j2k/ast/DummyStringExpression.kt      |   4 +-
 j2k/src/org/jetbrains/jet/j2k/ast/Element.kt  |  14 +--
 j2k/src/org/jetbrains/jet/j2k/ast/Enum.kt     |  24 ++--
 .../org/jetbrains/jet/j2k/ast/EnumConstant.kt |  14 ++-
 .../org/jetbrains/jet/j2k/ast/Expression.kt   |  12 +-
 .../jetbrains/jet/j2k/ast/ExpressionList.kt   |   4 +-
 .../org/jetbrains/jet/j2k/ast/Expressions.kt  |  26 ++---
 j2k/src/org/jetbrains/jet/j2k/ast/Field.kt    |  18 +--
 j2k/src/org/jetbrains/jet/j2k/ast/File.kt     |  10 +-
 j2k/src/org/jetbrains/jet/j2k/ast/Function.kt |  20 ++--
 .../org/jetbrains/jet/j2k/ast/Identifier.kt   |  19 ++--
 j2k/src/org/jetbrains/jet/j2k/ast/Imports.kt  |  10 +-
 .../org/jetbrains/jet/j2k/ast/Initializer.kt  |   4 +-
 .../jetbrains/jet/j2k/ast/LocalVariable.kt    |  14 ++-
 j2k/src/org/jetbrains/jet/j2k/ast/Members.kt  |  16 +--
 .../jet/j2k/ast/MethodCallExpression.kt       |  14 ++-
 j2k/src/org/jetbrains/jet/j2k/ast/Modifier.kt |   2 +-
 .../jet/j2k/ast/NewClassExpression.kt         |  12 +-
 j2k/src/org/jetbrains/jet/j2k/ast/Node.kt     |   4 +-
 .../org/jetbrains/jet/j2k/ast/Parameter.kt    |   4 +-
 .../jetbrains/jet/j2k/ast/ParameterList.kt    |   4 +-
 .../jet/j2k/ast/PolyadicExpression.kt         |   4 +-
 .../jetbrains/jet/j2k/ast/ReferenceElement.kt |   4 +-
 .../org/jetbrains/jet/j2k/ast/Statements.kt   | 106 +++++++++---------
 j2k/src/org/jetbrains/jet/j2k/ast/Trait.kt    |  22 ++--
 .../org/jetbrains/jet/j2k/ast/TypeElement.kt  |   4 +-
 .../jetbrains/jet/j2k/ast/TypeParameters.kt   |  18 +--
 j2k/src/org/jetbrains/jet/j2k/ast/Util.kt     |  10 +-
 .../org/jetbrains/jet/j2k/ast/WhiteSpace.kt   |   8 +-
 .../jetbrains/jet/j2k/ast/types/ArrayType.kt  |  11 +-
 .../jetbrains/jet/j2k/ast/types/ClassType.kt  |   8 +-
 .../jetbrains/jet/j2k/ast/types/EmptyType.kt  |   4 +-
 .../jet/j2k/ast/types/InProjectionType.kt     |   4 +-
 .../jet/j2k/ast/types/OutProjectionType.kt    |   4 +-
 .../jet/j2k/ast/types/PrimitiveType.kt        |   4 +-
 .../jet/j2k/ast/types/StarProjectionType.kt   |   4 +-
 .../org/jetbrains/jet/j2k/ast/types/Type.kt   |  20 ++--
 .../org/jetbrains/jet/j2k/ast/types/VarArg.kt |   4 +-
 .../jet/j2k/visitors/ClassVisitor.kt          |   4 +-
 .../jetbrains/jet/j2k/visitors/Dispatcher.kt  |   4 +-
 .../jet/j2k/visitors/ElementVisitor.kt        |  20 ++--
 .../jet/j2k/visitors/ExpressionVisitor.kt     |  46 ++++----
 ...ressionVisitorForDirectObjectInheritors.kt |   4 +-
 .../jet/j2k/visitors/StatementVisitor.kt      |  40 +++----
 .../jet/j2k/visitors/SuperVisitor.kt          |   6 +-
 .../jetbrains/jet/j2k/visitors/TypeVisitor.kt |  14 +--
 .../test/AbstractJavaToKotlinConverterTest.kt |  10 +-
 60 files changed, 413 insertions(+), 392 deletions(-)

diff --git a/j2k/src/org/jetbrains/jet/j2k/ConstructorUtils.kt b/j2k/src/org/jetbrains/jet/j2k/ConstructorUtils.kt
index 1849ae1194c..b80807732c5 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ConstructorUtils.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ConstructorUtils.kt
@@ -19,12 +19,11 @@ package org.jetbrains.jet.j2k
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiReferenceExpression
-import com.intellij.psi.PsiReference
 import com.intellij.psi.PsiElement
 import com.intellij.psi.JavaRecursiveElementVisitor
 import java.util.LinkedHashSet
 
-public fun isConstructorPrimary(constructor: PsiMethod): Boolean {
+fun isConstructorPrimary(constructor: PsiMethod): Boolean {
     val parent = constructor.getParent()
     if (parent is PsiClass) {
         if (parent.getConstructors().size == 1) {
@@ -49,7 +48,7 @@ private fun getPrimaryConstructorForThisCase(psiClass: PsiClass): PsiMethod? {
 private class FindPrimaryConstructorVisitor() : JavaRecursiveElementVisitor() {
     private val myResolvedConstructors = LinkedHashSet<PsiMethod>()
 
-    public override fun visitReferenceExpression(expression: PsiReferenceExpression?) {
+    override fun visitReferenceExpression(expression: PsiReferenceExpression?) {
         for (r in expression?.getReferences()!!) {
             if (r.getCanonicalText() == "this") {
                 val res: PsiElement? = r.resolve()
@@ -60,7 +59,7 @@ private class FindPrimaryConstructorVisitor() : JavaRecursiveElementVisitor() {
         }
     }
 
-    public fun getPrimaryConstructor(): PsiMethod? {
+    fun getPrimaryConstructor(): PsiMethod? {
         if (myResolvedConstructors.size() > 0) {
             val first: PsiMethod = myResolvedConstructors.iterator().next()
             for (m in myResolvedConstructors)
diff --git a/j2k/src/org/jetbrains/jet/j2k/Converter.kt b/j2k/src/org/jetbrains/jet/j2k/Converter.kt
index 94703784c0b..b39f605cacf 100644
--- a/j2k/src/org/jetbrains/jet/j2k/Converter.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/Converter.kt
@@ -38,14 +38,14 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
 
     private val dispatcher: Dispatcher = Dispatcher(this)
 
-    public var methodReturnType: PsiType? = null
+    var methodReturnType: PsiType? = null
         private set
 
     public fun setClassIdentifiers(identifiers: MutableSet<String>) {
         classIdentifiersSet = identifiers
     }
 
-    public fun getClassIdentifiers(): Set<String> {
+    fun getClassIdentifiers(): Set<String> {
         return Collections.unmodifiableSet(classIdentifiersSet)
     }
 
@@ -58,7 +58,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
         return kElement?.toKotlin() ?: ""
     }
 
-    public fun convertTopElement(element: PsiElement?): Element? = when(element) {
+    fun convertTopElement(element: PsiElement?): Element? = when(element) {
         is PsiJavaFile -> convertFile(element)
         is PsiClass -> convertClass(element)
         is PsiMethod -> convertMethod(element)
@@ -78,7 +78,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
         return File(fileMembers, createMainFunction(javaFile))
     }
 
-    public fun convertAnonymousClass(anonymousClass: PsiAnonymousClass): AnonymousClass {
+    fun convertAnonymousClass(anonymousClass: PsiAnonymousClass): AnonymousClass {
         return AnonymousClass(this, convertMembers(anonymousClass))
     }
 
@@ -270,22 +270,22 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
         return ParameterList(result)
     }
 
-    public fun convertBlock(block: PsiCodeBlock?, notEmpty: Boolean): Block {
+    fun convertBlock(block: PsiCodeBlock?, notEmpty: Boolean): Block {
         if (block == null)
             return Block.Empty
 
         return Block(convertStatements(block.getChildren().toList()), notEmpty)
     }
 
-    public fun convertBlock(block: PsiCodeBlock?): Block {
+    fun convertBlock(block: PsiCodeBlock?): Block {
         return convertBlock(block, true)
     }
 
-    public fun convertStatements(statements: List<PsiElement>): StatementList {
+    fun convertStatements(statements: List<PsiElement>): StatementList {
         return StatementList(statements.map { if (it is PsiStatement) convertStatement(it) else convertElement(it) })
     }
 
-    public fun convertStatement(s: PsiStatement?): Statement {
+    fun convertStatement(s: PsiStatement?): Statement {
         if (s == null)
             return Statement.Empty
 
@@ -294,14 +294,14 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
         return statementVisitor.getResult() as Statement
     }
 
-    public fun convertExpressions(expressions: Array<PsiExpression>): List<Expression> {
+    fun convertExpressions(expressions: Array<PsiExpression>): List<Expression> {
         val result = ArrayList<Expression>()
         for (e : PsiExpression? in expressions)
             result.add(convertExpression(e))
         return result
     }
 
-    public fun convertExpression(e: PsiExpression?): Expression {
+    fun convertExpression(e: PsiExpression?): Expression {
         if (e == null)
             return Expression.Empty
 
@@ -310,7 +310,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
         return expressionVisitor.getResult()
     }
 
-    public fun convertElement(e: PsiElement?): Element {
+    fun convertElement(e: PsiElement?): Element {
         if (e == null)
             return Element.Empty
 
@@ -319,7 +319,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
         return elementVisitor.getResult()
     }
 
-    public fun convertElements(elements: Array<out PsiElement?>): List<Element> {
+    fun convertElements(elements: Array<out PsiElement?>): List<Element> {
         val result = ArrayList<Element>()
         for (element in elements) {
             result.add(convertElement(element))
@@ -327,14 +327,14 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
         return result
     }
 
-    public fun convertTypeElement(element: PsiTypeElement?): TypeElement {
+    fun convertTypeElement(element: PsiTypeElement?): TypeElement {
         return TypeElement(if (element == null)
                                EmptyType()
                            else
                                convertType(element.getType()))
     }
 
-    public fun convertType(`type`: PsiType?): Type {
+    fun convertType(`type`: PsiType?): Type {
         if (`type` == null)
             return EmptyType()
 
@@ -343,11 +343,11 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
         return typeVisitor.getResult()
     }
 
-    public fun convertTypes(types: Array<PsiType>): List<Type> {
+    fun convertTypes(types: Array<PsiType>): List<Type> {
         return types.map { convertType(it) }
     }
 
-    public fun convertType(`type`: PsiType?, notNull: Boolean): Type {
+    fun convertType(`type`: PsiType?, notNull: Boolean): Type {
         val result: Type = convertType(`type`)
         if (notNull) {
             return result.convertedToNotNull()
@@ -364,17 +364,17 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
         return result
     }
 
-    public fun convertParameterList(parameters: Array<PsiParameter>): List<Parameter?> {
+    fun convertParameterList(parameters: Array<PsiParameter>): List<Parameter?> {
         return parameters.map { convertParameter(it) }
     }
 
-    public fun convertParameter(parameter: PsiParameter, forceNotNull: Boolean = false): Parameter {
+    fun convertParameter(parameter: PsiParameter, forceNotNull: Boolean = false): Parameter {
         return Parameter(Identifier(parameter.getName()!!),
                          convertType(parameter.getType(),
                                      forceNotNull || isAnnotatedAsNotNull(parameter.getModifierList())), true)
     }
 
-    public fun convertArguments(expression: PsiCallExpression): List<Expression> {
+    fun convertArguments(expression: PsiCallExpression): List<Expression> {
         val argumentList: PsiExpressionList? = expression.getArgumentList()
         val arguments: Array<PsiExpression> = (if (argumentList != null)
             argumentList.getExpressions()
@@ -399,7 +399,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
         return result
     }
 
-    public fun convertExpression(argument: PsiExpression?, expectedType: PsiType?): Expression {
+    fun convertExpression(argument: PsiExpression?, expectedType: PsiType?): Expression {
         if (argument == null)
             return Identifier.Empty
 
@@ -429,7 +429,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
         return expression
     }
 
-    public fun quoteKeywords(packageName: String): String {
+    fun quoteKeywords(packageName: String): String {
         return packageName.split("\\.").map { Identifier(it).toKotlin() }.makeString(".")
     }
 
@@ -460,14 +460,14 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
         return s + "(" + fields.map { initializers[it.identifier.toKotlin()] }.makeString(", ") + ")"
     }
 
-    public fun convertIdentifier(identifier: PsiIdentifier?): Identifier {
+    fun convertIdentifier(identifier: PsiIdentifier?): Identifier {
         if (identifier == null)
             return Identifier.Empty
 
         return Identifier(identifier.getText()!!)
     }
 
-    public fun convertModifierList(modifierList: PsiModifierList?): MutableSet<Modifier> {
+    fun convertModifierList(modifierList: PsiModifierList?): MutableSet<Modifier> {
         val modifiersSet: HashSet<Modifier> = hashSetOf()
         if (modifierList != null) {
             if (modifierList.hasExplicitModifier(PsiModifier.ABSTRACT))
@@ -516,8 +516,8 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
     }
 }
 
-public val NOT_NULL_ANNOTATIONS: Set<String> = ImmutableSet.of<String>("org.jetbrains.annotations.NotNull", "com.sun.istack.internal.NotNull", "javax.annotation.Nonnull")!!
-public val PRIMITIVE_TYPE_CONVERSIONS: Map<String, String> = ImmutableMap.builder<String, String>()
+val NOT_NULL_ANNOTATIONS: Set<String> = ImmutableSet.of<String>("org.jetbrains.annotations.NotNull", "com.sun.istack.internal.NotNull", "javax.annotation.Nonnull")!!
+val PRIMITIVE_TYPE_CONVERSIONS: Map<String, String> = ImmutableMap.builder<String, String>()
 ?.put("byte", BYTE.asString())
 ?.put("short", SHORT.asString())
 ?.put("int", INT.asString())
@@ -535,7 +535,7 @@ public val PRIMITIVE_TYPE_CONVERSIONS: Map<String, String> = ImmutableMap.builde
 ?.build()!!
 
 
-public fun countWritingAccesses(element: PsiElement?, container: PsiElement?): Int {
+fun countWritingAccesses(element: PsiElement?, container: PsiElement?): Int {
     var counter: Int = 0
     if (container != null) {
         val visitor: ReferenceCollector = ReferenceCollector()
@@ -552,11 +552,11 @@ public fun countWritingAccesses(element: PsiElement?, container: PsiElement?): I
 open class ReferenceCollector() : JavaRecursiveElementVisitor() {
     private val myCollectedReferences = ArrayList<PsiReferenceExpression>()
 
-    public open fun getCollectedReferences(): List<PsiReferenceExpression> {
+    open fun getCollectedReferences(): List<PsiReferenceExpression> {
         return myCollectedReferences
     }
 
-    public override fun visitReferenceExpression(expression: PsiReferenceExpression?) {
+    override fun visitReferenceExpression(expression: PsiReferenceExpression?) {
         super.visitReferenceExpression(expression)
         if (expression != null) {
             myCollectedReferences.add(expression)
@@ -564,11 +564,11 @@ open class ReferenceCollector() : JavaRecursiveElementVisitor() {
     }
 }
 
-public fun isReadOnly(element: PsiElement?, container: PsiElement?): Boolean {
+fun isReadOnly(element: PsiElement?, container: PsiElement?): Boolean {
     return countWritingAccesses(element, container) == 0
 }
 
-public fun isAnnotatedAsNotNull(modifierList: PsiModifierList?): Boolean {
+fun isAnnotatedAsNotNull(modifierList: PsiModifierList?): Boolean {
     if (modifierList != null) {
         val annotations: Array<PsiAnnotation> = modifierList.getAnnotations()
         for (a : PsiAnnotation in annotations) {
@@ -581,13 +581,13 @@ public fun isAnnotatedAsNotNull(modifierList: PsiModifierList?): Boolean {
     return false
 }
 
-public fun isDefinitelyNotNull(element: PsiElement?): Boolean = when(element) {
+fun isDefinitelyNotNull(element: PsiElement?): Boolean = when(element) {
     is PsiLiteralExpression -> element.getValue() != null
     is PsiNewExpression -> true
     else -> false
 }
 
-public fun getDefaultInitializer(f: Field): String {
+fun getDefaultInitializer(f: Field): String {
     if (f.`type`.nullable) {
         return "null"
     }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ConverterSettings.kt b/j2k/src/org/jetbrains/jet/j2k/ConverterSettings.kt
index 974389c65b4..859101cb462 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ConverterSettings.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ConverterSettings.kt
@@ -21,7 +21,8 @@ public class ConverterSettings(
         val forceLocalVariableImmutability: Boolean,
         val specifyLocalVariableTypeByDefault: Boolean,
         val openByDefault: Boolean
-) {}
+) {
+}
 
 public val PluginSettings: ConverterSettings = ConverterSettings(
         forceNotNullTypes = true,
diff --git a/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt b/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt
index 4a491dac4de..d09b03cec0e 100644
--- a/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt
@@ -32,7 +32,7 @@ import java.io.File
 import java.net.URLClassLoader
 import java.util.HashSet
 
-object JavaToKotlinTranslator {
+public object JavaToKotlinTranslator {
     private val DISPOSABLE: Disposable? = Disposer.newDisposable()
 
     private fun createFile(text: String): PsiFile? {
@@ -40,7 +40,7 @@ object JavaToKotlinTranslator {
         return PsiFileFactory.getInstance(javaCoreEnvironment?.getProject())?.createFileFromText("test.java", JavaLanguage.INSTANCE, text)
     }
 
-    public fun createFile(project: Project, text: String): PsiFile? {
+    fun createFile(project: Project, text: String): PsiFile? {
         return PsiFileFactory.getInstance(project)?.createFileFromText("test.java", JavaLanguage.INSTANCE, text)
     }
 
@@ -70,7 +70,7 @@ object JavaToKotlinTranslator {
                 .trim()
     }
 
-    public fun findAnnotations(): File? {
+    fun findAnnotations(): File? {
         var classLoader = javaClass<JavaToKotlinTranslator>().getClassLoader()
         while (classLoader != null) {
             val loader = classLoader
@@ -104,7 +104,7 @@ object JavaToKotlinTranslator {
     }
 }
 
-public fun main(args: Array<String>) {
+fun main(args: Array<String>) {
     if (args.size == 1) {
         try {
             val kotlinCode = JavaToKotlinTranslator.generateKotlinCode(args[0])
diff --git a/j2k/src/org/jetbrains/jet/j2k/MainMethodUtils.kt b/j2k/src/org/jetbrains/jet/j2k/MainMethodUtils.kt
index ab9ba391366..efbb1142f45 100644
--- a/j2k/src/org/jetbrains/jet/j2k/MainMethodUtils.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/MainMethodUtils.kt
@@ -25,10 +25,9 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiAnonymousClass
 import com.intellij.psi.PsiModifier
 import com.intellij.psi.PsiType
-import com.intellij.psi.PsiParameter
 import com.intellij.psi.PsiArrayType
 
-public fun createMainFunction(file: PsiFile): String {
+fun createMainFunction(file: PsiFile): String {
     val classNamesWithMains = ArrayList<Pair<String, PsiMethod>>()
     for (c in (file as PsiJavaFile).getClasses()) {
         val main = findMainMethod(c)
@@ -69,7 +68,7 @@ private fun findMainMethod(mainMethods: Array<PsiMethod>): PsiMethod? {
     return mainMethods.find { isMainMethod(it) }
 }
 
-public fun isMainMethod(method: PsiMethod): Boolean {
+fun isMainMethod(method: PsiMethod): Boolean {
     if (method.getContainingClass() == null)
         return false
 
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.kt b/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.kt
index e4838ef51d4..2cb5c7a07e0 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.kt
@@ -20,7 +20,7 @@ import org.jetbrains.jet.j2k.Converter
 import org.jetbrains.jet.j2k.ast.types.Type
 import java.util.Collections
 
-public class AnonymousClass(converter: Converter, members: List<Element>)
+class AnonymousClass(converter: Converter, members: List<Element>)
 : Class(converter,
         Identifier("anonClass"),
         MemberComments.Empty,
@@ -29,5 +29,5 @@ public class AnonymousClass(converter: Converter, members: List<Element>)
         Collections.emptyList<Type>(),
         Collections.emptyList<Expression>(),
         Collections.emptyList<Type>(), members) {
-    public override fun toKotlin() = bodyToKotlin()
+    override fun toKotlin() = bodyToKotlin()
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayInitializerExpression.kt b/j2k/src/org/jetbrains/jet/j2k/ast/ArrayInitializerExpression.kt
index a516e99a8e1..5883b8647c4 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayInitializerExpression.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/ArrayInitializerExpression.kt
@@ -16,14 +16,12 @@
 
 package org.jetbrains.jet.j2k.ast
 
-import org.jetbrains.jet.j2k.ast.types.Type
 import org.jetbrains.jet.lang.types.expressions.OperatorConventions
-import com.intellij.openapi.util.text.StringUtil
 import org.jetbrains.jet.j2k.ast.types.ArrayType
 import org.jetbrains.jet.j2k.ast.types.isPrimitive
 
-public open class ArrayInitializerExpression(val arrayType: ArrayType, val initializers: List<Expression>) : Expression() {
-    public override fun toKotlin(): String {
+open class ArrayInitializerExpression(val arrayType: ArrayType, val initializers: List<Expression>) : Expression() {
+    override fun toKotlin(): String {
         return createArrayFunction() + "(" + createInitializers() + ")"
     }
 
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayWithoutInitializationExpression.kt b/j2k/src/org/jetbrains/jet/j2k/ast/ArrayWithoutInitializationExpression.kt
index f1dd17ec359..ddb6cd6724b 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayWithoutInitializationExpression.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/ArrayWithoutInitializationExpression.kt
@@ -20,8 +20,8 @@ import org.jetbrains.jet.j2k.ast.types.ArrayType
 import org.jetbrains.jet.j2k.ast.types.Type
 import org.jetbrains.jet.j2k.ast.types.PrimitiveType
 
-public open class ArrayWithoutInitializationExpression(val `type`: Type, val expressions: List<Expression>) : Expression() {
-    public override fun toKotlin(): String {
+open class ArrayWithoutInitializationExpression(val `type`: Type, val expressions: List<Expression>) : Expression() {
+    override fun toKotlin(): String {
         if (`type` is ArrayType) {
             return constructInnerType(`type`, expressions)
         }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/AssertStatement.kt b/j2k/src/org/jetbrains/jet/j2k/ast/AssertStatement.kt
index fffd00dab6a..a43fef22c9f 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/AssertStatement.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/AssertStatement.kt
@@ -17,8 +17,8 @@
 package org.jetbrains.jet.j2k.ast
 
 
-public class AssertStatement(val condition: Expression, val detail: Expression) : Statement() {
-    public override fun toKotlin(): String {
+class AssertStatement(val condition: Expression, val detail: Expression) : Statement() {
+    override fun toKotlin(): String {
         val lazyStringMessage = if (detail != Expression.Empty)
             " {" + detail.toKotlin() + "}"
         else
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Block.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Block.kt
index c60d51c9b2e..97653605397 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Block.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Block.kt
@@ -18,7 +18,7 @@ package org.jetbrains.jet.j2k.ast
 
 import java.util.ArrayList
 
-public fun Block(statements: List<Statement>, notEmpty: Boolean = false): Block {
+fun Block(statements: List<Statement>, notEmpty: Boolean = false): Block {
     val elements = ArrayList<Element>()
     elements.add(WhiteSpace.NewLine)
     elements.addAll(statements)
@@ -26,15 +26,15 @@ public fun Block(statements: List<Statement>, notEmpty: Boolean = false): Block
     return Block(StatementList(elements), notEmpty)
 }
 
-public class Block(val statementList: StatementList, val notEmpty: Boolean = false) : Statement() {
+class Block(val statementList: StatementList, val notEmpty: Boolean = false) : Statement() {
 
-    public val statements: List<Statement> = statementList.statements
+    val statements: List<Statement> = statementList.statements
 
-    public override fun isEmpty(): Boolean {
+    override fun isEmpty(): Boolean {
         return !notEmpty && statements.all { it.isEmpty() }
     }
 
-    public override fun toKotlin(): String {
+    override fun toKotlin(): String {
         if (!isEmpty()) {
             return "{${statementList.toKotlin()}}"
         }
@@ -43,6 +43,6 @@ public class Block(val statementList: StatementList, val notEmpty: Boolean = fal
     }
 
     class object {
-        public val Empty: Block = Block(StatementList(ArrayList()))
+        val Empty = Block(StatementList(ArrayList()))
     }
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/CallChainExpression.kt b/j2k/src/org/jetbrains/jet/j2k/ast/CallChainExpression.kt
index 4a93bf15894..27a16de4a77 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/CallChainExpression.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/CallChainExpression.kt
@@ -16,13 +16,13 @@
 
 package org.jetbrains.jet.j2k.ast
 
-public class CallChainExpression(val expression: Expression, val identifier: Expression) : Expression() {
-    public override fun isNullable(): Boolean {
+class CallChainExpression(val expression: Expression, val identifier: Expression) : Expression() {
+    override fun isNullable(): Boolean {
         if (!expression.isEmpty() && expression.isNullable()) return true
         return identifier.isNullable()
     }
 
-    public override fun toKotlin(): String {
+    override fun toKotlin(): String {
         if (!expression.isEmpty()) {
             return expression.toKotlin() + (if (expression.isNullable()) "?." else ".") + identifier.toKotlin()
         }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Class.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Class.kt
index e922ae2c9ee..9f1a77020de 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Class.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Class.kt
@@ -22,15 +22,17 @@ import org.jetbrains.jet.j2k.ast.types.Type
 import java.util.HashSet
 import java.util.ArrayList
 
-public open class Class(val converter: Converter,
-                        val name: Identifier,
-                        comments: MemberComments,
-                        modifiers: Set<Modifier>,
-                        val typeParameterList: TypeParameterList,
-                        val extendsTypes: List<Type>,
-                        val baseClassParams: List<Expression>,
-                        val implementsTypes: List<Type>,
-                        val members: List<Element>) : Member(comments, modifiers) {
+open class Class(
+        val converter: Converter,
+        val name: Identifier,
+        comments: MemberComments,
+        modifiers: Set<Modifier>,
+        val typeParameterList: TypeParameterList,
+        val extendsTypes: List<Type>,
+        val baseClassParams: List<Expression>,
+        val implementsTypes: List<Type>,
+        val members: List<Element>
+) : Member(comments, modifiers) {
     open val TYPE: String
         get() = "class"
 
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Constructor.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Constructor.kt
index f92746f20a1..f9a3fd23db2 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Constructor.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Constructor.kt
@@ -19,22 +19,24 @@ package org.jetbrains.jet.j2k.ast
 import org.jetbrains.jet.j2k.ast.types.Type
 import org.jetbrains.jet.j2k.Converter
 
-public class Constructor(converter: Converter,
-                         identifier: Identifier,
-                         comments: MemberComments,
-                         modifiers: Set<Modifier>,
-                         `type`: Type,
-                         typeParameters: TypeParameterList,
-                         params: Element,
-                         block: Block,
-                         val isPrimary: Boolean) : Function(converter, identifier, comments, modifiers,
-                                                            `type`, typeParameters, params, block) {
+class Constructor(
+        converter: Converter,
+        identifier: Identifier,
+        comments: MemberComments,
+        modifiers: Set<Modifier>,
+        `type`: Type,
+        typeParameters: TypeParameterList,
+        params: Element,
+        block: Block,
+        val isPrimary: Boolean
+) : Function(converter, identifier, comments, modifiers,
+             `type`, typeParameters, params, block) {
 
-    public fun primarySignatureToKotlin(): String {
+    fun primarySignatureToKotlin(): String {
         return "(" + params.toKotlin() + ")"
     }
 
-    public fun primaryBodyToKotlin(): String {
+    fun primaryBodyToKotlin(): String {
         return block!!.toKotlin()
     }
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/DummyStringExpression.kt b/j2k/src/org/jetbrains/jet/j2k/ast/DummyStringExpression.kt
index 6067f05d7de..607c7550262 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/DummyStringExpression.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/DummyStringExpression.kt
@@ -17,6 +17,6 @@
 package org.jetbrains.jet.j2k.ast
 
 
-public open class DummyStringExpression(val string: String) : Expression() {
-    public override fun toKotlin(): String = string
+open class DummyStringExpression(val string: String) : Expression() {
+    override fun toKotlin(): String = string
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Element.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Element.kt
index d459c2c7c22..19a87da3f6b 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Element.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Element.kt
@@ -17,17 +17,15 @@
 package org.jetbrains.jet.j2k.ast
 
 
-public trait Element : Node {
-    public fun isEmpty(): Boolean = false
+trait Element : Node {
+    fun isEmpty(): Boolean = false
 
-    class object {
-        public val Empty: Element = object : Element {
-            override fun toKotlin() = ""
-            override fun isEmpty() = true
-        }
+    object Empty : Element {
+        override fun toKotlin() = ""
+        override fun isEmpty() = true
     }
 }
 
-public class Comment(val text: String) : Element {
+class Comment(val text: String) : Element {
     override fun toKotlin() = text
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Enum.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Enum.kt
index 3098d574e8e..32051b5d9ee 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Enum.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Enum.kt
@@ -19,16 +19,18 @@ package org.jetbrains.jet.j2k.ast
 import org.jetbrains.jet.j2k.Converter
 import org.jetbrains.jet.j2k.ast.types.Type
 
-public class Enum(converter: Converter,
-                  name: Identifier,
-                  comments: MemberComments,
-                  modifiers: Set<Modifier>,
-                  typeParameterList: TypeParameterList,
-                  extendsTypes: List<Type>,
-                  baseClassParams: List<Expression>,
-                  implementsTypes: List<Type>,
-                  members: List<Element>) : Class(converter, name, comments, modifiers, typeParameterList,
-                                                  extendsTypes, baseClassParams, implementsTypes, members) {
+class Enum(
+        converter: Converter,
+        name: Identifier,
+        comments: MemberComments,
+        modifiers: Set<Modifier>,
+        typeParameterList: TypeParameterList,
+        extendsTypes: List<Type>,
+        baseClassParams: List<Expression>,
+        implementsTypes: List<Type>,
+        members: List<Element>
+) : Class(converter, name, comments, modifiers, typeParameterList,
+          extendsTypes, baseClassParams, implementsTypes, members) {
 
     override fun primaryConstructorSignatureToKotlin(): String {
         val s: String = super.primaryConstructorSignatureToKotlin()
@@ -37,7 +39,7 @@ public class Enum(converter: Converter,
 
     override fun isDefinitelyFinal() = true
 
-    public override fun toKotlin(): String {
+    override fun toKotlin(): String {
         val primaryConstructorBody = primaryConstructorBodyToKotlin() ?: ""
         return modifiersToKotlin() +
         "enum class " + name.toKotlin() +
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/EnumConstant.kt b/j2k/src/org/jetbrains/jet/j2k/ast/EnumConstant.kt
index dcba09127d7..8821caabe44 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/EnumConstant.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/EnumConstant.kt
@@ -18,13 +18,15 @@ package org.jetbrains.jet.j2k.ast
 
 import org.jetbrains.jet.j2k.ast.types.Type
 
-public open class EnumConstant(identifier: Identifier,
-                               members: MemberComments,
-                               modifiers: Set<Modifier>,
-                               `type`: Type,
-                               params: Element) : Field(identifier, members, modifiers, `type`.convertedToNotNull(), params, 0) {
+open class EnumConstant(
+        identifier: Identifier,
+        members: MemberComments,
+        modifiers: Set<Modifier>,
+        `type`: Type,
+        params: Element
+) : Field(identifier, members, modifiers, `type`.convertedToNotNull(), params, 0) {
 
-    public override fun toKotlin(): String {
+    override fun toKotlin(): String {
         if (initializer.toKotlin().isEmpty()) {
             return identifier.toKotlin()
         }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Expression.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Expression.kt
index c697760bd71..d03230a21c8 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Expression.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Expression.kt
@@ -17,15 +17,13 @@
 package org.jetbrains.jet.j2k.ast
 
 
-public abstract class Expression() : Statement() {
-    public open fun isNullable(): Boolean {
+abstract class Expression() : Statement() {
+    open fun isNullable(): Boolean {
         return false
     }
 
-    class object {
-        public val Empty: Expression = object: Expression() {
-            public override fun toKotlin() = ""
-            public override fun isEmpty() = true
-        }
+    object Empty : Expression() {
+        override fun toKotlin() = ""
+        override fun isEmpty() = true
     }
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ExpressionList.kt b/j2k/src/org/jetbrains/jet/j2k/ast/ExpressionList.kt
index 771754297e2..742b056cd76 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/ExpressionList.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/ExpressionList.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.jet.j2k.ast
 
-public open class ExpressionList(val expressions: List<Expression>) : Expression() {
-    public override fun toKotlin(): String = expressions.map { it.toKotlin() }.makeString(", ")
+open class ExpressionList(val expressions: List<Expression>) : Expression() {
+    override fun toKotlin(): String = expressions.map { it.toKotlin() }.makeString(", ")
     override fun isEmpty(): Boolean = expressions.isEmpty()
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt
index 5c1ef6c14bd..a38cd866758 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt
@@ -18,57 +18,57 @@ package org.jetbrains.jet.j2k.ast
 
 import org.jetbrains.jet.j2k.ast.types.Type
 
-public open class ArrayAccessExpression(val expression: Expression, val index: Expression, val lvalue: Boolean) : Expression() {
+open class ArrayAccessExpression(val expression: Expression, val index: Expression, val lvalue: Boolean) : Expression() {
     override fun toKotlin() = expression.toKotlin() +
     (if (!lvalue && expression.isNullable()) "!!" else "") +
     "[" + index.toKotlin() + "]"
 }
 
-public open class AssignmentExpression(val left: Expression, val right: Expression, val op: String) : Expression() {
+open class AssignmentExpression(val left: Expression, val right: Expression, val op: String) : Expression() {
     override fun toKotlin() = left.toKotlin() + " " + op + " " + right.toKotlin()
 }
 
-public class BangBangExpression(val expr: Expression) : Expression() {
+class BangBangExpression(val expr: Expression) : Expression() {
     override fun toKotlin() = expr.toKotlin() + "!!"
 }
 
-public open class BinaryExpression(val left: Expression, val right: Expression, val op: String) : Expression() {
+open class BinaryExpression(val left: Expression, val right: Expression, val op: String) : Expression() {
     override fun toKotlin() = left.toKotlin() + " " + op + " " + right.toKotlin()
 }
 
-public open class ClassObjectAccessExpression(val typeElement: TypeElement) : Expression() {
+open class ClassObjectAccessExpression(val typeElement: TypeElement) : Expression() {
     override fun toKotlin() = "javaClass<" + typeElement.toKotlinNotNull() + ">()"
 }
 
-public open class IsOperator(val expression: Expression, val typeElement: TypeElement) : Expression() {
+open class IsOperator(val expression: Expression, val typeElement: TypeElement) : Expression() {
     override fun toKotlin() = expression.toKotlin() + " is " + typeElement.toKotlinNotNull()
 }
 
-public open class TypeCastExpression(val `type`: Type, val expression: Expression) : Expression() {
+open class TypeCastExpression(val `type`: Type, val expression: Expression) : Expression() {
     override fun toKotlin() = "(" + expression.toKotlin() + " as " + `type`.toKotlin() + ")"
 }
 
-public open class LiteralExpression(val literalText: String) : Expression() {
+open class LiteralExpression(val literalText: String) : Expression() {
     override fun toKotlin() = literalText
 }
 
-public open class ParenthesizedExpression(val expression: Expression) : Expression() {
+open class ParenthesizedExpression(val expression: Expression) : Expression() {
     override fun toKotlin() = "(" + expression.toKotlin() + ")"
 }
 
-public open class PrefixOperator(val op: String, val expression: Expression) : Expression() {
+open class PrefixOperator(val op: String, val expression: Expression) : Expression() {
     override fun toKotlin() = op + expression.toKotlin()
     override fun isNullable() = expression.isNullable()
 }
 
-public open class PostfixOperator(val op: String, val expression: Expression) : Expression() {
+open class PostfixOperator(val op: String, val expression: Expression) : Expression() {
     override fun toKotlin() = expression.toKotlin() + op
 }
 
-public open class ThisExpression(val identifier: Identifier) : Expression() {
+open class ThisExpression(val identifier: Identifier) : Expression() {
     override fun toKotlin() = "this" + identifier.withPrefix("@")
 }
 
-public open class SuperExpression(val identifier: Identifier) : Expression() {
+open class SuperExpression(val identifier: Identifier) : Expression() {
     override fun toKotlin() = "super" + identifier.withPrefix("@")
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Field.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Field.kt
index 090e30b2c38..a151d99d8c2 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Field.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Field.kt
@@ -20,12 +20,14 @@ import org.jetbrains.jet.j2k.ast.types.Type
 import org.jetbrains.jet.j2k.*
 import java.util.ArrayList
 
-public open class Field(val identifier: Identifier,
-                        comments: MemberComments,
-                        modifiers: Set<Modifier>,
-                        val `type`: Type,
-                        val initializer: Element,
-                        val writingAccesses: Int) : Member(comments, modifiers) {
+open class Field(
+        val identifier: Identifier,
+        comments: MemberComments,
+        modifiers: Set<Modifier>,
+        val `type`: Type,
+        val initializer: Element,
+        val writingAccesses: Int
+) : Member(comments, modifiers) {
 
     fun modifiersToKotlin(): String {
         val modifierList = ArrayList<Modifier>()
@@ -41,9 +43,9 @@ public open class Field(val identifier: Identifier,
         return modifierList.toKotlin() + (if (isVal()) "val " else "var ")
     }
 
-    public fun isVal(): Boolean = modifiers.contains(Modifier.FINAL)
+    fun isVal(): Boolean = modifiers.contains(Modifier.FINAL)
 
-    public override fun toKotlin(): String {
+    override fun toKotlin(): String {
         val declaration: String = commentsToKotlin() +
         modifiersToKotlin() + identifier.toKotlin() + " : " + `type`.toKotlin()
         if (initializer.isEmpty()) {
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/File.kt b/j2k/src/org/jetbrains/jet/j2k/ast/File.kt
index a49d97c1eea..351fbf149ce 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/File.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/File.kt
@@ -16,14 +16,16 @@
 
 package org.jetbrains.jet.j2k.ast
 
-class FileMemberList(elements: List<Element>): WhiteSpaceSeparatedElementList(elements, WhiteSpace.NewLine, false)
+class FileMemberList(elements: List<Element>) : WhiteSpaceSeparatedElementList(elements, WhiteSpace.NewLine, false)
 
-class PackageStatement(val packageName: String): Element {
+class PackageStatement(val packageName: String) : Element {
     override fun toKotlin(): String = "package " + packageName
 }
 
-public class File(val body: FileMemberList,
-                  val mainFunction: String) : Element {
+class File(
+        val body: FileMemberList,
+        val mainFunction: String
+) : Element {
 
     override fun toKotlin(): String {
         return body.toKotlin() + mainFunction
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Function.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Function.kt
index c20c986ea55..9b5efdaa3a2 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Function.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Function.kt
@@ -21,14 +21,16 @@ import java.util.ArrayList
 import org.jetbrains.jet.j2k.ast.types.isUnit
 import org.jetbrains.jet.j2k.Converter
 
-public open class Function(val converter: Converter,
-                           val name: Identifier,
-                           comments: MemberComments,
-                           modifiers: Set<Modifier>,
-                           val `type`: Type,
-                           val typeParameterList: TypeParameterList,
-                           val params: Element,
-                           var block: Block?) : Member(comments, modifiers) {
+open class Function(
+        val converter: Converter,
+        val name: Identifier,
+        comments: MemberComments,
+        modifiers: Set<Modifier>,
+        val `type`: Type,
+        val typeParameterList: TypeParameterList,
+        val params: Element,
+        var block: Block?
+) : Member(comments, modifiers) {
 
     private fun modifiersToKotlin(): String {
         val resultingModifiers = ArrayList<Modifier>()
@@ -63,7 +65,7 @@ public open class Function(val converter: Converter,
 
     private fun returnTypeToKotlin() = if (!`type`.isUnit()) " : " + `type`.toKotlin() + " " else " "
 
-    public override fun toKotlin(): String {
+    override fun toKotlin(): String {
         return commentsToKotlin() +
         modifiersToKotlin() +
         "fun ${typeParameterList.toKotlin().withSuffix(" ")}${name.toKotlin()}" +
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.kt
index 9686b13962b..2e8d5889cbf 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.kt
@@ -17,10 +17,12 @@
 package org.jetbrains.jet.j2k.ast
 
 
-public open class Identifier(val name: String,
-                             val myNullable: Boolean = true,
-                             val quotingNeeded: Boolean = true) : Expression() {
-    public override fun isEmpty() = name.length() == 0
+open class Identifier(
+        val name: String,
+        val myNullable: Boolean = true,
+        val quotingNeeded: Boolean = true
+) : Expression() {
+    override fun isEmpty() = name.length() == 0
 
     private open fun ifNeedQuote(): String {
         if (quotingNeeded && (ONLY_KOTLIN_KEYWORDS.contains(name)) || name.contains("$")) {
@@ -30,16 +32,17 @@ public open class Identifier(val name: String,
         return name
     }
 
-    public override fun toKotlin(): String = ifNeedQuote()
-    public override fun isNullable(): Boolean = myNullable
+    override fun toKotlin(): String = ifNeedQuote()
+    override fun isNullable(): Boolean = myNullable
 
     class object {
-        public val Empty: Identifier = Identifier("")
+        val Empty = Identifier("")
+
         private open fun quote(str: String): String {
             return "`" + str + "`"
         }
 
-        public val ONLY_KOTLIN_KEYWORDS: Set<String> = setOf(
+        val ONLY_KOTLIN_KEYWORDS: Set<String> = setOf(
                 "package", "as", "type", "val", "var", "fun", "is", "in", "object", "when", "trait", "This"
         );
     }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Imports.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Imports.kt
index a5716190d9a..a90ae6416a5 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Imports.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Imports.kt
@@ -24,11 +24,11 @@ import org.jetbrains.jet.util.QualifiedNamesUtil
 import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap
 
 
-public class Import(val name: String) : Element {
-    public override fun toKotlin() = "import " + name
+class Import(val name: String) : Element {
+    override fun toKotlin() = "import " + name
 }
 
-public class ImportList(val imports: List<Import>) : Element {
+class ImportList(val imports: List<Import>) : Element {
     val filteredImports = imports.filter {
         !it.name.isEmpty() && it.name !in NOT_NULL_ANNOTATIONS
     }.filter {
@@ -49,10 +49,10 @@ public class ImportList(val imports: List<Import>) : Element {
     override fun toKotlin() = filteredImports.toKotlin("\n")
 }
 
-public fun Converter.convertImportList(importList: PsiImportList): ImportList =
+fun Converter.convertImportList(importList: PsiImportList): ImportList =
         ImportList(importList.getAllImportStatements() map { convertImport(it) })
 
-public fun Converter.convertImport(i: PsiImportStatementBase): Import {
+fun Converter.convertImport(i: PsiImportStatementBase): Import {
     val reference = i.getImportReference()
     if (reference != null) {
         return Import(quoteKeywords(reference.getQualifiedName()!!) + if (i.isOnDemand()) ".*" else "")
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Initializer.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Initializer.kt
index 1ce967b2133..f6616007bb1 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Initializer.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Initializer.kt
@@ -18,8 +18,8 @@ package org.jetbrains.jet.j2k.ast
 
 
 //TODO: is a member?
-public class Initializer(val block: Block, modifiers: Set<Modifier>) : Member(MemberComments.Empty, modifiers) {
-    public override fun toKotlin(): String {
+class Initializer(val block: Block, modifiers: Set<Modifier>) : Member(MemberComments.Empty, modifiers) {
+    override fun toKotlin(): String {
         return block.toKotlin()
     }
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/LocalVariable.kt b/j2k/src/org/jetbrains/jet/j2k/ast/LocalVariable.kt
index 5fa34666a3e..85b05bcd431 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/LocalVariable.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/LocalVariable.kt
@@ -19,13 +19,15 @@ package org.jetbrains.jet.j2k.ast
 import org.jetbrains.jet.j2k.ast.types.Type
 import org.jetbrains.jet.j2k.Converter
 
-public class LocalVariable(val identifier: Identifier,
-                           val modifiersSet: Set<Modifier>,
-                           val javaType: Type,
-                           val initializer: Expression,
-                           val converter: Converter) : Expression() {
+class LocalVariable(
+        val identifier: Identifier,
+        val modifiersSet: Set<Modifier>,
+        val javaType: Type,
+        val initializer: Expression,
+        val converter: Converter
+) : Expression() {
 
-    public fun isImmutable(): Boolean =
+    fun isImmutable(): Boolean =
             converter.settings.forceLocalVariableImmutability || modifiersSet.contains(Modifier.FINAL)
 
     override fun toKotlin(): String {
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Members.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Members.kt
index 5719660dc3f..9497c019e8c 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Members.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Members.kt
@@ -18,31 +18,31 @@ package org.jetbrains.jet.j2k.ast
 
 import java.util.ArrayList
 
-public class MemberComments(elements: List<Element>) : WhiteSpaceSeparatedElementList(elements, WhiteSpace.NoSpace) {
+class MemberComments(elements: List<Element>) : WhiteSpaceSeparatedElementList(elements, WhiteSpace.NoSpace) {
     class object {
-        public val Empty: MemberComments = MemberComments(ArrayList())
+        val Empty = MemberComments(ArrayList())
     }
 }
 
-public abstract class Member(val comments: MemberComments, val modifiers: Set<Modifier>) : Element {
+abstract class Member(val comments: MemberComments, val modifiers: Set<Modifier>) : Element {
     fun accessModifier(): Modifier? {
         return modifiers.find { m -> m == Modifier.PUBLIC || m == Modifier.PROTECTED || m == Modifier.PRIVATE }
     }
 
-    public fun isAbstract(): Boolean = modifiers.contains(Modifier.ABSTRACT)
-    public fun isStatic(): Boolean = modifiers.contains(Modifier.STATIC)
-    public fun commentsToKotlin(): String = comments.toKotlin()
+    fun isAbstract(): Boolean = modifiers.contains(Modifier.ABSTRACT)
+    fun isStatic(): Boolean = modifiers.contains(Modifier.STATIC)
+    fun commentsToKotlin(): String = comments.toKotlin()
 }
 
 //member itself and all the elements before it in the code (comments, whitespaces)
 class MemberHolder(val member: Member, val elements: List<Element>)
 
-public class MemberList(elements: List<Element>) : WhiteSpaceSeparatedElementList(elements, WhiteSpace.NewLine) {
+class MemberList(elements: List<Element>) : WhiteSpaceSeparatedElementList(elements, WhiteSpace.NewLine) {
     val members: List<Member>
         get() = elements.filter { it is Member }.map { it as Member }
 }
 
-public class ClassMembers(
+class ClassMembers(
         val primaryConstructor: Constructor?,
         val secondaryConstructors: MemberList,
         val allMembers: MemberList,
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/MethodCallExpression.kt b/j2k/src/org/jetbrains/jet/j2k/ast/MethodCallExpression.kt
index 4af05e053e8..1f911ea7c7a 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/MethodCallExpression.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/MethodCallExpression.kt
@@ -19,13 +19,15 @@ package org.jetbrains.jet.j2k.ast
 import org.jetbrains.jet.j2k.ast.types.Type
 import java.util.ArrayList
 
-public open class MethodCallExpression(val methodCall: Expression,
-                                       val arguments: List<Expression>,
-                                       val typeParameters: List<Type>,
-                                       val resultIsNullable: Boolean = false) : Expression() {
-    public override fun isNullable(): Boolean = methodCall.isNullable() || resultIsNullable
+open class MethodCallExpression(
+        val methodCall: Expression,
+        val arguments: List<Expression>,
+        val typeParameters: List<Type>,
+        val resultIsNullable: Boolean = false
+) : Expression() {
+    override fun isNullable(): Boolean = methodCall.isNullable() || resultIsNullable
 
-    public override fun toKotlin(): String {
+    override fun toKotlin(): String {
         val typeParamsToKotlin: String = typeParameters.toKotlin(", ", "<", ">")
         val argumentsMapped = arguments.map { it.toKotlin() }
         return methodCall.toKotlin() + typeParamsToKotlin + "(" + argumentsMapped.makeString(", ") + ")"
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Modifier.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Modifier.kt
index c6316b22cab..db2b0adfc2a 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Modifier.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Modifier.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.jet.j2k.ast
 
-public enum class Modifier(val name: String) {
+enum class Modifier(val name: String) {
     PUBLIC: Modifier("public")
     PROTECTED: Modifier("protected")
     PRIVATE: Modifier("private")
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/NewClassExpression.kt b/j2k/src/org/jetbrains/jet/j2k/ast/NewClassExpression.kt
index cc3d138d7fb..d05bb973a19 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/NewClassExpression.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/NewClassExpression.kt
@@ -16,11 +16,13 @@
 
 package org.jetbrains.jet.j2k.ast
 
-public open class NewClassExpression(val name: Element,
-                                     val arguments: List<Expression>,
-                                     val qualifier: Expression = Expression.Empty,
-                                     val anonymousClass: AnonymousClass? = null) : Expression() {
-    public override fun toKotlin(): String {
+open class NewClassExpression(
+        val name: Element,
+        val arguments: List<Expression>,
+        val qualifier: Expression = Expression.Empty,
+        val anonymousClass: AnonymousClass? = null
+) : Expression() {
+    override fun toKotlin(): String {
         val callOperator: String? = (if (qualifier.isNullable())
             "?."
         else
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Node.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Node.kt
index 80932effd5a..39e27714dab 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Node.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Node.kt
@@ -16,9 +16,7 @@
 
 package org.jetbrains.jet.j2k.ast
 
-import org.jetbrains.jet.j2k.Converter
 
-
-public trait Node {
+trait Node {
     public fun toKotlin(): String
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Parameter.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Parameter.kt
index 60d9b6b2159..5aca7825035 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Parameter.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Parameter.kt
@@ -19,8 +19,8 @@ package org.jetbrains.jet.j2k.ast
 import org.jetbrains.jet.j2k.ast.types.Type
 import org.jetbrains.jet.j2k.ast.types.VarArg
 
-public open class Parameter(val identifier: Identifier, val `type`: Type, val readOnly: Boolean = true) : Expression() {
-    public override fun toKotlin(): String {
+open class Parameter(val identifier: Identifier, val `type`: Type, val readOnly: Boolean = true) : Expression() {
+    override fun toKotlin(): String {
         val vararg: String = (if (`type` is VarArg)
             "vararg "
         else
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ParameterList.kt b/j2k/src/org/jetbrains/jet/j2k/ast/ParameterList.kt
index 5912d5053ed..e674efecf17 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/ParameterList.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/ParameterList.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.jet.j2k.ast
 
 
-public open class ParameterList(val parameters: List<Parameter>) : Expression() {
-    public override fun toKotlin() = parameters.map { it.toKotlin() }.makeString(", ")
+open class ParameterList(val parameters: List<Parameter>) : Expression() {
+    override fun toKotlin() = parameters.map { it.toKotlin() }.makeString(", ")
 }
 
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/PolyadicExpression.kt b/j2k/src/org/jetbrains/jet/j2k/ast/PolyadicExpression.kt
index 9df8b44c2c9..51780b12980 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/PolyadicExpression.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/PolyadicExpression.kt
@@ -17,8 +17,8 @@
 package org.jetbrains.jet.j2k.ast
 
 
-public open class PolyadicExpression(val expressions: List<Expression>, val token: String) : Expression() {
-    public override fun toKotlin(): String {
+open class PolyadicExpression(val expressions: List<Expression>, val token: String) : Expression() {
+    override fun toKotlin(): String {
         val expressionsWithConversions = expressions.map { it.toKotlin() }
         return expressionsWithConversions.makeString(" " + token + " ")
     }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ReferenceElement.kt b/j2k/src/org/jetbrains/jet/j2k/ast/ReferenceElement.kt
index f1307f2f0d8..6af085bbc34 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/ReferenceElement.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/ReferenceElement.kt
@@ -18,6 +18,6 @@ package org.jetbrains.jet.j2k.ast
 
 import org.jetbrains.jet.j2k.ast.types.Type
 
-public class ReferenceElement(val reference: Identifier, val types: List<Type>) : Element {
-    public override fun toKotlin() = reference.toKotlin() + types.toKotlin(", ", "<", ">")
+class ReferenceElement(val reference: Identifier, val types: List<Type>) : Element {
+    override fun toKotlin() = reference.toKotlin() + types.toKotlin(", ", "<", ">")
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Statements.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Statements.kt
index ed95d07116d..98756847148 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Statements.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Statements.kt
@@ -17,17 +17,15 @@
 package org.jetbrains.jet.j2k.ast
 
 
-public abstract class Statement() : Element {
-    class object {
-        public val Empty: Statement = object : Statement() {
-            override fun toKotlin() = ""
-            override fun isEmpty() = true
-        }
+abstract class Statement() : Element {
+    object Empty : Statement() {
+        override fun toKotlin() = ""
+        override fun isEmpty() = true
     }
 }
 
-public open class DeclarationStatement(val elements: List<Element>) : Statement() {
-    public override fun toKotlin(): String {
+open class DeclarationStatement(val elements: List<Element>) : Statement() {
+    override fun toKotlin(): String {
         return elements.filter { it is LocalVariable }.map { convertDeclaration(it as LocalVariable) }.makeString("\n")
     }
 
@@ -40,22 +38,24 @@ public open class DeclarationStatement(val elements: List<Element>) : Statement(
     }
 }
 
-public open class ExpressionListStatement(val expressions: List<Expression>) : Expression() {
-    public override fun toKotlin() = expressions.toKotlin("\n")
+open class ExpressionListStatement(val expressions: List<Expression>) : Expression() {
+    override fun toKotlin() = expressions.toKotlin("\n")
 }
 
-public open class LabelStatement(val name: Identifier, val statement: Element) : Statement() {
-    public override fun toKotlin(): String = "@" + name.toKotlin() + " " + statement.toKotlin()
+open class LabelStatement(val name: Identifier, val statement: Element) : Statement() {
+    override fun toKotlin(): String = "@" + name.toKotlin() + " " + statement.toKotlin()
 }
 
-public open class ReturnStatement(val expression: Expression) : Statement() {
-    public override fun toKotlin() = "return " + expression.toKotlin()
+open class ReturnStatement(val expression: Expression) : Statement() {
+    override fun toKotlin() = "return " + expression.toKotlin()
 }
 
-public open class IfStatement(val condition: Expression,
-                              val thenStatement: Element,
-                              val elseStatement: Element) : Expression() {
-    public override fun toKotlin(): String {
+open class IfStatement(
+        val condition: Expression,
+        val thenStatement: Element,
+        val elseStatement: Element
+) : Expression() {
+    override fun toKotlin(): String {
         val result: String = "if (" + condition.toKotlin() + ")\n" + thenStatement.toKotlin()
         if (elseStatement != Statement.Empty) {
             return result + "\nelse\n" + elseStatement.toKotlin()
@@ -67,41 +67,43 @@ public open class IfStatement(val condition: Expression,
 
 // Loops --------------------------------------------------------------------------------------------------
 
-public open class WhileStatement(val condition: Expression, val body: Element) : Statement() {
-    public override fun toKotlin() = "while (" + condition.toKotlin() + ")\n" + body.toKotlin()
+open class WhileStatement(val condition: Expression, val body: Element) : Statement() {
+    override fun toKotlin() = "while (" + condition.toKotlin() + ")\n" + body.toKotlin()
 }
 
-public open class DoWhileStatement(condition: Expression, body: Element) : WhileStatement(condition, body) {
-    public override fun toKotlin() = "do\n" + body.toKotlin() + "\nwhile (" + condition.toKotlin() + ")"
+open class DoWhileStatement(condition: Expression, body: Element) : WhileStatement(condition, body) {
+    override fun toKotlin() = "do\n" + body.toKotlin() + "\nwhile (" + condition.toKotlin() + ")"
 }
 
-public open class ForeachStatement(val variable: Parameter,
-                                   val expression: Expression,
-                                   val body: Element) : Statement() {
-    public override fun toKotlin() = "for (" + variable.identifier.name + " in " +
+open class ForeachStatement(
+        val variable: Parameter,
+        val expression: Expression,
+        val body: Element
+) : Statement() {
+    override fun toKotlin() = "for (" + variable.identifier.name + " in " +
     expression.toKotlin() + ")\n" + body.toKotlin()
 }
 
-public open class ForeachWithRangeStatement(val identifier: Identifier,
-                                            val start: Expression,
-                                            val end: Expression,
-                                            val body: Element) : Statement() {
-    public override fun toKotlin() = "for (" + identifier.toKotlin() + " in " +
+open class ForeachWithRangeStatement(val identifier: Identifier,
+                                     val start: Expression,
+                                     val end: Expression,
+                                     val body: Element) : Statement() {
+    override fun toKotlin() = "for (" + identifier.toKotlin() + " in " +
     start.toKotlin() + ".." + end.toKotlin() + ") " + body.toKotlin()
 }
 
-public open class BreakStatement(val label: Identifier = Identifier.Empty) : Statement() {
-    public override fun toKotlin() = "break" + label.withPrefix("@")
+open class BreakStatement(val label: Identifier = Identifier.Empty) : Statement() {
+    override fun toKotlin() = "break" + label.withPrefix("@")
 }
 
-public open class ContinueStatement(val label: Identifier = Identifier.Empty) : Statement() {
-    public override fun toKotlin() = "continue" + label.withPrefix("@")
+open class ContinueStatement(val label: Identifier = Identifier.Empty) : Statement() {
+    override fun toKotlin() = "continue" + label.withPrefix("@")
 }
 
 // Exceptions ----------------------------------------------------------------------------------------------
 
-public open class TryStatement(val block: Block, val catches: List<CatchStatement>, val finallyBlock: Block) : Statement() {
-    public override fun toKotlin(): String {
+open class TryStatement(val block: Block, val catches: List<CatchStatement>, val finallyBlock: Block) : Statement() {
+    override fun toKotlin(): String {
         return "try\n" + block.toKotlin() + "\n" + catches.toKotlin("\n") + "\n" + (if (finallyBlock.isEmpty())
             ""
         else
@@ -109,21 +111,21 @@ public open class TryStatement(val block: Block, val catches: List<CatchStatemen
     }
 }
 
-public open class ThrowStatement(val expression: Expression) : Expression() {
-    public override fun toKotlin() = "throw " + expression.toKotlin()
+open class ThrowStatement(val expression: Expression) : Expression() {
+    override fun toKotlin() = "throw " + expression.toKotlin()
 }
 
-public open class CatchStatement(val variable: Parameter, val block: Block) : Statement() {
-    public override fun toKotlin(): String = "catch (" + variable.toKotlin() + ") " + block.toKotlin()
+open class CatchStatement(val variable: Parameter, val block: Block) : Statement() {
+    override fun toKotlin(): String = "catch (" + variable.toKotlin() + ") " + block.toKotlin()
 }
 
 // Switch --------------------------------------------------------------------------------------------------
 
-public open class SwitchContainer(val expression: Expression, val caseContainers: List<CaseContainer>) : Statement() {
-    public override fun toKotlin() = "when (" + expression.toKotlin() + ") {\n" + caseContainers.toKotlin("\n") + "\n}"
+open class SwitchContainer(val expression: Expression, val caseContainers: List<CaseContainer>) : Statement() {
+    override fun toKotlin() = "when (" + expression.toKotlin() + ") {\n" + caseContainers.toKotlin("\n") + "\n}"
 }
 
-public open class CaseContainer(val caseStatement: List<Element>, statements: List<Statement>) : Statement() {
+open class CaseContainer(val caseStatement: List<Element>, statements: List<Statement>) : Statement() {
     private val myBlock: Block
 
     {
@@ -131,24 +133,24 @@ public open class CaseContainer(val caseStatement: List<Element>, statements: Li
         myBlock = Block(newStatements, true)
     }
 
-    public override fun toKotlin() = caseStatement.toKotlin(", ") + " -> " + myBlock.toKotlin()
+    override fun toKotlin() = caseStatement.toKotlin(", ") + " -> " + myBlock.toKotlin()
 }
 
-public open class SwitchLabelStatement(val expression: Expression) : Statement() {
-    public override fun toKotlin() = expression.toKotlin()
+open class SwitchLabelStatement(val expression: Expression) : Statement() {
+    override fun toKotlin() = expression.toKotlin()
 }
 
-public open class DefaultSwitchLabelStatement() : Statement() {
-    public override fun toKotlin() = "else"
+open class DefaultSwitchLabelStatement() : Statement() {
+    override fun toKotlin() = "else"
 }
 
 // Other ------------------------------------------------------------------------------------------------------
 
-public open class SynchronizedStatement(val expression: Expression, val block: Block) : Statement() {
-    public override fun toKotlin() = "synchronized (" + expression.toKotlin() + ") " + block.toKotlin()
+open class SynchronizedStatement(val expression: Expression, val block: Block) : Statement() {
+    override fun toKotlin() = "synchronized (" + expression.toKotlin() + ") " + block.toKotlin()
 }
 
-public class StatementList(elements: List<Element>) : WhiteSpaceSeparatedElementList(elements, WhiteSpace.NewLine) {
+class StatementList(elements: List<Element>) : WhiteSpaceSeparatedElementList(elements, WhiteSpace.NewLine) {
     val statements: List<Statement>
         get() = elements.filter { it is Statement }.map { it as Statement }
 }
\ No newline at end of file
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Trait.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Trait.kt
index 90b2acc66c3..8070fe89731 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Trait.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Trait.kt
@@ -19,16 +19,18 @@ package org.jetbrains.jet.j2k.ast
 import org.jetbrains.jet.j2k.Converter
 import org.jetbrains.jet.j2k.ast.types.Type
 
-public class Trait(converter: Converter,
-                   name: Identifier,
-                   comments: MemberComments,
-                   modifiers: Set<Modifier>,
-                   typeParameterList: TypeParameterList,
-                   extendsTypes: List<Type>,
-                   baseClassParams: List<Expression>,
-                   implementsTypes: List<Type>,
-                   members: List<Element>) : Class(converter, name, comments, modifiers, typeParameterList,
-                                                   extendsTypes, baseClassParams, implementsTypes, members) {
+class Trait(
+        converter: Converter,
+        name: Identifier,
+        comments: MemberComments,
+        modifiers: Set<Modifier>,
+        typeParameterList: TypeParameterList,
+        extendsTypes: List<Type>,
+        baseClassParams: List<Expression>,
+        implementsTypes: List<Type>,
+        members: List<Element>
+) : Class(converter, name, comments, modifiers, typeParameterList,
+          extendsTypes, baseClassParams, implementsTypes, members) {
 
     override val TYPE: String
         get() = "trait"
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/TypeElement.kt b/j2k/src/org/jetbrains/jet/j2k/ast/TypeElement.kt
index f77805f26af..79e989f2619 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/TypeElement.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/TypeElement.kt
@@ -18,8 +18,8 @@ package org.jetbrains.jet.j2k.ast
 
 import org.jetbrains.jet.j2k.ast.types.Type
 
-public open class TypeElement(val `type`: Type) : Element {
+open class TypeElement(val `type`: Type) : Element {
     override fun toKotlin() = `type`.toKotlin()
 
-    public fun toKotlinNotNull(): String = `type`.convertedToNotNull().toKotlin()
+    fun toKotlinNotNull(): String = `type`.convertedToNotNull().toKotlin()
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt b/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt
index fedffd4d290..82b9692cbb6 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt
@@ -22,9 +22,9 @@ import org.jetbrains.jet.j2k.Converter
 import com.intellij.psi.PsiTypeParameterList
 import java.util.ArrayList
 
-public class TypeParameter(val name: Identifier, val extendsTypes: List<Type>) : Element {
-    public fun hasWhere(): Boolean = extendsTypes.size() > 1
-    public fun getWhereToKotlin(): String {
+class TypeParameter(val name: Identifier, val extendsTypes: List<Type>) : Element {
+    fun hasWhere(): Boolean = extendsTypes.size() > 1
+    fun getWhereToKotlin(): String {
         if (hasWhere()) {
             return name.toKotlin() + " : " + extendsTypes.get(1).toKotlin()
         }
@@ -32,7 +32,7 @@ public class TypeParameter(val name: Identifier, val extendsTypes: List<Type>) :
         return ""
     }
 
-    public override fun toKotlin(): String {
+    override fun toKotlin(): String {
         if (extendsTypes.size() > 0) {
             return name.toKotlin() + " : " + extendsTypes [0].toKotlin()
         }
@@ -41,14 +41,14 @@ public class TypeParameter(val name: Identifier, val extendsTypes: List<Type>) :
     }
 }
 
-public class TypeParameterList(val parameters: List<TypeParameter>) : Element {
+class TypeParameterList(val parameters: List<TypeParameter>) : Element {
     override fun toKotlin(): String = if (!parameters.isEmpty())
         parameters.map {
             it.toKotlin()
         }.makeString(", ", "<", ">")
     else ""
 
-    public fun whereToKotlin(): String {
+    fun whereToKotlin(): String {
         if (hasWhere()) {
             val wheres = parameters.map { it.getWhereToKotlin() }
             return "where " + wheres.makeString(", ")
@@ -61,15 +61,15 @@ public class TypeParameterList(val parameters: List<TypeParameter>) : Element {
     private fun hasWhere(): Boolean = parameters.any { it.hasWhere() }
 
     class object {
-        public val Empty: TypeParameterList = TypeParameterList(ArrayList())
+        val Empty = TypeParameterList(ArrayList())
     }
 }
 
-public fun Converter.convertTypeParameter(psiTypeParameter: PsiTypeParameter): TypeParameter {
+fun Converter.convertTypeParameter(psiTypeParameter: PsiTypeParameter): TypeParameter {
     return convertElement(psiTypeParameter) as TypeParameter
 }
 
-public fun Converter.convertTypeParameterList(psiTypeParameterlist: PsiTypeParameterList?): TypeParameterList {
+fun Converter.convertTypeParameterList(psiTypeParameterlist: PsiTypeParameterList?): TypeParameterList {
     return if (psiTypeParameterlist == null) TypeParameterList.Empty
     else TypeParameterList(psiTypeParameterlist.getTypeParameters()!!.toList().map { convertTypeParameter(it) })
 }
\ No newline at end of file
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Util.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Util.kt
index bfe09e4dc04..6a5ecd1f472 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Util.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Util.kt
@@ -18,7 +18,7 @@ package org.jetbrains.jet.j2k.ast
 
 import java.util.ArrayList
 
-public fun List<Node>.toKotlin(separator: String, prefix: String = "", suffix: String = ""): String {
+fun List<Node>.toKotlin(separator: String, prefix: String = "", suffix: String = ""): String {
     val result = StringBuilder()
     if (size() > 0) {
         result.append(prefix)
@@ -33,7 +33,7 @@ public fun List<Node>.toKotlin(separator: String, prefix: String = "", suffix: S
     return result.toString()
 }
 
-public fun Collection<Modifier>.toKotlin(separator: String = " "): String {
+fun Collection<Modifier>.toKotlin(separator: String = " "): String {
     val result = StringBuilder()
     for (x in this) {
         result.append(x.name)
@@ -42,9 +42,9 @@ public fun Collection<Modifier>.toKotlin(separator: String = " "): String {
     return result.toString()
 }
 
-public fun String.withSuffix(suffix: String): String = if (isEmpty()) "" else this + suffix
-public fun String.withPrefix(prefix: String): String = if (isEmpty()) "" else prefix + this
-public fun Expression.withPrefix(prefix: String): String = if (isEmpty()) "" else prefix + toKotlin()
+fun String.withSuffix(suffix: String): String = if (isEmpty()) "" else this + suffix
+fun String.withPrefix(prefix: String): String = if (isEmpty()) "" else prefix + this
+fun Expression.withPrefix(prefix: String): String = if (isEmpty()) "" else prefix + toKotlin()
 
 open class WhiteSpaceSeparatedElementList(
         val elements: List<Element>,
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/WhiteSpace.kt b/j2k/src/org/jetbrains/jet/j2k/ast/WhiteSpace.kt
index bce4e6d3bf5..91d70e56f6d 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/WhiteSpace.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/WhiteSpace.kt
@@ -17,11 +17,11 @@
 package org.jetbrains.jet.j2k.ast
 
 
-public class WhiteSpace(val text: String) : Element {
+class WhiteSpace(val text: String) : Element {
     override fun toKotlin() = text
     override fun isEmpty() = text.isEmpty()
 
-    public fun compareTo(other: WhiteSpace): Int {
+    fun compareTo(other: WhiteSpace): Int {
 
         fun newLinesCount(w: WhiteSpace) = w.text.count { it == '\n' }
 
@@ -36,8 +36,8 @@ public class WhiteSpace(val text: String) : Element {
     }
 
     class object {
-        public val NewLine: WhiteSpace = WhiteSpace("\n")
-        public val NoSpace: WhiteSpace = WhiteSpace("")
+        val NewLine = WhiteSpace("\n")
+        val NoSpace = WhiteSpace("")
     }
 }
 
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/types/ArrayType.kt b/j2k/src/org/jetbrains/jet/j2k/ast/types/ArrayType.kt
index 45f65b0ba9d..f185689ab7f 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/types/ArrayType.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/types/ArrayType.kt
@@ -18,9 +18,12 @@ package org.jetbrains.jet.j2k.ast.types
 
 import org.jetbrains.jet.j2k.Converter
 
-public class ArrayType(val elementType: Type, nullable: Boolean,
-                       converter: Converter) : MayBeNullableType(nullable, converter) {
-    public override fun toKotlin(): String {
+class ArrayType(
+        val elementType: Type,
+        nullable: Boolean,
+        converter: Converter
+) : MayBeNullableType(nullable, converter) {
+    override fun toKotlin(): String {
         if (elementType is PrimitiveType) {
             return elementType.toKotlin() + "Array" + isNullableStr()
         }
@@ -28,5 +31,5 @@ public class ArrayType(val elementType: Type, nullable: Boolean,
         return "Array<" + elementType.toKotlin() + ">" + isNullableStr()
     }
 
-    public override fun convertedToNotNull(): Type = ArrayType(elementType, false, converter)
+    override fun convertedToNotNull(): Type = ArrayType(elementType, false, converter)
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/types/ClassType.kt b/j2k/src/org/jetbrains/jet/j2k/ast/types/ClassType.kt
index b7fb26a431a..b563cb6ca12 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/types/ClassType.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/types/ClassType.kt
@@ -21,10 +21,10 @@ import org.jetbrains.jet.j2k.ast.Identifier
 import java.util.ArrayList
 import org.jetbrains.jet.j2k.Converter
 
-public open class ClassType(val `type`: Identifier, val parameters: List<Element>, nullable: Boolean,
-                            converter: Converter) : MayBeNullableType(nullable, converter) {
+open class ClassType(val `type`: Identifier, val parameters: List<Element>, nullable: Boolean,
+                     converter: Converter) : MayBeNullableType(nullable, converter) {
 
-    public override fun toKotlin(): String {
+    override fun toKotlin(): String {
         // TODO change to map() when KT-2051 is fixed
         val parametersToKotlin = ArrayList<String>()
         for (param in parameters) {
@@ -38,5 +38,5 @@ public open class ClassType(val `type`: Identifier, val parameters: List<Element
     }
 
 
-    public override fun convertedToNotNull(): Type = ClassType(`type`, parameters, false, converter)
+    override fun convertedToNotNull(): Type = ClassType(`type`, parameters, false, converter)
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/types/EmptyType.kt b/j2k/src/org/jetbrains/jet/j2k/ast/types/EmptyType.kt
index b524964eba2..e4d0c3b5fc3 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/types/EmptyType.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/types/EmptyType.kt
@@ -16,6 +16,6 @@
 
 package org.jetbrains.jet.j2k.ast.types
 
-public open class EmptyType() : NotNullType {
-    public override fun toKotlin(): String = "UNRESOLVED_TYPE"
+open class EmptyType() : NotNullType {
+    override fun toKotlin(): String = "UNRESOLVED_TYPE"
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/types/InProjectionType.kt b/j2k/src/org/jetbrains/jet/j2k/ast/types/InProjectionType.kt
index d090f207eff..4ea99da170b 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/types/InProjectionType.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/types/InProjectionType.kt
@@ -16,6 +16,6 @@
 
 package org.jetbrains.jet.j2k.ast.types
 
-public open class InProjectionType(val bound: Type) : NotNullType {
-    public override fun toKotlin(): String = "in " + bound.toKotlin()
+open class InProjectionType(val bound: Type) : NotNullType {
+    override fun toKotlin(): String = "in " + bound.toKotlin()
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/types/OutProjectionType.kt b/j2k/src/org/jetbrains/jet/j2k/ast/types/OutProjectionType.kt
index 7ec760b33ab..2ee59704923 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/types/OutProjectionType.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/types/OutProjectionType.kt
@@ -16,6 +16,6 @@
 
 package org.jetbrains.jet.j2k.ast.types
 
-public open class OutProjectionType(val bound: Type) : NotNullType {
-    public override fun toKotlin(): String = "out " + bound.toKotlin()
+open class OutProjectionType(val bound: Type) : NotNullType {
+    override fun toKotlin(): String = "out " + bound.toKotlin()
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/types/PrimitiveType.kt b/j2k/src/org/jetbrains/jet/j2k/ast/types/PrimitiveType.kt
index b40b82a78a6..990bc51e02c 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/types/PrimitiveType.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/types/PrimitiveType.kt
@@ -18,6 +18,6 @@ package org.jetbrains.jet.j2k.ast.types
 
 import org.jetbrains.jet.j2k.ast.Identifier
 
-public open class PrimitiveType(val `type`: Identifier) : NotNullType {
-    public override fun toKotlin(): String = `type`.toKotlin()
+open class PrimitiveType(val `type`: Identifier) : NotNullType {
+    override fun toKotlin(): String = `type`.toKotlin()
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/types/StarProjectionType.kt b/j2k/src/org/jetbrains/jet/j2k/ast/types/StarProjectionType.kt
index 1ddac3ff6d1..4956cdcc4f8 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/types/StarProjectionType.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/types/StarProjectionType.kt
@@ -16,6 +16,6 @@
 
 package org.jetbrains.jet.j2k.ast.types
 
-public open class StarProjectionType() : NotNullType {
-    public override fun toKotlin(): String = "*"
+open class StarProjectionType() : NotNullType {
+    override fun toKotlin(): String = "*"
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/types/Type.kt b/j2k/src/org/jetbrains/jet/j2k/ast/types/Type.kt
index e819632d192..29741bea4c1 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/types/Type.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/types/Type.kt
@@ -19,27 +19,27 @@ package org.jetbrains.jet.j2k.ast.types
 import org.jetbrains.jet.j2k.ast.Element
 import org.jetbrains.jet.j2k.Converter
 
-public fun Type.isPrimitive(): Boolean = this is PrimitiveType
-public fun Type.isUnit(): Boolean = this == UnitType
+fun Type.isPrimitive(): Boolean = this is PrimitiveType
+fun Type.isUnit(): Boolean = this == UnitType
 
-public abstract class MayBeNullableType(nullable: Boolean, val converter: Converter): Type {
-    override public val nullable: Boolean = !converter.settings.forceNotNullTypes && nullable
+abstract class MayBeNullableType(nullable: Boolean, val converter: Converter) : Type {
+    override val nullable: Boolean = !converter.settings.forceNotNullTypes && nullable
 }
 
-public trait NotNullType : Type {
-    override public val nullable: Boolean
+trait NotNullType : Type {
+    override val nullable: Boolean
         get() = false
 }
 
-public object UnitType: NotNullType {
+object UnitType: NotNullType {
     override fun toKotlin() = "Unit"
 }
 
-public trait Type : Element {
+trait Type : Element {
 
-    public val nullable: Boolean
+    val nullable: Boolean
 
-    public open fun convertedToNotNull(): Type {
+    open fun convertedToNotNull(): Type {
         if (nullable) throw UnsupportedOperationException("convertedToNotNull must be defined")
         return this
     }
diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/types/VarArg.kt b/j2k/src/org/jetbrains/jet/j2k/ast/types/VarArg.kt
index 9aefc5976ef..6b2e29b49cc 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/types/VarArg.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/types/VarArg.kt
@@ -16,6 +16,6 @@
 
 package org.jetbrains.jet.j2k.ast.types
 
-public open class VarArg(val `type`: Type) : NotNullType {
-    public override fun toKotlin(): String = `type`.toKotlin()
+open class VarArg(val `type`: Type) : NotNullType {
+    override fun toKotlin(): String = `type`.toKotlin()
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ClassVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/ClassVisitor.kt
index 0a86543bacc..1f88b1a19fd 100644
--- a/j2k/src/org/jetbrains/jet/j2k/visitors/ClassVisitor.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ClassVisitor.kt
@@ -23,11 +23,11 @@ import java.util.HashSet
 public open class ClassVisitor() : JavaRecursiveElementVisitor() {
     private val myClassIdentifiers = HashSet<String>()
 
-    public open fun getClassIdentifiers(): Set<String> {
+    public fun getClassIdentifiers(): Set<String> {
         return HashSet<String>(myClassIdentifiers)
     }
 
-    public override fun visitClass(aClass: PsiClass?) {
+    override fun visitClass(aClass: PsiClass?) {
         val qName = aClass?.getQualifiedName()
         if (qName != null) {
             myClassIdentifiers.add(qName)
diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/Dispatcher.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/Dispatcher.kt
index 08d4dc4664d..616a36bbe7f 100644
--- a/j2k/src/org/jetbrains/jet/j2k/visitors/Dispatcher.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/visitors/Dispatcher.kt
@@ -18,6 +18,6 @@ package org.jetbrains.jet.j2k.visitors
 
 import org.jetbrains.jet.j2k.Converter
 
-public open class Dispatcher(converter: Converter) {
-    public var expressionVisitor: ExpressionVisitor = ExpressionVisitor(converter)
+open class Dispatcher(converter: Converter) {
+    var expressionVisitor: ExpressionVisitor = ExpressionVisitor(converter)
 }
diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt
index b0def6e51d5..74f2e274f16 100644
--- a/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt
@@ -21,18 +21,18 @@ import org.jetbrains.jet.j2k.*
 import org.jetbrains.jet.j2k.ast.*
 import org.jetbrains.jet.j2k.ast.types.Type
 
-public open class ElementVisitor(val myConverter: Converter) : JavaElementVisitor() {
+open class ElementVisitor(val myConverter: Converter) : JavaElementVisitor() {
     protected var myResult: Element = Element.Empty
 
-    public fun getConverter(): Converter {
+    fun getConverter(): Converter {
         return myConverter
     }
 
-    public open fun getResult(): Element {
+    open fun getResult(): Element {
         return myResult
     }
 
-    public override fun visitLocalVariable(variable: PsiLocalVariable?) {
+    override fun visitLocalVariable(variable: PsiLocalVariable?) {
         val theVariable = variable!!
         var kType = myConverter.convertType(theVariable.getType(), isAnnotatedAsNotNull(theVariable.getModifierList()))
         if (theVariable.hasModifierProperty(PsiModifier.FINAL) && isDefinitelyNotNull(theVariable.getInitializer())) {
@@ -45,11 +45,11 @@ public open class ElementVisitor(val myConverter: Converter) : JavaElementVisito
                                  myConverter)
     }
 
-    public override fun visitExpressionList(list: PsiExpressionList?) {
+    override fun visitExpressionList(list: PsiExpressionList?) {
         myResult = ExpressionList(myConverter.convertExpressions(list!!.getExpressions()))
     }
 
-    public override fun visitReferenceElement(reference: PsiJavaCodeReferenceElement?) {
+    override fun visitReferenceElement(reference: PsiJavaCodeReferenceElement?) {
         val theReference = reference!!
         val types: List<Type> = myConverter.convertTypes(theReference.getTypeParameters())
         if (!theReference.isQualified()) {
@@ -68,20 +68,20 @@ public open class ElementVisitor(val myConverter: Converter) : JavaElementVisito
         }
     }
 
-    public override fun visitTypeElement(`type`: PsiTypeElement?) {
+    override fun visitTypeElement(`type`: PsiTypeElement?) {
         myResult = TypeElement(myConverter.convertType(`type`!!.getType()))
     }
 
-    public override fun visitTypeParameter(classParameter: PsiTypeParameter?) {
+    override fun visitTypeParameter(classParameter: PsiTypeParameter?) {
         myResult = TypeParameter(Identifier(classParameter!!.getName()!!),
                                  classParameter.getExtendsListTypes().map { myConverter.convertType(it) })
     }
 
-    public override fun visitParameterList(list: PsiParameterList?) {
+    override fun visitParameterList(list: PsiParameterList?) {
         myResult = ParameterList(myConverter.convertParameterList(list!!.getParameters()).requireNoNulls())
     }
 
-    public override fun visitComment(comment: PsiComment?) {
+    override fun visitComment(comment: PsiComment?) {
         myResult = Comment(comment!!.getText()!!)
     }
 
diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt
index e05b8977794..d2ed7c1a75b 100644
--- a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt
@@ -29,16 +29,16 @@ import org.jetbrains.jet.lang.types.lang.PrimitiveType
 import org.jetbrains.jet.j2k.*
 import org.jetbrains.jet.j2k.ast.types.ArrayType
 
-public open class ExpressionVisitor(converter: Converter) : StatementVisitor(converter) {
+open class ExpressionVisitor(converter: Converter) : StatementVisitor(converter) {
     {
         myResult = Expression.Empty
     }
 
-    public override fun getResult(): Expression {
+    override fun getResult(): Expression {
         return myResult as Expression
     }
 
-    public override fun visitArrayAccessExpression(expression: PsiArrayAccessExpression?) {
+    override fun visitArrayAccessExpression(expression: PsiArrayAccessExpression?) {
         val assignment = PsiTreeUtil.getParentOfType(expression, javaClass<PsiAssignmentExpression>())
         val lvalue = assignment != null && expression == assignment.getLExpression();
         myResult = ArrayAccessExpression(getConverter().convertExpression(expression?.getArrayExpression()),
@@ -46,14 +46,14 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
                                          lvalue)
     }
 
-    public override fun visitArrayInitializerExpression(expression: PsiArrayInitializerExpression?) {
+    override fun visitArrayInitializerExpression(expression: PsiArrayInitializerExpression?) {
         val expressionType = getConverter().convertType(expression?.getType())
         assert(expressionType is ArrayType) { "Array initializer must have array type" }
         myResult = ArrayInitializerExpression(expressionType as ArrayType,
                                               getConverter().convertExpressions(expression?.getInitializers()!!))
     }
 
-    public override fun visitAssignmentExpression(expression: PsiAssignmentExpression?) {
+    override fun visitAssignmentExpression(expression: PsiAssignmentExpression?) {
         val tokenType: IElementType = expression?.getOperationSign()?.getTokenType()!!
         val secondOp: String = when(tokenType) {
             JavaTokenType.GTGTEQ -> "shr"
@@ -75,7 +75,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
         }
     }
 
-    public override fun visitBinaryExpression(expression: PsiBinaryExpression?) {
+    override fun visitBinaryExpression(expression: PsiBinaryExpression?) {
         val lhs = getConverter().convertExpression(expression?.getLOperand()!!, expression?.getType())
         val rhs = getConverter().convertExpression(expression?.getROperand(), expression?.getType())
         if (expression?.getOperationSign()?.getTokenType() == JavaTokenType.GTGTGT) {
@@ -87,11 +87,11 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
         }
     }
 
-    public override fun visitClassObjectAccessExpression(expression: PsiClassObjectAccessExpression?) {
+    override fun visitClassObjectAccessExpression(expression: PsiClassObjectAccessExpression?) {
         myResult = ClassObjectAccessExpression(getConverter().convertTypeElement(expression?.getOperand()))
     }
 
-    public override fun visitConditionalExpression(expression: PsiConditionalExpression?) {
+    override fun visitConditionalExpression(expression: PsiConditionalExpression?) {
         val condition: PsiExpression? = expression?.getCondition()
         val `type`: PsiType? = condition?.getType()
         val e: Expression = (if (`type` != null)
@@ -103,17 +103,17 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
                                                        getConverter().convertExpression(expression?.getElseExpression())))
     }
 
-    public override fun visitExpressionList(list: PsiExpressionList?) {
+    override fun visitExpressionList(list: PsiExpressionList?) {
         myResult = ExpressionList(getConverter().convertExpressions(list!!.getExpressions()))
     }
 
-    public override fun visitInstanceOfExpression(expression: PsiInstanceOfExpression?) {
+    override fun visitInstanceOfExpression(expression: PsiInstanceOfExpression?) {
         val checkType: PsiTypeElement? = expression?.getCheckType()
         myResult = IsOperator(getConverter().convertExpression(expression?.getOperand()),
                               myConverter.convertTypeElement(checkType))
     }
 
-    public override fun visitLiteralExpression(expression: PsiLiteralExpression?) {
+    override fun visitLiteralExpression(expression: PsiLiteralExpression?) {
         val value: Any? = expression?.getValue()
         var text: String = expression?.getText()!!
         val `type`: PsiType? = expression?.getType()
@@ -143,7 +143,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
         myResult = LiteralExpression(text)
     }
 
-    public override fun visitMethodCallExpression(expression: PsiMethodCallExpression?) {
+    override fun visitMethodCallExpression(expression: PsiMethodCallExpression?) {
         convertMethodCallExpression(expression!!)
     }
 
@@ -156,7 +156,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
         }
     }
 
-    public override fun visitNewExpression(expression: PsiNewExpression?) {
+    override fun visitNewExpression(expression: PsiNewExpression?) {
         if (expression?.getArrayInitializer() != null)
         {
             myResult = createNewEmptyArray(expression)
@@ -211,16 +211,16 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
         return getConverter().convertExpression(expression?.getArrayInitializer())
     }
 
-    public override fun visitParenthesizedExpression(expression: PsiParenthesizedExpression?) {
+    override fun visitParenthesizedExpression(expression: PsiParenthesizedExpression?) {
         myResult = ParenthesizedExpression(getConverter().convertExpression(expression?.getExpression()))
     }
 
-    public override fun visitPostfixExpression(expression: PsiPostfixExpression?) {
+    override fun visitPostfixExpression(expression: PsiPostfixExpression?) {
         myResult = PostfixOperator(getOperatorString(expression!!.getOperationSign().getTokenType()!!),
                                    getConverter().convertExpression(expression.getOperand()))
     }
 
-    public override fun visitPrefixExpression(expression: PsiPrefixExpression?) {
+    override fun visitPrefixExpression(expression: PsiPrefixExpression?) {
         val operand = getConverter().convertExpression(expression?.getOperand(), expression?.getOperand()!!.getType())
         val token = expression?.getOperationTokenType()!!
         if (token == JavaTokenType.TILDE) {
@@ -231,7 +231,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
         }
     }
 
-    public override fun visitReferenceExpression(expression: PsiReferenceExpression?) {
+    override fun visitReferenceExpression(expression: PsiReferenceExpression?) {
         val isFieldReference: Boolean = isFieldReference(expression!!, getContainingClass(expression))
         val insideSecondaryConstructor: Boolean = isInsideSecondaryConstructor(expression)
         val hasReceiver: Boolean = isFieldReference && insideSecondaryConstructor
@@ -243,7 +243,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
         var identifier: Expression = Identifier(referencedName, isNullable)
         val __: String = "__"
         val qualifier = expression.getQualifierExpression()
-        if (hasReceiver){
+        if (hasReceiver) {
             identifier = CallChainExpression(Identifier(__, false), Identifier(referencedName, isNullable))
         }
         else if (insideSecondaryConstructor && isThis) {
@@ -268,7 +268,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
             !isStaticallyImported(resolved, expression)) {
                 var member = resolved as PsiMember
                 var result = Identifier(referencedName).toKotlin()
-                while(member.getContainingClass() != null) {
+                while (member.getContainingClass() != null) {
                     result = Identifier(member.getContainingClass()!!.getName()!!).toKotlin() + "." + result
                     member = member.getContainingClass()!!
                 }
@@ -291,7 +291,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
         return false;
     }
 
-    public override fun visitSuperExpression(expression: PsiSuperExpression?) {
+    override fun visitSuperExpression(expression: PsiSuperExpression?) {
         val qualifier: PsiJavaCodeReferenceElement? = expression?.getQualifier()
         myResult = SuperExpression((if (qualifier != null)
             Identifier(qualifier.getQualifiedName()!!)
@@ -299,7 +299,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
             Identifier.Empty))
     }
 
-    public override fun visitThisExpression(expression: PsiThisExpression?) {
+    override fun visitThisExpression(expression: PsiThisExpression?) {
         val qualifier: PsiJavaCodeReferenceElement? = expression?.getQualifier()
         myResult = ThisExpression((if (qualifier != null)
             Identifier(qualifier.getQualifiedName()!!)
@@ -307,7 +307,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
             Identifier.Empty))
     }
 
-    public override fun visitTypeCastExpression(expression: PsiTypeCastExpression?) {
+    override fun visitTypeCastExpression(expression: PsiTypeCastExpression?) {
         val castType: PsiTypeElement? = expression?.getCastType()
         if (castType != null) {
             val operand = expression?.getOperand()
@@ -324,7 +324,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
         }
     }
 
-    public override fun visitPolyadicExpression(expression: PsiPolyadicExpression?) {
+    override fun visitPolyadicExpression(expression: PsiPolyadicExpression?) {
         var parameters = ArrayList<Expression>()
         for (operand : PsiExpression in expression?.getOperands()!!) {
             parameters.add(getConverter().convertExpression(operand, expression?.getType()))
diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.kt
index 85f446d6f28..5de326a5408 100644
--- a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.kt
@@ -23,8 +23,8 @@ import org.jetbrains.jet.j2k.ast.Identifier
 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?) {
+open class ExpressionVisitorForDirectObjectInheritors(converter: Converter) : ExpressionVisitor(converter) {
+    override fun visitMethodCallExpression(expression: PsiMethodCallExpression?) {
         val methodExpression = expression?.getMethodExpression()!!
         if (superMethodInvocation(methodExpression, "hashCode")) {
             myResult = MethodCallExpression.build(Identifier("System", false), "identityHashCode", listOf(Identifier("this")))
diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt
index d278266981c..cd661031b44 100644
--- a/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt
@@ -22,17 +22,17 @@ import org.jetbrains.jet.j2k.ast.*
 import org.jetbrains.jet.j2k.countWritingAccesses
 import java.util.ArrayList
 
-public open class StatementVisitor(converter: Converter) : ElementVisitor(converter) {
-    public override fun visitAssertStatement(statement: PsiAssertStatement?) {
+open class StatementVisitor(converter: Converter) : ElementVisitor(converter) {
+    override fun visitAssertStatement(statement: PsiAssertStatement?) {
         myResult = AssertStatement(getConverter().convertExpression(statement?.getAssertCondition()),
                                    getConverter().convertExpression(statement?.getAssertDescription()))
     }
 
-    public override fun visitBlockStatement(statement: PsiBlockStatement?) {
+    override fun visitBlockStatement(statement: PsiBlockStatement?) {
         myResult = getConverter().convertBlock(statement?.getCodeBlock(), true)
     }
 
-    public override fun visitBreakStatement(statement: PsiBreakStatement?) {
+    override fun visitBreakStatement(statement: PsiBreakStatement?) {
         if (statement?.getLabelIdentifier() == null) {
             myResult = BreakStatement(Identifier.Empty)
         }
@@ -42,7 +42,7 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
         }
     }
 
-    public override fun visitContinueStatement(statement: PsiContinueStatement?) {
+    override fun visitContinueStatement(statement: PsiContinueStatement?) {
         if (statement?.getLabelIdentifier() == null)
         {
             myResult = ContinueStatement(Identifier.Empty)
@@ -53,11 +53,11 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
         }
     }
 
-    public override fun visitDeclarationStatement(statement: PsiDeclarationStatement?) {
+    override fun visitDeclarationStatement(statement: PsiDeclarationStatement?) {
         myResult = DeclarationStatement(getConverter().convertElements(statement?.getDeclaredElements()!!))
     }
 
-    public override fun visitDoWhileStatement(statement: PsiDoWhileStatement?) {
+    override fun visitDoWhileStatement(statement: PsiDoWhileStatement?) {
         val condition: PsiExpression? = statement?.getCondition()
         val expression: Expression = (if (condition != null && condition.getType() != null)
             getConverter().convertExpression(condition, condition.getType())
@@ -66,16 +66,16 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
         myResult = DoWhileStatement(expression, getConverter().convertStatement(statement?.getBody()))
     }
 
-    public override fun visitExpressionStatement(statement: PsiExpressionStatement?) {
+    override fun visitExpressionStatement(statement: PsiExpressionStatement?) {
         myResult = getConverter().convertExpression(statement?.getExpression())
     }
 
-    public override fun visitExpressionListStatement(statement: PsiExpressionListStatement?) {
+    override fun visitExpressionListStatement(statement: PsiExpressionListStatement?) {
         myResult = ExpressionListStatement(getConverter().convertExpressions(
                 statement?.getExpressionList()?.getExpressions()!!))
     }
 
-    public override fun visitForStatement(statement: PsiForStatement?) {
+    override fun visitForStatement(statement: PsiForStatement?) {
         val initialization = statement?.getInitialization()
         val update = statement?.getUpdate()
         val condition = statement?.getCondition()
@@ -122,7 +122,7 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
         }
     }
 
-    public override fun visitForeachStatement(statement: PsiForeachStatement?) {
+    override fun visitForeachStatement(statement: PsiForeachStatement?) {
         val iterator = {
             val iteratorExpr = getConverter().convertExpression(statement?.getIteratedValue())
             if (iteratorExpr.isNullable())
@@ -135,7 +135,7 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
                                     getConverter().convertStatement(statement?.getBody()))
     }
 
-    public override fun visitIfStatement(statement: PsiIfStatement?) {
+    override fun visitIfStatement(statement: PsiIfStatement?) {
         val condition: PsiExpression? = statement?.getCondition()
         val expression: Expression = getConverter().convertExpression(condition, PsiType.BOOLEAN)
         myResult = IfStatement(expression,
@@ -143,19 +143,19 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
                                getConverter().convertStatement(statement?.getElseBranch()))
     }
 
-    public override fun visitLabeledStatement(statement: PsiLabeledStatement?) {
+    override fun visitLabeledStatement(statement: PsiLabeledStatement?) {
         myResult = LabelStatement(getConverter().convertIdentifier(statement?.getLabelIdentifier()),
                                   getConverter().convertStatement(statement?.getStatement()))
     }
 
-    public override fun visitSwitchLabelStatement(statement: PsiSwitchLabelStatement?) {
+    override fun visitSwitchLabelStatement(statement: PsiSwitchLabelStatement?) {
         myResult = (if (statement?.isDefaultCase()!!)
             DefaultSwitchLabelStatement()
         else
             SwitchLabelStatement(getConverter().convertExpression(statement?.getCaseValue())))
     }
 
-    public override fun visitSwitchStatement(statement: PsiSwitchStatement?) {
+    override fun visitSwitchStatement(statement: PsiSwitchStatement?) {
         myResult = SwitchContainer(getConverter().convertExpression(statement?.getExpression()),
                                    switchBodyToCases(statement?.getBody()))
     }
@@ -203,16 +203,16 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
         return result
     }
 
-    public override fun visitSynchronizedStatement(statement: PsiSynchronizedStatement?) {
+    override fun visitSynchronizedStatement(statement: PsiSynchronizedStatement?) {
         myResult = SynchronizedStatement(getConverter().convertExpression(statement?.getLockExpression()),
                                          getConverter().convertBlock(statement?.getBody()))
     }
 
-    public override fun visitThrowStatement(statement: PsiThrowStatement?) {
+    override fun visitThrowStatement(statement: PsiThrowStatement?) {
         myResult = ThrowStatement(getConverter().convertExpression(statement?.getException()))
     }
 
-    public override fun visitTryStatement(statement: PsiTryStatement?) {
+    override fun visitTryStatement(statement: PsiTryStatement?) {
         val catches = ArrayList<CatchStatement>()
         val catchBlocks = statement?.getCatchBlocks()!!
         val catchBlockParameters = statement?.getCatchBlockParameters()!!
@@ -224,7 +224,7 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
                                 catches, getConverter().convertBlock(statement?.getFinallyBlock(), true))
     }
 
-    public override fun visitWhileStatement(statement: PsiWhileStatement?) {
+    override fun visitWhileStatement(statement: PsiWhileStatement?) {
         var condition: PsiExpression? = statement?.getCondition()
         val expression: Expression = (if (condition != null && condition?.getType() != null)
             this.getConverter().convertExpression(condition, condition?.getType())
@@ -233,7 +233,7 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
         myResult = WhileStatement(expression, getConverter().convertStatement(statement?.getBody()))
     }
 
-    public override fun visitReturnStatement(statement: PsiReturnStatement?) {
+    override fun visitReturnStatement(statement: PsiReturnStatement?) {
         val returnValue: PsiExpression? = statement?.getReturnValue()
         val methodReturnType: PsiType? = getConverter().methodReturnType
         val expression: Expression = (if (returnValue != null && methodReturnType != null)
diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/SuperVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/SuperVisitor.kt
index 5cfe8464366..4bb424f3bfe 100644
--- a/j2k/src/org/jetbrains/jet/j2k/visitors/SuperVisitor.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/visitors/SuperVisitor.kt
@@ -19,10 +19,10 @@ package org.jetbrains.jet.j2k.visitors
 import com.intellij.psi.*
 import java.util.HashSet
 
-public open class SuperVisitor() : JavaRecursiveElementVisitor() {
-    public val resolvedSuperCallParameters: HashSet<PsiExpressionList> = HashSet()
+open class SuperVisitor() : JavaRecursiveElementVisitor() {
+    val resolvedSuperCallParameters: HashSet<PsiExpressionList> = HashSet()
 
-    public override fun visitMethodCallExpression(expression: PsiMethodCallExpression?) {
+    override fun visitMethodCallExpression(expression: PsiMethodCallExpression?) {
         if (expression != null && isSuper(expression.getMethodExpression())) {
             resolvedSuperCallParameters.add(expression.getArgumentList())
         }
diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt
index 25005fb582e..b640351e86e 100644
--- a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt
@@ -28,13 +28,13 @@ import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType
 
 private val PRIMITIVE_TYPES_NAMES = JvmPrimitiveType.values().map { it.getName() }
 
-public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisitor<Type>() {
+open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisitor<Type>() {
     private var myResult: Type = EmptyType()
-    public open fun getResult(): Type {
+    open fun getResult(): Type {
         return myResult
     }
 
-    public override fun visitPrimitiveType(primitiveType: PsiPrimitiveType?): Type {
+    override fun visitPrimitiveType(primitiveType: PsiPrimitiveType?): Type {
         val name: String = primitiveType?.getCanonicalText()!!
         if (name == "void") {
             myResult = UnitType
@@ -48,7 +48,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit
         return myResult
     }
 
-    public override fun visitArrayType(arrayType: PsiArrayType?): Type {
+    override fun visitArrayType(arrayType: PsiArrayType?): Type {
         if (myResult is EmptyType) {
             myResult = ArrayType(myConverter.convertType(arrayType?.getComponentType()), true, myConverter)
         }
@@ -56,7 +56,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit
         return myResult
     }
 
-    public override fun visitClassType(classType: PsiClassType?): Type {
+    override fun visitClassType(classType: PsiClassType?): Type {
         if (classType == null) return myResult
         val identifier: Identifier = constructClassTypeIdentifier(classType)
         val resolvedClassTypeParams: List<Type> = createRawTypesForResolvedReference(classType)
@@ -130,7 +130,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit
         return typeParams
     }
 
-    public override fun visitWildcardType(wildcardType: PsiWildcardType?): Type {
+    override fun visitWildcardType(wildcardType: PsiWildcardType?): Type {
         if (wildcardType!!.isExtends()) {
             myResult = OutProjectionType(myConverter.convertType(wildcardType.getExtendsBound()))
         }
@@ -144,7 +144,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit
         return myResult
     }
 
-    public override fun visitEllipsisType(ellipsisType: PsiEllipsisType?): Type {
+    override fun visitEllipsisType(ellipsisType: PsiEllipsisType?): Type {
         myResult = VarArg(myConverter.convertType(ellipsisType?.getComponentType()))
         return myResult
     }
diff --git a/j2k/tests/test/org/jetbrains/jet/j2k/test/AbstractJavaToKotlinConverterTest.kt b/j2k/tests/test/org/jetbrains/jet/j2k/test/AbstractJavaToKotlinConverterTest.kt
index 1c5ee790bff..46f3c02c13b 100644
--- a/j2k/tests/test/org/jetbrains/jet/j2k/test/AbstractJavaToKotlinConverterTest.kt
+++ b/j2k/tests/test/org/jetbrains/jet/j2k/test/AbstractJavaToKotlinConverterTest.kt
@@ -18,7 +18,6 @@ package org.jetbrains.jet.j2k.test
 
 import java.io.File
 import com.intellij.openapi.util.io.FileUtil
-import junit.framework.Assert
 import com.intellij.psi.PsiJavaFile
 import com.intellij.psi.PsiFile
 import org.jetbrains.jet.j2k.Converter
@@ -35,17 +34,18 @@ import com.intellij.psi.codeStyle.CodeStyleManager
 import org.jetbrains.jet.JetTestUtils
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.project.Project
-import kotlin.test.fail
 
 public abstract class AbstractJavaToKotlinConverterPluginTest() : AbstractJavaToKotlinConverterTest("ide.kt", PluginSettings)
 public abstract class AbstractJavaToKotlinConverterBasicTest() : AbstractJavaToKotlinConverterTest("kt", TestSettings)
 
-public abstract class AbstractJavaToKotlinConverterTest(val kotlinFileExtension: String,
-                                                        val settings: ConverterSettings) : LightIdeaTestCase() {
+abstract class AbstractJavaToKotlinConverterTest(
+        val kotlinFileExtension: String,
+                                                 val settings: ConverterSettings
+) : LightIdeaTestCase() {
 
     val testHeaderPattern = Pattern.compile("//(element|expression|statement|method|class|file|comp)\n")
 
-    protected fun doTest(javaPath: String) {
+    public fun doTest(javaPath: String) {
         val project = LightPlatformTestCase.getProject()!!
         val converter = Converter(project, settings)
         val javaFile = File(javaPath)