[FIR] Change errors location from Errors.java to FirErrors.kt

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

@@ -5,5 +5,5 @@ class A {
 }
 
 abstract class B {
-    <!FIR_EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(str: String): A.InnerA<!>
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(str: String): A.InnerA<!>
 }

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

@@ -17,7 +17,7 @@ class Property {
     var var1: String
     var var2: String
     var var3: Int
-    <!FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE!>var var4: A.AInnerPrivate<!>
+    <!EXPOSED_PROPERTY_TYPE!>var var4: A.AInnerPrivate<!>
     var var5: A.AInnerPublic
-    <!FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE!>var var6: A.AInnerProtectedEnum<!>
+    <!EXPOSED_PROPERTY_TYPE!>var var6: A.AInnerProtectedEnum<!>
 }

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

@@ -2,7 +2,7 @@ class A {
     private inner class Inner
 }
 class B {
-    <!FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias AInner = A.Inner<!>
+    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias AInner = A.Inner<!>
     inner class Inner
 }
 
@@ -10,5 +10,5 @@ class C {
     typealias BInner = B.Inner
 }
 
-<!FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias AInner0 = A.Inner<!>
+<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias AInner0 = A.Inner<!>
 typealias BInner0 = B.Inner

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

@@ -5,10 +5,12 @@
 
 package org.jetbrains.kotlin.fir.analysis.checkers.declaration
 
-import org.jetbrains.kotlin.diagnostics.Errors
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.diagnostics.DiagnosticFactory3
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+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
@@ -25,30 +27,30 @@ object FirExposedVisibilityChecker : FirDeclarationChecker<FirMemberDeclaration>
 
     private fun checkTypeAlias(declaration: FirTypeAlias, context: CheckerContext, reporter: DiagnosticReporter) {
         val expandedType = declaration.expandedConeType
-
+        val typeAliasVisibility = declaration.firEffectiveVisibility(declaration.session)
-        val restricting = expandedType?.leastPermissiveDescriptor(declaration.session, declaration.effectiveVisibility)
+        val restricting = expandedType?.leastPermissiveDescriptor(declaration.session, typeAliasVisibility)
         if (restricting != null) {
-            reporter.reportExposure(Error.EXPOSED_TYPEALIAS_EXPANDED_TYPE, declaration.source)
+            reporter.reportExposure(FirErrors.EXPOSED_TYPEALIAS_EXPANDED_TYPE, declaration, restricting)
         }
     }
 
     private fun checkFunction(declaration: FirFunction<*>, context: CheckerContext, reporter: DiagnosticReporter) {
-        val functionVisibility = (declaration as FirMemberDeclaration).effectiveVisibility
+        val functionVisibility = (declaration as FirMemberDeclaration).firEffectiveVisibility(declaration.session)
         if (declaration !is FirConstructor) {
             val restricting = declaration.returnTypeRef.coneTypeSafe<ConeClassLikeType>()
                 ?.leastPermissiveDescriptor(declaration.session, functionVisibility)
             if (restricting != null) {
-                reporter.reportExposure(Error.EXPOSED_FUNCTION_RETURN_TYPE, declaration.source)
+                reporter.reportExposure(FirErrors.EXPOSED_FUNCTION_RETURN_TYPE, declaration, restricting)
             }
         }
     }
 
     private fun checkProperty(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
-        val propertyVisibility = declaration.effectiveVisibility
+        val propertyVisibility = declaration.firEffectiveVisibility(declaration.session)
         val restricting =
             declaration.returnTypeRef.coneTypeSafe<ConeClassLikeType>()?.leastPermissiveDescriptor(declaration.session, propertyVisibility)
         if (restricting != null) {
-            reporter.reportExposure(Error.EXPOSED_PROPERTY_TYPE, declaration.source)
+            reporter.reportExposure(FirErrors.EXPOSED_PROPERTY_TYPE, declaration, restricting)
         }
         checkMemberReceiver(declaration.receiverTypeRef?.coneTypeSafe(), declaration, reporter)
     }
@@ -62,42 +64,26 @@ object FirExposedVisibilityChecker : FirDeclarationChecker<FirMemberDeclaration>
         val memberVisibility = memberDeclaration.effectiveVisibility
         val restricting = receiverParameterType?.leastPermissiveDescriptor(memberDeclaration.session, memberVisibility)
         if (restricting != null) {
-            reporter.reportExposure(Error.EXPOSED_RECEIVER_TYPE, memberDeclaration.source)
+            reporter.reportExposure(FirErrors.EXPOSED_RECEIVER_TYPE, memberDeclaration, restricting)
         }
     }
 
-    private enum class Error {
+    private inline fun <E : FirMemberDeclaration, reified P : PsiElement> DiagnosticReporter.reportExposure(
-        EXPOSED_TYPEALIAS_EXPANDED_TYPE,
+        er: DiagnosticFactory3<P, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>,
-        EXPOSED_PROPERTY_TYPE,
+        element: E,
-        EXPOSED_RECEIVER_TYPE,
+        restrictingDeclaration: DeclarationWithRelation,
-        EXPOSED_FUNCTION_RETURN_TYPE
+        elementVisibility: FirEffectiveVisibility = element.effectiveVisibility,
-    }
+        source: FirSourceElement? = element.source
-
-    private fun DiagnosticReporter.reportExposure(
-        error: Error,
-        source: FirSourceElement?
     ) {
-        when (error) {
+        source?.let {
-            Error.EXPOSED_TYPEALIAS_EXPANDED_TYPE -> {
+            report(
-                source?.let {
+                er.onSource(
-                    report(Errors.FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE.onSource(it))
+                    it,
-                }
+                    elementVisibility,
-            }
+                    restrictingDeclaration,
-            Error.EXPOSED_PROPERTY_TYPE -> {
+                    restrictingDeclaration.firEffectiveVisibility(element.session)
-                source?.let {
+                )
-                    report(Errors.FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE.onSource(it))
+            )
-                }
-            }
-            Error.EXPOSED_RECEIVER_TYPE -> {
-                source?.let {
-                    report(Errors.FIR_EXPOSED_RECEIVER_TYPE.onSource(it))
-                }
-            }
-            Error.EXPOSED_FUNCTION_RETURN_TYPE -> {
-                source?.let {
-                    report(Errors.FIR_EXPOSED_FUNCTION_RETURN_TYPE.onSource(it))
-                }
-            }
         }
     }
 }

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

@@ -30,6 +30,10 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SYNTAX_ERROR
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPE_PARAMETER_AS_SUPERTYPE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UNRESOLVED_LABEL
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UNRESOLVED_REFERENCE
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_TYPEALIAS_EXPANDED_TYPE
+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
 
 @Suppress("unused")
 class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
@@ -38,6 +42,7 @@ 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)
@@ -55,11 +60,16 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
             map.put(ERROR_FROM_JAVA_RESOLUTION, "Java resolution error")
             map.put(OTHER_ERROR, "Unknown (other) error")
             map.put(SUPER_IS_NOT_AN_EXPRESSION, "Super cannot be a callee")
-
             map.put(REPEATED_MODIFIER, "Repeated ''{0}''", TO_STRING)
             map.put(REDUNDANT_MODIFIER, "Modifier ''{0}'' is redundant because ''{1}'' is present", TO_STRING, TO_STRING)
             map.put(DEPRECATED_MODIFIER_PAIR, "Modifier ''{0}'' is deprecated in presence of ''{1}''", TO_STRING, TO_STRING)
             map.put(INCOMPATIBLE_MODIFIERS, "Modifier ''{0}'' is incompatible with ''{1}''", TO_STRING, TO_STRING)
+
+            // Exposed visibility group
+            map.put(EXPOSED_TYPEALIAS_EXPANDED_TYPE, "{0} typealias exposes {2} in expanded type{1}", TO_STRING, TO_STRING, TO_STRING)
+            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)
         }
     }
 }

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

@@ -23,5 +23,7 @@ object FirDiagnosticRenderers {
         }
     }
 
-    val TO_STRING = Renderer<Any> { it.toString() }
+    val TO_STRING = Renderer { element: Any ->
+        element.toString()
+    }
 }

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

@@ -7,6 +7,8 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.fir.DeclarationWithRelation
+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
@@ -46,8 +48,16 @@ object FirErrors {
     val NON_PRIVATE_CONSTRUCTOR_IN_ENUM by existing<FirSourceElement, PsiElement>(Errors.NON_PRIVATE_CONSTRUCTOR_IN_ENUM)
     val NON_PRIVATE_CONSTRUCTOR_IN_SEALED by existing<FirSourceElement, PsiElement>(Errors.NON_PRIVATE_CONSTRUCTOR_IN_SEALED)
 
+    // Exposed visibility group
+    val EXPOSED_TYPEALIAS_EXPANDED_TYPE by error3<FirSourceElement, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
+    val EXPOSED_FUNCTION_RETURN_TYPE by error3<FirSourceElement, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
+    val EXPOSED_RECEIVER_TYPE by error3<FirSourceElement, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
+    val EXPOSED_PROPERTY_TYPE by error3<FirSourceElement, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
+    val EXPOSED_PARAMETER_TYPE by error3<FirSourceElement, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
+
     val REPEATED_MODIFIER by error1<FirSourceElement, PsiElement, KtModifierKeywordToken>()
     val REDUNDANT_MODIFIER by error2<FirSourceElement, PsiElement, KtModifierKeywordToken, KtModifierKeywordToken>()
     val DEPRECATED_MODIFIER_PAIR by error2<FirSourceElement, PsiElement, KtModifierKeywordToken, KtModifierKeywordToken>()
     val INCOMPATIBLE_MODIFIERS by error2<FirSourceElement, PsiElement, KtModifierKeywordToken, KtModifierKeywordToken>()
 }
+

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -135,12 +135,6 @@ public interface Errors {
     DiagnosticFactory3<KtSuperTypeListEntry, EffectiveVisibility, DescriptorWithRelation, EffectiveVisibility> EXPOSED_SUPER_INTERFACE = DiagnosticFactory3.create(ERROR);
     DiagnosticFactory3<PsiElement, EffectiveVisibility, DescriptorWithRelation, EffectiveVisibility> EXPOSED_TYPEALIAS_EXPANDED_TYPE = DiagnosticFactory3.create(ERROR);
 
-    // (FIR) Exposed visibility group
-    DiagnosticFactory0<PsiElement> FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<PsiElement> FIR_EXPOSED_PROPERTY_TYPE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<KtTypeParameter> FIR_EXPOSED_RECEIVER_TYPE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<PsiElement> FIR_EXPOSED_FUNCTION_RETURN_TYPE = DiagnosticFactory0.create(ERROR);
-
     DiagnosticFactory2<KtExpression, KotlinType, Collection<ClassDescriptor>> INACCESSIBLE_TYPE = DiagnosticFactory2.create(WARNING);
 
     DiagnosticFactory1<KtElement, Collection<ClassDescriptor>> PLATFORM_CLASS_MAPPED_TO_KOTLIN = DiagnosticFactory1.create(WARNING);

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -82,11 +82,6 @@ public class DefaultErrorMessages {
         MAP.put(EXPOSED_SUPER_INTERFACE, "''{0}'' sub-interface exposes its ''{2}'' supertype{1}", TO_STRING, TO_STRING, TO_STRING);
         MAP.put(EXPOSED_TYPEALIAS_EXPANDED_TYPE, "''{0}'' typealias exposes ''{2}'' in expanded type{1}", TO_STRING, TO_STRING, TO_STRING);
 
-        MAP.put(FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE, "FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE");
-        MAP.put(FIR_EXPOSED_PROPERTY_TYPE, "FIR_EXPOSED_PROPERTY_TYPE");
-        MAP.put(FIR_EXPOSED_RECEIVER_TYPE, "FIR_EXPOSED_RECEIVER_TYPE");
-        MAP.put(FIR_EXPOSED_FUNCTION_RETURN_TYPE, "FIR_EXPOSED_FUNCTION_RETURN_TYPE");
-
         MAP.put(EXTENSION_SHADOWED_BY_MEMBER, "Extension is shadowed by a member: {0}", COMPACT_WITH_MODIFIERS);
         MAP.put(EXTENSION_FUNCTION_SHADOWED_BY_INNER_CLASS_CONSTRUCTOR,
                 "Extension function is shadowed by an inner class constructor: {0}", COMPACT_WITH_MODIFIERS);