[SLC] drop redundant resolve for visibility, fix several cases

^KTIJ-23783

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightAccessorMethod.kt

@@ -156,21 +156,15 @@ internal class SymbolLightAccessorMethod private constructor(
     private fun computeModifiers(): Set<String> = analyzeForLightClasses(ktModule) {
         val propertySymbol = propertySymbol()
         val propertyAccessorSymbol = propertyAccessorSymbol()
-        val isOverrideMethod = propertyAccessorSymbol.isOverride || propertySymbol.isOverride
-        val isInterfaceMethod = containingClass.isInterface
-
         val modifiers = mutableSetOf<String>()
 
         propertySymbol.computeModalityForMethod(
             isTopLevel = isTopLevel,
-            suppressFinal = isOverrideMethod || isInterfaceMethod,
+            suppressFinal = containingClass.isInterface || propertySymbol.isOverride,
             result = modifiers,
         )
 
-        val visibility = isOverrideMethod.ifTrue {
+        modifiers.add(propertyAccessorSymbol.toPsiVisibilityForMember())
-            tryGetEffectiveVisibility(propertySymbol)?.toPsiVisibilityForMember()
-        } ?: propertyAccessorSymbol.toPsiVisibilityForMember()
-        modifiers.add(visibility)
 
         if (!suppressStatic &&
             (propertySymbol.hasJvmStaticAnnotation() || propertyAccessorSymbol.hasJvmStaticAnnotation(accessorSite))

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightMethodBase.kt

@@ -27,8 +27,6 @@ import org.jetbrains.kotlin.light.classes.symbol.SymbolLightMemberBase
 import org.jetbrains.kotlin.light.classes.symbol.annotations.getJvmNameFromAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasPublishedApiAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassBase
-import org.jetbrains.kotlin.light.classes.symbol.tryGetEffectiveVisibility
-import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 
 internal abstract class SymbolLightMethodBase(
     lightMemberOrigin: LightMemberOrigin?,
@@ -93,12 +91,7 @@ internal abstract class SymbolLightMethodBase(
         annotationUseSiteTarget: AnnotationUseSiteTarget?,
     ): String where T : KtAnnotatedSymbol, T : KtSymbolWithVisibility, T : KtCallableSymbol {
         getJvmNameFromAnnotation(annotationUseSiteTarget)?.let { return it }
-
+        if (visibility != Visibilities.Internal) return defaultName
-        val effectiveVisibilityIfNotInternal = (visibility != Visibilities.Internal).ifTrue {
-            tryGetEffectiveVisibility(this)
-        } ?: this.visibility
-
-        if (effectiveVisibilityIfNotInternal != Visibilities.Internal) return defaultName
         if (containingClass is KtLightClassForFacade) return defaultName
         if (hasPublishedApiAnnotation(annotationUseSiteTarget)) return defaultName
 

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightSimpleMethod.kt

@@ -100,12 +100,7 @@ internal class SymbolLightSimpleMethod(
             result = modifiers
         )
 
-        val visibility: String = functionSymbol.isOverride.ifTrue {
+        modifiers.add(functionSymbol.toPsiVisibilityForMember())
-            tryGetEffectiveVisibility(functionSymbol)
-                ?.toPsiVisibilityForMember()
-        } ?: functionSymbol.toPsiVisibilityForMember()
-
-        modifiers.add(visibility)
 
         if (!suppressStatic && functionSymbol.hasJvmStaticAnnotation()) {
             modifiers.add(PsiModifier.STATIC)

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/symbolLightUtils.kt

@@ -12,7 +12,10 @@ import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.annotations.*
 import org.jetbrains.kotlin.analysis.api.base.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.components.DefaultTypeClassIds
-import org.jetbrains.kotlin.analysis.api.symbols.*
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithModality
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithTypeParameters
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithVisibility
@@ -89,64 +92,45 @@ internal fun KtSymbolWithModality.computeModalityForMethod(
     if (this is KtFunctionSymbol && isExternal) {
         result.add(PsiModifier.NATIVE)
     }
+
     if (isTopLevel) {
         result.add(PsiModifier.STATIC)
         val needFinalModifier = when (this) {
             is KtPropertySymbol -> isDelegatedProperty || isVal
             else -> true
         }
+
         if (needFinalModifier) {
             result.add(PsiModifier.FINAL)
         }
     }
 }
 
-context(KtAnalysisSession)
+internal fun KtSymbolWithVisibility.toPsiVisibilityForMember(): String = visibility.toPsiVisibilityForMember()
-internal fun PsiElement.tryGetEffectiveVisibility(symbol: KtCallableSymbol): Visibility? {
-    if (symbol !is KtPropertySymbol && symbol !is KtFunctionSymbol) return null
 
-    var visibility = (symbol as? KtSymbolWithVisibility)?.visibility
+internal fun KtSymbolWithVisibility.toPsiVisibilityForClass(isNested: Boolean): String = visibility.toPsiVisibilityForClass(isNested)
 
-    for (overriddenSymbol in symbol.getAllOverriddenSymbols()) {
+internal fun Visibility.toPsiVisibilityForMember(): String = when (this) {
-        val newVisibility = (overriddenSymbol as? KtSymbolWithVisibility)?.visibility
+    Visibilities.Private, Visibilities.PrivateToThis -> PsiModifier.PRIVATE
-        if (newVisibility != null) {
+    Visibilities.Protected -> PsiModifier.PROTECTED
-            visibility = newVisibility
+    else -> PsiModifier.PUBLIC
-        }
-    }
-
-    return visibility
 }
 
-internal fun KtSymbolWithVisibility.toPsiVisibilityForMember(): String =
+private fun Visibility.toPsiVisibilityForClass(isNested: Boolean): String = when (isNested) {
-    visibility.toPsiVisibilityForMember()
+    false -> when (this) {
+        Visibilities.Public,
+        Visibilities.Protected,
+        Visibilities.Local,
+        Visibilities.Internal -> PsiModifier.PUBLIC
 
-internal fun KtSymbolWithVisibility.toPsiVisibilityForClass(isNested: Boolean): String =
+        else -> PsiModifier.PACKAGE_LOCAL
-    visibility.toPsiVisibilityForClass(isNested)
-
-internal fun Visibility.toPsiVisibilityForMember(): String =
-    when (this) {
-        Visibilities.Private, Visibilities.PrivateToThis -> PsiModifier.PRIVATE
-        Visibilities.Protected -> PsiModifier.PROTECTED
-        else -> PsiModifier.PUBLIC
     }
 
-private fun Visibility.toPsiVisibilityForClass(isNested: Boolean): String {
+    true -> when (this) {
-    return when (isNested) {
+        Visibilities.Public, Visibilities.Internal, Visibilities.Local -> PsiModifier.PUBLIC
-        false -> when (this) {
+        Visibilities.Protected -> PsiModifier.PROTECTED
-            Visibilities.Public,
+        Visibilities.Private -> PsiModifier.PRIVATE
-            Visibilities.Protected,
+        else -> PsiModifier.PACKAGE_LOCAL
-            Visibilities.Local,
-            Visibilities.Internal -> PsiModifier.PUBLIC
-
-            else -> PsiModifier.PACKAGE_LOCAL
-        }
-
-        true -> when (this) {
-            Visibilities.Public, Visibilities.Internal, Visibilities.Local -> PsiModifier.PUBLIC
-            Visibilities.Protected -> PsiModifier.PROTECTED
-            Visibilities.Private -> PsiModifier.PRIVATE
-            else -> PsiModifier.PACKAGE_LOCAL
-        }
     }
 }
 

compiler/testData/asJava/ultraLightClasses/inheritance.fir.java

@@ -38,14 +38,14 @@ public final class Derived /* Derived*/ extends Base implements IntfWithProp {
   private final int x = 3 /* initializer type: int */;
 
   @java.lang.Override()
-  protected error.NonExistentClass v();//  v()
+  public error.NonExistentClass v();//  v()
 
   @java.lang.Override()
   public int abs();//  abs()
 
   public  Derived(int);//  .ctor(int)
 
-  public int getX$light_idea_test_case();//  getX$light_idea_test_case()
+  public int getX();//  getX()
 
 }