[FIR] Implement FirNativeThrowsChecker

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirNativeDiagnosticsList.kt

@@ -7,10 +7,24 @@ package org.jetbrains.kotlin.fir.checkers.generator.diagnostics
 
 import org.jetbrains.kotlin.fir.PrivateForInline
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.model.DiagnosticList
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtElement
 
 @Suppress("UNUSED_VARIABLE", "LocalVariableName", "ClassName", "unused")
 @OptIn(PrivateForInline::class)
 object NATIVE_DIAGNOSTICS_LIST : DiagnosticList("FirNativeErrors") {
     val ALL by object : DiagnosticGroup("All") {
+        val THROWS_LIST_EMPTY by error<KtElement>()
+        val INCOMPATIBLE_THROWS_OVERRIDE by error<KtElement> {
+            parameter<FirRegularClassSymbol>("containingClass")
+        }
+        val INCOMPATIBLE_THROWS_INHERITED by error<KtDeclaration> {
+            parameter<Collection<FirRegularClassSymbol>>("containingClasses")
+        }
+        val MISSING_EXCEPTION_IN_THROWS_ON_SUSPEND by error<KtElement> {
+            parameter<FqName>("exceptionName")
+        }
     }
 }

compiler/fir/checkers/checkers.native/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/native/FirNativeErrors.kt

@@ -8,6 +8,10 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics.native
 import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory
 import org.jetbrains.kotlin.fir.analysis.diagnostics.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtElement
 
 /*
  * This file was generated automatically
@@ -16,6 +20,10 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.*
 
 object FirNativeErrors {
     // All
+    val THROWS_LIST_EMPTY by error0<KtElement>()
+    val INCOMPATIBLE_THROWS_OVERRIDE by error1<KtElement, FirRegularClassSymbol>()
+    val INCOMPATIBLE_THROWS_INHERITED by error1<KtDeclaration, Collection<FirRegularClassSymbol>>()
+    val MISSING_EXCEPTION_IN_THROWS_ON_SUSPEND by error1<KtElement, FqName>()
 
     init {
         RootDiagnosticRendererFactory.registerFactory(FirNativeErrorsDefaultMessages)

compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/diagnostics/native/FirNativeErrorsDefaultMessages.kt

@@ -6,8 +6,26 @@
 package org.jetbrains.kotlin.fir.analysis.diagnostics.native
 
 import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactoryToRendererMap
+import org.jetbrains.kotlin.diagnostics.KtDiagnosticRenderers.TO_STRING
 import org.jetbrains.kotlin.diagnostics.rendering.BaseDiagnosticRendererFactory
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.SYMBOL
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.SYMBOLS
+import org.jetbrains.kotlin.fir.analysis.diagnostics.checkMissingMessages
+import org.jetbrains.kotlin.fir.analysis.diagnostics.native.FirNativeErrors.INCOMPATIBLE_THROWS_INHERITED
+import org.jetbrains.kotlin.fir.analysis.diagnostics.native.FirNativeErrors.INCOMPATIBLE_THROWS_OVERRIDE
+import org.jetbrains.kotlin.fir.analysis.diagnostics.native.FirNativeErrors.MISSING_EXCEPTION_IN_THROWS_ON_SUSPEND
+import org.jetbrains.kotlin.fir.analysis.diagnostics.native.FirNativeErrors.THROWS_LIST_EMPTY
 
 object FirNativeErrorsDefaultMessages : BaseDiagnosticRendererFactory() {
-    override val MAP = KtDiagnosticFactoryToRendererMap("FIR")
-}
+    override val MAP = KtDiagnosticFactoryToRendererMap("FIR").also { map ->
+        map.put(THROWS_LIST_EMPTY, "Throws must have non-empty class list")
+        map.put(INCOMPATIBLE_THROWS_OVERRIDE, "Member overrides different @Throws filter from {0}", SYMBOL)
+        map.put(INCOMPATIBLE_THROWS_INHERITED, "Member inherits different @Throws filters from {0}", SYMBOLS)
+        map.put(
+            MISSING_EXCEPTION_IN_THROWS_ON_SUSPEND, "@Throws on suspend declaration must have {0} (or any of its superclasses) listed",
+            TO_STRING
+        )
+
+        map.checkMissingMessages(FirNativeErrors)
+    }
+}

compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeThrowsChecker.kt

@@ -0,0 +1,184 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.analysis.native.checkers
+
+import org.jetbrains.kotlin.builtins.StandardNames
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.diagnostics.reportOn
+import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
+import org.jetbrains.kotlin.fir.analysis.checkers.hasModifier
+import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
+import org.jetbrains.kotlin.fir.analysis.diagnostics.native.FirNativeErrors
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
+import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
+import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol
+import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.classId
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.annotations.KOTLIN_THROWS_ANNOTATION_FQ_NAME
+
+object FirNativeThrowsChecker : FirBasicDeclarationChecker() {
+    private val throwsFqName = ClassId.topLevel(KOTLIN_THROWS_ANNOTATION_FQ_NAME)
+
+    private val cancellationExceptionFqName = FqName("kotlin.coroutines.cancellation.CancellationException")
+
+    private val cancellationExceptionAndSupersClassIds = setOf(
+        ClassId.topLevel(StandardNames.FqNames.throwable),
+        ClassId.topLevel(FqName("kotlin.Exception")),
+        ClassId.topLevel(FqName("kotlin.RuntimeException")),
+        ClassId.topLevel(FqName("kotlin.IllegalStateException")),
+        ClassId.topLevel(cancellationExceptionFqName)
+    )
+
+    override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+        val throwsAnnotation = declaration.getAnnotationByClassId(throwsFqName) as? FirAnnotationCall
+
+        if (!checkInheritance(declaration, throwsAnnotation, context, reporter)) return
+
+        if (throwsAnnotation.hasUnresolvedArgument()) return
+
+        val classTypes = throwsAnnotation?.getClassTypes(context.session) ?: return
+
+        if (classTypes.isEmpty()) {
+            reporter.reportOn(throwsAnnotation.source, FirNativeErrors.THROWS_LIST_EMPTY, context)
+            return
+        }
+
+        if (declaration.hasModifier(KtTokens.SUSPEND_KEYWORD) && classTypes.none { it.classId in cancellationExceptionAndSupersClassIds }) {
+            reporter.reportOn(
+                throwsAnnotation.source,
+                FirNativeErrors.MISSING_EXCEPTION_IN_THROWS_ON_SUSPEND,
+                cancellationExceptionFqName,
+                context
+            )
+        }
+    }
+
+    private fun checkInheritance(
+        declaration: FirDeclaration,
+        throwsAnnotation: FirAnnotationCall?,
+        context: CheckerContext,
+        reporter: DiagnosticReporter
+    ): Boolean {
+        if (declaration !is FirSimpleFunction) return true
+
+        val inherited = getInheritedThrows(declaration, throwsAnnotation, context).entries.distinctBy { it.value }
+
+        if (inherited.size >= 2) {
+            reporter.reportOn(
+                declaration.source,
+                FirNativeErrors.INCOMPATIBLE_THROWS_INHERITED,
+                inherited.mapNotNull { it.key.containingClass()?.toFirRegularClassSymbol(context.session) },
+                context
+            )
+            return false
+        }
+
+        val (overriddenMember, overriddenThrows) = inherited.firstOrNull()
+            ?: return true // Should not happen though.
+
+        if (decodeThrowsFilter(throwsAnnotation, context.session) != overriddenThrows) {
+            val containingClassSymbol = overriddenMember.containingClass()?.toFirRegularClassSymbol(context.session)
+            if (containingClassSymbol != null) {
+                reporter.reportOn(throwsAnnotation?.source, FirNativeErrors.INCOMPATIBLE_THROWS_OVERRIDE, containingClassSymbol, context)
+            }
+            return false
+        }
+
+        return true
+    }
+
+    private fun getInheritedThrows(
+        function: FirSimpleFunction,
+        throwsAnnotation: FirAnnotationCall?,
+        context: CheckerContext
+    ): Map<FirNamedFunctionSymbol, ThrowsFilter> {
+        val visited = mutableSetOf<FirNamedFunctionSymbol>()
+        val result = mutableMapOf<FirNamedFunctionSymbol, ThrowsFilter>()
+
+        fun getInheritedThrows(localThrowsAnnotation: FirAnnotationCall?, localFunctionSymbol: FirNamedFunctionSymbol) {
+            if (!visited.add(localFunctionSymbol)) return
+            val containingClassSymbol = localFunctionSymbol.containingClass()?.toFirRegularClassSymbol(context.session)
+
+            if (containingClassSymbol != null) {
+                val unsubstitutedScope = containingClassSymbol.unsubstitutedScope(context)
+                unsubstitutedScope.processFunctionsByName(localFunctionSymbol.name) {}
+                val overriddenFunctions = unsubstitutedScope.getDirectOverriddenFunctions(localFunctionSymbol)
+                if (localFunctionSymbol == function.symbol || localThrowsAnnotation == null && overriddenFunctions.isNotEmpty()) {
+                    for (overriddenFunction in overriddenFunctions) {
+                        val annotation = if (overriddenFunction.isSubstitutionOrIntersectionOverride) {
+                            null
+                        } else {
+                            overriddenFunction.getAnnotationByClassId(throwsFqName) as? FirAnnotationCall
+                        }
+                        getInheritedThrows(annotation, overriddenFunction)
+                    }
+                } else {
+                    result[localFunctionSymbol] = decodeThrowsFilter(localThrowsAnnotation, context.session)
+                }
+            }
+        }
+
+        getInheritedThrows(throwsAnnotation, function.symbol)
+
+        return result
+    }
+
+    private fun FirElement?.hasUnresolvedArgument(): Boolean {
+        if (this is FirWrappedArgumentExpression) {
+            return expression.hasUnresolvedArgument()
+        }
+
+        if (this is FirResolvable) {
+            if (this.calleeReference is FirErrorNamedReference) {
+                return true
+            }
+        }
+
+        if (this is FirVarargArgumentsExpression) {
+            for (argument in this.arguments) {
+                if (argument.hasUnresolvedArgument()) {
+                    return true
+                }
+            }
+        }
+
+        if (this is FirCall) {
+            for (argument in this.argumentList.arguments) {
+                if (argument.hasUnresolvedArgument()) {
+                    return true
+                }
+            }
+        }
+
+        return false
+    }
+
+    private fun decodeThrowsFilter(throwsAnnotation: FirAnnotationCall?, session: FirSession): ThrowsFilter {
+        return ThrowsFilter(throwsAnnotation?.getClassTypes(session)?.toSet())
+    }
+
+    private fun FirAnnotationCall.getClassTypes(session: FirSession): List<ConeKotlinType> {
+        val arguments = argumentList.arguments
+        return (arguments.firstOrNull() as? FirVarargArgumentsExpression)?.arguments
+            ?.filterIsInstance<FirGetClassCall>()
+            ?.map { it.arguments.first().typeRef }
+            ?.filterIsInstance<FirResolvedTypeRef>()
+            ?.map { it.type.fullyExpandedType(session) }
+            ?: emptyList()
+    }
+
+    private data class ThrowsFilter(val classes: Set<ConeKotlinType>?)
+}

compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/NativeDeclarationCheckers.kt

@@ -6,6 +6,11 @@
 package org.jetbrains.kotlin.fir.analysis.native.checkers
 
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
 
 object NativeDeclarationCheckers : DeclarationCheckers() {
+    override val basicDeclarationCheckers: Set<FirBasicDeclarationChecker>
+        get() = setOf(
+            FirNativeThrowsChecker
+        )
 }