[FIR] Support for EXPOSED_PARAMETER_TYPE

compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.kt

@@ -0,0 +1,9 @@
+class A {
+    private class AInner
+}
+
+class B {
+    fun foo(<!EXPOSED_PARAMETER_TYPE!>value: A.AInner<!>) {
+
+    }
+}

compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.txt

@@ -0,0 +1,23 @@
+FILE: exposedFunctionParameterType.kt
+    public final class A : R|kotlin/Any| {
+        public constructor(): R|A| {
+            super<R|kotlin/Any|>()
+        }
+
+        private final class AInner : R|kotlin/Any| {
+            public[private] constructor(): R|A.AInner| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+    }
+    public final class B : R|kotlin/Any| {
+        public constructor(): R|B| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final fun foo(value: R|A.AInner|): R|kotlin/Unit| {
+        }
+
+    }

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java

@@ -2138,6 +2138,11 @@ public class FirDiagnosticsTestGenerated extends AbstractFirDiagnosticsTest {
             KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/visibility"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
         }
 
+        @TestMetadata("exposedFunctionParameterType.kt")
+        public void testExposedFunctionParameterType() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.kt");
+        }
+
         @TestMetadata("exposedFunctionReturnType.kt")
         public void testExposedFunctionReturnType() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionReturnType.kt");

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java

@@ -2138,6 +2138,11 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
             KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/visibility"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
         }
 
+        @TestMetadata("exposedFunctionParameterType.kt")
+        public void testExposedFunctionParameterType() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.kt");
+        }
+
         @TestMetadata("exposedFunctionReturnType.kt")
         public void testExposedFunctionReturnType() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionReturnType.kt");

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityChecker.kt

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.onSource
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
 
@@ -44,7 +45,7 @@ object FirExposedVisibilityChecker : FirDeclarationChecker<FirMemberDeclaration>
     private fun checkFunction(declaration: FirFunction<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         val functionVisibility = (declaration as FirMemberDeclaration).firEffectiveVisibility(declaration.session)
         if (declaration !is FirConstructor) {
-            val restricting = declaration.returnTypeRef.coneTypeSafe<ConeClassLikeType>()
+            val restricting = declaration.returnTypeRef.coneTypeSafe<ConeKotlinType>()
                 ?.leastPermissiveDescriptor(declaration.session, functionVisibility)
             if (restricting != null) {
                 reporter.reportExposure(
@@ -56,12 +57,29 @@ object FirExposedVisibilityChecker : FirDeclarationChecker<FirMemberDeclaration>
                 )
             }
         }
+        declaration.valueParameters.forEachIndexed { i, valueParameter ->
+            if (i < declaration.valueParameters.size) {
+                val restricting =
+                    valueParameter.returnTypeRef.coneTypeSafe<ConeKotlinType>()
+                        ?.leastPermissiveDescriptor(declaration.session, functionVisibility)
+                if (restricting != null) {
+                    reporter.reportExposure(
+                        FirErrors.EXPOSED_PARAMETER_TYPE,
+                        restricting,
+                        functionVisibility,
+                        restricting.firEffectiveVisibility(declaration.session),
+                        valueParameter.source
+                    )
+                }
+            }
+        }
+        checkMemberReceiver(declaration.receiverTypeRef, declaration as? FirCallableMemberDeclaration<*>, reporter)
     }
 
     private fun checkProperty(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
         val propertyVisibility = declaration.firEffectiveVisibility(declaration.session)
         val restricting =
-            declaration.returnTypeRef.coneTypeSafe<ConeClassLikeType>()?.leastPermissiveDescriptor(declaration.session, propertyVisibility)
+            declaration.returnTypeRef.coneTypeSafe<ConeKotlinType>()?.leastPermissiveDescriptor(declaration.session, propertyVisibility)
         if (restricting != null) {
             reporter.reportExposure(
                 FirErrors.EXPOSED_PROPERTY_TYPE,
@@ -76,10 +94,10 @@ object FirExposedVisibilityChecker : FirDeclarationChecker<FirMemberDeclaration>
 
     private fun checkMemberReceiver(
         typeRef: FirTypeRef?,
-        memberDeclaration: FirCallableMemberDeclaration<*>, reporter: DiagnosticReporter
+        memberDeclaration: FirCallableMemberDeclaration<*>?, reporter: DiagnosticReporter
     ) {
-        if (typeRef == null) return
+        if (typeRef == null || memberDeclaration == null) return
-        val receiverParameterType = typeRef.coneTypeSafe<ConeClassLikeType>()
+        val receiverParameterType = typeRef.coneTypeSafe<ConeKotlinType>()
         val memberVisibility = memberDeclaration.firEffectiveVisibility(memberDeclaration.session)
         val restricting = receiverParameterType?.leastPermissiveDescriptor(memberDeclaration.session, memberVisibility)
         if (restricting != null) {

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

@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_TYPEALIAS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_FUNCTION_RETURN_TYPE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_PROPERTY_TYPE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_RECEIVER_TYPE
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_PARAMETER_TYPE
 
 @Suppress("unused")
 class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
@@ -42,7 +43,6 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
     }
 
     companion object {
-<<<<<<< HEAD:compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt
         val MAP = FirDiagnosticFactoryToRendererMap("FIR").also { map ->
             map.put(UNRESOLVED_REFERENCE, "Unresolved reference: {0}", NULLABLE_STRING)
             map.put(INAPPLICABLE_CANDIDATE, "Inapplicable candidate(s): {0}", SYMBOLS)
@@ -70,6 +70,6 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
             map.put(EXPOSED_PROPERTY_TYPE, "{0} property exposes its {2} type{1}", TO_STRING, TO_STRING, TO_STRING)
             map.put(EXPOSED_FUNCTION_RETURN_TYPE, "{0} function exposes its {2} return type{1}", TO_STRING, TO_STRING, TO_STRING)
             map.put(EXPOSED_RECEIVER_TYPE, "{0} member exposes its {2} receiver type{1}", TO_STRING, TO_STRING, TO_STRING)
-        }
+            map.put(EXPOSED_PARAMETER_TYPE, "{0} function exposes its {2} parameter type{1}", TO_STRING, TO_STRING, TO_STRING)
     }
 }

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

@@ -12,11 +12,8 @@ import org.jetbrains.kotlin.fir.FirEffectiveVisibility
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
-<<<<<<< HEAD
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
-=======
->>>>>>> d43c780e5de... [FIR] Fixed EXPOSED_RECEIVER_TYPE
 
 object FirErrors {
     val UNRESOLVED_REFERENCE by error1<FirSourceElement, PsiElement, String?>()
@@ -64,3 +61,4 @@ object FirErrors {
     val INCOMPATIBLE_MODIFIERS by error2<FirSourceElement, PsiElement, KtModifierKeywordToken, KtModifierKeywordToken>()
 }
 
+