Refactor delegate members to light members conversion

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<KtLightField> {
+    override fun getOwnFields(containingClass: KtLightClass) = KtLightFieldImpl.fromClsFields(clsDelegate, containingClass)
-        return clsDelegate.fields.map { KtLightFieldImpl.fromClsField(it, containingClass) }
-    }
 
-    override fun getOwnMethods(containingClass: KtLightClass): List<KtLightMethod> {
+    override fun getOwnMethods(containingClass: KtLightClass) = KtLightMethodImpl.fromClsMethods(clsDelegate, containingClass)
-        return clsDelegate.methods.map { KtLightMethodImpl.fromClsMethod(it, containingClass) }
-    }
 }
 
 object InvalidLightClassDataHolder : LightClassDataHolder.ForClass {

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.ItemPresentationProviders
-import com.intellij.navigation.ItemPresentation;
+import com.intellij.psi.*
-import com.intellij.navigation.ItemPresentationProviders;
+import com.intellij.psi.impl.PsiClassImplUtil
-import com.intellij.psi.*;
+import com.intellij.psi.impl.light.AbstractLightClass
-import com.intellij.psi.impl.PsiClassImplUtil;
+import com.intellij.psi.impl.source.ClassInnerStuffCache
-import com.intellij.psi.impl.light.AbstractLightClass;
+import com.intellij.psi.impl.source.PsiExtensibleClass
-import com.intellij.psi.impl.source.ClassInnerStuffCache;
+import com.intellij.psi.scope.PsiScopeProcessor
-import com.intellij.psi.impl.source.PsiExtensibleClass;
+import org.jetbrains.kotlin.asJava.elements.KtLightFieldImpl
-import com.intellij.psi.scope.PsiScopeProcessor;
+import org.jetbrains.kotlin.asJava.elements.KtLightMethodImpl
-import com.intellij.util.Function;
+import org.jetbrains.kotlin.idea.KotlinLanguage
-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 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 {
+    override fun getDelegate() = clsDelegate
-    private final ClassInnerStuffCache myInnersCache = new ClassInnerStuffCache(this);
 
-    protected KtLightClassBase(PsiManager manager) {
+    override fun getFields() = myInnersCache.fields
-        super(manager, KotlinLanguage.INSTANCE);
-    }
 
-    @NotNull
+    override fun getMethods() = myInnersCache.methods
-    @Override
-    public PsiClass getDelegate() {
-        return getClsDelegate();
-    }
 
-    @Override
+    override fun getConstructors() = myInnersCache.constructors
-    @NotNull
-    public PsiField[] getFields() {
-        return myInnersCache.getFields();
-    }
 
-    @Override
+    override fun getInnerClasses() = myInnersCache.innerClasses
-    @NotNull
-    public PsiMethod[] getMethods() {
-        return myInnersCache.getMethods();
-    }
 
-    @Override
+    override fun getAllFields() = PsiClassImplUtil.getAllFields(this)
-    @NotNull
-    public PsiMethod[] getConstructors() {
-        return myInnersCache.getConstructors();
-    }
 
-    @Override
+    override fun getAllMethods() = PsiClassImplUtil.getAllMethods(this)
-    @NotNull
-    public PsiClass[] getInnerClasses() {
-        return myInnersCache.getInnerClasses();
-    }
 
-    @Override
+    override fun getAllInnerClasses() = PsiClassImplUtil.getAllInnerClasses(this)
-    @NotNull
-    public PsiField[] getAllFields() {
-        return PsiClassImplUtil.getAllFields(this);
-    }
 
-    @Override
+    override fun findFieldByName(name: String, checkBases: Boolean) = myInnersCache.findFieldByName(name, checkBases)
-    @NotNull
-    public PsiMethod[] getAllMethods() {
-        return PsiClassImplUtil.getAllMethods(this);
-    }
 
-    @Override
+    override fun findMethodsByName(name: String, checkBases: Boolean) = myInnersCache.findMethodsByName(name, checkBases)
-    @NotNull
-    public PsiClass[] getAllInnerClasses() {
-        return PsiClassImplUtil.getAllInnerClasses(this);
-    }
 
-    @Override
+    override fun findInnerClassByName(name: String, checkBases: Boolean) = myInnersCache.findInnerClassByName(name, checkBases)
-    public PsiField findFieldByName(String name, boolean checkBases) {
-        return myInnersCache.findFieldByName(name, checkBases);
-    }
 
-    @Override
+    override fun getOwnFields(): List<PsiField> = KtLightFieldImpl.fromClsFields(delegate, this)
-    @NotNull
-    public PsiMethod[] findMethodsByName(String name, boolean checkBases) {
-        return myInnersCache.findMethodsByName(name, checkBases);
-    }
 
-    @Override
+    override fun getOwnMethods(): List<PsiMethod> = KtLightMethodImpl.fromClsMethods(delegate, this)
-    public PsiClass findInnerClassByName(String name, boolean checkBases) {
-        return myInnersCache.findInnerClassByName(name, checkBases);
-    }
 
-    /**
+    override fun processDeclarations(
-     * @see org.jetbrains.kotlin.codegen.binding.CodegenBinding#ENUM_ENTRY_CLASS_NEED_SUBCLASS
+            processor: PsiScopeProcessor, state: ResolveState, lastParent: PsiElement?, place: PsiElement
-      */
+    ): Boolean {
-    @NotNull
+        if (isEnum) {
-    @Override
+            if (!PsiClassImplUtil.processDeclarationsInEnum(processor, state, myInnersCache)) return false
-    public List<PsiField> getOwnFields() {
-        return ContainerUtil.map(getDelegate().getFields(), new Function<PsiField, PsiField>() {
-            @Override
-            public PsiField fun(PsiField field) {
-                return KtLightFieldImpl.Factory.fromClsField(field, KtLightClassBase.this);
-            }
-        });
-    }
-
-    @NotNull
-    @Override
-    public List<PsiMethod> getOwnMethods() {
-        return ArraysKt.map(getDelegate().getMethods(), new Function1<PsiMethod, PsiMethod>() {
-            @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;
         }
 
-        return super.processDeclarations(processor, state, lastParent, place);
+        return super.processDeclarations(processor, state, lastParent, place)
     }
 
-    @Override
+    override fun getText(): String {
-    public String getText() {
+        val origin = kotlinOrigin
-        KtClassOrObject origin = getKotlinOrigin();
+        return if (origin == null) "" else origin.text
-        return origin == null ? "" : origin.getText();
     }
 
-    @NotNull
+    override fun getLanguage() = KotlinLanguage.INSTANCE
-    @Override
-    public Language getLanguage() {
-        return KotlinLanguage.INSTANCE;
-    }
 
-    @Override
+    override fun getPresentation() = ItemPresentationProviders.getItemPresentation(this)
-    public ItemPresentation getPresentation() {
-        return ItemPresentationProviders.getItemPresentation(this);
-    }
 
-    @Override
+    abstract override fun equals(other: Any?): Boolean
-    public abstract boolean equals(Object obj);
 
-    @Override
+    abstract override fun hashCode(): Int
-    public abstract int hashCode();
 
-    @Override
+    override fun getContext() = parent
-    public PsiElement getContext() {
-        return getParent();
-    }
 }

compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightFieldImpl.kt

@@ -183,10 +183,9 @@ sealed class KtLightFieldImpl<T: PsiField>(
             return KtLightFieldForDeclaration(origin, computeRealDelegate, containingClass, dummyDelegate)
         }
 
-        @JvmStatic
+        fun fromClsFields(delegateClass: PsiClass, containingClass: KtLightClass) = delegateClass.fields.map {
-        fun fromClsField(field: PsiField, containingClass: KtLightClass): KtLightField {
+            val origin = ClsWrapperStubPsiFactory.getMemberOrigin(it)
-            val origin = ClsWrapperStubPsiFactory.getMemberOrigin(field)
+            KtLightFieldImpl.create(origin, it, containingClass)
-            return KtLightFieldImpl.create(origin, field, containingClass)
         }
     }
 }

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

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<KtLightField> {
-            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<KtLightMethod> {
-            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