Class and its subclasses converted to Kotlin
This commit is contained in:
Dmitry Jemerov
committed by
Pavel V. Talanov
Pavel V. Talanov
parent
46003dc1f6
commit
3130b750d3
@@ -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<Member> members) {
|
||||
super(converter,
|
||||
new IdentifierImpl("anonClass"),
|
||||
Collections.<String>emptySet(),
|
||||
Collections.<Element>emptyList(),
|
||||
Collections.<Type>emptyList(),
|
||||
Collections.<Expression>emptyList(),
|
||||
Collections.<Type>emptyList(),
|
||||
getMembers(members, converter)
|
||||
);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return bodyToKotlin();
|
||||
}
|
||||
}
|
||||
@@ -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<Member>)
|
||||
: Class(converter,
|
||||
IdentifierImpl("anonClass"),
|
||||
Collections.emptySet<String?>()!!,
|
||||
Collections.emptyList<Element>()!!,
|
||||
Collections.emptyList<Type>()!!,
|
||||
Collections.emptyList<Expression>()!!,
|
||||
Collections.emptyList<Type>()!!, members) {
|
||||
public override fun toKotlin() = bodyToKotlin()
|
||||
}
|
||||
@@ -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<Expression> myBaseClassParams;
|
||||
private final List<Member> myMembers;
|
||||
private final List<Element> myTypeParameters;
|
||||
private final List<Type> myExtendsTypes;
|
||||
private final List<Type> myImplementsTypes;
|
||||
|
||||
public Class(Converter converter, Identifier name, Set<String> modifiers, List<Element> typeParameters, List<Type> extendsTypes,
|
||||
List<Expression> baseClassParams, List<Type> implementsTypes, List<Member> 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<Member> getMembers(List<Member> members, Converter converter) {
|
||||
List<Member> withoutPrivate = new LinkedList<Member>();
|
||||
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<String> wheres = new LinkedList<String>();
|
||||
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<Member> membersExceptConstructors() {
|
||||
final LinkedList<Member> result = new LinkedList<Member>();
|
||||
for (Member m : myMembers)
|
||||
if (m.getKind() != Kind.CONSTRUCTOR) {
|
||||
result.add(m);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
List<Function> secondaryConstructorsAsStaticInitFunction() {
|
||||
final LinkedList<Function> result = new LinkedList<Function>();
|
||||
for (Member m : myMembers)
|
||||
if (m.getKind() == Kind.CONSTRUCTOR && !((Constructor) m).getIsPrimary()) {
|
||||
Function f = (Function) m;
|
||||
Set<String> modifiers = new HashSet<String>(m.myModifiers);
|
||||
modifiers.add(Modifier.STATIC);
|
||||
|
||||
final List<Statement> 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<Element> typeParameters = new LinkedList<Element>();
|
||||
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<String> baseClassSignatureWithParams() {
|
||||
if (TYPE.equals("class") && myExtendsTypes.size() == 1) {
|
||||
LinkedList<String> result = new LinkedList<String>();
|
||||
result.add(myExtendsTypes.get(0).toKotlin() + "(" + joinNodes(myBaseClassParams, COMMA_WITH_SPACE) + ")");
|
||||
return result;
|
||||
}
|
||||
else {
|
||||
return nodesToKotlin(myExtendsTypes);
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
String implementTypesToKotlin() {
|
||||
List<String> allTypes = new LinkedList<String>() {
|
||||
{
|
||||
addAll(baseClassSignatureWithParams());
|
||||
addAll(nodesToKotlin(myImplementsTypes));
|
||||
}
|
||||
};
|
||||
return allTypes.size() == 0 ? EMPTY : SPACE + COLON + SPACE + join(allTypes, COMMA_WITH_SPACE);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
String modifiersToKotlin() {
|
||||
List<String> modifierList = new LinkedList<String>();
|
||||
|
||||
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<Member> getStatic(@NotNull List<? extends Member> members) {
|
||||
List<Member> result = new LinkedList<Member>();
|
||||
for (Member m : members)
|
||||
if (m.isStatic()) {
|
||||
result.add(m);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static List<Member> getNonStatic(@NotNull List<? extends Member> members) {
|
||||
List<Member> result = new LinkedList<Member>();
|
||||
for (Member m : members)
|
||||
if (!m.isStatic()) {
|
||||
result.add(m);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private String classObjectToKotlin() {
|
||||
final List<Member> staticMembers = new LinkedList<Member>(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();
|
||||
}
|
||||
}
|
||||
@@ -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<String?>,
|
||||
val typeParameters : List<Element>,
|
||||
val extendsTypes : List<Type>,
|
||||
val baseClassParams : List<Expression>,
|
||||
val implementsTypes : List<Type>,
|
||||
members : List<Member>) : 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<Member> = members.filterNot { it is Constructor }
|
||||
|
||||
open fun secondaryConstructorsAsStaticInitFunction() : List<Function> {
|
||||
return members.filter { it is Constructor && !it.isPrimary }.map { constructorToInit(it as Function) }
|
||||
}
|
||||
|
||||
private fun constructorToInit(f: Function): Function {
|
||||
val modifiers : Set<String?> = HashSet<String?>(f.getModifiers())
|
||||
modifiers.add(Modifier.STATIC)
|
||||
val statements : List<Statement?> = f.block?.getStatements() ?: arrayList()
|
||||
statements.add(ReturnStatement(IdentifierImpl("__")))
|
||||
val block : Block = Block(statements)
|
||||
val constructorTypeParameters : List<Element> = 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<String?> {
|
||||
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<String?> = arrayList()
|
||||
allTypes.addAll(baseClassSignatureWithParams())
|
||||
allTypes.addAll(nodesToKotlin(implementsTypes))
|
||||
return if (allTypes.size() == 0)
|
||||
""
|
||||
else
|
||||
" : " + allTypes.makeString(", ")
|
||||
}
|
||||
|
||||
open fun modifiersToKotlin() : String {
|
||||
val modifierList : List<String> = 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<Member> = 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<Member>, converter : Converter) : List<Member> {
|
||||
if (converter.hasFlag(J2KConverterFlags.SKIP_NON_PUBLIC_MEMBERS).sure())
|
||||
{
|
||||
val withoutPrivate : List<Member> = 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<out Member>) : List<Member> {
|
||||
val result : List<Member> = arrayList()
|
||||
for (m in members)
|
||||
if (m.isStatic())
|
||||
result.add(m)
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
private fun getNonStatic(members : List<out Member>) : List<Member> {
|
||||
val result : List<Member> = arrayList()
|
||||
for (m in members)
|
||||
if (!m.isStatic())
|
||||
{
|
||||
result.add(m)
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<String> modifiers, List<Element> typeParameters, List<Type> extendsTypes,
|
||||
List<Expression> baseClassParams, List<Type> implementsTypes, List<Member> 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 +
|
||||
"}";
|
||||
}
|
||||
}
|
||||
@@ -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<String?>,
|
||||
typeParameters : List<Element>,
|
||||
extendsTypes : List<Type>,
|
||||
baseClassParams : List<Expression>,
|
||||
implementsTypes : List<Type>,
|
||||
members : List<Member>) : 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}"
|
||||
}
|
||||
}
|
||||
@@ -48,4 +48,9 @@ public abstract class Member extends Node implements IMember {
|
||||
public boolean isStatic() {
|
||||
return myModifiers.contains(Modifier.STATIC);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public Set<String> getModifiers() {
|
||||
return myModifiers;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<String> modifiers, List<Element> typeParameters, List<Type> extendsTypes,
|
||||
List<Expression> baseClassParams, List<Type> implementsTypes, List<Member> members) {
|
||||
super(converter, name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, getMembers(members, converter));
|
||||
TYPE = "trait";
|
||||
}
|
||||
|
||||
@Override
|
||||
String primaryConstructorSignatureToKotlin() {
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
boolean needOpenModifier() {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -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<String?>,
|
||||
typeParameters : List<Element>,
|
||||
extendsTypes : List<Type>,
|
||||
baseClassParams : List<Expression>,
|
||||
implementsTypes : List<Type>,
|
||||
members : List<Member>) : Class(converter, name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, members) {
|
||||
|
||||
override val TYPE: String
|
||||
get() = "trait"
|
||||
|
||||
override fun primaryConstructorSignatureToKotlin() = ""
|
||||
override fun needOpenModifier() = false
|
||||
}
|
||||
Reference in New Issue
Block a user