Fix compilation

lukellmann · ting-yuan · commit 981fb70528f6 · 2023-10-24T11:21:25.000-07:00
Abstract implementation classes that inherited from now sealed types
have those supertypes removed and replace overridden with open members.
Additional casts had to be introduced in a few places.

A few when statements had to be made exhaustive (by specifying all
cases) because they now operate on subjects with a sealed type.
diff --git a/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/Incremental.kt b/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/Incremental.kt
@@ -703,6 +703,8 @@ class IncrementalContext(
         when (declaration) {
             is KSPropertyDeclarationJavaImpl -> recordLookupForJavaField(declaration.psi)
             is KSFunctionDeclarationJavaImpl -> recordLookupForJavaMethod(declaration.psi)
+            is KSClassDeclaration, is KSFunctionDeclaration, is KSPropertyDeclaration, is KSTypeAlias,
+            is KSTypeParameter -> Unit
         }
     }
 
diff --git a/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/processing/impl/ResolverImpl.kt b/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/processing/impl/ResolverImpl.kt
@@ -1192,6 +1192,7 @@ class ResolverImpl(
                         if (declaration.isAbstract)
                             modifiers.add(Modifier.ABSTRACT)
                     }
+                    is KSTypeAlias, is KSTypeParameter -> Unit
                 }
             }
             Origin.KOTLIN_LIB, Origin.JAVA_LIB -> {
@@ -1208,6 +1209,7 @@ class ResolverImpl(
                         if (declaration.jvmAccessFlag and Opcodes.ACC_SYNCHRONIZED != 0)
                             modifiers.add(Modifier.JAVA_SYNCHRONIZED)
                     }
+                    is KSClassDeclaration, is KSTypeAlias, is KSTypeParameter -> Unit
                 }
             }
             else -> Unit
diff --git a/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/binary/KSDeclarationDescriptorImpl.kt b/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/binary/KSDeclarationDescriptorImpl.kt
@@ -30,21 +30,22 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.parents
 import org.jetbrains.kotlin.resolve.descriptorUtil.parentsWithSelf
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
-abstract class KSDeclarationDescriptorImpl(private val descriptor: DeclarationDescriptor) : KSDeclaration {
+abstract class KSDeclarationDescriptorImpl(private val descriptor: DeclarationDescriptor) /*: KSDeclaration*/ {
 
-    override val origin by lazy {
+    open /*override*/ val origin by lazy {
         descriptor.origin
     }
 
-    override val containingFile: KSFile? = null
+    open /*override*/ val containingFile: KSFile? = null
 
-    override val location: Location = NonExistLocation
+    open /*override*/ val location: Location = NonExistLocation
 
-    override val annotations: Sequence<KSAnnotation> by lazy {
-        descriptor.annotations.asSequence().map { KSAnnotationDescriptorImpl.getCached(it, this) }.memoized()
+    open /*override*/ val annotations: Sequence<KSAnnotation> by lazy {
+        descriptor.annotations.asSequence().map { KSAnnotationDescriptorImpl.getCached(it, this as KSDeclaration) }
+            .memoized()
     }
 
-    override val parentDeclaration: KSDeclaration? by lazy {
+    open /*override*/ val parentDeclaration: KSDeclaration? by lazy {
         val containingDescriptor = descriptor.parents.first()
         when (containingDescriptor) {
             is ClassDescriptor -> KSClassDeclarationDescriptorImpl.getCached(containingDescriptor)
@@ -53,27 +54,27 @@ abstract class KSDeclarationDescriptorImpl(private val descriptor: DeclarationDe
         } as KSDeclaration?
     }
 
-    override val parent: KSNode? by lazy {
+    open /*override*/ val parent: KSNode? by lazy {
         parentDeclaration
     }
 
-    override val packageName: KSName by lazy {
+    open /*override*/ val packageName: KSName by lazy {
         KSNameImpl.getCached(descriptor.findPackage().fqName.asString())
     }
 
-    override val qualifiedName: KSName by lazy {
+    open /*override*/ val qualifiedName: KSName by lazy {
         KSNameImpl.getCached(descriptor.fqNameSafe.asString())
     }
 
-    override val simpleName: KSName by lazy {
+    open /*override*/ val simpleName: KSName by lazy {
         KSNameImpl.getCached(descriptor.name.asString())
     }
 
     override fun toString(): String {
         return this.simpleName.asString()
     }
 
-    override val docString = null
+    open /*override*/ val docString: String? = null
 }
 
 val DeclarationDescriptor.origin: Origin
diff --git a/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/binary/KSPropertyAccessorDescriptorImpl.kt b/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/binary/KSPropertyAccessorDescriptorImpl.kt
@@ -25,8 +25,8 @@ import com.google.devtools.ksp.symbol.impl.toKSPropertyDeclaration
 import com.google.devtools.ksp.toKSModifiers
 import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor
 
-abstract class KSPropertyAccessorDescriptorImpl(val descriptor: PropertyAccessorDescriptor) : KSPropertyAccessor {
-    override val origin: Origin by lazy {
+abstract class KSPropertyAccessorDescriptorImpl(val descriptor: PropertyAccessorDescriptor) /*: KSPropertyAccessor*/ {
+    open /*override*/ val origin: Origin by lazy {
         when (receiver.origin) {
             // if receiver is kotlin source, that means we are a synthetic where developer
             // didn't declare an explicit accessor so we used the descriptor instead
@@ -35,26 +35,27 @@ abstract class KSPropertyAccessorDescriptorImpl(val descriptor: PropertyAccessor
         }
     }
 
-    override val receiver: KSPropertyDeclaration by lazy {
+    open /*override*/ val receiver: KSPropertyDeclaration by lazy {
         descriptor.correspondingProperty.toKSPropertyDeclaration()
     }
 
-    override val parent: KSNode? by lazy {
+    open /*override*/ val parent: KSNode? by lazy {
         receiver
     }
 
-    override val location: Location
+    open /*override*/ val location: Location
         get() {
             // if receiver is kotlin source, that means `this` is synthetic hence we want the property's location
             // Otherwise, receiver is also from a .class file where the location will be NoLocation
             return receiver.location
         }
 
-    override val annotations: Sequence<KSAnnotation> by lazy {
-        descriptor.annotations.asSequence().map { KSAnnotationDescriptorImpl.getCached(it, this) }.memoized()
+    open /*override*/ val annotations: Sequence<KSAnnotation> by lazy {
+        descriptor.annotations.asSequence().map { KSAnnotationDescriptorImpl.getCached(it, this as KSPropertyAccessor) }
+            .memoized()
     }
 
-    override val modifiers: Set<Modifier> by lazy {
+    open /*override*/ val modifiers: Set<Modifier> by lazy {
         val modifiers = mutableSetOf<Modifier>()
         modifiers.addAll(descriptor.toKSModifiers())
         modifiers.addAll(descriptor.toFunctionKSModifiers())
diff --git a/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/java/KSDeclarationJavaImpl.kt b/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/java/KSDeclarationJavaImpl.kt
@@ -25,24 +25,24 @@ import com.google.devtools.ksp.symbol.impl.findParentDeclaration
 import com.google.devtools.ksp.symbol.impl.getDocString
 import com.intellij.psi.PsiElement
 
-abstract class KSDeclarationJavaImpl(private val psi: PsiElement) : KSDeclaration {
-    override val packageName: KSName by lazy {
-        this.containingFile!!.packageName
+abstract class KSDeclarationJavaImpl(private val psi: PsiElement) /*: KSDeclaration*/ {
+    open /*override*/ val packageName: KSName by lazy {
+        (this as KSDeclaration).containingFile!!.packageName
     }
 
     override fun toString(): String {
-        return this.simpleName.asString()
+        return (this as KSDeclaration).simpleName.asString()
     }
 
-    override val docString by lazy {
+    open /*override*/ val docString by lazy {
         psi.getDocString()
     }
 
-    override val parentDeclaration: KSDeclaration? by lazy {
+    open /*override*/ val parentDeclaration: KSDeclaration? by lazy {
         psi.findParentDeclaration()
     }
 
-    override val parent: KSNode? by lazy {
+    open /*override*/ val parent: KSNode? by lazy {
         psi.findParentAnnotated()
     }
 }
diff --git a/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/kotlin/KSDeclarationImpl.kt b/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/kotlin/KSDeclarationImpl.kt
@@ -24,26 +24,26 @@ import com.google.devtools.ksp.symbol.*
 import com.google.devtools.ksp.symbol.impl.*
 import org.jetbrains.kotlin.psi.*
 
-abstract class KSDeclarationImpl(val ktDeclaration: KtDeclaration) : KSDeclaration {
-    override val origin: Origin = Origin.KOTLIN
+abstract class KSDeclarationImpl(val ktDeclaration: KtDeclaration) /*: KSDeclaration*/ {
+    open /*override*/ val origin: Origin = Origin.KOTLIN
 
-    override val location: Location by lazy {
+    open /*override*/ val location: Location by lazy {
         ktDeclaration.toLocation()
     }
 
-    override val simpleName: KSName by lazy {
+    open /*override*/ val simpleName: KSName by lazy {
         KSNameImpl.getCached(ktDeclaration.name!!)
     }
 
-    override val qualifiedName: KSName? by lazy {
+    open /*override*/ val qualifiedName: KSName? by lazy {
         (ktDeclaration as? KtNamedDeclaration)?.fqName?.let { KSNameImpl.getCached(it.asString()) }
     }
 
-    override val annotations: Sequence<KSAnnotation> by lazy {
+    open /*override*/ val annotations: Sequence<KSAnnotation> by lazy {
         ktDeclaration.annotationEntries.asSequence().map { KSAnnotationImpl.getCached(it) }.memoized()
     }
 
-    override val modifiers: Set<Modifier> by lazy {
+    open /*override*/ val modifiers: Set<Modifier> by lazy {
         // we do not check for JVM_STATIC here intentionally as it actually means static in parent class,
         // not in this class.
         // see: https://github.com/google/ksp/issues/378
@@ -56,25 +56,25 @@ abstract class KSDeclarationImpl(val ktDeclaration: KtDeclaration) : KSDeclarati
         }
     }
 
-    override val containingFile: KSFile? by lazy {
+    open /*override*/ val containingFile: KSFile? by lazy {
         KSFileImpl.getCached(ktDeclaration.containingKtFile)
     }
 
-    override val packageName: KSName by lazy {
+    open /*override*/ val packageName: KSName by lazy {
         this.containingFile!!.packageName
     }
 
-    override val typeParameters: List<KSTypeParameter> by lazy {
+    open /*override*/ val typeParameters: List<KSTypeParameter> by lazy {
         (ktDeclaration as? KtTypeParameterListOwner)?.let {
             it.typeParameters.map { KSTypeParameterImpl.getCached(it) }
         } ?: emptyList()
     }
 
-    override val parentDeclaration: KSDeclaration? by lazy {
+    open /*override*/ val parentDeclaration: KSDeclaration? by lazy {
         ktDeclaration.findParentDeclaration()
     }
 
-    override val parent: KSNode? by lazy {
+    open /*override*/ val parent: KSNode? by lazy {
         ktDeclaration.findParentAnnotated()
     }
 
@@ -86,7 +86,7 @@ abstract class KSDeclarationImpl(val ktDeclaration: KtDeclaration) : KSDeclarati
         ktDeclaration.annotationEntries.map { KSAnnotationImpl.getCached(it) }
     }
 
-    override val docString by lazy {
+    open /*override*/ val docString by lazy {
         ktDeclaration.getDocString()
     }
 }
diff --git a/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/kotlin/KSPropertyAccessorImpl.kt b/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/kotlin/KSPropertyAccessorImpl.kt
@@ -26,7 +26,7 @@ import com.google.devtools.ksp.symbol.impl.toLocation
 import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.KtPropertyAccessor
 
-abstract class KSPropertyAccessorImpl(val ktPropertyAccessor: KtPropertyAccessor) : KSPropertyAccessor {
+abstract class KSPropertyAccessorImpl(val ktPropertyAccessor: KtPropertyAccessor) /*: KSPropertyAccessor*/ {
     companion object {
         fun getCached(ktPropertyAccessor: KtPropertyAccessor): KSPropertyAccessor {
             return if (ktPropertyAccessor.isGetter) {
@@ -36,27 +36,27 @@ abstract class KSPropertyAccessorImpl(val ktPropertyAccessor: KtPropertyAccessor
             }
         }
     }
-    override val receiver: KSPropertyDeclaration by lazy {
+    open /*override*/ val receiver: KSPropertyDeclaration by lazy {
         KSPropertyDeclarationImpl.getCached(ktPropertyAccessor.property as KtProperty)
     }
-    override val annotations: Sequence<KSAnnotation> by lazy {
+    open /*override*/ val annotations: Sequence<KSAnnotation> by lazy {
         ktPropertyAccessor.filterUseSiteTargetAnnotations().map { KSAnnotationImpl.getCached(it) }
-            .plus(this.findAnnotationFromUseSiteTarget())
+            .plus((this as KSPropertyAccessor).findAnnotationFromUseSiteTarget())
     }
 
-    override val parent: KSNode? by lazy {
+    open /*override*/ val parent: KSNode? by lazy {
         receiver
     }
 
-    override val location: Location by lazy {
+    open /*override*/ val location: Location by lazy {
         ktPropertyAccessor.toLocation()
     }
 
-    override val modifiers: Set<Modifier> by lazy {
+    open /*override*/ val modifiers: Set<Modifier> by lazy {
         ktPropertyAccessor.toKSModifiers()
     }
 
-    override val declarations: Sequence<KSDeclaration> by lazy {
+    open /*override*/ val declarations: Sequence<KSDeclaration> by lazy {
         if (!ktPropertyAccessor.hasBlockBody()) {
             emptySequence()
         } else {
@@ -65,10 +65,10 @@ abstract class KSPropertyAccessorImpl(val ktPropertyAccessor: KtPropertyAccessor
         }
     }
 
-    override val origin: Origin = Origin.KOTLIN
+    open /*override*/ val origin: Origin = Origin.KOTLIN
 
-    override fun <D, R> accept(visitor: KSVisitor<D, R>, data: D): R {
-        return visitor.visitPropertyAccessor(this, data)
+    open /*override*/ fun <D, R> accept(visitor: KSVisitor<D, R>, data: D): R {
+        return visitor.visitPropertyAccessor(this as KSPropertyAccessor, data)
     }
 
     internal val originalAnnotations: List<KSAnnotation> by lazy {
diff --git a/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/synthetic/KSConstructorSyntheticImpl.kt b/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/synthetic/KSConstructorSyntheticImpl.kt
@@ -25,9 +25,7 @@ import com.google.devtools.ksp.processing.impl.ResolverImpl
 import com.google.devtools.ksp.symbol.*
 
 class KSConstructorSyntheticImpl private constructor(val ksClassDeclaration: KSClassDeclaration) :
-    KSFunctionDeclaration,
-    KSDeclaration
-    by ksClassDeclaration {
+    KSFunctionDeclaration {
     companion object : KSObjectCache<KSClassDeclaration, KSConstructorSyntheticImpl>() {
         fun getCached(ksClassDeclaration: KSClassDeclaration) =
             KSConstructorSyntheticImpl.cache.getOrPut(ksClassDeclaration) {
@@ -43,6 +41,10 @@ class KSConstructorSyntheticImpl private constructor(val ksClassDeclaration: KSC
 
     override val functionKind: FunctionKind = FunctionKind.MEMBER
 
+    override val docString: String? get() = ksClassDeclaration.docString
+
+    override val packageName: KSName get() = ksClassDeclaration.packageName
+
     override val qualifiedName: KSName? by lazy {
         KSNameImpl.getCached(ksClassDeclaration.qualifiedName?.asString()?.plus(".<init>") ?: "")
     }
diff --git a/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/synthetic/KSPropertyAccessorSyntheticImpl.kt b/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/synthetic/KSPropertyAccessorSyntheticImpl.kt
@@ -20,22 +20,22 @@ package com.google.devtools.ksp.symbol.impl.synthetic
 import com.google.devtools.ksp.processing.impl.findAnnotationFromUseSiteTarget
 import com.google.devtools.ksp.symbol.*
 
-abstract class KSPropertyAccessorSyntheticImpl(ksPropertyDeclaration: KSPropertyDeclaration) : KSPropertyAccessor {
-    override val annotations: Sequence<KSAnnotation> by lazy {
-        this.findAnnotationFromUseSiteTarget()
+abstract class KSPropertyAccessorSyntheticImpl(ksPropertyDeclaration: KSPropertyDeclaration) /*: KSPropertyAccessor*/ {
+    open /*override*/ val annotations: Sequence<KSAnnotation> by lazy {
+        (this as KSPropertyAccessor).findAnnotationFromUseSiteTarget()
     }
 
-    override val location: Location by lazy {
+    open /*override*/ val location: Location by lazy {
         ksPropertyDeclaration.location
     }
 
-    override val modifiers: Set<Modifier> = emptySet()
+    open /*override*/ val modifiers: Set<Modifier> = emptySet()
 
-    override val origin: Origin = Origin.SYNTHETIC
+    open /*override*/ val origin: Origin = Origin.SYNTHETIC
 
-    override val receiver: KSPropertyDeclaration = ksPropertyDeclaration
+    open /*override*/ val receiver: KSPropertyDeclaration = ksPropertyDeclaration
 
-    override fun <D, R> accept(visitor: KSVisitor<D, R>, data: D): R {
-        return visitor.visitPropertyAccessor(this, data)
+    open /*override*/ fun <D, R> accept(visitor: KSVisitor<D, R>, data: D): R {
+        return visitor.visitPropertyAccessor(this as KSPropertyAccessor, data)
     }
 }
diff --git a/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/utils.kt b/compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/utils.kt
@@ -319,7 +319,7 @@ internal class DeclarationOrdering(
     }
 
     private fun getOrder(decl: KSDeclarationDescriptorImpl): Int {
-        return declOrdering.getOrPut(decl) {
+        return declOrdering.getOrPut(decl as KSDeclaration) {
             when (decl) {
                 is KSPropertyDeclarationDescriptorImpl -> {
                     fieldOrdering[decl.simpleName.asString()]?.let {
@@ -467,7 +467,8 @@ internal val KSDeclarationContainer.declarationsInSourceOrder: Sequence<KSDeclar
             DeclarationOrdering(it)
         } ?: return declarations
 
-        return (declarations as? Sequence<KSDeclarationDescriptorImpl>)?.sortedWith(declarationOrdering.comparator)
+        return (declarations as? Sequence<KSDeclarationDescriptorImpl>)
+            ?.sortedWith(declarationOrdering.comparator) as Sequence<KSDeclaration>?
             ?: declarations
     }
 
diff --git a/kotlin-analysis-api/src/main/kotlin/com/google/devtools/ksp/impl/ResolverAAImpl.kt b/kotlin-analysis-api/src/main/kotlin/com/google/devtools/ksp/impl/ResolverAAImpl.kt
@@ -169,6 +169,7 @@ class ResolverAAImpl(
                         if (declaration.isAbstract)
                             modifiers.add(Modifier.ABSTRACT)
                     }
+                    is KSTypeAlias, is KSTypeParameter -> Unit
                 }
             }
             Origin.KOTLIN_LIB, Origin.JAVA_LIB -> {
@@ -189,6 +190,7 @@ class ResolverAAImpl(
                         if (declaration.jvmAccessFlag and Opcodes.ACC_SYNCHRONIZED != 0)
                             modifiers.add(Modifier.JAVA_SYNCHRONIZED)
                     }
+                    is KSClassDeclaration, is KSTypeAlias, is KSTypeParameter -> Unit
                 }
             }
             else -> Unit
diff --git a/kotlin-analysis-api/src/main/kotlin/com/google/devtools/ksp/impl/symbol/kotlin/AbstractKSDeclarationImpl.kt b/kotlin-analysis-api/src/main/kotlin/com/google/devtools/ksp/impl/symbol/kotlin/AbstractKSDeclarationImpl.kt
diff --git a/kotlin-analysis-api/src/main/kotlin/com/google/devtools/ksp/impl/symbol/kotlin/KSPropertyAccessorImpl.kt b/kotlin-analysis-api/src/main/kotlin/com/google/devtools/ksp/impl/symbol/kotlin/KSPropertyAccessorImpl.kt

Original file line number	Diff line number	Diff line change
`@@ -703,6 +703,8 @@ class IncrementalContext(`
`703`	`703`	`when (declaration) {`
`704`	`704`	`is KSPropertyDeclarationJavaImpl -> recordLookupForJavaField(declaration.psi)`
`705`	`705`	`is KSFunctionDeclarationJavaImpl -> recordLookupForJavaMethod(declaration.psi)`
	`706`	`+ is KSClassDeclaration, is KSFunctionDeclaration, is KSPropertyDeclaration, is KSTypeAlias,`
	`707`	`+ is KSTypeParameter -> Unit`
`706`	`708`	`}`
`707`	`709`	`}`
`708`	`710`
Original file line number	Diff line number	Diff line change
`@@ -1192,6 +1192,7 @@ class ResolverImpl(`
`1192`	`1192`	`if (declaration.isAbstract)`
`1193`	`1193`	`modifiers.add(Modifier.ABSTRACT)`
`1194`	`1194`	`}`
	`1195`	`+ is KSTypeAlias, is KSTypeParameter -> Unit`
`1195`	`1196`	`}`
`1196`	`1197`	`}`
`1197`	`1198`	`Origin.KOTLIN_LIB, Origin.JAVA_LIB -> {`
`@@ -1208,6 +1209,7 @@ class ResolverImpl(`
`1208`	`1209`	`if (declaration.jvmAccessFlag and Opcodes.ACC_SYNCHRONIZED != 0)`
`1209`	`1210`	`modifiers.add(Modifier.JAVA_SYNCHRONIZED)`
`1210`	`1211`	`}`
	`1212`	`+ is KSClassDeclaration, is KSTypeAlias, is KSTypeParameter -> Unit`
`1211`	`1213`	`}`
`1212`	`1214`	`}`
`1213`	`1215`	`else -> Unit`
Original file line number	Diff line number	Diff line change
`@@ -30,21 +30,22 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.parents`
`30`	`30`	`import org.jetbrains.kotlin.resolve.descriptorUtil.parentsWithSelf`
`31`	`31`	`import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull`
`32`	`32`
`33`		`-abstract class KSDeclarationDescriptorImpl(private val descriptor: DeclarationDescriptor) : KSDeclaration {`
	`33`	`+abstract class KSDeclarationDescriptorImpl(private val descriptor: DeclarationDescriptor) /: KSDeclaration/ {`
`34`	`34`
`35`		`- override val origin by lazy {`
	`35`	`+ open /override/ val origin by lazy {`
`36`	`36`	`descriptor.origin`
`37`	`37`	`}`
`38`	`38`
`39`		`- override val containingFile: KSFile? = null`
	`39`	`+ open /override/ val containingFile: KSFile? = null`
`40`	`40`
`41`		`- override val location: Location = NonExistLocation`
	`41`	`+ open /override/ val location: Location = NonExistLocation`
`42`	`42`
`43`		`- override val annotations: Sequence<KSAnnotation> by lazy {`
`44`		`- descriptor.annotations.asSequence().map { KSAnnotationDescriptorImpl.getCached(it, this) }.memoized()`
	`43`	`+ open /override/ val annotations: Sequence<KSAnnotation> by lazy {`
	`44`	`+ descriptor.annotations.asSequence().map { KSAnnotationDescriptorImpl.getCached(it, this as KSDeclaration) }`
	`45`	`+ .memoized()`
`45`	`46`	`}`
`46`	`47`
`47`		`- override val parentDeclaration: KSDeclaration? by lazy {`
	`48`	`+ open /override/ val parentDeclaration: KSDeclaration? by lazy {`
`48`	`49`	`val containingDescriptor = descriptor.parents.first()`
`49`	`50`	`when (containingDescriptor) {`
`50`	`51`	`is ClassDescriptor -> KSClassDeclarationDescriptorImpl.getCached(containingDescriptor)`
`@@ -53,27 +54,27 @@ abstract class KSDeclarationDescriptorImpl(private val descriptor: DeclarationDe`
`53`	`54`	`} as KSDeclaration?`
`54`	`55`	`}`
`55`	`56`
`56`		`- override val parent: KSNode? by lazy {`
	`57`	`+ open /override/ val parent: KSNode? by lazy {`
`57`	`58`	`parentDeclaration`
`58`	`59`	`}`
`59`	`60`
`60`		`- override val packageName: KSName by lazy {`
	`61`	`+ open /override/ val packageName: KSName by lazy {`
`61`	`62`	`KSNameImpl.getCached(descriptor.findPackage().fqName.asString())`
`62`	`63`	`}`
`63`	`64`
`64`		`- override val qualifiedName: KSName by lazy {`
	`65`	`+ open /override/ val qualifiedName: KSName by lazy {`
`65`	`66`	`KSNameImpl.getCached(descriptor.fqNameSafe.asString())`
`66`	`67`	`}`
`67`	`68`
`68`		`- override val simpleName: KSName by lazy {`
	`69`	`+ open /override/ val simpleName: KSName by lazy {`
`69`	`70`	`KSNameImpl.getCached(descriptor.name.asString())`
`70`	`71`	`}`
`71`	`72`
`72`	`73`	`override fun toString(): String {`
`73`	`74`	`return this.simpleName.asString()`
`74`	`75`	`}`
`75`	`76`
`76`		`- override val docString = null`
	`77`	`+ open /override/ val docString: String? = null`
`77`	`78`	`}`
`78`	`79`
`79`	`80`	`val DeclarationDescriptor.origin: Origin`
Original file line number	Diff line number	Diff line change
`@@ -25,24 +25,24 @@ import com.google.devtools.ksp.symbol.impl.findParentDeclaration`
`25`	`25`	`import com.google.devtools.ksp.symbol.impl.getDocString`
`26`	`26`	`import com.intellij.psi.PsiElement`
`27`	`27`
`28`		`-abstract class KSDeclarationJavaImpl(private val psi: PsiElement) : KSDeclaration {`
`29`		`- override val packageName: KSName by lazy {`
`30`		`- this.containingFile!!.packageName`
	`28`	`+abstract class KSDeclarationJavaImpl(private val psi: PsiElement) /: KSDeclaration/ {`
	`29`	`+ open /override/ val packageName: KSName by lazy {`
	`30`	`+ (this as KSDeclaration).containingFile!!.packageName`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`override fun toString(): String {`
`34`		`- return this.simpleName.asString()`
	`34`	`+ return (this as KSDeclaration).simpleName.asString()`
`35`	`35`	`}`
`36`	`36`
`37`		`- override val docString by lazy {`
	`37`	`+ open /override/ val docString by lazy {`
`38`	`38`	`psi.getDocString()`
`39`	`39`	`}`
`40`	`40`
`41`		`- override val parentDeclaration: KSDeclaration? by lazy {`
	`41`	`+ open /override/ val parentDeclaration: KSDeclaration? by lazy {`
`42`	`42`	`psi.findParentDeclaration()`
`43`	`43`	`}`
`44`	`44`
`45`		`- override val parent: KSNode? by lazy {`
	`45`	`+ open /override/ val parent: KSNode? by lazy {`
`46`	`46`	`psi.findParentAnnotated()`
`47`	`47`	`}`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,26 +24,26 @@ import com.google.devtools.ksp.symbol.*`
`24`	`24`	`import com.google.devtools.ksp.symbol.impl.*`
`25`	`25`	`import org.jetbrains.kotlin.psi.*`
`26`	`26`
`27`		`-abstract class KSDeclarationImpl(val ktDeclaration: KtDeclaration) : KSDeclaration {`
`28`		`- override val origin: Origin = Origin.KOTLIN`
	`27`	`+abstract class KSDeclarationImpl(val ktDeclaration: KtDeclaration) /: KSDeclaration/ {`
	`28`	`+ open /override/ val origin: Origin = Origin.KOTLIN`
`29`	`29`
`30`		`- override val location: Location by lazy {`
	`30`	`+ open /override/ val location: Location by lazy {`
`31`	`31`	`ktDeclaration.toLocation()`
`32`	`32`	`}`
`33`	`33`
`34`		`- override val simpleName: KSName by lazy {`
	`34`	`+ open /override/ val simpleName: KSName by lazy {`
`35`	`35`	`KSNameImpl.getCached(ktDeclaration.name!!)`
`36`	`36`	`}`
`37`	`37`
`38`		`- override val qualifiedName: KSName? by lazy {`
	`38`	`+ open /override/ val qualifiedName: KSName? by lazy {`
`39`	`39`	`(ktDeclaration as? KtNamedDeclaration)?.fqName?.let { KSNameImpl.getCached(it.asString()) }`
`40`	`40`	`}`
`41`	`41`
`42`		`- override val annotations: Sequence<KSAnnotation> by lazy {`
	`42`	`+ open /override/ val annotations: Sequence<KSAnnotation> by lazy {`
`43`	`43`	`ktDeclaration.annotationEntries.asSequence().map { KSAnnotationImpl.getCached(it) }.memoized()`
`44`	`44`	`}`
`45`	`45`
`46`		`- override val modifiers: Set<Modifier> by lazy {`
	`46`	`+ open /override/ val modifiers: Set<Modifier> by lazy {`
`47`	`47`	`// we do not check for JVM_STATIC here intentionally as it actually means static in parent class,`
`48`	`48`	`// not in this class.`
`49`	`49`	`// see: https://github.com/google/ksp/issues/378`
`@@ -56,25 +56,25 @@ abstract class KSDeclarationImpl(val ktDeclaration: KtDeclaration) : KSDeclarati`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`		`- override val containingFile: KSFile? by lazy {`
	`59`	`+ open /override/ val containingFile: KSFile? by lazy {`
`60`	`60`	`KSFileImpl.getCached(ktDeclaration.containingKtFile)`
`61`	`61`	`}`
`62`	`62`
`63`		`- override val packageName: KSName by lazy {`
	`63`	`+ open /override/ val packageName: KSName by lazy {`
`64`	`64`	`this.containingFile!!.packageName`
`65`	`65`	`}`
`66`	`66`
`67`		`- override val typeParameters: List<KSTypeParameter> by lazy {`
	`67`	`+ open /override/ val typeParameters: List<KSTypeParameter> by lazy {`
`68`	`68`	`(ktDeclaration as? KtTypeParameterListOwner)?.let {`
`69`	`69`	`it.typeParameters.map { KSTypeParameterImpl.getCached(it) }`
`70`	`70`	`} ?: emptyList()`
`71`	`71`	`}`
`72`	`72`
`73`		`- override val parentDeclaration: KSDeclaration? by lazy {`
	`73`	`+ open /override/ val parentDeclaration: KSDeclaration? by lazy {`
`74`	`74`	`ktDeclaration.findParentDeclaration()`
`75`	`75`	`}`
`76`	`76`
`77`		`- override val parent: KSNode? by lazy {`
	`77`	`+ open /override/ val parent: KSNode? by lazy {`
`78`	`78`	`ktDeclaration.findParentAnnotated()`
`79`	`79`	`}`
`80`	`80`
`@@ -86,7 +86,7 @@ abstract class KSDeclarationImpl(val ktDeclaration: KtDeclaration) : KSDeclarati`
`86`	`86`	`ktDeclaration.annotationEntries.map { KSAnnotationImpl.getCached(it) }`
`87`	`87`	`}`
`88`	`88`
`89`		`- override val docString by lazy {`
	`89`	`+ open /override/ val docString by lazy {`
`90`	`90`	`ktDeclaration.getDocString()`
`91`	`91`	`}`
`92`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ import com.google.devtools.ksp.symbol.impl.toLocation`
`26`	`26`	`import org.jetbrains.kotlin.psi.KtProperty`
`27`	`27`	`import org.jetbrains.kotlin.psi.KtPropertyAccessor`
`28`	`28`
`29`		`-abstract class KSPropertyAccessorImpl(val ktPropertyAccessor: KtPropertyAccessor) : KSPropertyAccessor {`
	`29`	`+abstract class KSPropertyAccessorImpl(val ktPropertyAccessor: KtPropertyAccessor) /: KSPropertyAccessor/ {`
`30`	`30`	`companion object {`
`31`	`31`	`fun getCached(ktPropertyAccessor: KtPropertyAccessor): KSPropertyAccessor {`
`32`	`32`	`return if (ktPropertyAccessor.isGetter) {`
`@@ -36,27 +36,27 @@ abstract class KSPropertyAccessorImpl(val ktPropertyAccessor: KtPropertyAccessor`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`	`}`
`39`		`- override val receiver: KSPropertyDeclaration by lazy {`
	`39`	`+ open /override/ val receiver: KSPropertyDeclaration by lazy {`
`40`	`40`	`KSPropertyDeclarationImpl.getCached(ktPropertyAccessor.property as KtProperty)`
`41`	`41`	`}`
`42`		`- override val annotations: Sequence<KSAnnotation> by lazy {`
	`42`	`+ open /override/ val annotations: Sequence<KSAnnotation> by lazy {`
`43`	`43`	`ktPropertyAccessor.filterUseSiteTargetAnnotations().map { KSAnnotationImpl.getCached(it) }`
`44`		`- .plus(this.findAnnotationFromUseSiteTarget())`
	`44`	`+ .plus((this as KSPropertyAccessor).findAnnotationFromUseSiteTarget())`
`45`	`45`	`}`
`46`	`46`
`47`		`- override val parent: KSNode? by lazy {`
	`47`	`+ open /override/ val parent: KSNode? by lazy {`
`48`	`48`	`receiver`
`49`	`49`	`}`
`50`	`50`
`51`		`- override val location: Location by lazy {`
	`51`	`+ open /override/ val location: Location by lazy {`
`52`	`52`	`ktPropertyAccessor.toLocation()`
`53`	`53`	`}`
`54`	`54`
`55`		`- override val modifiers: Set<Modifier> by lazy {`
	`55`	`+ open /override/ val modifiers: Set<Modifier> by lazy {`
`56`	`56`	`ktPropertyAccessor.toKSModifiers()`
`57`	`57`	`}`
`58`	`58`
`59`		`- override val declarations: Sequence<KSDeclaration> by lazy {`
	`59`	`+ open /override/ val declarations: Sequence<KSDeclaration> by lazy {`
`60`	`60`	`if (!ktPropertyAccessor.hasBlockBody()) {`
`61`	`61`	`emptySequence()`
`62`	`62`	`} else {`
`@@ -65,10 +65,10 @@ abstract class KSPropertyAccessorImpl(val ktPropertyAccessor: KtPropertyAccessor`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`
`68`		`- override val origin: Origin = Origin.KOTLIN`
	`68`	`+ open /override/ val origin: Origin = Origin.KOTLIN`
`69`	`69`
`70`		`- override fun <D, R> accept(visitor: KSVisitor<D, R>, data: D): R {`
`71`		`- return visitor.visitPropertyAccessor(this, data)`
	`70`	`+ open /override/ fun <D, R> accept(visitor: KSVisitor<D, R>, data: D): R {`
	`71`	`+ return visitor.visitPropertyAccessor(this as KSPropertyAccessor, data)`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`internal val originalAnnotations: List<KSAnnotation> by lazy {`
Original file line number	Diff line number	Diff line change
`@@ -169,6 +169,7 @@ class ResolverAAImpl(`
`169`	`169`	`if (declaration.isAbstract)`
`170`	`170`	`modifiers.add(Modifier.ABSTRACT)`
`171`	`171`	`}`
	`172`	`+ is KSTypeAlias, is KSTypeParameter -> Unit`
`172`	`173`	`}`
`173`	`174`	`}`
`174`	`175`	`Origin.KOTLIN_LIB, Origin.JAVA_LIB -> {`
`@@ -189,6 +190,7 @@ class ResolverAAImpl(`
`189`	`190`	`if (declaration.jvmAccessFlag and Opcodes.ACC_SYNCHRONIZED != 0)`
`190`	`191`	`modifiers.add(Modifier.JAVA_SYNCHRONIZED)`
`191`	`192`	`}`
	`193`	`+ is KSClassDeclaration, is KSTypeAlias, is KSTypeParameter -> Unit`
`192`	`194`	`}`
`193`	`195`	`}`
`194`	`196`	`else -> Unit`