diff --git a/src/org/jetbrains/jet/j2k/ast/AnonymousClass.java b/src/org/jetbrains/jet/j2k/ast/AnonymousClass.java deleted file mode 100644 index d533ecad252..00000000000 --- a/src/org/jetbrains/jet/j2k/ast/AnonymousClass.java +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Copyright 2010-2012 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.annotations.NotNull; -import org.jetbrains.jet.j2k.Converter; -import org.jetbrains.jet.j2k.ast.types.Type; - -import java.util.Collections; -import java.util.List; - -/** - * @author ignatov - */ -public class AnonymousClass extends Class { - public AnonymousClass(Converter converter, List members) { - super(converter, - new IdentifierImpl("anonClass"), - Collections.emptySet(), - Collections.emptyList(), - Collections.emptyList(), - Collections.emptyList(), - Collections.emptyList(), - getMembers(members, converter) - ); - } - - @NotNull - @Override - public String toKotlin() { - return bodyToKotlin(); - } -} diff --git a/src/org/jetbrains/jet/j2k/ast/AnonymousClass.kt b/src/org/jetbrains/jet/j2k/ast/AnonymousClass.kt new file mode 100644 index 00000000000..de9c2f787f8 --- /dev/null +++ b/src/org/jetbrains/jet/j2k/ast/AnonymousClass.kt @@ -0,0 +1,17 @@ +package org.jetbrains.jet.j2k.ast + +import org.jetbrains.jet.j2k.Converter +import org.jetbrains.jet.j2k.ast.types.Type +import java.util.Collections +import java.util.List + +public open class AnonymousClass(converter : Converter, members : List) + : Class(converter, + IdentifierImpl("anonClass"), + Collections.emptySet()!!, + Collections.emptyList()!!, + Collections.emptyList()!!, + Collections.emptyList()!!, + Collections.emptyList()!!, members) { + public override fun toKotlin() = bodyToKotlin() +} diff --git a/src/org/jetbrains/jet/j2k/ast/Class.java b/src/org/jetbrains/jet/j2k/ast/Class.java deleted file mode 100644 index a9a9b536986..00000000000 --- a/src/org/jetbrains/jet/j2k/ast/Class.java +++ /dev/null @@ -1,274 +0,0 @@ -/* - * Copyright 2010-2012 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.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.j2k.Converter; -import org.jetbrains.jet.j2k.J2KConverterFlags; -import org.jetbrains.jet.j2k.ast.types.ClassType; -import org.jetbrains.jet.j2k.ast.types.Type; -import org.jetbrains.jet.j2k.util.AstUtil; - -import java.util.HashSet; -import java.util.LinkedList; -import java.util.List; -import java.util.Set; - -import static org.jetbrains.jet.j2k.util.AstUtil.*; - -/** - * @author ignatov - */ -public class Class extends Member { - @NotNull - String TYPE = "class"; - final Identifier myName; - private final List myBaseClassParams; - private final List myMembers; - private final List myTypeParameters; - private final List myExtendsTypes; - private final List myImplementsTypes; - - public Class(Converter converter, Identifier name, Set modifiers, List typeParameters, List extendsTypes, - List baseClassParams, List implementsTypes, List members) { - super(modifiers); - if (extendsTypes.size() > 0) { - System.out.println("here"); - } - myName = name; - myBaseClassParams = baseClassParams; - myTypeParameters = typeParameters; - myExtendsTypes = extendsTypes; - myImplementsTypes = implementsTypes; - myMembers = getMembers(members, converter); - } - - /*package*/ static List getMembers(List members, Converter converter) { - List withoutPrivate = new LinkedList(); - if (converter.hasFlag(J2KConverterFlags.SKIP_NON_PUBLIC_MEMBERS)) { - for (Member m : members) { - if (m.accessModifier().equals("public") || m.accessModifier().equals("protected")) { - withoutPrivate.add(m); - } - } - } - else { - withoutPrivate = members; - } - return withoutPrivate; - } - - - @Nullable - private Constructor getPrimaryConstructor() { - for (Member m : myMembers) - if (m.getKind() == Kind.CONSTRUCTOR) { - if (((Constructor) m).getIsPrimary()) { - return (Constructor) m; - } - } - return null; - } - - String primaryConstructorSignatureToKotlin() { - Constructor maybeConstructor = getPrimaryConstructor(); - if (maybeConstructor != null) { - return maybeConstructor.primarySignatureToKotlin(); - } - return "(" + ")"; - } - - String primaryConstructorBodyToKotlin() { - Constructor maybeConstructor = getPrimaryConstructor(); - if (maybeConstructor != null && !maybeConstructor.getBlock().isEmpty()) { - return maybeConstructor.primaryBodyToKotlin(); - } - return EMPTY; - } - - private boolean hasWhere() { - for (Element t : myTypeParameters) - if (t instanceof TypeParameter && ((TypeParameter) t).hasWhere()) { - return true; - } - return false; - } - - @NotNull - String typeParameterWhereToKotlin() { - if (hasWhere()) { - List wheres = new LinkedList(); - for (Element t : myTypeParameters) - if (t instanceof TypeParameter) { - wheres.add(((TypeParameter) t).getWhereToKotlin()); - } - return SPACE + "where" + SPACE + join(wheres, COMMA_WITH_SPACE) + SPACE; - } - return EMPTY; - } - - @NotNull - LinkedList membersExceptConstructors() { - final LinkedList result = new LinkedList(); - for (Member m : myMembers) - if (m.getKind() != Kind.CONSTRUCTOR) { - result.add(m); - } - return result; - } - - @NotNull - List secondaryConstructorsAsStaticInitFunction() { - final LinkedList result = new LinkedList(); - for (Member m : myMembers) - if (m.getKind() == Kind.CONSTRUCTOR && !((Constructor) m).getIsPrimary()) { - Function f = (Function) m; - Set modifiers = new HashSet(m.myModifiers); - modifiers.add(Modifier.STATIC); - - final List statements = f.getBlock().getStatements(); - statements.add(new ReturnStatement(new IdentifierImpl("__"))); // TODO: move to one place, find other __ usages - final Block block = new Block(statements); - - final List typeParameters = new LinkedList(); - if (f.getTypeParameters().size() == 0) { - typeParameters.addAll(myTypeParameters); - } - else { - typeParameters.addAll(myTypeParameters); - typeParameters.addAll(f.getTypeParameters()); - } - - result.add(new Function( - new IdentifierImpl("init"), - modifiers, - new ClassType(myName, typeParameters, false), - typeParameters, - f.getParams(), - block - )); - } - return result; - } - - @NotNull - String typeParametersToKotlin() { - return myTypeParameters.size() > 0 ? "<" + AstUtil.joinNodes(myTypeParameters, COMMA_WITH_SPACE) + ">" : EMPTY; - } - - List baseClassSignatureWithParams() { - if (TYPE.equals("class") && myExtendsTypes.size() == 1) { - LinkedList result = new LinkedList(); - result.add(myExtendsTypes.get(0).toKotlin() + "(" + joinNodes(myBaseClassParams, COMMA_WITH_SPACE) + ")"); - return result; - } - else { - return nodesToKotlin(myExtendsTypes); - } - } - - @NotNull - String implementTypesToKotlin() { - List allTypes = new LinkedList() { - { - addAll(baseClassSignatureWithParams()); - addAll(nodesToKotlin(myImplementsTypes)); - } - }; - return allTypes.size() == 0 ? EMPTY : SPACE + COLON + SPACE + join(allTypes, COMMA_WITH_SPACE); - } - - @NotNull - String modifiersToKotlin() { - List modifierList = new LinkedList(); - - modifierList.add(accessModifier()); - - if (needAbstractModifier()) { - modifierList.add(Modifier.ABSTRACT); - } - - if (needOpenModifier()) { - modifierList.add(Modifier.OPEN); - } - - if (modifierList.size() > 0) { - return join(modifierList, SPACE) + SPACE; - } - - return EMPTY; - } - - boolean needOpenModifier() { - return !myModifiers.contains(Modifier.FINAL) && !myModifiers.contains(Modifier.ABSTRACT); - } - - boolean needAbstractModifier() { - return isAbstract(); - } - - @NotNull - String bodyToKotlin() { - return SPACE + "{" + N + - AstUtil.joinNodes(getNonStatic(membersExceptConstructors()), N) + N + - primaryConstructorBodyToKotlin() + N + - classObjectToKotlin() + N + - "}"; - } - - @NotNull - private static List getStatic(@NotNull List members) { - List result = new LinkedList(); - for (Member m : members) - if (m.isStatic()) { - result.add(m); - } - return result; - } - - @NotNull - private static List getNonStatic(@NotNull List members) { - List result = new LinkedList(); - for (Member m : members) - if (!m.isStatic()) { - result.add(m); - } - return result; - } - - @NotNull - private String classObjectToKotlin() { - final List staticMembers = new LinkedList(secondaryConstructorsAsStaticInitFunction()); - staticMembers.addAll(getStatic(membersExceptConstructors())); - if (staticMembers.size() > 0) { - return "class" + SPACE + "object" + SPACE + "{" + N + - AstUtil.joinNodes(staticMembers, N) + N + - "}"; - } - return EMPTY; - } - - @NotNull - @Override - public String toKotlin() { - return modifiersToKotlin() + TYPE + SPACE + myName.toKotlin() + typeParametersToKotlin() + primaryConstructorSignatureToKotlin() + - implementTypesToKotlin() + - typeParameterWhereToKotlin() + - bodyToKotlin(); - } -} diff --git a/src/org/jetbrains/jet/j2k/ast/Class.kt b/src/org/jetbrains/jet/j2k/ast/Class.kt new file mode 100644 index 00000000000..b57b116746f --- /dev/null +++ b/src/org/jetbrains/jet/j2k/ast/Class.kt @@ -0,0 +1,191 @@ +package org.jetbrains.jet.j2k.ast + +import org.jetbrains.annotations.Nullable +import org.jetbrains.jet.j2k.Converter +import org.jetbrains.jet.j2k.J2KConverterFlags +import org.jetbrains.jet.j2k.ast.types.ClassType +import org.jetbrains.jet.j2k.ast.types.Type +import org.jetbrains.jet.j2k.util.AstUtil +import java.util.HashSet +import java.util.LinkedList +import java.util.List +import java.util.Set +import org.jetbrains.jet.j2k.util.AstUtil.* +import java.util.ArrayList + +public open class Class(converter : Converter, + val name : Identifier, + modifiers : Set, + val typeParameters : List, + val extendsTypes : List, + val baseClassParams : List, + val implementsTypes : List, + members : List) : Member(modifiers) { + val members = getMembers(members, converter) + + open val TYPE: String + get() = "class" + + private fun getPrimaryConstructor() : Constructor? { + return members.find { it is Constructor && it.isPrimary } as Constructor? + } + + open fun primaryConstructorSignatureToKotlin() : String { + val maybeConstructor : Constructor? = getPrimaryConstructor() + return if (maybeConstructor != null) maybeConstructor.primarySignatureToKotlin() else "()" + } + + open fun primaryConstructorBodyToKotlin() : String? { + var maybeConstructor : Constructor? = getPrimaryConstructor() + if (maybeConstructor != null && !(maybeConstructor?.block?.isEmpty() ?: true)) + { + return maybeConstructor?.primaryBodyToKotlin() + } + + return "" + } + + private fun hasWhere() : Boolean = typeParameters.any { it is TypeParameter && it.hasWhere() } + + 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 { + return members.filter { it is Constructor && !it.isPrimary }.map { constructorToInit(it as Function) } + } + + private fun constructorToInit(f: Function): Function { + val modifiers : Set = HashSet(f.getModifiers()) + modifiers.add(Modifier.STATIC) + val statements : List = f.block?.getStatements() ?: arrayList() + statements.add(ReturnStatement(IdentifierImpl("__"))) + val block : Block = Block(statements) + val constructorTypeParameters : List = arrayList() + constructorTypeParameters.addAll(typeParameters) + constructorTypeParameters.addAll(f.typeParameters) + return Function(IdentifierImpl("init"), modifiers, ClassType(name, constructorTypeParameters, false), + constructorTypeParameters, f.params, block) + } + + open fun typeParametersToKotlin() : String { + return (if (typeParameters.size() > 0) + "<" + typeParameters.map { it.toKotlin() }.makeString(", ") + ">" + else + "") + } + + open fun baseClassSignatureWithParams() : List { + if (TYPE.equals("class") && extendsTypes.size() == 1) + { + val baseParams = baseClassParams.map { it.toKotlin() }.makeString(", ") + return arrayList(extendsTypes[0].toKotlin() + "(" + baseParams + ")") + } + return nodesToKotlin(extendsTypes) + } + + open fun implementTypesToKotlin() : String { + val allTypes : List = arrayList() + allTypes.addAll(baseClassSignatureWithParams()) + allTypes.addAll(nodesToKotlin(implementsTypes)) + return if (allTypes.size() == 0) + "" + else + " : " + allTypes.makeString(", ") + } + + open fun modifiersToKotlin() : String { + val modifierList : List = arrayList() + modifierList.add(accessModifier()) + if (needAbstractModifier()) + { + modifierList.add(Modifier.ABSTRACT) + } + + if (needOpenModifier()) + { + modifierList.add(Modifier.OPEN) + } + + if (modifierList.size() > 0) + { + return modifierList.makeString(" ") + " " + } + + return "" + } + + open fun needOpenModifier() = !myModifiers.contains(Modifier.FINAL) && !myModifiers.contains(Modifier.ABSTRACT) + + open fun needAbstractModifier() = isAbstract() + + open fun bodyToKotlin() : String { + return " {\n" + AstUtil.joinNodes(getNonStatic(membersExceptConstructors()), "\n") + "\n" + primaryConstructorBodyToKotlin() + "\n" + classObjectToKotlin() + "\n}" + } + + private fun classObjectToKotlin() : String { + val staticMembers : List = arrayList() + staticMembers.addAll(secondaryConstructorsAsStaticInitFunction()) + staticMembers.addAll(getStatic(membersExceptConstructors())) + if (staticMembers.size() > 0) + { + return "class object {\n" + AstUtil.joinNodes(staticMembers, "\n") + "\n}" + } + + return "" + } + public override fun toKotlin() : String = + modifiersToKotlin() + + TYPE + " " + name.toKotlin() + + typeParametersToKotlin() + + primaryConstructorSignatureToKotlin() + + implementTypesToKotlin() + + typeParameterWhereToKotlin() + + bodyToKotlin() + + class object { + open fun getMembers(members : List, converter : Converter) : List { + if (converter.hasFlag(J2KConverterFlags.SKIP_NON_PUBLIC_MEMBERS).sure()) + { + val withoutPrivate : List = arrayList() + for (m : Member in members) + { + if (m.accessModifier().equals("public") || m.accessModifier().equals("protected")) + { + withoutPrivate.add(m) + } + + } + return withoutPrivate + } + return members + } + + private fun getStatic(members : List) : List { + val result : List = arrayList() + for (m in members) + if (m.isStatic()) + result.add(m) + + return result + } + + private fun getNonStatic(members : List) : List { + val result : List = arrayList() + for (m in members) + if (!m.isStatic()) + { + result.add(m) + } + + return result + } + } +} diff --git a/src/org/jetbrains/jet/j2k/ast/Enum.java b/src/org/jetbrains/jet/j2k/ast/Enum.java deleted file mode 100644 index b234d578da9..00000000000 --- a/src/org/jetbrains/jet/j2k/ast/Enum.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright 2010-2012 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.annotations.NotNull; -import org.jetbrains.jet.j2k.Converter; -import org.jetbrains.jet.j2k.ast.types.Type; -import org.jetbrains.jet.j2k.util.AstUtil; - -import java.util.List; -import java.util.Set; - -/** - * @author ignatov - */ -public class Enum extends Class { - public Enum(Converter converter, Identifier name, Set modifiers, List typeParameters, List extendsTypes, - List baseClassParams, List implementsTypes, List members) { - super(converter, name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, getMembers(members, converter)); - } - - String primaryConstructorSignatureToKotlin() { - String s = super.primaryConstructorSignatureToKotlin(); - return s.equals("()") ? EMPTY : s; - } - - @Override - boolean needOpenModifier() { - return false; - } - - @NotNull - @Override - public String toKotlin() { - return modifiersToKotlin() + "enum class" + SPACE + myName.toKotlin() + primaryConstructorSignatureToKotlin() + - typeParametersToKotlin() + implementTypesToKotlin() + SPACE + "{" + N + - AstUtil.joinNodes(membersExceptConstructors(), N) + N + - primaryConstructorBodyToKotlin() + N + - "public fun name() : String { return \"\" }" + N + // TODO : remove hack - "public fun order() : Int { return 0 }" + N + - "}"; - } -} diff --git a/src/org/jetbrains/jet/j2k/ast/Enum.kt b/src/org/jetbrains/jet/j2k/ast/Enum.kt new file mode 100644 index 00000000000..f03e11578fd --- /dev/null +++ b/src/org/jetbrains/jet/j2k/ast/Enum.kt @@ -0,0 +1,35 @@ +package org.jetbrains.jet.j2k.ast + +import org.jetbrains.jet.j2k.Converter +import org.jetbrains.jet.j2k.ast.types.Type +import org.jetbrains.jet.j2k.util.AstUtil +import java.util.List +import java.util.Set + +public open class Enum(converter : Converter, + name : Identifier, + modifiers : Set, + typeParameters : List, + extendsTypes : List, + baseClassParams : List, + implementsTypes : List, + members : List) : Class(converter, name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, members) { + + override fun primaryConstructorSignatureToKotlin() : String { + val s : String = super.primaryConstructorSignatureToKotlin() + return if (s.equals("()")) "" else s + } + + override fun needOpenModifier() : Boolean = false + + public override fun toKotlin() : String { + return modifiersToKotlin() + + "enum class " + name.toKotlin() + + primaryConstructorSignatureToKotlin() + + typeParametersToKotlin() + + implementTypesToKotlin() + + " {\n" + AstUtil.joinNodes(membersExceptConstructors(), "\n") + "\n" + + primaryConstructorBodyToKotlin() + + "\npublic fun name() : String { return \"\" }\npublic fun order() : Int { return 0 }\n}" + } +} diff --git a/src/org/jetbrains/jet/j2k/ast/Member.java b/src/org/jetbrains/jet/j2k/ast/Member.java index 86af822e3a4..8855b799d37 100644 --- a/src/org/jetbrains/jet/j2k/ast/Member.java +++ b/src/org/jetbrains/jet/j2k/ast/Member.java @@ -48,4 +48,9 @@ public abstract class Member extends Node implements IMember { public boolean isStatic() { return myModifiers.contains(Modifier.STATIC); } + + @NotNull + public Set getModifiers() { + return myModifiers; + } } diff --git a/src/org/jetbrains/jet/j2k/ast/Trait.java b/src/org/jetbrains/jet/j2k/ast/Trait.java deleted file mode 100644 index b4773460ee2..00000000000 --- a/src/org/jetbrains/jet/j2k/ast/Trait.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright 2010-2012 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.Converter; -import org.jetbrains.jet.j2k.ast.types.Type; - -import java.util.List; -import java.util.Set; - -/** - * @author ignatov - */ -public class Trait extends Class { - public Trait(Converter converter, Identifier name, Set modifiers, List typeParameters, List extendsTypes, - List baseClassParams, List implementsTypes, List members) { - super(converter, name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, getMembers(members, converter)); - TYPE = "trait"; - } - - @Override - String primaryConstructorSignatureToKotlin() { - return EMPTY; - } - - boolean needOpenModifier() { - return false; - } -} diff --git a/src/org/jetbrains/jet/j2k/ast/Trait.kt b/src/org/jetbrains/jet/j2k/ast/Trait.kt new file mode 100644 index 00000000000..5f1a111320d --- /dev/null +++ b/src/org/jetbrains/jet/j2k/ast/Trait.kt @@ -0,0 +1,22 @@ +package org.jetbrains.jet.j2k.ast + +import org.jetbrains.jet.j2k.Converter +import org.jetbrains.jet.j2k.ast.types.Type +import java.util.List +import java.util.Set + +public open class Trait(converter : Converter, + name : Identifier, + modifiers : Set, + typeParameters : List, + extendsTypes : List, + baseClassParams : List, + implementsTypes : List, + members : List) : Class(converter, name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, members) { + + override val TYPE: String + get() = "trait" + + override fun primaryConstructorSignatureToKotlin() = "" + override fun needOpenModifier() = false +}