Light classes in IDE: Make light class delegate construction a two step process

Step 0: Light class object is created, no delegates are computed Step 1: constructs dummy delegate which can not be relied upon to know signature of any member It can be used to construct light field and light method objects (which can correctly respond to some queries) before constructing real delegate Step 2: Construct real delegate if dummy delegate is not enough to respond to a query This speeds up multiple scenarios where getMethods() and getFields() are called on numerous classes Dummy delegate's faster consruction is achieved by using specially setup dumb analysis instead of ide analysis Introduce LazyLightClassDataHolder: which manages creation of Step 1 and Step 2 delegates Introduce MemberIndex: keeping track of member creation order, helps matching light class delegates created in different contexts KtLightMethod and Field: make use of dummy delegate KtLightMethod no longer extends LightMethod since it requires eager delegate construction KtLightMethod now implements PsiAnnotationMethod for convenience (ClsMethodImpl implements PsiAnnotationMethod)
2017-02-16 16:26:11 +03:00
parent ed9e94c632
commit daef8a0eed
15 changed files with 683 additions and 200 deletions
@@ -17,15 +17,23 @@
 package org.jetbrains.kotlin.asJava.builder

 import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiClassType
 import com.intellij.psi.impl.DebugUtil
 import com.intellij.psi.impl.java.stubs.PsiJavaFileStub
 import com.intellij.psi.stubs.StubElement
 import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.asJava.LightClassUtil.findClass
 import org.jetbrains.kotlin.asJava.builder.InvalidLightClassDataHolder.javaFileStub
+import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject
+import org.jetbrains.kotlin.asJava.elements.KtLightField
+import org.jetbrains.kotlin.asJava.elements.KtLightFieldImpl
+import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.asJava.elements.KtLightMethodImpl
+import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.debugText.getDebugText
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics

 interface LightClassDataHolder {
@@ -33,15 +41,33 @@ interface LightClassDataHolder {
    val extraDiagnostics: Diagnostics

    fun findData(findDelegate: (PsiJavaFileStub) -> PsiClass): LightClassData
-    fun findData(classOrObject: KtClassOrObject): LightClassData = findData { it.findDelegate(classOrObject) }
-    fun findData(classFqName: FqName): LightClassData = findData { it.findDelegate(classFqName) }
+
+    fun findDataForDefaultImpls(classOrObject: KtClassOrObject) = findData {
+        it.findDelegate(classOrObject).findInnerClassByName(JvmAbi.DEFAULT_IMPLS_CLASS_NAME, false)
+        ?: throw IllegalStateException("Couldn't get delegate for $this\n in ${DebugUtil.stubTreeToString(it)}")
+    }
+
+    fun findDataForClassOrObject(classOrObject: KtClassOrObject): LightClassData = findData { it.findDelegate(classOrObject) }
+    fun findDataForFacade(classFqName: FqName): LightClassData = findData { it.findDelegate(classFqName) }
 }

 interface LightClassData {
    val clsDelegate: PsiClass
+
+    val supertypes: Array<PsiClassType> get() { return clsDelegate.superTypes }
+
+    fun getOwnFields(containingClass: KtLightClass): List<KtLightField>
+    fun getOwnMethods(containingClass: KtLightClass): List<KtLightMethod>
 }

 class LightClassDataImpl(override val clsDelegate: PsiClass) : LightClassData {
+    override fun getOwnFields(containingClass: KtLightClass): List<KtLightField> {
+        return clsDelegate.fields.map { KtLightFieldImpl.fromClsField(it, containingClass) }
+    }
+
+    override fun getOwnMethods(containingClass: KtLightClass): List<KtLightMethod> {
+        return clsDelegate.methods.map { KtLightMethodImpl.fromClsMethod(it, containingClass) }
+    }
 }

 object InvalidLightClassDataHolder : LightClassDataHolder {
@@ -77,7 +103,7 @@ fun PsiJavaFileStub.findDelegate(classOrObject: KtClassOrObject): PsiClass {
    }

    val stubFileText = DebugUtil.stubTreeToString(this)
-    throw IllegalStateException("Couldn't get delegate for $this\nin $ktFileText\nstub: \n$stubFileText")
+    throw IllegalStateException("Couldn't get delegate for ${classOrObject.getDebugText()}\nin $ktFileText\nstub: \n$stubFileText")
 }

 fun PsiJavaFileStub.findDelegate(classFqName: FqName): PsiClass {
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2017 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.kotlin.asJava.builder
+
+import com.intellij.openapi.util.Key
+import com.intellij.openapi.util.UserDataHolder
+import com.intellij.psi.PsiMember
+import com.intellij.psi.StubBasedPsiElement
+
+data class MemberIndex(private val index: Int) {
+    companion object {
+        @JvmField
+        val KEY = Key.create<MemberIndex>("MEMBER_INDEX")
+    }
+}
+
+val PsiMember.memberIndex: MemberIndex?
+    get() = ((this as? StubBasedPsiElement<*>)?.stub as? UserDataHolder)?.getUserData(MemberIndex.KEY)
@@ -26,8 +26,8 @@ import com.intellij.psi.stubs.StubElement;
 import com.intellij.util.containers.Stack;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.fileClasses.OldPackageFacadeClassUtils;
 import org.jetbrains.kotlin.codegen.AbstractClassBuilder;
+import org.jetbrains.kotlin.fileClasses.OldPackageFacadeClassUtils;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
@@ -53,6 +53,7 @@ public class StubClassBuilder extends AbstractClassBuilder {
    private StubBuildingVisitor v;
    private final Stack<StubElement> parentStack;
    private boolean isPackageClass = false;
+    private int memberIndex = 0;

    public StubClassBuilder(@NotNull Stack<StubElement> parentStack) {
        this.parentStack = parentStack;
@@ -196,6 +197,7 @@ public class StubClassBuilder extends AbstractClassBuilder {
        }

        last.putUserData(ClsWrapperStubPsiFactory.ORIGIN, LightElementOriginKt.toLightMemberOrigin(origin));
+        last.putUserData(MemberIndex.KEY, new MemberIndex(memberIndex++));
    }

    @Override
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2017 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.kotlin.asJava.classes
+
+import com.intellij.psi.PsiManager
+import org.jetbrains.kotlin.asJava.builder.LightClassData
+
+abstract class KtLazyLightClass(manager: PsiManager) : KtLightClassBase(manager) {
+    abstract val lightClassData: LightClassData
+
+
+    override fun getOwnFields() = lightClassData.getOwnFields(this)
+    override fun getOwnMethods() = lightClassData.getOwnMethods(this)
+    override fun getSuperTypes() = lightClassData.supertypes
+
+}
@@ -51,7 +51,7 @@ class KtLightClassForFacade private constructor(
        private val facadeClassFqName: FqName,
        private val lightClassDataCache: CachedValue<LightClassDataHolder>,
        files: Collection<KtFile>
-) : KtLightClassBase(manager) {
+) : KtLazyLightClass(manager) {
    private data class StubCacheKey(val fqName: FqName, val searchScope: GlobalSearchScope)

    class FacadeStubCache(private val project: Project) {
@@ -194,8 +194,12 @@ class KtLightClassForFacade private constructor(

    override fun copy() = KtLightClassForFacade(manager, facadeClassFqName, lightClassDataCache, files)

+    override val lightClassData by lazy(LazyThreadSafetyMode.PUBLICATION) {
+        lightClassDataCache.value.findDataForFacade(facadeClassFqName)
+    }
+
    override val clsDelegate: PsiClass
-        get() = lightClassDataCache.value.findData(facadeClassFqName).clsDelegate
+        get() = lightClassData.clsDelegate

    override fun getNavigationElement() = files.iterator().next()

@@ -17,15 +17,12 @@
 package org.jetbrains.kotlin.asJava.classes

 import com.intellij.psi.*
-import com.intellij.psi.impl.DebugUtil
 import com.intellij.util.IncorrectOperationException
 import org.jetbrains.kotlin.asJava.builder.LightClassData
-import org.jetbrains.kotlin.asJava.builder.findDelegate
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.KtClassOrObject

-class KtLightClassForInterfaceDefaultImpls(
-        classOrObject: KtClassOrObject)
+class KtLightClassForInterfaceDefaultImpls(classOrObject: KtClassOrObject)
    : KtLightClassForSourceDeclaration(classOrObject) {
    override fun getQualifiedName(): String? = containingClass?.qualifiedName?.let { it + ".${JvmAbi.DEFAULT_IMPLS_CLASS_NAME}" }

@@ -37,10 +34,7 @@ class KtLightClassForInterfaceDefaultImpls(
    }

    override fun findLightClassData(): LightClassData {
-        return getLightClassDataHolder().findData {
-            it.findDelegate(classOrObject).findInnerClassByName(JvmAbi.DEFAULT_IMPLS_CLASS_NAME, false)
-            ?: throw IllegalStateException("Couldn't get delegate for $this\n in ${DebugUtil.stubTreeToString(it)}")
-        }
+        return getLightClassDataHolder().findDataForDefaultImpls(classOrObject)
    }

    override fun getTypeParameterList(): PsiTypeParameterList? = null
@@ -59,7 +59,7 @@ import java.util.*
 import javax.swing.Icon

 abstract class KtLightClassForSourceDeclaration(protected val classOrObject: KtClassOrObject)
-    : KtLightClassBase(classOrObject.manager), StubBasedPsiElement<KotlinClassOrObjectStub<out KtClassOrObject>> {
+    : KtLazyLightClass(classOrObject.manager), StubBasedPsiElement<KotlinClassOrObjectStub<out KtClassOrObject>> {
    private val lightIdentifier = KtLightIdentifier(this, classOrObject)

    private val _extendsList by lazy(LazyThreadSafetyMode.PUBLICATION) {
@@ -80,9 +80,9 @@ abstract class KtLightClassForSourceDeclaration(protected val classOrObject: KtC

    override val clsDelegate: PsiClass get() = lightClassData.clsDelegate

-    private val lightClassData: LightClassData by lazy(LazyThreadSafetyMode.PUBLICATION) { findLightClassData() }
+    override val lightClassData: LightClassData by lazy(LazyThreadSafetyMode.PUBLICATION) { findLightClassData() }

-    open protected fun findLightClassData() = getLightClassDataHolder().findData(classOrObject)
+    open protected fun findLightClassData() = getLightClassDataHolder().findDataForClassOrObject(classOrObject)

    private fun getJavaFileStub(): PsiJavaFileStub = getLightClassDataHolder().javaFileStub

@@ -36,13 +36,16 @@ import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import java.lang.UnsupportedOperationException

 // Copied from com.intellij.psi.impl.light.LightField
-sealed class KtLightFieldImpl(
+sealed class KtLightFieldImpl<T: PsiField>(
        override val lightMemberOrigin: LightMemberOrigin?,
-        override val clsDelegate: PsiField,
-        private val containingClass: KtLightClass
-) : LightElement(clsDelegate.manager, KotlinLanguage.INSTANCE), KtLightField {
+        computeRealDelegate: () -> T,
+        private val containingClass: KtLightClass,
+        private val dummyDelegate: PsiField?
+) : LightElement(containingClass.manager, KotlinLanguage.INSTANCE), KtLightField {
    private val lightIdentifier by lazy(LazyThreadSafetyMode.PUBLICATION) { KtLightIdentifier(this, kotlinOrigin as? KtNamedDeclaration) }

+    override val clsDelegate: T by lazy(LazyThreadSafetyMode.PUBLICATION, computeRealDelegate)
+
    @Throws(IncorrectOperationException::class)
    override fun setInitializer(initializer: PsiExpression?) = throw IncorrectOperationException("Not supported")

@@ -50,7 +53,7 @@ sealed class KtLightFieldImpl(

    override fun getPresentation(): ItemPresentation? = (kotlinOrigin ?: this).let { ItemPresentationProviders.getItemPresentation(it) }

-    override fun getName() = clsDelegate.name
+    override fun getName() = dummyDelegate?.name ?: clsDelegate.name

    override fun getNameIdentifier() = lightIdentifier

@@ -134,41 +137,58 @@ sealed class KtLightFieldImpl(

    class KtLightEnumConstant(
            origin: LightMemberOrigin?,
-            override val clsDelegate: PsiEnumConstant,
+            computeDelegate: () -> PsiEnumConstant,
            containingClass: KtLightClass,
-            private val initializingClass: PsiEnumConstantInitializer?
-    ) : KtLightFieldImpl(origin, clsDelegate, containingClass), PsiEnumConstant {
+            dummyDelegate: PsiField?
+    ) : KtLightFieldImpl<PsiEnumConstant>(origin, computeDelegate , containingClass, dummyDelegate), PsiEnumConstant {
+        private val initializingClass by lazy(LazyThreadSafetyMode.PUBLICATION) {
+            val kotlinEnumEntry = (lightMemberOrigin as? LightMemberOriginForDeclaration)?.originalElement as? KtEnumEntry
+            if (kotlinEnumEntry != null && kotlinEnumEntry.declarations.isNotEmpty()) {
+                KtLightClassForEnumEntry(kotlinEnumEntry, clsDelegate)
+            }
+            else null
+        }
+
        // NOTE: we don't use "delegation by" because the compiler would generate method calls to ALL of PsiEnumConstant members,
        // but we need only members whose implementations are not present in KotlinLightField
        override fun getArgumentList() = clsDelegate.argumentList

        override fun getInitializingClass(): PsiEnumConstantInitializer? = initializingClass
-        override fun getOrCreateInitializingClass(): PsiEnumConstantInitializer =
-                initializingClass ?: throw UnsupportedOperationException("Can't create enum constant body: ${clsDelegate.name}")
+        override fun getOrCreateInitializingClass(): PsiEnumConstantInitializer {
+            return initializingClass ?: throw UnsupportedOperationException("Can't create enum constant body: ${clsDelegate.name}")
+        }

        override fun resolveConstructor() = clsDelegate.resolveConstructor()
        override fun resolveMethod() = clsDelegate.resolveMethod()
        override fun resolveMethodGenerics() = clsDelegate.resolveMethodGenerics()
    }

-    class KtLightFieldForDeclaration(origin: LightMemberOrigin?, delegate: PsiField, containingClass: KtLightClass) :
-            KtLightFieldImpl(origin, delegate, containingClass)
+    class KtLightFieldForDeclaration(origin: LightMemberOrigin?, computeDelegate: () -> PsiField, containingClass: KtLightClass, dummyDelegate: PsiField?) :
+            KtLightFieldImpl<PsiField>(origin, computeDelegate, containingClass, dummyDelegate)

    companion object Factory {
        fun create(origin: LightMemberOrigin?, delegate: PsiField, containingClass: KtLightClass): KtLightField {
            when (delegate) {
                is PsiEnumConstant -> {
-                    val kotlinEnumEntry = (origin as? LightMemberOriginForDeclaration)?.originalElement as? KtEnumEntry
-                    val initializingClass = if (kotlinEnumEntry != null && kotlinEnumEntry.declarations.isNotEmpty()) {
-                        KtLightClassForEnumEntry(kotlinEnumEntry, delegate)
-                    }
-                    else null
-                    return KtLightEnumConstant(origin, delegate, containingClass, initializingClass)
+                    return KtLightEnumConstant(origin, { delegate }, containingClass, null)
                }
-                else -> return KtLightFieldForDeclaration(origin, delegate, containingClass)
+                else -> return KtLightFieldForDeclaration(origin, { delegate }, containingClass, null)
            }
        }

+        fun lazy(
+                dummyDelegate: PsiField,
+                origin: LightMemberOriginForDeclaration,
+                containingClass: KtLightClass,
+                computeRealDelegate: () -> PsiField
+        ): KtLightField {
+            if (dummyDelegate is PsiEnumConstant) {
+                @Suppress("UNCHECKED_CAST")
+                return KtLightEnumConstant(origin, computeRealDelegate as () -> PsiEnumConstant, containingClass, dummyDelegate)
+            }
+            return KtLightFieldForDeclaration(origin, computeRealDelegate, containingClass, dummyDelegate)
+        }
+
        @JvmStatic
        fun fromClsField(field: PsiField, containingClass: KtLightClass): KtLightField {
            val origin = ClsWrapperStubPsiFactory.getMemberOrigin(field)
@@ -21,8 +21,8 @@ import com.intellij.navigation.ItemPresentation
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.*
 import com.intellij.psi.impl.compiled.ClsTypeElementImpl
-import com.intellij.psi.impl.light.LightMethod
-import com.intellij.psi.impl.light.LightModifierList
+import com.intellij.psi.impl.light.LightElement
+import com.intellij.psi.javadoc.PsiDocComment
 import com.intellij.psi.scope.PsiScopeProcessor
 import com.intellij.psi.util.*
 import com.intellij.util.IncorrectOperationException
@@ -35,22 +35,26 @@ import org.jetbrains.kotlin.asJava.propertyNameByAccessor
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind

-interface KtLightMethod : PsiMethod, KtLightDeclaration<KtDeclaration, PsiMethod> {
+interface KtLightMethod : PsiAnnotationMethod, KtLightDeclaration<KtDeclaration, PsiMethod> {
    val lightMethodOrigin: LightMemberOrigin?
    val isDelegated: Boolean
 }

-sealed class KtLightMethodImpl(
-        override val clsDelegate: PsiMethod,
+class KtLightMethodImpl private constructor(
+        computeRealDelegate: () -> PsiMethod,
        override val lightMethodOrigin: LightMemberOrigin?,
-        containingClass: KtLightClass
-) : LightMethod(clsDelegate.manager, clsDelegate, containingClass), KtLightMethod {
+        private val containingClass: KtLightClass,
+        private val dummyDelegate: PsiMethod? = null
+) : LightElement(containingClass.manager, containingClass.language), KtLightMethod {
    override val kotlinOrigin: KtDeclaration? get() = lightMethodOrigin?.originalElement as? KtDeclaration

+    override val clsDelegate by lazy(LazyThreadSafetyMode.PUBLICATION, computeRealDelegate)
+
    private val lightIdentifier by lazy(LazyThreadSafetyMode.PUBLICATION) { KtLightIdentifier(this, kotlinOrigin as? KtNamedDeclaration) }
    private val returnTypeElem by lazy(LazyThreadSafetyMode.PUBLICATION) {
        val delegateTypeElement = clsDelegate.returnTypeElement as? ClsTypeElementImpl
@@ -59,7 +63,7 @@ sealed class KtLightMethodImpl(

    private val calculatingReturnType = ThreadLocal<Boolean>()

-    override fun getContainingClass(): KtLightClass = super.getContainingClass() as KtLightClass
+    override fun getContainingClass(): KtLightClass = containingClass

    private val paramsList: CachedValue<PsiParameterList> by lazy(LazyThreadSafetyMode.PUBLICATION) {
        val cacheManager = CachedValuesManager.getManager(clsDelegate.project)
@@ -95,7 +99,7 @@ sealed class KtLightMethodImpl(

    override fun getNavigationElement(): PsiElement = kotlinOrigin?.navigationElement ?: super.getNavigationElement()
    override fun getPresentation(): ItemPresentation? = kotlinOrigin?.presentation ?: super.getPresentation()
-    override fun getParent(): PsiElement? = containingClass
+    override fun getParent(): PsiElement = containingClass
    override fun getText() = kotlinOrigin?.text ?: ""
    override fun getTextRange() = kotlinOrigin?.textRange ?: TextRange.EMPTY_RANGE

@@ -198,21 +202,11 @@ sealed class KtLightMethodImpl(
            containingClass == other.containingClass &&
            clsDelegate == other.clsDelegate

-    override fun hashCode(): Int = ((name.hashCode() * 31 + (lightMethodOrigin?.hashCode() ?: 0)) * 31 + containingClass.hashCode()) * 31 + clsDelegate.hashCode()
+    override fun hashCode(): Int = ((getName().hashCode() * 31 + (lightMethodOrigin?.hashCode() ?: 0)) * 31 + containingClass.hashCode()) * 31 + clsDelegate.hashCode()

    override fun toString(): String = "${this::class.java.simpleName}:$name"

-    private class KtLightMethodForDeclaration(
-            delegate: PsiMethod, origin: LightMemberOrigin?, containingClass: KtLightClass
-    ) : KtLightMethodImpl(delegate, origin, containingClass)
-
-    class KtLightAnnotationMethod(
-            override val clsDelegate: PsiAnnotationMethod,
-            origin: LightMemberOrigin?,
-            containingClass: KtLightClass
-    ) : KtLightMethodImpl(clsDelegate, origin, containingClass), PsiAnnotationMethod {
-        override fun getDefaultValue() = clsDelegate.defaultValue
-    }
+    override fun getDefaultValue() = (clsDelegate as? PsiAnnotationMethod)?.defaultValue

    // override getReturnType() so return type resolves to type parameters of this method not delegate's
    // which is relied upon by java type inference
@@ -229,27 +223,72 @@ sealed class KtLightMethodImpl(
    }

    companion object Factory {
+        private fun adjustMethodOrigin(origin: LightMemberOriginForDeclaration?): LightMemberOriginForDeclaration? {
+            val originalElement = origin?.originalElement
+            if (originalElement is KtPropertyAccessor) {
+                return origin.copy(originalElement.getStrictParentOfType<KtProperty>()!!, origin.originKind)
+            }
+            return origin
+        }
+
        fun create(
                delegate: PsiMethod, origin: LightMemberOrigin?, containingClass: KtLightClass
        ): KtLightMethodImpl {
-            return when (delegate) {
-                is PsiAnnotationMethod -> KtLightAnnotationMethod(delegate, origin, containingClass)
-                else -> KtLightMethodForDeclaration(delegate, origin, containingClass)
-            }
+            return KtLightMethodImpl({ delegate}, origin, containingClass)
        }

        @JvmStatic
        fun fromClsMethod(method: PsiMethod, containingClass: KtLightClass): KtLightMethodImpl {
-            var origin = ClsWrapperStubPsiFactory.getMemberOrigin(method)
-            val originalElement = if (origin != null) origin.originalElement else null
-            if (originalElement is KtPropertyAccessor) {
+            val origin = ClsWrapperStubPsiFactory.getMemberOrigin(method)
+            return KtLightMethodImpl.create(method, adjustMethodOrigin(origin), containingClass)
+        }

-                origin = origin!!.copy(PsiTreeUtil.getParentOfType(originalElement, KtProperty::class.java)!!, origin.originKind)
-            }
-
-            return KtLightMethodImpl.create(method, origin, containingClass)
+        @JvmStatic
+        fun lazy(
+                dummyDelegate: PsiMethod?,
+                containingClass: KtLightClass,
+                origin: LightMemberOriginForDeclaration?,
+                computeRealDelegate: () -> PsiMethod
+        ): KtLightMethodImpl {
+            return KtLightMethodImpl(computeRealDelegate, adjustMethodOrigin(origin), containingClass, dummyDelegate)
        }
    }
+
+    override fun getName() = dummyDelegate?.name ?: clsDelegate.name
+
+    override fun hasModifierProperty(name: String) = clsDelegate.hasModifierProperty(name)
+
+    override fun getThrowsList() = clsDelegate.throwsList
+
+    override fun hasTypeParameters() = clsDelegate.hasTypeParameters()
+
+    override fun isVarArgs() = clsDelegate.isVarArgs
+
+    override fun isConstructor() = clsDelegate.isConstructor
+
+    override fun getHierarchicalMethodSignature() = clsDelegate.hierarchicalMethodSignature
+
+    override fun getDocComment() = clsDelegate.docComment
+
+    override fun findSuperMethodSignaturesIncludingStatic(checkAccess: Boolean) = clsDelegate.findSuperMethodSignaturesIncludingStatic(checkAccess)
+
+    override fun getBody() = null
+
+    override fun isDeprecated() = clsDelegate.isDeprecated
+
+    override fun findDeepestSuperMethod() = clsDelegate.findDeepestSuperMethod()
+
+    override fun findDeepestSuperMethods() = clsDelegate.findDeepestSuperMethods()
+
+    override fun findSuperMethods() = clsDelegate.findSuperMethods()
+
+    override fun findSuperMethods(checkAccess: Boolean) = clsDelegate.findSuperMethods(checkAccess)
+
+    override fun findSuperMethods(parentClass: PsiClass?) = clsDelegate.findSuperMethods(parentClass)
+
+    override fun getContainingFile() = parent.containingFile
+
+    override fun isValid() = containingClass.isValid
 }

 fun KtLightMethod.isTraitFakeOverride(): Boolean {