diff --git a/j2k/src/org/jetbrains/jet/j2k/Converter.kt b/j2k/src/org/jetbrains/jet/j2k/Converter.kt index 0a95248b242..e9bf358b95e 100644 --- a/j2k/src/org/jetbrains/jet/j2k/Converter.kt +++ b/j2k/src/org/jetbrains/jet/j2k/Converter.kt @@ -112,15 +112,15 @@ public class Converter(val project: Project, val settings: ConverterSettings) { } private fun classToClass(psiClass: PsiClass): Class { - val modifiers: Set = modifiersListToModifiersSet(psiClass.getModifierList()) - val fields: List = fieldsToFieldList(psiClass.getFields(), psiClass) - val typeParameters: List = elementsToElementList(psiClass.getTypeParameters()) - val implementsTypes: List = typesToNotNullableTypeList(psiClass.getImplementsListTypes()) - val extendsTypes: List = typesToNotNullableTypeList(psiClass.getExtendsListTypes()) + 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()) val name: Identifier = Identifier(psiClass.getName()!!) val baseClassParams = ArrayList() val members = ArrayList(getMembers(psiClass)) - val visitor: SuperVisitor = SuperVisitor() + val visitor = SuperVisitor() psiClass.accept(visitor) val resolvedSuperCallParameters = visitor.resolvedSuperCallParameters if (resolvedSuperCallParameters.size() == 1) { @@ -169,7 +169,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) { } members.add(Constructor(this, Identifier.EMPTY_IDENTIFIER, null, Collections.emptySet(), ClassType(name, Collections.emptyList(), false, this), - Collections.emptyList(), + TypeParameterList.Empty, ParameterList(createParametersFromFields(finalOrWithEmptyInitializer)), Block(createInitStatementsFromFields(finalOrWithEmptyInitializer)), true)) @@ -234,7 +234,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) { val body = blockToBlock(method.getBody(), notEmpty) val params: Element = createFunctionParameters(method) - val typeParameters = elementsToElementList(method.getTypeParameters()) + val typeParameterList = typeParameterListToTypeParameterList(method.getTypeParameterList()) val modifiers = modifiersListToModifiersSet(method.getModifierList()) if (isOverride(method)) { modifiers.add(Modifier.OVERRIDE) @@ -250,11 +250,11 @@ public class Converter(val project: Project, val settings: ConverterSettings) { } if (method.isConstructor()) { - return Constructor(this, identifier, getDocComment(method), modifiers, returnType, typeParameters, params, + return Constructor(this, identifier, getDocComment(method), modifiers, returnType, typeParameterList, params, Block(body.statements), isConstructorPrimary(method)) } - return Function(this, identifier, getDocComment(method), modifiers, returnType, typeParameters, params, body) + return Function(this, identifier, getDocComment(method), modifiers, returnType, typeParameterList, params, body) } private fun createFunctionParameters(method: PsiMethod): ParameterList { diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.kt b/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.kt index 8607be55edf..8a201bd2257 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.kt @@ -25,7 +25,7 @@ public class AnonymousClass(converter: Converter, members: List) Identifier("anonClass"), null, Collections.emptySet(), - Collections.emptyList(), + TypeParameterList.Empty, Collections.emptyList(), Collections.emptyList(), Collections.emptyList(), members) { diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Class.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Class.kt index 1b8d01192b8..0348a3350c8 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Class.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Class.kt @@ -26,7 +26,7 @@ public open class Class(val converter: Converter, val name: Identifier, docComment: Comment?, modifiers: Set, - val typeParameters: List, + val typeParameterList: TypeParameterList, val extendsTypes: List, val baseClassParams: List, val implementsTypes: List, @@ -43,7 +43,7 @@ public open class Class(val converter: Converter, return if (maybeConstructor != null) maybeConstructor.primarySignatureToKotlin() else "()" } - open fun primaryConstructorBodyToKotlin(): String? { + fun primaryConstructorBodyToKotlin(): String? { val maybeConstructor = getPrimaryConstructor() if (maybeConstructor != null && !(maybeConstructor.block?.isEmpty() ?: true)) { return maybeConstructor.primaryBodyToKotlin() + "\n" @@ -52,19 +52,9 @@ public open class Class(val converter: Converter, return "" } - private fun hasWhere(): Boolean = typeParameters.any { it is TypeParameter && it.hasWhere() } + fun membersExceptConstructors(): List = members.filterNot { it is Constructor } - open fun typeParameterWhereToKotlin(): String { - if (hasWhere()) { - val wheres = typeParameters.filter { it is TypeParameter }.map { (it as TypeParameter).getWhereToKotlin() } - return " where " + wheres.makeString(", ") - } - return "" - } - - open fun membersExceptConstructors(): List = members.filterNot { it is Constructor } - - open fun secondaryConstructorsAsStaticInitFunction(): List { + fun secondaryConstructorsAsStaticInitFunction(): List { return members.filter { it is Constructor && !it.isPrimary }.map { constructorToInit(it as Function) } } @@ -74,25 +64,23 @@ public open class Class(val converter: Converter, val statements = ArrayList(f.block?.statements ?: listOf()) statements.add(ReturnStatement(Identifier("__"))) val block = Block(statements) - val constructorTypeParameters = ArrayList() - constructorTypeParameters.addAll(typeParameters) - constructorTypeParameters.addAll(f.typeParameters) + val constructorTypeParameters = ArrayList() + constructorTypeParameters.addAll(typeParameterList.parameters) + constructorTypeParameters.addAll(f.typeParameterList.parameters) return Function(converter, Identifier("init"), null, modifiers, ClassType(name, constructorTypeParameters, false, converter), - constructorTypeParameters, f.params, block) + TypeParameterList(constructorTypeParameters), f.params, block) } - open fun typeParametersToKotlin(): String = typeParameters.toKotlin(", ", "<", ">") - - open fun baseClassSignatureWithParams(): List { + fun baseClassSignatureWithParams(): List { if (TYPE.equals("class") && extendsTypes.size() == 1) { val baseParams = baseClassParams.toKotlin(", ") - return arrayList(extendsTypes[0].toKotlin() + "(" + baseParams + ")") + return arrayListOf(extendsTypes[0].toKotlin() + "(" + baseParams + ")") } return extendsTypes.map { it.toKotlin() } } - open fun implementTypesToKotlin(): String { + fun implementTypesToKotlin(): String { val allTypes = ArrayList() allTypes.addAll(baseClassSignatureWithParams()) allTypes.addAll(implementsTypes.map { it.toKotlin() }) @@ -102,7 +90,7 @@ public open class Class(val converter: Converter, " : " + allTypes.makeString(", ") } - open fun modifiersToKotlin(): String { + fun modifiersToKotlin(): String { val modifierList = ArrayList() val modifier = accessModifier() if (modifier != null) { @@ -125,21 +113,21 @@ public open class Class(val converter: Converter, return " {\n" + getNonStatic(membersExceptConstructors()).toKotlin("\n", "", "\n") + primaryConstructorBodyToKotlin() + classObjectToKotlin() + "}" } - private fun classObjectToKotlin(): String { + fun classObjectToKotlin(): String { val staticMembers = ArrayList() staticMembers.addAll(secondaryConstructorsAsStaticInitFunction()) staticMembers.addAll(getStatic(membersExceptConstructors())) return staticMembers.toKotlin("\n", "class object {\n", "\n}") } - public override fun toKotlin(): String = + override fun toKotlin(): String = docCommentToKotlin() + modifiersToKotlin() + TYPE + " " + name.toKotlin() + - typeParametersToKotlin() + + typeParameterList.toKotlin() + primaryConstructorSignatureToKotlin() + implementTypesToKotlin() + - typeParameterWhereToKotlin() + + typeParameterList.whereToKotlin().withPrefix(" ") + bodyToKotlin() diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Constructor.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Constructor.kt index 36d9b079b81..75878a721b9 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Constructor.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Constructor.kt @@ -24,7 +24,7 @@ public class Constructor(converter: Converter, docComment: Comment?, modifiers: Set, `type`: Type, - typeParameters: List, + typeParameters: TypeParameterList, params: Element, block: Block, val isPrimary: Boolean) : Function(converter, identifier, docComment, modifiers, diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Enum.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Enum.kt index 39e9c8c569f..f1442f9a227 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Enum.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Enum.kt @@ -20,15 +20,15 @@ import org.jetbrains.jet.j2k.Converter import org.jetbrains.jet.j2k.ast.types.Type public class Enum(converter: Converter, - name: Identifier, - docComments: Comment?, - modifiers: Set, - typeParameters: List, - extendsTypes: List, - baseClassParams: List, - implementsTypes: List, - members: List) : Class(converter, name, docComments, modifiers, typeParameters, - extendsTypes, baseClassParams, implementsTypes, members) { + name: Identifier, + docComments: Comment?, + modifiers: Set, + typeParameterList: TypeParameterList, + extendsTypes: List, + baseClassParams: List, + implementsTypes: List, + members: List) : Class(converter, name, docComments, modifiers, typeParameterList, + extendsTypes, baseClassParams, implementsTypes, members) { override fun primaryConstructorSignatureToKotlin(): String { val s: String = super.primaryConstructorSignatureToKotlin() @@ -42,7 +42,7 @@ public class Enum(converter: Converter, return modifiersToKotlin() + "enum class " + name.toKotlin() + primaryConstructorSignatureToKotlin() + - typeParametersToKotlin() + + typeParameterList.toKotlin() + implementTypesToKotlin() + " {\n" + membersExceptConstructors().toKotlin("\n", "", "\n") + (if (primaryConstructorBody.isEmpty()) "" else primaryConstructorBody) + diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Function.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Function.kt index d052f440e4c..eaba2a1fa58 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Function.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Function.kt @@ -26,28 +26,10 @@ public open class Function(val converter: Converter, docComment: Comment?, modifiers: Set, val `type`: Type, - val typeParameters: List, + val typeParameterList: TypeParameterList, val params: Element, var block: Block?) : Member(docComment, modifiers) { - private fun typeParametersToKotlin() = when { - !typeParameters.isEmpty() -> typeParameters.map { it.toKotlin() }.makeString(", ", "<", "> ") - else -> "" - } - - - private fun hasWhere(): Boolean = typeParameters.any { it is TypeParameter && it.hasWhere() } - - private fun typeParameterWhereToKotlin(): String { - if (hasWhere()) - { - val wheres = typeParameters.filter { it is TypeParameter }.map { ((it as TypeParameter).getWhereToKotlin() ) } - return "where " + wheres.makeString(", ") + " " - } - - return "" - } - private fun modifiersToKotlin(): String { val resultingModifiers = ArrayList() val isOverride = modifiers.contains(Modifier.OVERRIDE) @@ -84,10 +66,10 @@ public open class Function(val converter: Converter, public override fun toKotlin(): String { return docCommentToKotlin() + modifiersToKotlin() + - "fun ${typeParametersToKotlin()}${name.toKotlin()}" + + "fun ${typeParameterList.toKotlin().withSuffix(" ")}${name.toKotlin()}" + "(${params.toKotlin()})" + returnTypeToKotlin() + - typeParameterWhereToKotlin() + + typeParameterList.whereToKotlin() + block?.toKotlin() } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Trait.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Trait.kt index 55d151dec65..65fabcfe234 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Trait.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Trait.kt @@ -20,15 +20,15 @@ import org.jetbrains.jet.j2k.Converter import org.jetbrains.jet.j2k.ast.types.Type public class Trait(converter: Converter, - name: Identifier, - docComment: Comment?, - modifiers: Set, - typeParameters: List, - extendsTypes: List, - baseClassParams: List, - implementsTypes: List, - members: List) : Class(converter, name, docComment, modifiers, typeParameters, - extendsTypes, baseClassParams, implementsTypes, members) { + name: Identifier, + docComment: Comment?, + modifiers: Set, + typeParameterList: TypeParameterList, + extendsTypes: List, + baseClassParams: List, + implementsTypes: List, + members: List) : Class(converter, name, docComment, modifiers, typeParameterList, + extendsTypes, baseClassParams, implementsTypes, members) { override val TYPE: String get() = "trait" diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameter.kt b/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameter.kt deleted file mode 100644 index e0dd54b50f2..00000000000 --- a/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameter.kt +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright 2010-2013 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.j2k.ast - -import org.jetbrains.jet.j2k.ast.types.Type - -public class TypeParameter(val name: Identifier, val extendsTypes: List) : Element { - public fun hasWhere(): Boolean = extendsTypes.size() > 1 - public fun getWhereToKotlin(): String { - if (hasWhere()) { - return name.toKotlin() + " : " + extendsTypes.get(1).toKotlin() - } - - return "" - } - - public override fun toKotlin(): String { - if (extendsTypes.size() > 0) { - return name.toKotlin() + " : " + extendsTypes [0].toKotlin() - } - - return name.toKotlin() - } -} diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt b/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt new file mode 100644 index 00000000000..875e72c0868 --- /dev/null +++ b/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt @@ -0,0 +1,75 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.j2k.ast + +import org.jetbrains.jet.j2k.ast.types.Type +import com.intellij.psi.PsiTypeParameter +import org.jetbrains.jet.j2k.Converter +import com.intellij.psi.PsiTypeParameterList +import java.util.ArrayList + +public class TypeParameter(val name: Identifier, val extendsTypes: List) : Element { + public fun hasWhere(): Boolean = extendsTypes.size() > 1 + public fun getWhereToKotlin(): String { + if (hasWhere()) { + return name.toKotlin() + " : " + extendsTypes.get(1).toKotlin() + } + + return "" + } + + public override fun toKotlin(): String { + if (extendsTypes.size() > 0) { + return name.toKotlin() + " : " + extendsTypes [0].toKotlin() + } + + return name.toKotlin() + } +} + +public class TypeParameterList(val parameters: List) : Element { + override fun toKotlin(): String = if (!parameters.isEmpty()) + parameters.map { + it.toKotlin() + }.makeString(", ", "<", ">") + else "" + + public fun whereToKotlin(): String { + if (hasWhere()) { + val wheres = parameters.map { it.getWhereToKotlin() } + return "where " + wheres.makeString(", ") + } + return "" + } + + override fun isEmpty(): Boolean = parameters.isEmpty() + + private fun hasWhere(): Boolean = parameters.any { it.hasWhere() } + + class object { + public val Empty: TypeParameterList = TypeParameterList(ArrayList()) + } +} + +public fun Converter.typeParameterToTypeParameter(psiTypeParameter: PsiTypeParameter): TypeParameter { + return elementToElement(psiTypeParameter) as TypeParameter +} + +public fun Converter.typeParameterListToTypeParameterList(psiTypeParameterlist: PsiTypeParameterList?): TypeParameterList { + return if (psiTypeParameterlist == null) TypeParameterList.Empty + else TypeParameterList(psiTypeParameterlist.getTypeParameters()!!.toList().map { typeParameterToTypeParameter(it) }) +} \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Util.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Util.kt index 30a912b4324..937477c2b88 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Util.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Util.kt @@ -16,7 +16,7 @@ package org.jetbrains.jet.j2k.ast -fun List.toKotlin(separator: String, prefix: String = "", suffix: String = ""): String { +public fun List.toKotlin(separator: String, prefix: String = "", suffix: String = ""): String { val result = StringBuilder() if (size() > 0) { result.append(prefix) @@ -31,7 +31,7 @@ fun List.toKotlin(separator: String, prefix: String = "", suffix: String = return result.toString() } -fun Collection.toKotlin(separator: String = " "): String { +public fun Collection.toKotlin(separator: String = " "): String { val result = StringBuilder() for (x in this) { result.append(x.name) @@ -40,5 +40,6 @@ fun Collection.toKotlin(separator: String = " "): String { return result.toString() } -fun String.withPrefix(prefix: String) = if (isEmpty()) "" else prefix + this -fun Expression.withPrefix(prefix: String) = if (isEmpty()) "" else prefix + toKotlin() +public fun String.withSuffix(suffix: String): String = if (isEmpty()) "" else this + suffix +public fun String.withPrefix(prefix: String): String = if (isEmpty()) "" else prefix + this +public fun Expression.withPrefix(prefix: String): String = if (isEmpty()) "" else prefix + toKotlin()