From 600446bbd2d089f47d1bf9700cc81b16dfe468db Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Tue, 17 Jun 2014 13:32:03 +0400 Subject: [PATCH] Java to Kotlin converter: working on not loosing comments - refactored redundant .toKotlin() calls --- .../actions/JavaToKotlinActionUtil.java | 2 +- j2k/src/org/jetbrains/jet/j2k/Converter.kt | 63 ++++++++++--------- .../jet/j2k/JavaToKotlinTranslator.kt | 2 +- j2k/src/org/jetbrains/jet/j2k/Utils.kt | 27 ++++---- .../org/jetbrains/jet/j2k/ast/Constructors.kt | 6 +- .../org/jetbrains/jet/j2k/ast/Expressions.kt | 6 +- j2k/src/org/jetbrains/jet/j2k/ast/Field.kt | 2 +- .../org/jetbrains/jet/j2k/ast/Identifier.kt | 8 ++- j2k/src/org/jetbrains/jet/j2k/ast/Types.kt | 10 +-- .../jet/j2k/visitors/ElementVisitor.kt | 4 +- .../jet/j2k/visitors/ExpressionVisitor.kt | 8 +-- .../jet/j2k/visitors/StatementVisitor.kt | 2 +- .../jetbrains/jet/j2k/visitors/TypeVisitor.kt | 4 +- 13 files changed, 75 insertions(+), 69 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java b/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java index e52740e2a0b..5047f3e56f0 100644 --- a/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java @@ -124,7 +124,7 @@ public class JavaToKotlinActionUtil { if (psiFile instanceof PsiJavaFile && virtualFile != null) { String result = ""; try { - result = converter.convertFile((PsiJavaFile) psiFile).toKotlin(); + result = converter.elementToKotlin(psiFile); } 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 77ffac60388..c0921baa502 100644 --- a/j2k/src/org/jetbrains/jet/j2k/Converter.kt +++ b/j2k/src/org/jetbrains/jet/j2k/Converter.kt @@ -60,7 +60,7 @@ public class Converter private(val project: Project, val settings: ConverterSett = Converter(project, settings, conversionScope, State(typeConverter, state.methodReturnType, state.expressionVisitorFactory, factory)) public fun elementToKotlin(element: PsiElement): String - = convertTopElement(element)?.toKotlin() ?: "" + = convertTopElement(element)?.toKotlin(/*CommentConverter(element)*/) ?: "" private fun convertTopElement(element: PsiElement?): Element? = when(element) { is PsiJavaFile -> convertFile(element) @@ -69,7 +69,7 @@ public class Converter private(val project: Project, val settings: ConverterSett is PsiField -> convertField(element) is PsiStatement -> convertStatement(element) is PsiExpression -> convertExpression(element) - is PsiComment -> Comment(element.getText()!!) + is PsiComment -> Comment(element.getText()!!/*, listOf(element)*/) is PsiImportList -> convertImportList(element) is PsiImportStatementBase -> convertImport(element, false) is PsiAnnotation -> convertAnnotation(element, false) @@ -78,7 +78,7 @@ public class Converter private(val project: Project, val settings: ConverterSett else -> null } - public fun convertFile(javaFile: PsiJavaFile): File { + fun convertFile(javaFile: PsiJavaFile): File { var convertedChildren = javaFile.getChildren().map { if (it is PsiImportList) { val importList = convertImportList(it) @@ -100,7 +100,7 @@ public class Converter private(val project: Project, val settings: ConverterSett return File(FileMemberList(convertedChildren), createMainFunction(javaFile)) } - public fun convertAnonymousClassBody(anonymousClass: PsiAnonymousClass): AnonymousClassBody { + fun convertAnonymousClassBody(anonymousClass: PsiAnonymousClass): AnonymousClassBody { return AnonymousClassBody(convertClassBody(anonymousClass), anonymousClass.getBaseClassType().resolve()?.isInterface() ?: false) } @@ -248,13 +248,13 @@ public class Converter private(val project: Project, val settings: ConverterSett private fun generateArtificialPrimaryConstructor(className: Identifier, classBody: ClassBody): ClassBody { assert(classBody.primaryConstructor == null) - val finalOrWithEmptyInitializerFields = classBody.normalMembers.members.filterIsInstance(javaClass()).filter { it.isVal || it.initializer.toKotlin().isEmpty() } - val initializers = HashMap() + val finalOrWithEmptyInitializerFields = classBody.normalMembers.members.filterIsInstance(javaClass()).filter { it.isVal || it.initializer.isEmpty } + val initializers = HashMap() for (constructor in classBody.secondaryConstructors.members) { constructor as SecondaryConstructor for (field in finalOrWithEmptyInitializerFields) { - initializers.put(field.identifier.toKotlin(), getDefaultInitializer(field)) + initializers.put(field, getDefaultInitializer(field)) } val newStatements = ArrayList() @@ -262,11 +262,11 @@ public class Converter private(val project: Project, val settings: ConverterSett var keepStatement = true if (statement is AssignmentExpression) { val assignee = statement.left - if (assignee is QualifiedExpression) { + if (assignee is QualifiedExpression && (assignee.qualifier as? Identifier)?.name == SecondaryConstructor.tempValIdentifier.name) { + val name = (assignee.identifier as Identifier).name for (field in finalOrWithEmptyInitializerFields) { - val id = field.identifier.toKotlin() - if (assignee.identifier.toKotlin().endsWith("." + id)) { - initializers.put(id, statement.right.toKotlin()) + if (name == field.identifier.name) { + initializers.put(field, statement.right) keepStatement = false } @@ -280,7 +280,16 @@ public class Converter private(val project: Project, val settings: ConverterSett } } - newStatements.add(0, DummyStringExpression("val __ = " + createPrimaryConstructorInvocation(className.toKotlin(), finalOrWithEmptyInitializerFields, initializers))) + + val initializer = MethodCallExpression.buildNotNull(null, className.name, finalOrWithEmptyInitializerFields.map { initializers[it]!! }) + val localVar = LocalVariable(SecondaryConstructor.tempValIdentifier, + Annotations.Empty, + setOf(), + { ClassType(className, listOf(), Nullability.NotNull, settings) }, + initializer, + true, + settings) + newStatements.add(0, DeclarationStatement(listOf(localVar))) constructor.block = Block(newStatements) } @@ -506,7 +515,7 @@ public class Converter private(val project: Project, val settings: ConverterSett return null } - public fun convertBlock(block: PsiCodeBlock?, notEmpty: Boolean = true, statementFilter: (PsiStatement) -> Boolean = {true}): Block { + fun convertBlock(block: PsiCodeBlock?, notEmpty: Boolean = true, statementFilter: (PsiStatement) -> Boolean = {true}): Block { if (block == null) return Block.Empty val filteredChildren = block.getChildren().filter { it !is PsiStatement || statementFilter(it) } @@ -514,7 +523,7 @@ public class Converter private(val project: Project, val settings: ConverterSett return Block(statementList, notEmpty) } - public fun convertStatement(statement: PsiStatement?): Statement { + fun convertStatement(statement: PsiStatement?): Statement { if (statement == null) return Statement.Empty statementVisitor.reset() @@ -522,10 +531,10 @@ public class Converter private(val project: Project, val settings: ConverterSett return statementVisitor.result } - public fun convertExpressions(expressions: Array): List + fun convertExpressions(expressions: Array): List = expressions.map { convertExpression(it) } - public fun convertExpression(expression: PsiExpression?): Expression { + fun convertExpression(expression: PsiExpression?): Expression { if (expression == null) return Expression.Empty expressionVisitor.reset() @@ -533,7 +542,7 @@ public class Converter private(val project: Project, val settings: ConverterSett return expressionVisitor.result } - public fun convertElement(element: PsiElement?): Element { + fun convertElement(element: PsiElement?): Element { if (element == null) return Element.Empty val elementVisitor = ElementVisitor(this) @@ -541,16 +550,16 @@ public class Converter private(val project: Project, val settings: ConverterSett return elementVisitor.result } - public fun convertTypeElement(element: PsiTypeElement?): TypeElement + fun convertTypeElement(element: PsiTypeElement?): TypeElement = TypeElement(if (element == null) Type.Empty else typeConverter.convertType(element.getType())) private fun convertToNotNullableTypes(types: Array): List = types.map { typeConverter.convertType(it, Nullability.NotNull) } - public fun convertParameterList(parameterList: PsiParameterList): ParameterList + fun convertParameterList(parameterList: PsiParameterList): ParameterList = ParameterList(parameterList.getParameters().map { convertParameter(it) }) - public fun convertParameter(parameter: PsiParameter, + fun convertParameter(parameter: PsiParameter, nullability: Nullability = Nullability.Default, varValModifier: Parameter.VarValModifier = Parameter.VarValModifier.None, modifiers: Collection = listOf()): Parameter { @@ -562,7 +571,7 @@ public class Converter private(val project: Project, val settings: ConverterSett return Parameter(Identifier(parameter.getName()!!), `type`, varValModifier, convertAnnotations(parameter), modifiers) } - public fun convertExpression(argument: PsiExpression?, expectedType: PsiType?): Expression { + fun convertExpression(argument: PsiExpression?, expectedType: PsiType?): Expression { if (argument == null) return Identifier.Empty var expression = convertExpression(argument) @@ -590,17 +599,13 @@ public class Converter private(val project: Project, val settings: ConverterSett return expression } - private fun createPrimaryConstructorInvocation(s: String, fields: List, initializers: Map): String { - 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 convertModifiers(owner: PsiModifierListOwner): MutableSet + fun convertModifiers(owner: PsiModifierListOwner): MutableSet = HashSet(MODIFIERS_MAP.filter { owner.hasModifierProperty(it.first) }.map { it.second }) private val MODIFIERS_MAP = listOf( @@ -610,7 +615,7 @@ public class Converter private(val project: Project, val settings: ConverterSett PsiModifier.PRIVATE to Modifier.PRIVATE ) - public fun convertAnnotations(owner: PsiModifierListOwner): Annotations { + fun convertAnnotations(owner: PsiModifierListOwner): Annotations { val modifierList = owner.getModifierList() val annotations = modifierList?.getAnnotations()?.filter { it.getQualifiedName() !in ANNOTATIONS_TO_REMOVE } if (annotations == null || annotations.isEmpty()) return Annotations.Empty @@ -633,7 +638,7 @@ public class Converter private(val project: Project, val settings: ConverterSett return Annotations(list, newLines) } - public fun convertAnnotation(annotation: PsiAnnotation, brackets: Boolean): Annotation? { + private fun convertAnnotation(annotation: PsiAnnotation, brackets: Boolean): Annotation? { val qualifiedName = annotation.getQualifiedName() if (qualifiedName == CommonClassNames.JAVA_LANG_DEPRECATED && annotation.getParameterList().getAttributes().isEmpty()) { return Annotation(Identifier("deprecated"), listOf(null to LiteralExpression("\"\"")), brackets) //TODO: insert comment diff --git a/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt b/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt index 355a5d846c5..8c97cd0e710 100644 --- a/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt +++ b/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt @@ -90,7 +90,7 @@ public object JavaToKotlinTranslator { val file = createFile(javaCode) if (file is PsiJavaFile) { val converter = Converter.create(file.getProject(), ConverterSettings.defaultSettings, FilesConversionScope(listOf(file))) - return prettify(converter.convertFile(file).toKotlin()) + return prettify(converter.elementToKotlin(file)) } return "" } diff --git a/j2k/src/org/jetbrains/jet/j2k/Utils.kt b/j2k/src/org/jetbrains/jet/j2k/Utils.kt index d887d22b105..196db199a0d 100644 --- a/j2k/src/org/jetbrains/jet/j2k/Utils.kt +++ b/j2k/src/org/jetbrains/jet/j2k/Utils.kt @@ -16,14 +16,12 @@ package org.jetbrains.jet.j2k -import org.jetbrains.jet.j2k.ast.Identifier -import org.jetbrains.jet.j2k.ast.Field import org.jetbrains.jet.lang.types.expressions.OperatorConventions -import org.jetbrains.jet.j2k.ast.Nullability import com.intellij.psi.* import com.intellij.psi.util.PsiUtil import com.intellij.psi.search.LocalSearchScope import com.intellij.psi.search.searches.ReferencesSearch +import org.jetbrains.jet.j2k.ast.* fun quoteKeywords(packageName: String): String = packageName.split("\\.").map { Identifier(it).toKotlin() }.makeString(".") @@ -59,19 +57,22 @@ fun PsiModifierListOwner.nullabilityFromAnnotations(): Nullability { Nullability.Default } -fun getDefaultInitializer(field: Field): String { - if (field.`type`.isNullable) { - return "null" +fun getDefaultInitializer(field: Field): Expression { + val t = field.`type` + if (t.isNullable) { + return LiteralExpression("null") } - else { - return when(field.`type`.toKotlin()) { - "Boolean" -> "false" - "Char" -> "' '" - "Double" -> "0." + OperatorConventions.DOUBLE + "()" - "Float" -> "0." + OperatorConventions.FLOAT + "()" - else -> "0" + + if (t is PrimitiveType) { + when(t.`type`.name) { + "Boolean" -> return LiteralExpression("false") + "Char" -> return LiteralExpression("' '") + "Double" -> return MethodCallExpression.buildNotNull(LiteralExpression("0"), OperatorConventions.DOUBLE.toString()) + "Float" -> return MethodCallExpression.buildNotNull(LiteralExpression("0"), OperatorConventions.FLOAT.toString()) } } + + return LiteralExpression("0") } fun isQualifierEmptyOrThis(ref: PsiReferenceExpression): Boolean { diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Constructors.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Constructors.kt index 2fdef678779..bd33205e1cd 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Constructors.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Constructors.kt @@ -57,7 +57,7 @@ class SecondaryConstructor(converter: Converter, public fun toInitFunction(containingClass: Class): Function { val modifiers = HashSet(modifiers) val statements = ArrayList(block?.statements ?: listOf()) - statements.add(ReturnStatement(Identifier("__"))) + statements.add(ReturnStatement(tempValIdentifier)) val block = Block(statements) val typeParameters = ArrayList() typeParameters.addAll(containingClass.typeParameterList.parameters) @@ -65,4 +65,8 @@ class SecondaryConstructor(converter: Converter, ClassType(containingClass.name, typeParameters, Nullability.NotNull, converter.settings), TypeParameterList(typeParameters), parameterList, block, false) } + + class object { + public val tempValIdentifier: Identifier = Identifier("__", false) + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt index e1e5d1ead1e..d5eb98c534b 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt @@ -71,13 +71,13 @@ class SuperExpression(val identifier: Identifier) : Expression() { override fun toKotlin() = "super" + identifier.withPrefix("@") } -class QualifiedExpression(val expression: Expression, val identifier: Expression) : Expression() { +class QualifiedExpression(val qualifier: Expression, val identifier: Expression) : Expression() { override val isNullable: Boolean get() = identifier.isNullable override fun toKotlin(): String { - if (!expression.isEmpty) { - return operandToKotlin(expression) + (if (expression.isNullable) "!!." else ".") + identifier.toKotlin() + if (!qualifier.isEmpty) { + return operandToKotlin(qualifier) + (if (qualifier.isNullable) "!!." else ".") + identifier.toKotlin() } return identifier.toKotlin() diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Field.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Field.kt index 8e34ece0e49..ac07c21bd4f 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Field.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Field.kt @@ -33,7 +33,7 @@ open class Field( override fun toKotlin(): String { val declaration = commentsToKotlin() + annotations.toKotlin() + modifiersToKotlin() + (if (isVal) "val " else "var ") + identifier.toKotlin() + " : " + `type`.toKotlin() return if (initializer.isEmpty) - declaration + (if (isVal && hasWriteAccesses) "" else " = " + getDefaultInitializer(this)) + declaration + (if (isVal && hasWriteAccesses) "" else " = " + getDefaultInitializer(this).toKotlin()) else declaration + " = " + initializer.toKotlin() } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.kt index f8e409769c9..fb417e38a9a 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.kt @@ -26,7 +26,7 @@ class Identifier( override val isEmpty: Boolean get() = name.isEmpty() - override fun toKotlin(): String { + private fun identifierToKotlin(): String { if (quotingNeeded && ONLY_KOTLIN_KEYWORDS.contains(name) || name.contains("$")) { return quote(name) } @@ -34,6 +34,8 @@ class Identifier( return name } + override fun toKotlin(): String = identifierToKotlin() + private fun quote(str: String): String = "`" + str + "`" override fun toString() = if (isNullable) "$name?" else name @@ -43,6 +45,8 @@ class Identifier( val ONLY_KOTLIN_KEYWORDS: Set = setOf( "package", "as", "type", "val", "var", "fun", "is", "in", "object", "when", "trait", "This" - ); + ) + + fun toKotlin(name: String): String = Identifier(name).identifierToKotlin() } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Types.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Types.kt index 35c21717bde..d9323120e59 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Types.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Types.kt @@ -79,15 +79,7 @@ class ClassType(val `type`: Identifier, val typeArgs: List, nullability : MayBeNullableType(nullability, settings) { override fun toKotlin(): String { - // TODO change to map() when KT-2051 is fixed - val parametersToKotlin = ArrayList() - for (param in typeArgs) { - parametersToKotlin.add(param.toKotlin()) - } - var params: String = if (parametersToKotlin.size() == 0) - "" - else - "<" + parametersToKotlin.makeString(", ") + ">" + var params = if (typeArgs.isEmpty()) "" else typeArgs.map { it.toKotlin() }.makeString(", ", "<", ">") return `type`.toKotlin() + params + isNullableStr() } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt index 8732312f2d4..6a370792ceb 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt @@ -46,11 +46,11 @@ class ElementVisitor(private val converter: Converter) : JavaElementVisitor() { result = ReferenceElement(Identifier(reference.getReferenceName()!!), types) } else { - var code = Identifier(reference.getReferenceName()!!).toKotlin() + var code = Identifier.toKotlin(reference.getReferenceName()!!) var qualifier = reference.getQualifier() while (qualifier != null) { val p = qualifier as PsiJavaCodeReferenceElement - code = Identifier(p.getReferenceName()!!).toKotlin() + "." + code + code = Identifier.toKotlin(p.getReferenceName()!!) + "." + code qualifier = p.getQualifier() } result = ReferenceElement(Identifier(code), types) diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt index 478fc774ae0..f3e0d56830f 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt @@ -306,7 +306,7 @@ class ExpressionVisitor(private val converter: Converter, val insideSecondaryConstructor = containingConstructor != null && !containingConstructor.isPrimaryConstructor() if (insideSecondaryConstructor && (expression.getReference()?.resolve() as? PsiField)?.getContainingClass() == containingConstructor!!.getContainingClass()) { - identifier = QualifiedExpression(Identifier("__", false), Identifier(referencedName, isNullable)) + identifier = QualifiedExpression(SecondaryConstructor.tempValIdentifier, Identifier(referencedName, isNullable)) } else if (insideSecondaryConstructor && expression.isThisConstructorCall()) { identifier = Identifier("val __ = " + (containingConstructor?.getContainingClass()?.getNameIdentifier()?.getText() ?: "")) @@ -336,9 +336,9 @@ class ExpressionVisitor(private val converter: Converter, && !PsiTreeUtil.isAncestor(target.getContainingClass(), expression, true) && !isStaticallyImported(target, expression)) { var member: PsiMember = target - var code = Identifier(referencedName).toKotlin() + var code = Identifier.toKotlin(referencedName) while (member.getContainingClass() != null) { - code = Identifier(member.getContainingClass()!!.getName()!!).toKotlin() + "." + code + code = Identifier.toKotlin(member.getContainingClass()!!.getName()!!) + "." + code member = member.getContainingClass()!! } result = Identifier(code, false, false) @@ -354,7 +354,7 @@ class ExpressionVisitor(private val converter: Converter, } - result = QualifiedExpression(converter.convertExpression(qualifier), identifier) + result = if (qualifier != null) QualifiedExpression(converter.convertExpression(qualifier), identifier) else identifier } override fun visitSuperExpression(expression: PsiSuperExpression) { diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt index 9719fe6dcf9..feb536f6856 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt @@ -273,7 +273,7 @@ open class StatementVisitor(public val converter: Converter) : JavaElementVisito var statementList = bodyConverted.statementList var expression: Expression = Expression.Empty for (variable in variables.reverse()) { - val lambda = LambdaExpression(Identifier(variable.getName()!!).toKotlin(), statementList) + val lambda = LambdaExpression(Identifier.toKotlin(variable.getName()!!), statementList) expression = MethodCallExpression.build(converter.convertExpression(variable.getInitializer()), "use", listOf(), listOf(), false, lambda) statementList = StatementList(listOf(expression)) } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt index 9e1eaa766e9..9ab3db30cec 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt @@ -85,11 +85,11 @@ class TypeVisitor(private val converter: TypeConverter, private val classesToImp if (classType is PsiClassReferenceType) { val reference = classType.getReference() if (reference.isQualified()) { - var result = Identifier(reference.getReferenceName()!!).toKotlin() + var result = Identifier.toKotlin(reference.getReferenceName()!!) var qualifier = reference.getQualifier() while (qualifier != null) { val codeRefElement = qualifier as PsiJavaCodeReferenceElement - result = Identifier(codeRefElement.getReferenceName()!!).toKotlin() + "." + result + result = Identifier.toKotlin(codeRefElement.getReferenceName()!!) + "." + result qualifier = codeRefElement.getQualifier() } return Identifier(result)