From a07dae97346738ba663e10f65de825ad3989534d Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Tue, 10 Jun 2014 18:08:40 +0400 Subject: [PATCH] Java to Kotlin converter: minor code refining --- .../ArrayWithoutInitializationExpression.kt | 46 +++++++------------ .../jet/j2k/ast/DummyStringExpression.kt | 3 +- j2k/src/org/jetbrains/jet/j2k/ast/Types.kt | 8 ++-- .../jet/j2k/visitors/ExpressionVisitor.kt | 18 ++------ 4 files changed, 26 insertions(+), 49 deletions(-) diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayWithoutInitializationExpression.kt b/j2k/src/org/jetbrains/jet/j2k/ast/ArrayWithoutInitializationExpression.kt index d1432a41e10..631196362b9 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayWithoutInitializationExpression.kt +++ b/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() { - override fun toKotlin(): String { - if (`type` is ArrayType) { - return constructInnerType(`type`, expressions) - } - - return getConstructorName(`type`, expressions.size() != 0) - } +open class ArrayWithoutInitializationExpression(val `type`: ArrayType, val expressions: List) : Expression() { + override fun toKotlin(): String + = constructInnerType(`type`, expressions) private fun constructInnerType(hostType: ArrayType, expressions: List): 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 open fun oneDim(`type`: Type, size: Expression): String { - return oneDim(`type`, size, "") - } + private fun oneDim(`type`: ArrayType, size: Expression, init: String = ""): String { + return getConstructorName(`type`, !init.isEmpty()) + "(" + size.toKotlin() + init.withPrefix(", ") + ")" + } - private open fun oneDim(`type`: Type, size: Expression, init: String): String { - return getConstructorName(`type`, !init.isEmpty()) + "(" + size.toKotlin() + init.withPrefix(", ") + ")" - } - - 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 + private fun getConstructorName(`type`: ArrayType, hasInit: Boolean): String { + return 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() + ">" } } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/DummyStringExpression.kt b/j2k/src/org/jetbrains/jet/j2k/ast/DummyStringExpression.kt index 607c7550262..3971b3acb04 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/DummyStringExpression.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/DummyStringExpression.kt @@ -16,7 +16,6 @@ package org.jetbrains.jet.j2k.ast - -open class DummyStringExpression(val string: String) : Expression() { +class DummyStringExpression(val string: String) : Expression() { override fun toKotlin(): String = string } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Types.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Types.kt index 122b3b90e7a..35c21717bde 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Types.kt +++ b/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, nullability: Nullability, settings: ConverterSettings) +class ClassType(val `type`: Identifier, val typeArgs: List, nullability: Nullability, settings: ConverterSettings) : MayBeNullableType(nullability, settings) { override fun toKotlin(): String { // TODO change to map() when KT-2051 is fixed val parametersToKotlin = ArrayList() - 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, nullabili } - override fun toNotNullType(): Type = ClassType(`type`, parameters, Nullability.NotNull, settings) - override fun toNullableType(): Type = ClassType(`type`, parameters, Nullability.Nullable, settings) + override fun toNotNullType(): Type = ClassType(`type`, typeArgs, Nullability.NotNull, settings) + override fun toNullableType(): Type = ClassType(`type`, typeArgs, Nullability.Nullable, settings) } class ArrayType(val elementType: Type, nullability: Nullability, settings: ConverterSettings) diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt index 50202f2f6c3..e168941b40d 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt +++ b/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) { - result = createNewEmptyArrayWithoutInitialization(expression) + else if (expression.getArrayDimensions().size > 0 && expression.getType() is PsiArrayType) { + 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())) }