[Serialization] Implement serialization checker for K2 version of plugin

^KT-53178 Fixed
2022-08-24 10:59:11 +03:00
parent e048ffcf6d
commit 671083c701
69 changed files with 1767 additions and 453 deletions
@@ -114,7 +114,7 @@ fun FirTypeRef.toRegularClassSymbol(session: FirSession): FirRegularClassSymbol?
 * or null if no proper declaration has been found.
 */
 fun FirDeclaration.getContainingClassSymbol(session: FirSession): FirClassLikeSymbol<*>? =
-    this.safeAs<FirCallableDeclaration>()?.containingClass()?.toSymbol(session)
+    (this as? FirCallableDeclaration)?.containingClass()?.toSymbol(session)

@OptIn(SymbolInternals::class)
 fun FirBasedSymbol<*>.getContainingClassSymbol(session: FirSession): FirClassLikeSymbol<*>? = fir.getContainingClassSymbol(session)
@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.isLocal
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
@@ -223,14 +222,4 @@ object FirAnnotationClassDeclarationChecker : FirRegularClassChecker() {
            return annotationHasCycle(referencedAnnotation)
        }
    }
-
-
-    private fun FirRegularClassSymbol.primaryConstructorSymbol(): FirConstructorSymbol? {
-        for (declarationSymbol in this.declarationSymbols) {
-            if (declarationSymbol is FirConstructorSymbol && declarationSymbol.isPrimary) {
-                return declarationSymbol
-            }
-        }
-        return null
-    }
 }
@@ -101,3 +101,12 @@ internal val FirCallableDeclaration.isExtensionMember: Boolean

 internal val FirCallableSymbol<*>.isExtensionMember: Boolean
    get() = resolvedReceiverTypeRef != null && dispatchReceiverType != null
+
+fun FirClassSymbol<*>.primaryConstructorSymbol(): FirConstructorSymbol? {
+    for (declarationSymbol in this.declarationSymbols) {
+        if (declarationSymbol is FirConstructorSymbol && declarationSymbol.isPrimary) {
+            return declarationSymbol
+        }
+    }
+    return null
+}
@@ -101,6 +101,9 @@ object FirDiagnosticRenderers {
        t.renderReadableWithFqNames()
    }

+    // TODO: properly implement
+    val RENDER_TYPE_WITH_ANNOTATIONS = RENDER_TYPE
+
    val FQ_NAMES_IN_TYPES = Renderer { symbol: FirBasedSymbol<*> ->
        @OptIn(SymbolInternals::class)
        FirRenderer(
@@ -8,18 +8,28 @@ package org.jetbrains.kotlin.fir.types
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.StandardClassIds

+val ConeKotlinType.isByte: Boolean get() = isBuiltinType(StandardClassIds.Byte, false)
+val ConeKotlinType.isShort: Boolean get() = isBuiltinType(StandardClassIds.Short, false)
+val ConeKotlinType.isInt: Boolean get() = isBuiltinType(StandardClassIds.Int, false)
+val ConeKotlinType.isLong: Boolean get() = isBuiltinType(StandardClassIds.Long, false)
+val ConeKotlinType.isFloat: Boolean get() = isBuiltinType(StandardClassIds.Float, false)
+val ConeKotlinType.isDouble: Boolean get() = isBuiltinType(StandardClassIds.Double, false)
+
 val ConeKotlinType.isAny: Boolean get() = isBuiltinType(StandardClassIds.Any, false)
 val ConeKotlinType.isNullableAny: Boolean get() = isBuiltinType(StandardClassIds.Any, true)
 val ConeKotlinType.isNothing: Boolean get() = isBuiltinType(StandardClassIds.Nothing, false)
 val ConeKotlinType.isNullableNothing: Boolean get() = isBuiltinType(StandardClassIds.Nothing, true)
+
 val ConeKotlinType.isUnit: Boolean get() = isBuiltinType(StandardClassIds.Unit, false)
 val ConeKotlinType.isBoolean: Boolean get() = isBuiltinType(StandardClassIds.Boolean, false)
 val ConeKotlinType.isNullableBoolean: Boolean get() = isBuiltinType(StandardClassIds.Boolean, true)
 val ConeKotlinType.isBooleanOrNullableBoolean: Boolean get() = isAnyOfBuiltinType(setOf(StandardClassIds.Boolean))
-val ConeKotlinType.isEnum: Boolean get() = isBuiltinType(StandardClassIds.Enum, false)
+
+val ConeKotlinType.isChar: Boolean get() = isBuiltinType(StandardClassIds.Char, false)
 val ConeKotlinType.isString: Boolean get() = isBuiltinType(StandardClassIds.String, false)
-val ConeKotlinType.isInt: Boolean get() = isBuiltinType(StandardClassIds.Int, false)
-val ConeKotlinType.isLong: Boolean get() = isBuiltinType(StandardClassIds.Long, false)
+
+val ConeKotlinType.isEnum: Boolean get() = isBuiltinType(StandardClassIds.Enum, false)
+
 val ConeKotlinType.isUInt: Boolean get() = isBuiltinType(StandardClassIds.UInt, false)
 val ConeKotlinType.isULong: Boolean get() = isBuiltinType(StandardClassIds.ULong, false)
 val ConeKotlinType.isPrimitiveOrNullablePrimitive: Boolean get() = isAnyOfBuiltinType(StandardClassIds.primitiveTypes)
@@ -16,10 +16,7 @@ import org.jetbrains.kotlin.fir.resolvedSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
-import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.coneType
-import org.jetbrains.kotlin.fir.types.coneTypeSafe
+import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -99,11 +96,15 @@ private val DEFAULT_USE_SITE_TARGETS: Set<AnnotationUseSiteTarget> =
    USE_SITE_TARGET_NAME_MAP.values.fold(setOf<AnnotationUseSiteTarget>()) { a, b -> a + b } - setOf(AnnotationUseSiteTarget.FILE)

 fun FirDeclaration.hasAnnotation(classId: ClassId): Boolean {
-    return annotations.any { it.toAnnotationClassId() == classId }
+    return annotations.hasAnnotation(classId)
 }

 fun FirBasedSymbol<*>.hasAnnotation(classId: ClassId): Boolean {
-    return resolvedAnnotationsWithClassIds.any { it.toAnnotationClassId() == classId }
+    return resolvedAnnotationsWithClassIds.hasAnnotation(classId)
+}
+
+fun List<FirAnnotation>.hasAnnotation(classId: ClassId): Boolean {
+    return this.any { it.toAnnotationClassId() == classId }
 }

 fun <D> FirBasedSymbol<out D>.getAnnotationByClassId(classId: ClassId): FirAnnotation? where D : FirAnnotationContainer, D : FirDeclaration {
@@ -111,7 +112,11 @@ fun <D> FirBasedSymbol<out D>.getAnnotationByClassId(classId: ClassId): FirAnnot
 }

 fun FirAnnotationContainer.getAnnotationByClassId(classId: ClassId): FirAnnotation? {
-    return annotations.find {
+    return annotations.getAnnotationByClassId(classId)
+}
+
+fun List<FirAnnotation>.getAnnotationByClassId(classId: ClassId): FirAnnotation? {
+    return find {
        it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId == classId
    }
 }
@@ -173,6 +178,15 @@ private inline fun <reified T> FirAnnotation.getPrimitiveArgumentValue(name: Nam
    }
 }

+fun FirAnnotation.getKClassArgument(name: Name): ConeKotlinType? {
+    val argument = findArgumentByName(name) as? FirGetClassCall ?: return null
+    return argument.getTargetType()
+}
+
+fun FirGetClassCall.getTargetType(): ConeKotlinType? {
+    return typeRef.coneType.typeArguments.getOrNull(0)?.type
+}
+
 fun FirAnnotationContainer.getJvmNameFromAnnotation(target: AnnotationUseSiteTarget? = null): String? {
    val annotationCalls = getAnnotationsByClassId(StandardClassIds.Annotations.JvmName)
    return annotationCalls.firstNotNullOfOrNull { call ->
@@ -32,12 +32,13 @@ fun FirClass.primaryConstructorIfAny(session: FirSession): FirConstructorSymbol?
    return constructors(session).find(FirConstructorSymbol::isPrimary)
 }

-fun FirRegularClass.collectEnumEntries(): Collection<FirEnumEntry> {
+// TODO: dog shit, rewrite with scopes
+fun FirClass.collectEnumEntries(): Collection<FirEnumEntry> {
    assert(classKind == ClassKind.ENUM_CLASS)
    return declarations.filterIsInstance<FirEnumEntry>()
 }

-fun FirRegularClassSymbol.collectEnumEntries(): Collection<FirEnumEntrySymbol> {
+fun FirClassSymbol<*>.collectEnumEntries(): Collection<FirEnumEntrySymbol> {
    return fir.collectEnumEntries().map { it.symbol }
 }

@@ -118,6 +118,10 @@ fun FirSession.declaredMemberScope(klass: FirClassSymbol<*>): FirContainingNames
    return declaredMemberScope(klass.fir)
 }

+fun FirClassSymbol<*>.declaredMemberScope(session: FirSession): FirContainingNamesAwareScope {
+    return session.declaredMemberScope(fir)
+}
+
 fun FirSession.declaredMemberScopeWithLazyNestedScope(
    klass: FirClass,
    existingNames: List<Name>,
@@ -5,6 +5,8 @@

 package org.jetbrains.kotlin.fir.caches

+import kotlin.reflect.KProperty
+
 abstract class FirCache<in K : Any, out V, in CONTEXT> {
    abstract fun getValue(key: K, context: CONTEXT): V
    abstract fun getValueIfComputed(key: K): V?
@@ -24,6 +26,10 @@ class FirLazyValue<out V, in CONTEXT>(private val cache: FirCache<Unit, V, CONTE
    }
 }

+operator fun <V> FirLazyValue<V, Nothing?>.getValue(thisRef: Any?, property: KProperty<*>): V {
+    return getValue(context = null)
+}
+
@Suppress("NOTHING_TO_INLINE")
 inline fun <V> FirLazyValue<V, Nothing?>.getValue(): V {
    return getValue(null)
@@ -10,7 +10,12 @@ import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyBackingField
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
+import org.jetbrains.kotlin.fir.expressions.FirPropertyAccessExpression
+import org.jetbrains.kotlin.fir.references.impl.FirPropertyFromParameterResolvedNamedReference
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.name.Name

@@ -27,6 +32,12 @@ var FirProperty.fromPrimaryConstructor: Boolean? by FirDeclarationDataRegistry.d
 var FirClassLikeDeclaration.sourceElement: SourceElement? by FirDeclarationDataRegistry.data(SourceElementKey)
 var FirRegularClass.moduleName: String? by FirDeclarationDataRegistry.data(ModuleNameKey)

+val FirClassLikeSymbol<*>.sourceElement: SourceElement?
+    get() = fir.sourceElement
+
+val FirPropertySymbol.fromPrimaryConstructor: Boolean
+    get() = fir.fromPrimaryConstructor ?: false
+
 /**
 * Constraint without corresponding type argument
 */
@@ -93,6 +104,12 @@ val FirProperty.hasBackingField: Boolean
        }
    }

+val FirPropertySymbol.hasBackingField: Boolean
+    get() {
+        lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
+        return fir.hasBackingField
+    }
+
 fun FirDeclaration.getDanglingTypeConstraintsOrEmpty(): List<DanglingTypeConstraint> {
    return when (this) {
        is FirRegularClass -> danglingTypeConstraints
@@ -101,3 +118,11 @@ fun FirDeclaration.getDanglingTypeConstraintsOrEmpty(): List<DanglingTypeConstra
        else -> null
    } ?: emptyList()
 }
+
+val FirPropertySymbol.correspondingValueParameterFromPrimaryConstructor: FirValueParameterSymbol?
+    get() {
+        if (!fromPrimaryConstructor) return null
+        val initializer = resolvedInitializer as? FirPropertyAccessExpression ?: return null
+        val reference = initializer.calleeReference as? FirPropertyFromParameterResolvedNamedReference ?: return null
+        return reference.resolvedSymbol as? FirValueParameterSymbol
+    }
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.symbols.impl

 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
+import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.name.CallableId
@@ -39,6 +40,12 @@ open class FirPropertySymbol(
    val hasInitializer: Boolean
        get() = fir.initializer != null

+    val resolvedInitializer: FirExpression?
+        get() {
+            lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
+            return fir.initializer
+        }
+
    val hasDelegate: Boolean
        get() = fir.delegate != null

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.deserialization.PLATFORM_DEPENDENT_ANNOTATION_FQ_NAME
 import org.jetbrains.kotlin.load.java.JvmAbi.JVM_FIELD_ANNOTATION_FQ_NAME
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
+import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor
@@ -38,6 +39,9 @@ val VOLATILE_ANNOTATION_FQ_NAME = FqName("kotlin.jvm.Volatile")
@JvmField
 val TRANSIENT_ANNOTATION_FQ_NAME = FqName("kotlin.jvm.Transient")

+@JvmField
+val TRANSIENT_ANNOTATION_CLASS_ID = ClassId.topLevel(TRANSIENT_ANNOTATION_FQ_NAME)
+
@JvmField
 val JVM_SERIALIZABLE_LAMBDA_ANNOTATION_FQ_NAME = FqName("kotlin.jvm.JvmSerializableLambda")