From 1b948ef8f13a6862d999d6552da7a43b180d1d64 Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Tue, 10 Jun 2014 18:45:07 +0400 Subject: [PATCH] Java to Kotlin converter: minor code refactoring --- j2k/src/org/jetbrains/jet/j2k/Converter.kt | 2 +- .../org/jetbrains/jet/j2k/ast/Expressions.kt | 4 +-- .../jet/j2k/ast/MethodCallExpression.kt | 31 ++++++++++++++----- .../jet/j2k/visitors/ExpressionVisitor.kt | 28 +++++++++-------- 4 files changed, 42 insertions(+), 23 deletions(-) diff --git a/j2k/src/org/jetbrains/jet/j2k/Converter.kt b/j2k/src/org/jetbrains/jet/j2k/Converter.kt index da2413809e3..6331e6f5ec0 100644 --- a/j2k/src/org/jetbrains/jet/j2k/Converter.kt +++ b/j2k/src/org/jetbrains/jet/j2k/Converter.kt @@ -481,7 +481,7 @@ public class Converter(val project: Project, val settings: ConverterSettings, va if (isConversionNeeded(actualType, expectedType) && expression !is LiteralExpression) { val conversion = PRIMITIVE_TYPE_CONVERSIONS[expectedType?.getCanonicalText()] if (conversion != null) { - expression = MethodCallExpression.build(expression, conversion) + expression = MethodCallExpression.buildNotNull(expression, conversion) } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt index 312452f741c..2ff597097af 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt @@ -116,7 +116,7 @@ fun createArrayInitializerExpression(arrayType: ArrayType, initializers: List null } if (conversionFunction != null) { - return MethodCallExpression(QualifiedExpression(initializer, Identifier(conversionFunction)), listOf(), listOf()) + return MethodCallExpression.buildNotNull(initializer, conversionFunction) } } } @@ -124,5 +124,5 @@ fun createArrayInitializerExpression(arrayType: ArrayType, initializers: List, - val typeParameters: List, - override val isNullable: Boolean = false + val typeArguments: List, + override val isNullable: Boolean ) : Expression() { override fun toKotlin(): String { return operandToKotlin(methodExpression) + - typeParameters.toKotlin(", ", "<", ">") + + typeArguments.toKotlin(", ", "<", ">") + "(" + arguments.map { it.toKotlin() }.makeString(", ") + ")" } class object { - public fun build(receiver: Expression, methodName: String, arguments: List = ArrayList()): MethodCallExpression { - return MethodCallExpression(QualifiedExpression(receiver, Identifier(methodName, false)), + public fun buildNotNull(receiver: Expression?, + methodName: String, + arguments: List = listOf(), + typeArguments: List = listOf()): MethodCallExpression + = build(receiver, methodName, arguments, typeArguments, false) + + public fun buildNullable(receiver: Expression?, + methodName: String, + arguments: List = listOf(), + typeArguments: List = listOf()): MethodCallExpression + = build(receiver, methodName, arguments, typeArguments, true) + + public fun build(receiver: Expression?, + methodName: String, + arguments: List, + typeArguments: List, + isNullable: Boolean): MethodCallExpression { + val identifier = Identifier(methodName, false) + return MethodCallExpression(if (receiver != null) QualifiedExpression(receiver, identifier) else identifier, arguments, - listOf(), - false) + typeArguments, + isNullable) } } } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt index e168941b40d..e1ff68221f4 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt @@ -82,7 +82,7 @@ class ExpressionVisitor(private val converter: Converter, val lhs = converter.convertExpression(expression.getLOperand(), expression.getType()) val rhs = converter.convertExpression(expression.getROperand(), expression.getType()) if (expression.getOperationSign().getTokenType() == JavaTokenType.GTGTGT) { - result = MethodCallExpression.build(lhs, "ushr", listOf(rhs)) + result = MethodCallExpression.buildNotNull(lhs, "ushr", listOf(rhs)) } else { result = BinaryExpression(lhs, rhs, getOperatorString(expression.getOperationSign().getTokenType())) @@ -91,7 +91,7 @@ class ExpressionVisitor(private val converter: Converter, override fun visitClassObjectAccessExpression(expression: PsiClassObjectAccessExpression) { val typeElement = converter.convertTypeElement(expression.getOperand()) - result = MethodCallExpression(Identifier("javaClass"), listOf(), listOf(typeElement.`type`.toNotNullType()), false) + result = MethodCallExpression.buildNotNull(null, "javaClass", listOf(), listOf(typeElement.`type`.toNotNullType())) } override fun visitConditionalExpression(expression: PsiConditionalExpression) { @@ -193,16 +193,18 @@ class ExpressionVisitor(private val converter: Converter, if (isTopLevel) { result = if (origin.isExtensionDeclaration()) { val qualifier = converter.convertExpression(arguments.firstOrNull()) - MethodCallExpression(QualifiedExpression(qualifier, Identifier(origin.getName()!!, false)), - convertArguments(expression, isExtension = true), - typeArguments, - isNullable) + MethodCallExpression.build(qualifier, + origin.getName()!!, + convertArguments(expression, isExtension = true), + typeArguments, + isNullable) } else { - MethodCallExpression(Identifier(origin.getName()!!, false), - convertArguments(expression), - typeArguments, - isNullable) + MethodCallExpression.build(null, + origin.getName()!!, + convertArguments(expression), + typeArguments, + isNullable) } return } @@ -255,7 +257,7 @@ class ExpressionVisitor(private val converter: Converter, val reference = expression.getClassReference() val typeParameters = if (reference != null) typeConverter.convertTypes(reference.getTypeParameters()) else listOf() return QualifiedExpression(Identifier(constructor.getName(), false), - MethodCallExpression(Identifier("init"), converter.convertExpressions(arguments), typeParameters, false)) + MethodCallExpression.buildNotNull(null, "init", converter.convertExpressions(arguments), typeParameters)) } return NewClassExpression(converter.convertElement(classReference), @@ -277,7 +279,7 @@ class ExpressionVisitor(private val converter: Converter, val operand = converter.convertExpression(expression.getOperand(), expression.getOperand()!!.getType()) val token = expression.getOperationTokenType() if (token == JavaTokenType.TILDE) { - result = MethodCallExpression.build(operand, "inv", ArrayList()) + result = MethodCallExpression.buildNotNull(operand, "inv") } else if (token == JavaTokenType.EXCL && operand is BinaryExpression && operand.op == "==") { // happens when equals is converted to == result = BinaryExpression(operand.left, operand.right, "!=") @@ -366,7 +368,7 @@ class ExpressionVisitor(private val converter: Converter, val typeText = castType.getType().getCanonicalText() val typeConversion = PRIMITIVE_TYPE_CONVERSIONS[typeText] if (operandType is PsiPrimitiveType && typeConversion != null) { - result = MethodCallExpression.build(converter.convertExpression(operand), typeConversion) + result = MethodCallExpression.buildNotNull(converter.convertExpression(operand), typeConversion) } else { result = TypeCastExpression(typeConverter.convertType(castType.getType()),