From ee3eb05e7dc45e610c4f541b3dd8c8eccd6d6f4e Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Tue, 22 May 2012 19:53:28 +0200 Subject: [PATCH] couple more classes converted --- .../jet/j2k/ast/ReferenceElement.java | 45 ------- .../jetbrains/jet/j2k/ast/ReferenceElement.kt | 15 +++ .../jet/j2k/ast/SuperExpression.java | 39 ------ .../jetbrains/jet/j2k/ast/SuperExpression.kt | 11 ++ .../jet/j2k/visitors/ElementVisitor.java | 124 ------------------ .../jet/j2k/visitors/ElementVisitor.kt | 66 ++++++++++ 6 files changed, 92 insertions(+), 208 deletions(-) delete mode 100644 src/org/jetbrains/jet/j2k/ast/ReferenceElement.java create mode 100644 src/org/jetbrains/jet/j2k/ast/ReferenceElement.kt delete mode 100644 src/org/jetbrains/jet/j2k/ast/SuperExpression.java create mode 100644 src/org/jetbrains/jet/j2k/ast/SuperExpression.kt delete mode 100644 src/org/jetbrains/jet/j2k/visitors/ElementVisitor.java create mode 100644 src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt diff --git a/src/org/jetbrains/jet/j2k/ast/ReferenceElement.java b/src/org/jetbrains/jet/j2k/ast/ReferenceElement.java deleted file mode 100644 index 029e56fad5e..00000000000 --- a/src/org/jetbrains/jet/j2k/ast/ReferenceElement.java +++ /dev/null @@ -1,45 +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.ast.types.Type; -import org.jetbrains.jet.j2k.util.AstUtil; - -import java.util.List; - -/** - * @author ignatov - */ -public class ReferenceElement extends Element { - @NotNull - private final Identifier myReference; - @NotNull - private final List myTypes; - - public ReferenceElement(@NotNull Identifier reference, @NotNull List types) { - myReference = reference; - myTypes = types; - } - - @NotNull - @Override - public String toKotlin() { - String typesIfNeeded = myTypes.size() > 0 ? "<" + AstUtil.joinNodes(myTypes, COMMA_WITH_SPACE) + ">" : EMPTY; - return myReference.toKotlin() + typesIfNeeded; - } -} diff --git a/src/org/jetbrains/jet/j2k/ast/ReferenceElement.kt b/src/org/jetbrains/jet/j2k/ast/ReferenceElement.kt new file mode 100644 index 00000000000..ffb66d26fe4 --- /dev/null +++ b/src/org/jetbrains/jet/j2k/ast/ReferenceElement.kt @@ -0,0 +1,15 @@ +package org.jetbrains.jet.j2k.ast + +import org.jetbrains.jet.j2k.ast.types.Type +import org.jetbrains.jet.j2k.util.AstUtil +import java.util.List + +public open class ReferenceElement(val reference : Identifier, val types : List) : Element() { + public override fun toKotlin() : String { + val typesIfNeeded : String = (if (types.size() > 0) + "<" + AstUtil.joinNodes(types, ", ") + ">" + else + "") + return reference.toKotlin() + typesIfNeeded + } +} diff --git a/src/org/jetbrains/jet/j2k/ast/SuperExpression.java b/src/org/jetbrains/jet/j2k/ast/SuperExpression.java deleted file mode 100644 index 7c9f974a573..00000000000 --- a/src/org/jetbrains/jet/j2k/ast/SuperExpression.java +++ /dev/null @@ -1,39 +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; - -/** - * @author ignatov - */ -public class SuperExpression extends Expression { - private final Identifier myIdentifier; - - public SuperExpression(Identifier identifier) { - myIdentifier = identifier; - } - - @NotNull - @Override - public String toKotlin() { - if (myIdentifier.isEmpty()) { - return "super"; - } - return "super" + AT + myIdentifier.toKotlin(); - } -} diff --git a/src/org/jetbrains/jet/j2k/ast/SuperExpression.kt b/src/org/jetbrains/jet/j2k/ast/SuperExpression.kt new file mode 100644 index 00000000000..208bf81fb34 --- /dev/null +++ b/src/org/jetbrains/jet/j2k/ast/SuperExpression.kt @@ -0,0 +1,11 @@ +package org.jetbrains.jet.j2k.ast + + +public open class SuperExpression(val identifier : Identifier) : Expression() { + public override fun toKotlin() : String { + if (identifier.isEmpty()) { + return "super" + } + return "super@" + identifier.toKotlin() + } +} diff --git a/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.java b/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.java deleted file mode 100644 index 3caded05704..00000000000 --- a/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.java +++ /dev/null @@ -1,124 +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.visitors; - -import com.intellij.psi.*; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.j2k.Converter; -import org.jetbrains.jet.j2k.ast.*; -import org.jetbrains.jet.j2k.ast.types.Type; - -import java.util.List; - -import static org.jetbrains.jet.j2k.Converter.modifiersListToModifiersSet; -import static org.jetbrains.jet.j2k.ConverterUtil.isAnnotatedAsNotNull; - -/** - * @author ignatov - */ -public class ElementVisitor extends JavaElementVisitor implements J2KVisitor { - - private final Converter myConverter; - - @NotNull - private Element myResult = Element.EMPTY_ELEMENT; - - public ElementVisitor(@NotNull Converter converter) { - this.myConverter = converter; - } - - @Override - @NotNull - public Converter getConverter() { - return myConverter; - } - - @NotNull - public Element getResult() { - return myResult; - } - - @Override - public void visitLocalVariable(@NotNull PsiLocalVariable variable) { - super.visitLocalVariable(variable); - - myResult = new LocalVariable( - new IdentifierImpl(variable.getName()), // TODO - modifiersListToModifiersSet(variable.getModifierList()), - getConverter().typeToType(variable.getType(), isAnnotatedAsNotNull(variable.getModifierList())), - getConverter().createSureCallOnlyForChain(variable.getInitializer(), variable.getType()) - ); - } - - @Override - public void visitExpressionList(@NotNull PsiExpressionList list) { - super.visitExpressionList(list); - myResult = new ExpressionList( - getConverter().expressionsToExpressionList(list.getExpressions()), - getConverter().typesToTypeList(list.getExpressionTypes()) - ); - } - - @Override - public void visitReferenceElement(@NotNull PsiJavaCodeReferenceElement reference) { - super.visitReferenceElement(reference); - - final List types = getConverter().typesToTypeList(reference.getTypeParameters()); - if (!reference.isQualified()) { - myResult = new ReferenceElement( - new IdentifierImpl(reference.getReferenceName()), - types - ); - } - else { - String result = new IdentifierImpl(reference.getReferenceName()).toKotlin(); - PsiElement qualifier = reference.getQualifier(); - while (qualifier != null) { - final PsiJavaCodeReferenceElement p = (PsiJavaCodeReferenceElement) qualifier; - result = new IdentifierImpl(p.getReferenceName()).toKotlin() + "." + result; // TODO: maybe need to replace by safe call? - qualifier = p.getQualifier(); - } - myResult = new ReferenceElement( - new IdentifierImpl(result), - types - ); - } - } - - @Override - public void visitTypeElement(@NotNull PsiTypeElement type) { - super.visitTypeElement(type); - myResult = new TypeElement(getConverter().typeToType(type.getType())); - } - - @Override - public void visitTypeParameter(@NotNull PsiTypeParameter classParameter) { - super.visitTypeParameter(classParameter); - myResult = new TypeParameter( - new IdentifierImpl(classParameter.getName()), // TODO - getConverter().typesToTypeList(classParameter.getExtendsListTypes()) - ); - } - - @Override - public void visitParameterList(@NotNull PsiParameterList list) { - super.visitParameterList(list); - myResult = new ParameterList( - getConverter().parametersToParameterList(list.getParameters()) - ); - } -} diff --git a/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt b/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt new file mode 100644 index 00000000000..312290e2811 --- /dev/null +++ b/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt @@ -0,0 +1,66 @@ +package org.jetbrains.jet.j2k.visitors + +import com.intellij.psi.* +import org.jetbrains.jet.j2k.Converter +import org.jetbrains.jet.j2k.ast.* +import org.jetbrains.jet.j2k.ast.types.Type +import java.util.List +import org.jetbrains.jet.j2k.Converter.modifiersListToModifiersSet +import org.jetbrains.jet.j2k.ConverterUtil.isAnnotatedAsNotNull + +public open class ElementVisitor(val myConverter : Converter) : JavaElementVisitor(), J2KVisitor { + private var myResult : Element = Element.EMPTY_ELEMENT + + public override fun getConverter() : Converter { + return myConverter + } + + public open fun getResult() : Element { + return myResult + } + + public override fun visitLocalVariable(variable : PsiLocalVariable?) : Unit { + val theVariable = variable!! + myResult = LocalVariable(IdentifierImpl(theVariable.getName()), + modifiersListToModifiersSet(theVariable.getModifierList()), + myConverter.typeToType(theVariable.getType(), isAnnotatedAsNotNull(theVariable.getModifierList())), + myConverter.createSureCallOnlyForChain(theVariable.getInitializer(), theVariable.getType())) + } + + public override fun visitExpressionList(list : PsiExpressionList?) : Unit { + myResult = ExpressionList(myConverter.expressionsToExpressionList(list!!.getExpressions()), + myConverter.typesToTypeList(list!!.getExpressionTypes())) + } + + public override fun visitReferenceElement(reference : PsiJavaCodeReferenceElement?) : Unit { + val theReference = reference!! + val types : List = myConverter.typesToTypeList(theReference.getTypeParameters()).requireNoNulls() + if (!theReference.isQualified()) { + myResult = ReferenceElement(IdentifierImpl(theReference.getReferenceName()), types) + } + else { + var result : String = IdentifierImpl(reference?.getReferenceName()).toKotlin() + var qualifier : PsiElement? = theReference.getQualifier() + while (qualifier != null) + { + val p : PsiJavaCodeReferenceElement = (qualifier as PsiJavaCodeReferenceElement) + result = IdentifierImpl(p.getReferenceName()).toKotlin() + "." + result + qualifier = p.getQualifier() + } + myResult = ReferenceElement(IdentifierImpl(result), types) + } + } + + public override fun visitTypeElement(`type` : PsiTypeElement?) : Unit { + myResult = TypeElement(myConverter.typeToType(`type`!!.getType())) + } + + public override fun visitTypeParameter(classParameter : PsiTypeParameter?) : Unit { + myResult = TypeParameter(IdentifierImpl(classParameter!!.getName()), + classParameter!!.getExtendsListTypes().map { myConverter.typeToType(it) } ) + } + + public override fun visitParameterList(list : PsiParameterList?) : Unit { + myResult = ParameterList(myConverter.parametersToParameterList(list!!.getParameters())) + } +}