Java to Kotlin converter: minor code refining

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

@@ -16,14 +16,9 @@
 
 package org.jetbrains.jet.j2k.ast
 
-open class ArrayWithoutInitializationExpression(val `type`: Type, val expressions: List<Expression>) : Expression() {
+open class ArrayWithoutInitializationExpression(val `type`: ArrayType, val expressions: List<Expression>) : Expression() {
-    override fun toKotlin(): String {
+    override fun toKotlin(): String
-        if (`type` is ArrayType) {
+            = constructInnerType(`type`, expressions)
-            return constructInnerType(`type`, expressions)
-        }
-
-        return getConstructorName(`type`, expressions.size() != 0)
-    }
 
     private fun constructInnerType(hostType: ArrayType, expressions: List<Expression>): String {
         if (expressions.size() == 1) {
@@ -38,30 +33,21 @@ open class ArrayWithoutInitializationExpression(val `type`: Type, val expression
         return getConstructorName(hostType, expressions.size() != 0)
     }
 
-    class object {
+    private fun oneDim(`type`: ArrayType, size: Expression, init: String = ""): String {
-        private open fun oneDim(`type`: Type, size: Expression): String {
+        return getConstructorName(`type`, !init.isEmpty()) + "(" + size.toKotlin() + init.withPrefix(", ") + ")"
-            return oneDim(`type`, size, "")
+    }
-        }
 
-        private open fun oneDim(`type`: Type, size: Expression, init: String): String {
+    private fun getConstructorName(`type`: ArrayType, hasInit: Boolean): String {
-            return getConstructorName(`type`, !init.isEmpty()) + "(" + size.toKotlin() + init.withPrefix(", ") + ")"
+        return when (`type`.elementType) {
-        }
+            is PrimitiveType ->
-
-        private open fun getConstructorName(`type`: Type, hasInit: Boolean): String {
-            return if (`type` is ArrayType)
-                when (`type`.elementType) {
-                    is PrimitiveType ->
-                        `type`.toNotNullType().toKotlin()
-                    is ArrayType ->
-                        if (hasInit)
-                            `type`.toNotNullType().toKotlin()
-                        else
-                            "arrayOfNulls<" + `type`.elementType.toKotlin() + ">"
-                    else ->
-                        "arrayOfNulls<" + `type`.elementType.toKotlin() + ">"
-                }
-            else
                 `type`.toNotNullType().toKotlin()
+            is ArrayType ->
+                if (hasInit)
+                    `type`.toNotNullType().toKotlin()
+                else
+                    "arrayOfNulls<" + `type`.elementType.toKotlin() + ">"
+            else ->
+                "arrayOfNulls<" + `type`.elementType.toKotlin() + ">"
         }
     }
 }

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

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.j2k.ast
 
-
+class DummyStringExpression(val string: String) : Expression() {
-open class DummyStringExpression(val string: String) : Expression() {
     override fun toKotlin(): String = string
 }

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

@@ -75,13 +75,13 @@ trait Type : Element {
     override fun toString(): String = toKotlin()
 }
 
-class ClassType(val `type`: Identifier, val parameters: List<Element>, nullability: Nullability, settings: ConverterSettings)
+class ClassType(val `type`: Identifier, val typeArgs: List<Element>, nullability: Nullability, settings: ConverterSettings)
   : MayBeNullableType(nullability, settings) {
 
     override fun toKotlin(): String {
         // TODO change to map() when KT-2051 is fixed
         val parametersToKotlin = ArrayList<String>()
-        for (param in parameters) {
+        for (param in typeArgs) {
             parametersToKotlin.add(param.toKotlin())
         }
         var params: String = if (parametersToKotlin.size() == 0)
@@ -92,8 +92,8 @@ class ClassType(val `type`: Identifier, val parameters: List<Element>, nullabili
     }
 
 
-    override fun toNotNullType(): Type = ClassType(`type`, parameters, Nullability.NotNull, settings)
+    override fun toNotNullType(): Type = ClassType(`type`, typeArgs, Nullability.NotNull, settings)
-    override fun toNullableType(): Type = ClassType(`type`, parameters, Nullability.Nullable, settings)
+    override fun toNullableType(): Type = ClassType(`type`, typeArgs, Nullability.Nullable, settings)
 }
 
 class ArrayType(val elementType: Type, nullability: Nullability, settings: ConverterSettings)

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

@@ -231,10 +231,12 @@ class ExpressionVisitor(private val converter: Converter,
 
     override fun visitNewExpression(expression: PsiNewExpression) {
         if (expression.getArrayInitializer() != null) {
-            result = createNewEmptyArray(expression)
+            result = converter.convertExpression(expression.getArrayInitializer())
         }
-        else if (expression.getArrayDimensions().size > 0) {
+        else if (expression.getArrayDimensions().size > 0 && expression.getType() is PsiArrayType) {
-            result = createNewEmptyArrayWithoutInitialization(expression)
+            result = ArrayWithoutInitializationExpression(
+                    typeConverter.convertType(expression.getType(), Nullability.NotNull) as ArrayType,
+                    converter.convertExpressions(expression.getArrayDimensions()))
         }
         else {
             result = createNewClassExpression(expression)
@@ -262,16 +264,6 @@ class ExpressionVisitor(private val converter: Converter,
                                   if (anonymousClass != null) converter.convertAnonymousClass(anonymousClass) else null)
     }
 
-    private fun createNewEmptyArrayWithoutInitialization(expression: PsiNewExpression): Expression {
-        return ArrayWithoutInitializationExpression(
-                typeConverter.convertType(expression.getType(), Nullability.NotNull),
-                converter.convertExpressions(expression.getArrayDimensions()))
-    }
-
-    private fun createNewEmptyArray(expression: PsiNewExpression): Expression {
-        return converter.convertExpression(expression.getArrayInitializer())
-    }
-
     override fun visitParenthesizedExpression(expression: PsiParenthesizedExpression) {
         result = ParenthesizedExpression(converter.convertExpression(expression.getExpression()))
     }