diff --git a/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java b/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java index e34aead9d45..5a9e79a6122 100644 --- a/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java @@ -133,7 +133,7 @@ public class JavaToKotlinActionUtil { if (psiFile instanceof PsiJavaFile && virtualFile != null) { String result = ""; try { - result = converter.fileToFile((PsiJavaFile) psiFile).toKotlin(); + result = converter.convertFile((PsiJavaFile) psiFile).toKotlin(); } catch (Exception e) { //noinspection CallToPrintStackTrace e.printStackTrace(); diff --git a/j2k/src/org/jetbrains/jet/j2k/Converter.kt b/j2k/src/org/jetbrains/jet/j2k/Converter.kt index e9bf358b95e..660ae191b91 100644 --- a/j2k/src/org/jetbrains/jet/j2k/Converter.kt +++ b/j2k/src/org/jetbrains/jet/j2k/Converter.kt @@ -55,27 +55,27 @@ public class Converter(val project: Project, val settings: ConverterSettings) { } public fun elementToKotlin(element: PsiElement): String { - val kElement = topElementToElement(element) + val kElement = convertTopElement(element) return kElement?.toKotlin() ?: "" } - public fun topElementToElement(element: PsiElement?): Node? = when(element) { - is PsiJavaFile -> fileToFile(element) - is PsiClass -> classToClass(element) - is PsiMethod -> methodToFunction(element) - is PsiField -> fieldToField(element, element.getContainingClass()) - is PsiStatement -> statementToStatement(element) - is PsiExpression -> expressionToExpression(element) + public fun convertTopElement(element: PsiElement?): Node? = when(element) { + is PsiJavaFile -> convertFile(element) + is PsiClass -> convertClass(element) + is PsiMethod -> convertMethod(element) + is PsiField -> convertField(element, element.getContainingClass()) + is PsiStatement -> convertStatement(element) + is PsiExpression -> convertExpression(element) is PsiComment -> Comment(element.getText()!!) - is PsiImportList -> importsToImportList(element) - is PsiImportStatementBase -> importToImport(element) + is PsiImportList -> convertImportList(element) + is PsiImportStatementBase -> convertImport(element) else -> null } - public fun fileToFile(javaFile: PsiJavaFile): File { + public fun convertFile(javaFile: PsiJavaFile): File { val body = ArrayList() for (element in javaFile.getChildren()) { - val node = topElementToElement(element) + val node = convertTopElement(element) if (node != null) { body.add(node) } @@ -83,14 +83,14 @@ public class Converter(val project: Project, val settings: ConverterSettings) { return File(quoteKeywords(javaFile.getPackageName()), body, createMainFunction(javaFile)) } - public fun anonymousClassToAnonymousClass(anonymousClass: PsiAnonymousClass): AnonymousClass { + public fun convertAnonymousClass(anonymousClass: PsiAnonymousClass): AnonymousClass { return AnonymousClass(this, getMembers(anonymousClass)) } private fun getMembers(psiClass: PsiClass): List { val members = ArrayList() for (e in psiClass.getChildren()) { - val converted = memberToMember(e, psiClass) + val converted = convertMember(e, psiClass) if (converted != null) members.add(converted) } return members @@ -101,22 +101,22 @@ public class Converter(val project: Project, val settings: ConverterSettings) { return if (psiDocComment != null) Comment(psiDocComment.getText()!!) else null } - private fun memberToMember(e: PsiElement?, containingClass: PsiClass): Node? = when(e) { - is PsiMethod -> methodToFunction(e, true) - is PsiField -> fieldToField(e, containingClass) - is PsiClass -> classToClass(e) - is PsiClassInitializer -> initializerToInitializer(e) + private fun convertMember(e: PsiElement?, containingClass: PsiClass): Node? = when(e) { + is PsiMethod -> convertMethod(e, true) + is PsiField -> convertField(e, containingClass) + is PsiClass -> convertClass(e) + is PsiClassInitializer -> convertInitializer(e) is PsiDocComment -> null is PsiComment -> Comment(e.getText()!!) else -> null } - private fun classToClass(psiClass: PsiClass): Class { - val modifiers = modifiersListToModifiersSet(psiClass.getModifierList()) - val fields = fieldsToFieldList(psiClass.getFields(), psiClass) - val typeParameters = typeParameterListToTypeParameterList(psiClass.getTypeParameterList()) - val implementsTypes = typesToNotNullableTypeList(psiClass.getImplementsListTypes()) - val extendsTypes = typesToNotNullableTypeList(psiClass.getExtendsListTypes()) + private fun convertClass(psiClass: PsiClass): Class { + val modifiers = convertModifierList(psiClass.getModifierList()) + val fields = convertFields(psiClass.getFields(), psiClass) + val typeParameters = convertTypeParameterList(psiClass.getTypeParameterList()) + val implementsTypes = convertToNotNullableTypes(psiClass.getImplementsListTypes()) + val extendsTypes = convertToNotNullableTypes(psiClass.getExtendsListTypes()) val name: Identifier = Identifier(psiClass.getName()!!) val baseClassParams = ArrayList() val members = ArrayList(getMembers(psiClass)) @@ -125,7 +125,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) { val resolvedSuperCallParameters = visitor.resolvedSuperCallParameters if (resolvedSuperCallParameters.size() == 1) { val psiExpressionList = resolvedSuperCallParameters.iterator().next() - baseClassParams.addAll(expressionsToExpressionList(psiExpressionList.getExpressions())) + baseClassParams.addAll(convertExpressions(psiExpressionList.getExpressions())) } if (!psiClass.isEnum() && !psiClass.isInterface() && psiClass.getConstructors().size > 1 && @@ -186,25 +186,25 @@ public class Converter(val project: Project, val settings: ConverterSettings) { return Class(this, name, getDocComment(psiClass), modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, members) } - private fun initializerToInitializer(i: PsiClassInitializer): Initializer { - return Initializer(blockToBlock(i.getBody(), true), modifiersListToModifiersSet(i.getModifierList())) + private fun convertInitializer(i: PsiClassInitializer): Initializer { + return Initializer(convertBlock(i.getBody(), true), convertModifierList(i.getModifierList())) } - private fun fieldsToFieldList(fields: Array, psiClass: PsiClass): List { - return fields.map { fieldToField(it, psiClass) } + private fun convertFields(fields: Array, psiClass: PsiClass): List { + return fields.map { convertField(it, psiClass) } } - private fun fieldToField(field: PsiField, psiClass: PsiClass?): Field { - val modifiers = modifiersListToModifiersSet(field.getModifierList()) + private fun convertField(field: PsiField, psiClass: PsiClass?): Field { + val modifiers = convertModifierList(field.getModifierList()) if (field is PsiEnumConstant) { return EnumConstant(Identifier(field.getName()!!), getDocComment(field), modifiers, - typeToType(field.getType()), - elementToElement(field.getArgumentList())) + convertType(field.getType()), + convertElement(field.getArgumentList())) } - var kType = typeToType(field.getType(), isAnnotatedAsNotNull(field.getModifierList())) + var kType = convertType(field.getType(), isAnnotatedAsNotNull(field.getModifierList())) if (field.hasModifierProperty(PsiModifier.FINAL) && isDefinitelyNotNull(field.getInitializer())) { kType = kType.convertedToNotNull(); } @@ -213,15 +213,15 @@ public class Converter(val project: Project, val settings: ConverterSettings) { getDocComment(field), modifiers, kType, - expressionToExpression(field.getInitializer(), field.getType()), + convertExpression(field.getInitializer(), field.getType()), countWritingAccesses(field, psiClass)) } - private fun methodToFunction(method: PsiMethod): Function { - return methodToFunction(method, true) + private fun convertMethod(method: PsiMethod): Function { + return convertMethod(method, true) } - private fun methodToFunction(method: PsiMethod, notEmpty: Boolean): Function { + private fun convertMethod(method: PsiMethod, notEmpty: Boolean): Function { if (directlyOverridesMethodFromObject(method)) { dispatcher.expressionVisitor = ExpressionVisitorForDirectObjectInheritors(this) } @@ -230,12 +230,12 @@ public class Converter(val project: Project, val settings: ConverterSettings) { } methodReturnType = method.getReturnType() val identifier: Identifier = Identifier(method.getName()) - val returnType: Type = typeToType(method.getReturnType(), isAnnotatedAsNotNull(method.getModifierList())) - val body = blockToBlock(method.getBody(), notEmpty) + val returnType: Type = convertType(method.getReturnType(), isAnnotatedAsNotNull(method.getModifierList())) + val body = convertBlock(method.getBody(), notEmpty) val params: Element = createFunctionParameters(method) - val typeParameterList = typeParameterListToTypeParameterList(method.getTypeParameterList()) - val modifiers = modifiersListToModifiersSet(method.getModifierList()) + val typeParameterList = convertTypeParameterList(method.getTypeParameterList()) + val modifiers = convertModifierList(method.getModifierList()) if (isOverride(method)) { modifiers.add(Modifier.OVERRIDE) } @@ -261,33 +261,33 @@ public class Converter(val project: Project, val settings: ConverterSettings) { val result = ArrayList() for (parameter : PsiParameter? in method.getParameterList().getParameters()) { result.add(Parameter(Identifier(parameter?.getName()!!), - typeToType(parameter?.getType(), + convertType(parameter?.getType(), isAnnotatedAsNotNull(parameter?.getModifierList())), isReadOnly(parameter, method.getBody()))) } return ParameterList(result) } - public fun blockToBlock(block: PsiCodeBlock?, notEmpty: Boolean): Block { + public fun convertBlock(block: PsiCodeBlock?, notEmpty: Boolean): Block { if (block == null) return Block.EMPTY_BLOCK - return Block(statementsToStatementList(block.getChildren()), notEmpty) + return Block(convertStatements(block.getChildren()), notEmpty) } - public fun blockToBlock(block: PsiCodeBlock?): Block { - return blockToBlock(block, true) + public fun convertBlock(block: PsiCodeBlock?): Block { + return convertBlock(block, true) } - public fun statementsToStatementList(statements: Array): List { - return statements.filterNot { it is PsiWhiteSpace }.map { statementToStatement(it) } + public fun convertStatements(statements: Array): List { + return statements.filterNot { it is PsiWhiteSpace }.map { convertStatement(it) } } - public fun statementsToStatementList(statements: List): List { - return statements.filterNot { it is PsiWhiteSpace }.map { statementToStatement(it) } + public fun convertStatements(statements: List): List { + return statements.filterNot { it is PsiWhiteSpace }.map { convertStatement(it) } } - public fun statementToStatement(s: PsiElement?): Element { + public fun convertStatement(s: PsiElement?): Element { if (s == null) return Statement.EMPTY_STATEMENT @@ -296,14 +296,14 @@ public class Converter(val project: Project, val settings: ConverterSettings) { return statementVisitor.getResult() } - public fun expressionsToExpressionList(expressions: Array): List { + public fun convertExpressions(expressions: Array): List { val result = ArrayList() for (e : PsiExpression? in expressions) - result.add(expressionToExpression(e)) + result.add(convertExpression(e)) return result } - public fun expressionToExpression(e: PsiExpression?): Expression { + public fun convertExpression(e: PsiExpression?): Expression { if (e == null) return Expression.EMPTY_EXPRESSION @@ -312,7 +312,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) { return expressionVisitor.getResult() } - public fun elementToElement(e: PsiElement?): Element { + public fun convertElement(e: PsiElement?): Element { if (e == null) return Element.EMPTY_ELEMENT @@ -321,22 +321,22 @@ public class Converter(val project: Project, val settings: ConverterSettings) { return elementVisitor.getResult() } - public fun elementsToElementList(elements: Array): List { + public fun convertElements(elements: Array): List { val result = ArrayList() for (element in elements) { - result.add(elementToElement(element)) + result.add(convertElement(element)) } return result } - public fun typeElementToTypeElement(element: PsiTypeElement?): TypeElement { + public fun convertTypeElement(element: PsiTypeElement?): TypeElement { return TypeElement(if (element == null) EmptyType() else - typeToType(element.getType())) + convertType(element.getType())) } - public fun typeToType(`type`: PsiType?): Type { + public fun convertType(`type`: PsiType?): Type { if (`type` == null) return EmptyType() @@ -345,12 +345,12 @@ public class Converter(val project: Project, val settings: ConverterSettings) { return typeVisitor.getResult() } - public fun typesToTypeList(types: Array): List { - return types.map { typeToType(it) } + public fun convertTypes(types: Array): List { + return types.map { convertType(it) } } - public fun typeToType(`type`: PsiType?, notNull: Boolean): Type { - val result: Type = typeToType(`type`) + public fun convertType(`type`: PsiType?, notNull: Boolean): Type { + val result: Type = convertType(`type`) if (notNull) { return result.convertedToNotNull() } @@ -358,25 +358,25 @@ public class Converter(val project: Project, val settings: ConverterSettings) { return result } - private fun typesToNotNullableTypeList(types: Array): List { + private fun convertToNotNullableTypes(types: Array): List { val result = ArrayList() for (aType in types) { - result.add(typeToType(aType).convertedToNotNull()) + result.add(convertType(aType).convertedToNotNull()) } return result } - public fun parametersToParameterList(parameters: Array): List { - return parameters.map { parameterToParameter(it) } + public fun convertParameterList(parameters: Array): List { + return parameters.map { convertParameter(it) } } - public fun parameterToParameter(parameter: PsiParameter, forceNotNull: Boolean = false): Parameter { + public fun convertParameter(parameter: PsiParameter, forceNotNull: Boolean = false): Parameter { return Parameter(Identifier(parameter.getName()!!), - typeToType(parameter.getType(), + convertType(parameter.getType(), forceNotNull || isAnnotatedAsNotNull(parameter.getModifierList())), true) } - public fun argumentsToExpressionList(expression: PsiCallExpression): List { + public fun convertArguments(expression: PsiCallExpression): List { val argumentList: PsiExpressionList? = expression.getArgumentList() val arguments: Array = (if (argumentList != null) argumentList.getExpressions() @@ -391,21 +391,21 @@ public class Converter(val project: Project, val settings: ConverterSettings) { } if (arguments.size == expectedTypes.size()) { - for (i in 0..expectedTypes.size() - 1) result.add(expressionToExpression(arguments[i], expectedTypes.get(i))) + for (i in 0..expectedTypes.size() - 1) result.add(convertExpression(arguments[i], expectedTypes.get(i))) } else { for (argument : PsiExpression? in arguments) { - result.add(expressionToExpression(argument)) + result.add(convertExpression(argument)) } } return result } - public fun expressionToExpression(argument: PsiExpression?, expectedType: PsiType?): Expression { + public fun convertExpression(argument: PsiExpression?, expectedType: PsiType?): Expression { if (argument == null) return Identifier.EMPTY_IDENTIFIER - var expression: Expression = expressionToExpression(argument) + var expression: Expression = convertExpression(argument) val actualType: PsiType? = argument.getType() val isPrimitiveTypeOrNull: Boolean = actualType == null || actualType is PsiPrimitiveType if (isPrimitiveTypeOrNull && expression.isNullable()) { @@ -470,14 +470,14 @@ public class Converter(val project: Project, val settings: ConverterSettings) { } } - public fun identifierToIdentifier(identifier: PsiIdentifier?): Identifier { + public fun convertIdentifier(identifier: PsiIdentifier?): Identifier { if (identifier == null) return Identifier.EMPTY_IDENTIFIER return Identifier(identifier.getText()!!) } - public fun modifiersListToModifiersSet(modifierList: PsiModifierList?): MutableSet { + public fun convertModifierList(modifierList: PsiModifierList?): MutableSet { val modifiersSet: HashSet = hashSetOf() if (modifierList != null) { if (modifierList.hasExplicitModifier(PsiModifier.ABSTRACT)) diff --git a/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt b/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt index 5d87db1eb82..4a491dac4de 100644 --- a/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt +++ b/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt @@ -98,7 +98,7 @@ object JavaToKotlinTranslator { if (file is PsiJavaFile) { val converter = Converter(file.getProject(), TestSettings) setClassIdentifiers(converter, file) - return prettify(converter.fileToFile(file).toKotlin()) + return prettify(converter.convertFile(file).toKotlin()) } return "" } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Imports.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Imports.kt index 60eebe20bfa..c054e93b540 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Imports.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Imports.kt @@ -49,10 +49,10 @@ public class ImportList(val imports: List) : Element { override fun toKotlin() = filteredImports.toKotlin("\n") } -public fun Converter.importsToImportList(importList: PsiImportList): ImportList = - ImportList(importList.getAllImportStatements() map { importToImport(it) }) +public fun Converter.convertImportList(importList: PsiImportList): ImportList = + ImportList(importList.getAllImportStatements() map { convertImport(it) }) -public fun Converter.importToImport(i: PsiImportStatementBase): Import { +public 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/TypeParameters.kt b/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt index 875e72c0868..fedffd4d290 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt @@ -65,11 +65,11 @@ public class TypeParameterList(val parameters: List) : Element { } } -public fun Converter.typeParameterToTypeParameter(psiTypeParameter: PsiTypeParameter): TypeParameter { - return elementToElement(psiTypeParameter) as TypeParameter +public fun Converter.convertTypeParameter(psiTypeParameter: PsiTypeParameter): TypeParameter { + return convertElement(psiTypeParameter) as TypeParameter } -public fun Converter.typeParameterListToTypeParameterList(psiTypeParameterlist: PsiTypeParameterList?): TypeParameterList { +public fun Converter.convertTypeParameterList(psiTypeParameterlist: PsiTypeParameterList?): TypeParameterList { return if (psiTypeParameterlist == null) TypeParameterList.Empty - else TypeParameterList(psiTypeParameterlist.getTypeParameters()!!.toList().map { typeParameterToTypeParameter(it) }) + else TypeParameterList(psiTypeParameterlist.getTypeParameters()!!.toList().map { convertTypeParameter(it) }) } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt index f59aac27513..1d2ec4ed233 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt @@ -34,24 +34,24 @@ public open class ElementVisitor(val myConverter: Converter) : JavaElementVisito public override fun visitLocalVariable(variable: PsiLocalVariable?) { val theVariable = variable!! - var kType = myConverter.typeToType(theVariable.getType(), isAnnotatedAsNotNull(theVariable.getModifierList())) + var kType = myConverter.convertType(theVariable.getType(), isAnnotatedAsNotNull(theVariable.getModifierList())) if (theVariable.hasModifierProperty(PsiModifier.FINAL) && isDefinitelyNotNull(theVariable.getInitializer())) { kType = kType.convertedToNotNull(); } myResult = LocalVariable(Identifier(theVariable.getName()!!), - myConverter.modifiersListToModifiersSet(theVariable.getModifierList()), + myConverter.convertModifierList(theVariable.getModifierList()), kType, - myConverter.expressionToExpression(theVariable.getInitializer(), theVariable.getType()), + myConverter.convertExpression(theVariable.getInitializer(), theVariable.getType()), myConverter) } public override fun visitExpressionList(list: PsiExpressionList?) { - myResult = ExpressionList(myConverter.expressionsToExpressionList(list!!.getExpressions())) + myResult = ExpressionList(myConverter.convertExpressions(list!!.getExpressions())) } public override fun visitReferenceElement(reference: PsiJavaCodeReferenceElement?) { val theReference = reference!! - val types: List = myConverter.typesToTypeList(theReference.getTypeParameters()) + val types: List = myConverter.convertTypes(theReference.getTypeParameters()) if (!theReference.isQualified()) { myResult = ReferenceElement(Identifier(theReference.getReferenceName()!!), types) } @@ -69,16 +69,16 @@ public open class ElementVisitor(val myConverter: Converter) : JavaElementVisito } public override fun visitTypeElement(`type`: PsiTypeElement?) { - myResult = TypeElement(myConverter.typeToType(`type`!!.getType())) + myResult = TypeElement(myConverter.convertType(`type`!!.getType())) } public override fun visitTypeParameter(classParameter: PsiTypeParameter?) { myResult = TypeParameter(Identifier(classParameter!!.getName()!!), - classParameter.getExtendsListTypes().map { myConverter.typeToType(it) }) + classParameter.getExtendsListTypes().map { myConverter.convertType(it) }) } public override fun visitParameterList(list: PsiParameterList?) { - myResult = ParameterList(myConverter.parametersToParameterList(list!!.getParameters()).requireNoNulls()) + myResult = ParameterList(myConverter.convertParameterList(list!!.getParameters()).requireNoNulls()) } public override fun visitComment(comment: PsiComment?) { diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt index 6f1079958b2..aeccd81ce8e 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt @@ -41,16 +41,16 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con public override fun visitArrayAccessExpression(expression: PsiArrayAccessExpression?) { val assignment = PsiTreeUtil.getParentOfType(expression, javaClass()) val lvalue = assignment != null && expression == assignment.getLExpression(); - myResult = ArrayAccessExpression(getConverter().expressionToExpression(expression?.getArrayExpression()), - getConverter().expressionToExpression(expression?.getIndexExpression()), + myResult = ArrayAccessExpression(getConverter().convertExpression(expression?.getArrayExpression()), + getConverter().convertExpression(expression?.getIndexExpression()), lvalue) } public override fun visitArrayInitializerExpression(expression: PsiArrayInitializerExpression?) { - val expressionType = getConverter().typeToType(expression?.getType()) + val expressionType = getConverter().convertType(expression?.getType()) assert(expressionType is ArrayType) { "Array initializer must have array type" } myResult = ArrayInitializerExpression(expressionType as ArrayType, - getConverter().expressionsToExpressionList(expression?.getInitializers()!!)) + getConverter().convertExpressions(expression?.getInitializers()!!)) } public override fun visitAssignmentExpression(expression: PsiAssignmentExpression?) { @@ -65,8 +65,8 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con else -> "" } - val lhs = getConverter().expressionToExpression(expression?.getLExpression()!!) - val rhs = getConverter().expressionToExpression(expression?.getRExpression()!!, expression?.getLExpression()?.getType()) + val lhs = getConverter().convertExpression(expression?.getLExpression()!!) + val rhs = getConverter().convertExpression(expression?.getRExpression()!!, expression?.getLExpression()?.getType()) if (!secondOp.isEmpty()) { myResult = AssignmentExpression(lhs, BinaryExpression(lhs, rhs, secondOp), "=") } @@ -76,8 +76,8 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con } public override fun visitBinaryExpression(expression: PsiBinaryExpression?) { - val lhs = getConverter().expressionToExpression(expression?.getLOperand()!!, expression?.getType()) - val rhs = getConverter().expressionToExpression(expression?.getROperand(), expression?.getType()) + val lhs = getConverter().convertExpression(expression?.getLOperand()!!, expression?.getType()) + val rhs = getConverter().convertExpression(expression?.getROperand(), expression?.getType()) if (expression?.getOperationSign()?.getTokenType() == JavaTokenType.GTGTGT) { myResult = MethodCallExpression.build(lhs, "ushr", arrayList(rhs)) } @@ -88,29 +88,29 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con } public override fun visitClassObjectAccessExpression(expression: PsiClassObjectAccessExpression?) { - myResult = ClassObjectAccessExpression(getConverter().typeElementToTypeElement(expression?.getOperand())) + myResult = ClassObjectAccessExpression(getConverter().convertTypeElement(expression?.getOperand())) } public override fun visitConditionalExpression(expression: PsiConditionalExpression?) { val condition: PsiExpression? = expression?.getCondition() val `type`: PsiType? = condition?.getType() val e: Expression = (if (`type` != null) - getConverter().expressionToExpression(condition, `type`) + getConverter().convertExpression(condition, `type`) else - getConverter().expressionToExpression(condition)) + getConverter().convertExpression(condition)) myResult = ParenthesizedExpression(IfStatement(e, - getConverter().expressionToExpression(expression?.getThenExpression()), - getConverter().expressionToExpression(expression?.getElseExpression()))) + getConverter().convertExpression(expression?.getThenExpression()), + getConverter().convertExpression(expression?.getElseExpression()))) } public override fun visitExpressionList(list: PsiExpressionList?) { - myResult = ExpressionList(getConverter().expressionsToExpressionList(list!!.getExpressions())) + myResult = ExpressionList(getConverter().convertExpressions(list!!.getExpressions())) } public override fun visitInstanceOfExpression(expression: PsiInstanceOfExpression?) { val checkType: PsiTypeElement? = expression?.getCheckType() - myResult = IsOperator(getConverter().expressionToExpression(expression?.getOperand()), - myConverter.typeElementToTypeElement(checkType)) + myResult = IsOperator(getConverter().convertExpression(expression?.getOperand()), + myConverter.convertTypeElement(checkType)) } public override fun visitLiteralExpression(expression: PsiLiteralExpression?) { @@ -149,10 +149,10 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con protected fun convertMethodCallExpression(expression: PsiMethodCallExpression) { if (!SuperVisitor.isSuper(expression.getMethodExpression()) || !isInsidePrimaryConstructor(expression)) { - myResult = MethodCallExpression(getConverter().expressionToExpression(expression.getMethodExpression()), - getConverter().argumentsToExpressionList(expression), - getConverter().typesToTypeList(expression.getTypeArguments()), - getConverter().typeToType(expression.getType()).nullable) + myResult = MethodCallExpression(getConverter().convertExpression(expression.getMethodExpression()), + getConverter().convertArguments(expression), + getConverter().convertTypes(expression.getTypeArguments()), + getConverter().convertType(expression.getType()).nullable) } } @@ -183,45 +183,45 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con array()) if (constructor == null || isConstructorPrimary(constructor) || isNotConvertedClass) { - return NewClassExpression(getConverter().elementToElement(classReference), - getConverter().argumentsToExpressionList(expression!!), - getConverter().expressionToExpression(expression.getQualifier()), + return NewClassExpression(getConverter().convertElement(classReference), + getConverter().convertArguments(expression!!), + getConverter().convertExpression(expression.getQualifier()), (if (anonymousClass != null) - getConverter().anonymousClassToAnonymousClass(anonymousClass) + getConverter().convertAnonymousClass(anonymousClass) else null)) } val reference: PsiJavaCodeReferenceElement? = expression?.getClassReference() val typeParameters: List = (if (reference != null) - getConverter().typesToTypeList(reference.getTypeParameters()) + getConverter().convertTypes(reference.getTypeParameters()) else Collections.emptyList()) return CallChainExpression(Identifier(constructor.getName(), false), - MethodCallExpression(Identifier("init"), getConverter().expressionsToExpressionList(arguments), typeParameters, false)) + MethodCallExpression(Identifier("init"), getConverter().convertExpressions(arguments), typeParameters, false)) } private fun createNewEmptyArrayWithoutInitialization(expression: PsiNewExpression): Expression { return ArrayWithoutInitializationExpression( - getConverter().typeToType(expression.getType(), true), - getConverter().expressionsToExpressionList(expression.getArrayDimensions())) + getConverter().convertType(expression.getType(), true), + getConverter().convertExpressions(expression.getArrayDimensions())) } private fun createNewEmptyArray(expression: PsiNewExpression?): Expression { - return getConverter().expressionToExpression(expression?.getArrayInitializer()) + return getConverter().convertExpression(expression?.getArrayInitializer()) } public override fun visitParenthesizedExpression(expression: PsiParenthesizedExpression?) { - myResult = ParenthesizedExpression(getConverter().expressionToExpression(expression?.getExpression())) + myResult = ParenthesizedExpression(getConverter().convertExpression(expression?.getExpression())) } public override fun visitPostfixExpression(expression: PsiPostfixExpression?) { myResult = PostfixOperator(getOperatorString(expression!!.getOperationSign().getTokenType()!!), - getConverter().expressionToExpression(expression.getOperand())) + getConverter().convertExpression(expression.getOperand())) } public override fun visitPrefixExpression(expression: PsiPrefixExpression?) { - val operand = getConverter().expressionToExpression(expression?.getOperand(), expression?.getOperand()!!.getType()) + val operand = getConverter().convertExpression(expression?.getOperand(), expression?.getOperand()!!.getType()) val token = expression?.getOperationTokenType()!! if (token == JavaTokenType.TILDE) { myResult = MethodCallExpression.build(ParenthesizedExpression(operand), "inv", arrayList()) @@ -237,7 +237,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con val hasReceiver: Boolean = isFieldReference && insideSecondaryConstructor val isThis: Boolean = isThisExpression(expression) val notNull = isResolvedToNotNull(expression) - val isNullable: Boolean = getConverter().typeToType(expression.getType(), notNull).nullable + val isNullable: Boolean = getConverter().convertType(expression.getType(), notNull).nullable val className: String = getClassNameWithConstructor(expression) val referencedName = expression.getReferenceName()!! var identifier: Expression = Identifier(referencedName, isNullable) @@ -277,7 +277,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con } } - myResult = CallChainExpression(getConverter().expressionToExpression(qualifier), identifier) + myResult = CallChainExpression(getConverter().convertExpression(qualifier), identifier) } private fun isResolvedToNotNull(expression: PsiReference): Boolean { @@ -315,11 +315,11 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con val typeText = castType.getType().getCanonicalText() val typeConversion = PRIMITIVE_TYPE_CONVERSIONS[typeText] if (operandType is PsiPrimitiveType && typeConversion != null) { - myResult = MethodCallExpression.build(getConverter().expressionToExpression(operand), typeConversion) + myResult = MethodCallExpression.build(getConverter().convertExpression(operand), typeConversion) } else { - myResult = TypeCastExpression(getConverter().typeToType(castType.getType()), - getConverter().expressionToExpression(operand)) + myResult = TypeCastExpression(getConverter().convertType(castType.getType()), + getConverter().convertExpression(operand)) } } } @@ -327,7 +327,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con public override fun visitPolyadicExpression(expression: PsiPolyadicExpression?) { var parameters = ArrayList() for (operand : PsiExpression in expression?.getOperands()!!) { - parameters.add(getConverter().expressionToExpression(operand, expression?.getType())) + parameters.add(getConverter().convertExpression(operand, expression?.getType())) } myResult = PolyadicExpression(parameters, getOperatorString(expression?.getOperationTokenType()!!)) } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.kt index 65581805896..28480fbecd4 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.kt +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.kt @@ -30,7 +30,7 @@ public open class ExpressionVisitorForDirectObjectInheritors(converter: Converte myResult = MethodCallExpression.build(Identifier("System", false), "identityHashCode", arrayList(Identifier("this"))) } else if (superMethodInvocation(methodExpression, "equals")) { - myResult = MethodCallExpression.build(Identifier("this", false), "identityEquals", getConverter().argumentsToExpressionList(expression!!)) + myResult = MethodCallExpression.build(Identifier("this", false), "identityEquals", getConverter().convertArguments(expression!!)) } else if (superMethodInvocation(methodExpression, "toString")) { myResult = DummyStringExpression(java.lang.String.format("getJavaClass<%s>.getName() + '@' + Integer.toHexString(hashCode())", diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt index 4c9536ee703..7ac3ae93911 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt @@ -25,12 +25,12 @@ import java.util.ArrayList public open class StatementVisitor(converter: Converter) : ElementVisitor(converter) { public override fun visitAssertStatement(statement: PsiAssertStatement?) { - myResult = AssertStatement(getConverter().expressionToExpression(statement?.getAssertCondition()), - getConverter().expressionToExpression(statement?.getAssertDescription())) + myResult = AssertStatement(getConverter().convertExpression(statement?.getAssertCondition()), + getConverter().convertExpression(statement?.getAssertDescription())) } public override fun visitBlockStatement(statement: PsiBlockStatement?) { - myResult = getConverter().blockToBlock(statement?.getCodeBlock(), true) + myResult = getConverter().convertBlock(statement?.getCodeBlock(), true) } public override fun visitBreakStatement(statement: PsiBreakStatement?) { @@ -39,7 +39,7 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver } else { - myResult = BreakStatement(getConverter().identifierToIdentifier(statement?.getLabelIdentifier())) + myResult = BreakStatement(getConverter().convertIdentifier(statement?.getLabelIdentifier())) } } @@ -50,29 +50,29 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver } else { - myResult = ContinueStatement(getConverter().identifierToIdentifier(statement?.getLabelIdentifier())) + myResult = ContinueStatement(getConverter().convertIdentifier(statement?.getLabelIdentifier())) } } public override fun visitDeclarationStatement(statement: PsiDeclarationStatement?) { - myResult = DeclarationStatement(getConverter().elementsToElementList(statement?.getDeclaredElements()!!)) + myResult = DeclarationStatement(getConverter().convertElements(statement?.getDeclaredElements()!!)) } public override fun visitDoWhileStatement(statement: PsiDoWhileStatement?) { val condition: PsiExpression? = statement?.getCondition() val expression: Expression = (if (condition != null && condition.getType() != null) - getConverter().expressionToExpression(condition, condition.getType()) + getConverter().convertExpression(condition, condition.getType()) else - getConverter().expressionToExpression(condition)) - myResult = DoWhileStatement(expression, getConverter().statementToStatement(statement?.getBody())) + getConverter().convertExpression(condition)) + myResult = DoWhileStatement(expression, getConverter().convertStatement(statement?.getBody())) } public override fun visitExpressionStatement(statement: PsiExpressionStatement?) { - myResult = getConverter().expressionToExpression(statement?.getExpression()) + myResult = getConverter().convertExpression(statement?.getExpression()) } public override fun visitExpressionListStatement(statement: PsiExpressionListStatement?) { - myResult = ExpressionListStatement(getConverter().expressionsToExpressionList( + myResult = ExpressionListStatement(getConverter().convertExpressions( statement?.getExpressionList()?.getExpressions()!!)) } @@ -98,65 +98,65 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver (isPlusPlusExpression(update.getChildren()[0])) && (operationTokenType == JavaTokenType.LT || operationTokenType == JavaTokenType.LE) && initialization.getFirstChild() != null && (initialization.getFirstChild() is PsiLocalVariable) && firstChild != null && firstChild.getNameIdentifier() != null && onceWritableIterator) { - val end = getConverter().expressionToExpression((condition as PsiBinaryExpression).getROperand()) + val end = getConverter().convertExpression((condition as PsiBinaryExpression).getROperand()) val endExpression = (if (operationTokenType == JavaTokenType.LT) BinaryExpression(end, Identifier("1"), "-") else end) myResult = ForeachWithRangeStatement(Identifier(firstChild.getName()!!), - getConverter().expressionToExpression(firstChild.getInitializer()), + getConverter().convertExpression(firstChild.getInitializer()), endExpression, - getConverter().statementToStatement(body)) + getConverter().convertStatement(body)) } else { var forStatements = ArrayList() - forStatements.add(getConverter().statementToStatement(initialization)) + forStatements.add(getConverter().convertStatement(initialization)) forStatements.add(WhileStatement( if (condition == null) LiteralExpression("true") else - getConverter().expressionToExpression(condition), - Block(arrayListOf(getConverter().statementToStatement(body), - Block(arrayListOf(getConverter().statementToStatement(update)), false)), false))) + getConverter().convertExpression(condition), + Block(arrayListOf(getConverter().convertStatement(body), + Block(arrayListOf(getConverter().convertStatement(update)), false)), false))) myResult = Block(forStatements, false) } } public override fun visitForeachStatement(statement: PsiForeachStatement?) { val iterator = { - val iteratorExpr = getConverter().expressionToExpression(statement?.getIteratedValue()) + val iteratorExpr = getConverter().convertExpression(statement?.getIteratedValue()) if (iteratorExpr.isNullable()) BangBangExpression(iteratorExpr) else iteratorExpr }() - myResult = ForeachStatement(getConverter().parameterToParameter(statement?.getIterationParameter()!!), + myResult = ForeachStatement(getConverter().convertParameter(statement?.getIterationParameter()!!), iterator, - getConverter().statementToStatement(statement?.getBody())) + getConverter().convertStatement(statement?.getBody())) } public override fun visitIfStatement(statement: PsiIfStatement?) { val condition: PsiExpression? = statement?.getCondition() - val expression: Expression = getConverter().expressionToExpression(condition, PsiType.BOOLEAN) + val expression: Expression = getConverter().convertExpression(condition, PsiType.BOOLEAN) myResult = IfStatement(expression, - getConverter().statementToStatement(statement?.getThenBranch()), - getConverter().statementToStatement(statement?.getElseBranch())) + getConverter().convertStatement(statement?.getThenBranch()), + getConverter().convertStatement(statement?.getElseBranch())) } public override fun visitLabeledStatement(statement: PsiLabeledStatement?) { - myResult = LabelStatement(getConverter().identifierToIdentifier(statement?.getLabelIdentifier()), - getConverter().statementToStatement(statement?.getStatement())) + myResult = LabelStatement(getConverter().convertIdentifier(statement?.getLabelIdentifier()), + getConverter().convertStatement(statement?.getStatement())) } public override fun visitSwitchLabelStatement(statement: PsiSwitchLabelStatement?) { myResult = (if (statement?.isDefaultCase()!!) DefaultSwitchLabelStatement() else - SwitchLabelStatement(getConverter().expressionToExpression(statement?.getCaseValue()))) + SwitchLabelStatement(getConverter().convertExpression(statement?.getCaseValue()))) } public override fun visitSwitchStatement(statement: PsiSwitchStatement?) { - myResult = SwitchContainer(getConverter().expressionToExpression(statement?.getExpression()), + myResult = SwitchContainer(getConverter().convertExpression(statement?.getExpression()), switchBodyToCases(statement?.getBody())) } @@ -179,21 +179,21 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver // TODO assert {(label is PsiSwitchLabelStatement?)} // TODO assert("not a right index") {allSwitchStatements?.get(i) == label} if (ls.size() > 1) { - pendingLabels.add(getConverter().statementToStatement(label)) + pendingLabels.add(getConverter().convertStatement(label)) val slice: List = ls.subList(1, (ls.size())) if (!containsBreak(slice)) { - val statements = ArrayList(getConverter().statementsToStatementList(slice)) - statements.addAll(getConverter().statementsToStatementList(getAllToNextBreak(allSwitchStatements, i + ls.size()))) + val statements = ArrayList(getConverter().convertStatements(slice)) + statements.addAll(getConverter().convertStatements(getAllToNextBreak(allSwitchStatements, i + ls.size()))) result.add(CaseContainer(pendingLabels, statements)) pendingLabels = ArrayList() } else { - result.add(CaseContainer(pendingLabels, getConverter().statementsToStatementList(slice))) + result.add(CaseContainer(pendingLabels, getConverter().convertStatements(slice))) pendingLabels = ArrayList() } } else { - pendingLabels.add(getConverter().statementToStatement(label)) + pendingLabels.add(getConverter().convertStatement(label)) } i += ls.size() } @@ -204,12 +204,12 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver } public override fun visitSynchronizedStatement(statement: PsiSynchronizedStatement?) { - myResult = SynchronizedStatement(getConverter().expressionToExpression(statement?.getLockExpression()), - getConverter().blockToBlock(statement?.getBody())) + myResult = SynchronizedStatement(getConverter().convertExpression(statement?.getLockExpression()), + getConverter().convertBlock(statement?.getBody())) } public override fun visitThrowStatement(statement: PsiThrowStatement?) { - myResult = ThrowStatement(getConverter().expressionToExpression(statement?.getException())) + myResult = ThrowStatement(getConverter().convertExpression(statement?.getException())) } public override fun visitTryStatement(statement: PsiTryStatement?) { @@ -217,29 +217,29 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver val catchBlocks = statement?.getCatchBlocks()!! val catchBlockParameters = statement?.getCatchBlockParameters()!! for (i in 0..catchBlocks.size - 1) { - catches.add(CatchStatement(getConverter().parameterToParameter(catchBlockParameters[i], true), - getConverter().blockToBlock(catchBlocks[i], true))) + catches.add(CatchStatement(getConverter().convertParameter(catchBlockParameters[i], true), + getConverter().convertBlock(catchBlocks[i], true))) } - myResult = TryStatement(getConverter().blockToBlock(statement?.getTryBlock(), true), - catches, getConverter().blockToBlock(statement?.getFinallyBlock(), true)) + myResult = TryStatement(getConverter().convertBlock(statement?.getTryBlock(), true), + catches, getConverter().convertBlock(statement?.getFinallyBlock(), true)) } public override fun visitWhileStatement(statement: PsiWhileStatement?) { var condition: PsiExpression? = statement?.getCondition() val expression: Expression = (if (condition != null && condition?.getType() != null) - this.getConverter().expressionToExpression(condition, condition?.getType()) + this.getConverter().convertExpression(condition, condition?.getType()) else - getConverter().expressionToExpression(condition)) - myResult = WhileStatement(expression, getConverter().statementToStatement(statement?.getBody())) + getConverter().convertExpression(condition)) + myResult = WhileStatement(expression, getConverter().convertStatement(statement?.getBody())) } public override fun visitReturnStatement(statement: PsiReturnStatement?) { val returnValue: PsiExpression? = statement?.getReturnValue() val methodReturnType: PsiType? = getConverter().methodReturnType val expression: Expression = (if (returnValue != null && methodReturnType != null) - this.getConverter().expressionToExpression(returnValue, methodReturnType) + this.getConverter().convertExpression(returnValue, methodReturnType) else - getConverter().expressionToExpression(returnValue)) + getConverter().convertExpression(returnValue)) myResult = ReturnStatement(expression) } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt index 07e49dcfa65..25005fb582e 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt @@ -50,7 +50,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit public override fun visitArrayType(arrayType: PsiArrayType?): Type { if (myResult is EmptyType) { - myResult = ArrayType(myConverter.typeToType(arrayType?.getComponentType()), true, myConverter) + myResult = ArrayType(myConverter.convertType(arrayType?.getComponentType()), true, myConverter) } return myResult @@ -76,7 +76,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit } } else { - myResult = ClassType(identifier, myConverter.typesToTypeList(classType.getParameters()), true, myConverter) + myResult = ClassType(identifier, myConverter.convertTypes(classType.getParameters()), true, myConverter) } return myResult } @@ -118,7 +118,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit val superTypes = p!!.getSuperTypes() val boundType: Type = (if (superTypes.size > 0) ClassType(Identifier(getClassTypeName(superTypes[0])), - myConverter.typesToTypeList(superTypes[0].getParameters()), + myConverter.convertTypes(superTypes[0].getParameters()), true, myConverter) else StarProjectionType()) @@ -132,11 +132,11 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit public override fun visitWildcardType(wildcardType: PsiWildcardType?): Type { if (wildcardType!!.isExtends()) { - myResult = OutProjectionType(myConverter.typeToType(wildcardType.getExtendsBound())) + myResult = OutProjectionType(myConverter.convertType(wildcardType.getExtendsBound())) } else if (wildcardType.isSuper()) { - myResult = InProjectionType(myConverter.typeToType(wildcardType.getSuperBound())) + myResult = InProjectionType(myConverter.convertType(wildcardType.getSuperBound())) } else { myResult = StarProjectionType() @@ -145,7 +145,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit } public override fun visitEllipsisType(ellipsisType: PsiEllipsisType?): Type { - myResult = VarArg(myConverter.typeToType(ellipsisType?.getComponentType())) + myResult = VarArg(myConverter.convertType(ellipsisType?.getComponentType())) return myResult }