From e6b498f943c84cb058b363cd8b7f350b02ea8336 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Thu, 29 Oct 2015 16:19:34 +0300 Subject: [PATCH] J2K KotlinLightField: convert and fix compilation --- .../kotlin/asJava/KotlinLightField.kt | 194 +++++++----------- 1 file changed, 77 insertions(+), 117 deletions(-) diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightField.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightField.kt index 21d9100eb9b..53cc4fbdb18 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightField.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightField.kt @@ -14,177 +14,137 @@ * limitations under the License. */ -package org.jetbrains.kotlin.asJava; +package org.jetbrains.kotlin.asJava -import com.intellij.lang.Language; -import com.intellij.lang.java.JavaLanguage; -import com.intellij.openapi.util.TextRange; -import com.intellij.psi.*; -import com.intellij.psi.impl.light.LightElement; -import com.intellij.psi.javadoc.PsiDocComment; -import com.intellij.psi.search.SearchScope; -import com.intellij.util.IncorrectOperationException; -import org.jetbrains.annotations.NonNls; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.idea.KotlinLanguage; -import org.jetbrains.kotlin.psi.KtDeclaration; +import com.intellij.lang.Language +import com.intellij.lang.java.JavaLanguage +import com.intellij.openapi.util.TextRange +import com.intellij.psi.* +import com.intellij.psi.impl.light.LightElement +import com.intellij.psi.javadoc.PsiDocComment +import com.intellij.psi.search.SearchScope +import com.intellij.util.IncorrectOperationException +import org.jetbrains.annotations.NonNls +import org.jetbrains.kotlin.idea.KotlinLanguage +import org.jetbrains.kotlin.psi.KtDeclaration // Copied from com.intellij.psi.impl.light.LightField -public abstract class KotlinLightField extends LightElement - implements PsiField, KotlinLightElement { - private final T origin; - private final D delegate; - private final PsiClass containingClass; +abstract class KotlinLightField( + manager: PsiManager, + private val origin: T, + private val delegate: D, + private val containingClass: PsiClass +) : LightElement(manager, JavaLanguage.INSTANCE), PsiField, KotlinLightElement { - public KotlinLightField(@NotNull PsiManager manager, @NotNull T origin, @NotNull D delegate, @NotNull PsiClass containingClass) { - super(manager, JavaLanguage.INSTANCE); - this.origin = origin; - this.delegate = delegate; - this.containingClass = containingClass; + abstract override fun copy(): KotlinLightField + + @Throws(IncorrectOperationException::class) + override fun setInitializer(initializer: PsiExpression?) { + throw IncorrectOperationException("Not supported") } - @NotNull - @Override - public abstract KotlinLightField copy(); - - @Override - public void setInitializer(@Nullable PsiExpression initializer) throws IncorrectOperationException { - throw new IncorrectOperationException("Not supported"); + override fun getUseScope(): SearchScope { + return origin.useScope } - @NotNull - @Override - public SearchScope getUseScope() { - return origin.getUseScope(); + override fun getName(): String? { + return delegate.name } - @Override - public String getName() { - return delegate.getName(); + override fun getNameIdentifier(): PsiIdentifier { + return delegate.nameIdentifier } - @NotNull - @Override - public PsiIdentifier getNameIdentifier() { - return delegate.getNameIdentifier(); + override fun getDocComment(): PsiDocComment? { + return delegate.docComment } - @Override - public PsiDocComment getDocComment() { - return delegate.getDocComment(); + override fun isDeprecated(): Boolean { + return delegate.isDeprecated } - @Override - public boolean isDeprecated() { - return delegate.isDeprecated(); + override fun getContainingClass(): PsiClass? { + return containingClass } - @Override - public PsiClass getContainingClass() { - return containingClass; + override fun getType(): PsiType { + return delegate.type } - @NotNull - @Override - public PsiType getType() { - return delegate.getType(); + override fun getTypeElement(): PsiTypeElement? { + return delegate.typeElement } - @Override - public PsiTypeElement getTypeElement() { - return delegate.getTypeElement(); + override fun getInitializer(): PsiExpression? { + return delegate.initializer } - @Override - public PsiExpression getInitializer() { - return delegate.getInitializer(); + override fun hasInitializer(): Boolean { + return delegate.hasInitializer() } - @Override - public boolean hasInitializer() { - return delegate.hasInitializer(); + @Throws(IncorrectOperationException::class) + override fun normalizeDeclaration() { + throw IncorrectOperationException("Not supported") } - @Override - public void normalizeDeclaration() throws IncorrectOperationException { - throw new IncorrectOperationException("Not supported"); + override fun computeConstantValue(): Any? { + return delegate.computeConstantValue() } - @Override - public Object computeConstantValue() { - return delegate.computeConstantValue(); + @Throws(IncorrectOperationException::class) + override fun setName(@NonNls name: String): PsiElement { + throw IncorrectOperationException("Not supported") } - @Override - public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException { - throw new IncorrectOperationException("Not supported"); + override fun getModifierList(): PsiModifierList? { + return delegate.modifierList } - @Override - public PsiModifierList getModifierList() { - return delegate.getModifierList(); + override fun hasModifierProperty(@NonNls name: String): Boolean { + return delegate.hasModifierProperty(name) } - @Override - public boolean hasModifierProperty(@NonNls @NotNull String name) { - return delegate.hasModifierProperty(name); + override fun getText(): String { + return delegate.text } - @Override - public String getText() { - return delegate.getText(); + override fun getTextRange(): TextRange { + return TextRange(-1, -1) } - @Override - public TextRange getTextRange() { - return new TextRange(-1, -1); + override fun isValid(): Boolean { + return containingClass.isValid } - @Override - public boolean isValid() { - return containingClass.isValid(); + override fun toString(): String { + return "KotlinLightField:" + name!! } - @Override - public String toString() { - return "KotlinLightField:" + getName(); + override fun getOrigin(): T { + return origin } - @NotNull - @Override - public T getOrigin() { - return origin; + override fun getDelegate(): D { + return delegate } - @NotNull - @Override - public D getDelegate() { - return delegate; + override fun getNavigationElement(): PsiElement { + return getOrigin() } - @NotNull - @Override - public PsiElement getNavigationElement() { - return getOrigin(); + override fun getLanguage(): Language { + return KotlinLanguage.INSTANCE } - @NotNull - @Override - public Language getLanguage() { - return KotlinLanguage.INSTANCE; - } - - @Override - public boolean isEquivalentTo(PsiElement another) { - if (another instanceof KotlinLightField && origin.isEquivalentTo(((KotlinLightField) another).getOrigin())) { - return true; + override fun isEquivalentTo(another: PsiElement?): Boolean { + if (another is KotlinLightField<*, *> && origin.isEquivalentTo(another.getOrigin())) { + return true } - return super.isEquivalentTo(another); + return super.isEquivalentTo(another) } - @Override - public boolean isWritable() { - return getOrigin().isWritable(); + override fun isWritable(): Boolean { + return getOrigin().isWritable } }