diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/LightClassDataHolder.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/LightClassDataHolder.kt index ffef15dbdf0..b06d68f2814 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/LightClassDataHolder.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/LightClassDataHolder.kt @@ -66,13 +66,9 @@ interface LightClassData { } class LightClassDataImpl(override val clsDelegate: PsiClass) : LightClassData { - override fun getOwnFields(containingClass: KtLightClass): List { - return clsDelegate.fields.map { KtLightFieldImpl.fromClsField(it, containingClass) } - } + override fun getOwnFields(containingClass: KtLightClass) = KtLightFieldImpl.fromClsFields(clsDelegate, containingClass) - override fun getOwnMethods(containingClass: KtLightClass): List { - return clsDelegate.methods.map { KtLightMethodImpl.fromClsMethod(it, containingClass) } - } + override fun getOwnMethods(containingClass: KtLightClass) = KtLightMethodImpl.fromClsMethods(clsDelegate, containingClass) } object InvalidLightClassDataHolder : LightClassDataHolder.ForClass { diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassBase.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassBase.kt index 9b1f4eb0795..b6e818ed2b2 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassBase.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassBase.kt @@ -14,161 +14,71 @@ * limitations under the License. */ -package org.jetbrains.kotlin.asJava.classes; +package org.jetbrains.kotlin.asJava.classes -import com.intellij.lang.Language; -import com.intellij.navigation.ItemPresentation; -import com.intellij.navigation.ItemPresentationProviders; -import com.intellij.psi.*; -import com.intellij.psi.impl.PsiClassImplUtil; -import com.intellij.psi.impl.light.AbstractLightClass; -import com.intellij.psi.impl.source.ClassInnerStuffCache; -import com.intellij.psi.impl.source.PsiExtensibleClass; -import com.intellij.psi.scope.PsiScopeProcessor; -import com.intellij.util.Function; -import com.intellij.util.containers.ContainerUtil; -import kotlin.collections.ArraysKt; -import kotlin.jvm.functions.Function1; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.asJava.elements.KtLightFieldImpl; -import org.jetbrains.kotlin.asJava.elements.KtLightMethodImpl; -import org.jetbrains.kotlin.idea.KotlinLanguage; -import org.jetbrains.kotlin.psi.KtClassOrObject; +import com.intellij.navigation.ItemPresentationProviders +import com.intellij.psi.* +import com.intellij.psi.impl.PsiClassImplUtil +import com.intellij.psi.impl.light.AbstractLightClass +import com.intellij.psi.impl.source.ClassInnerStuffCache +import com.intellij.psi.impl.source.PsiExtensibleClass +import com.intellij.psi.scope.PsiScopeProcessor +import org.jetbrains.kotlin.asJava.elements.KtLightFieldImpl +import org.jetbrains.kotlin.asJava.elements.KtLightMethodImpl +import org.jetbrains.kotlin.idea.KotlinLanguage -import java.util.List; +abstract class KtLightClassBase protected constructor(manager: PsiManager) + : AbstractLightClass(manager, KotlinLanguage.INSTANCE), KtLightClass, PsiExtensibleClass { + private val myInnersCache = ClassInnerStuffCache(this) -public abstract class KtLightClassBase extends AbstractLightClass implements KtLightClass, PsiExtensibleClass { - private final ClassInnerStuffCache myInnersCache = new ClassInnerStuffCache(this); + override fun getDelegate() = clsDelegate - protected KtLightClassBase(PsiManager manager) { - super(manager, KotlinLanguage.INSTANCE); - } + override fun getFields() = myInnersCache.fields - @NotNull - @Override - public PsiClass getDelegate() { - return getClsDelegate(); - } + override fun getMethods() = myInnersCache.methods - @Override - @NotNull - public PsiField[] getFields() { - return myInnersCache.getFields(); - } + override fun getConstructors() = myInnersCache.constructors - @Override - @NotNull - public PsiMethod[] getMethods() { - return myInnersCache.getMethods(); - } + override fun getInnerClasses() = myInnersCache.innerClasses - @Override - @NotNull - public PsiMethod[] getConstructors() { - return myInnersCache.getConstructors(); - } + override fun getAllFields() = PsiClassImplUtil.getAllFields(this) - @Override - @NotNull - public PsiClass[] getInnerClasses() { - return myInnersCache.getInnerClasses(); - } + override fun getAllMethods() = PsiClassImplUtil.getAllMethods(this) - @Override - @NotNull - public PsiField[] getAllFields() { - return PsiClassImplUtil.getAllFields(this); - } + override fun getAllInnerClasses() = PsiClassImplUtil.getAllInnerClasses(this) - @Override - @NotNull - public PsiMethod[] getAllMethods() { - return PsiClassImplUtil.getAllMethods(this); - } + override fun findFieldByName(name: String, checkBases: Boolean) = myInnersCache.findFieldByName(name, checkBases) - @Override - @NotNull - public PsiClass[] getAllInnerClasses() { - return PsiClassImplUtil.getAllInnerClasses(this); - } + override fun findMethodsByName(name: String, checkBases: Boolean) = myInnersCache.findMethodsByName(name, checkBases) - @Override - public PsiField findFieldByName(String name, boolean checkBases) { - return myInnersCache.findFieldByName(name, checkBases); - } + override fun findInnerClassByName(name: String, checkBases: Boolean) = myInnersCache.findInnerClassByName(name, checkBases) - @Override - @NotNull - public PsiMethod[] findMethodsByName(String name, boolean checkBases) { - return myInnersCache.findMethodsByName(name, checkBases); - } + override fun getOwnFields(): List = KtLightFieldImpl.fromClsFields(delegate, this) - @Override - public PsiClass findInnerClassByName(String name, boolean checkBases) { - return myInnersCache.findInnerClassByName(name, checkBases); - } + override fun getOwnMethods(): List = KtLightMethodImpl.fromClsMethods(delegate, this) - /** - * @see org.jetbrains.kotlin.codegen.binding.CodegenBinding#ENUM_ENTRY_CLASS_NEED_SUBCLASS - */ - @NotNull - @Override - public List getOwnFields() { - return ContainerUtil.map(getDelegate().getFields(), new Function() { - @Override - public PsiField fun(PsiField field) { - return KtLightFieldImpl.Factory.fromClsField(field, KtLightClassBase.this); - } - }); - } - - @NotNull - @Override - public List getOwnMethods() { - return ArraysKt.map(getDelegate().getMethods(), new Function1() { - @Override - public PsiMethod invoke(PsiMethod method) { - return KtLightMethodImpl.fromClsMethod(method, KtLightClassBase.this); - } - }); - } - - @Override - public boolean processDeclarations( - @NotNull PsiScopeProcessor processor, @NotNull ResolveState state, PsiElement lastParent, @NotNull PsiElement place - ) { - if (isEnum()) { - if (!PsiClassImplUtil.processDeclarationsInEnum(processor, state, myInnersCache)) return false; + override fun processDeclarations( + processor: PsiScopeProcessor, state: ResolveState, lastParent: PsiElement?, place: PsiElement + ): Boolean { + if (isEnum) { + if (!PsiClassImplUtil.processDeclarationsInEnum(processor, state, myInnersCache)) return false } - return super.processDeclarations(processor, state, lastParent, place); + return super.processDeclarations(processor, state, lastParent, place) } - @Override - public String getText() { - KtClassOrObject origin = getKotlinOrigin(); - return origin == null ? "" : origin.getText(); + override fun getText(): String { + val origin = kotlinOrigin + return if (origin == null) "" else origin.text } - @NotNull - @Override - public Language getLanguage() { - return KotlinLanguage.INSTANCE; - } + override fun getLanguage() = KotlinLanguage.INSTANCE - @Override - public ItemPresentation getPresentation() { - return ItemPresentationProviders.getItemPresentation(this); - } + override fun getPresentation() = ItemPresentationProviders.getItemPresentation(this) - @Override - public abstract boolean equals(Object obj); + abstract override fun equals(other: Any?): Boolean - @Override - public abstract int hashCode(); + abstract override fun hashCode(): Int - @Override - public PsiElement getContext() { - return getParent(); - } + override fun getContext() = parent } diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightFieldImpl.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightFieldImpl.kt index c9cf930b28e..6d5c0342d80 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightFieldImpl.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightFieldImpl.kt @@ -183,10 +183,9 @@ sealed class KtLightFieldImpl( return KtLightFieldForDeclaration(origin, computeRealDelegate, containingClass, dummyDelegate) } - @JvmStatic - fun fromClsField(field: PsiField, containingClass: KtLightClass): KtLightField { - val origin = ClsWrapperStubPsiFactory.getMemberOrigin(field) - return KtLightFieldImpl.create(origin, field, containingClass) + fun fromClsFields(delegateClass: PsiClass, containingClass: KtLightClass) = delegateClass.fields.map { + val origin = ClsWrapperStubPsiFactory.getMemberOrigin(it) + KtLightFieldImpl.create(origin, it, containingClass) } } } diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightMethod.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightMethod.kt index f851cf11387..448475f19e8 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightMethod.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightMethod.kt @@ -238,13 +238,6 @@ class KtLightMethodImpl private constructor( return KtLightMethodImpl({ delegate}, origin, containingClass) } - @JvmStatic - fun fromClsMethod(method: PsiMethod, containingClass: KtLightClass): KtLightMethodImpl { - val origin = ClsWrapperStubPsiFactory.getMemberOrigin(method) - return KtLightMethodImpl.create(method, adjustMethodOrigin(origin), containingClass) - } - - @JvmStatic fun lazy( dummyDelegate: PsiMethod?, containingClass: KtLightClass, @@ -253,6 +246,11 @@ class KtLightMethodImpl private constructor( ): KtLightMethodImpl { return KtLightMethodImpl(computeRealDelegate, adjustMethodOrigin(origin), containingClass, dummyDelegate) } + + fun fromClsMethods(delegateClass: PsiClass, containingClass: KtLightClass) = delegateClass.methods.map { + val origin = ClsWrapperStubPsiFactory.getMemberOrigin(it) + KtLightMethodImpl.create(it, adjustMethodOrigin(origin), containingClass) + } } override fun getName() = dummyDelegate?.name ?: clsDelegate.name diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/lightClasses/LazyLightClassDataHolder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/lightClasses/LazyLightClassDataHolder.kt index 3c9cfe7e59f..64f7cf45db0 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/lightClasses/LazyLightClassDataHolder.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/lightClasses/LazyLightClassDataHolder.kt @@ -79,7 +79,7 @@ sealed class LazyLightClassDataHolder( private val dummyDelegate: PsiClass? by lazyPub { inexactResult?.let(findDelegate) } override fun getOwnFields(containingClass: KtLightClass): List { - if (dummyDelegate == null) return clsDelegate.fields.map { KtLightFieldImpl.fromClsField(it, containingClass) } + if (dummyDelegate == null) return KtLightFieldImpl.fromClsFields(clsDelegate, containingClass) return dummyDelegate!!.fields.map { dummyField -> val memberOrigin = ClsWrapperStubPsiFactory.getMemberOrigin(dummyField)!! @@ -93,7 +93,7 @@ sealed class LazyLightClassDataHolder( } override fun getOwnMethods(containingClass: KtLightClass): List { - if (dummyDelegate == null) return clsDelegate.methods.map { KtLightMethodImpl.fromClsMethod(it, containingClass) } + if (dummyDelegate == null) return KtLightMethodImpl.fromClsMethods(clsDelegate, containingClass) return dummyDelegate!!.methods.map { dummyMethod -> val methodName = dummyMethod.name