[FIR] Report INVISIBLE_REFERENCE on the first unresolved qualifier

#KT-61719 Fixed

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

@@ -3,7 +3,7 @@ class A {
 }
 
 class B {
-    fun foo(<!EXPOSED_PARAMETER_TYPE!>value: <!INVISIBLE_REFERENCE!>A.AInner<!><!>) {
+    fun foo(<!EXPOSED_PARAMETER_TYPE!>value: A.<!INVISIBLE_REFERENCE!>AInner<!><!>) {
 
     }
 }

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

@@ -5,7 +5,7 @@ class A {
 }
 
 abstract class B {
-    <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(str: String): <!INVISIBLE_REFERENCE!>A.InnerA<!><!>
+    <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(str: String): A.<!INVISIBLE_REFERENCE!>InnerA<!><!>
 }
 
 private enum class Some {

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

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

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

@@ -46,7 +46,7 @@ class Test3 : C.CPublicI, <!EXPOSED_SUPER_CLASS, FINAL_SUPERTYPE, SUPERTYPE_NOT_
 
 }
 
-class Test4 : E, <!INVISIBLE_REFERENCE!>A.AProtectedI<!> {
+class Test4 : E, A.<!INVISIBLE_REFERENCE!>AProtectedI<!> {
 
 }
 

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

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

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

@@ -15,7 +15,7 @@ public class Test1<T: <!EXPOSED_TYPE_PARAMETER_BOUND!>A<!>>
 public class Test2<T: C, P: E>
 
 // invalid, D is protected
-public class Test3<T: E, P: <!EXPOSED_TYPE_PARAMETER_BOUND, INVISIBLE_REFERENCE!>C.D<!>>
+public class Test3<T: E, P: <!EXPOSED_TYPE_PARAMETER_BOUND!>C.<!INVISIBLE_REFERENCE!>D<!><!>>
 
 // valid, B is internal
 internal class Test4<T: B>
@@ -32,4 +32,4 @@ public class Container : <!SUPERTYPE_NOT_INITIALIZED!>C<!> {
 }
 
 // invalid, A is private, B is internal, D is protected
-public interface Test8<T: <!EXPOSED_TYPE_PARAMETER_BOUND!>A<!>, P: <!EXPOSED_TYPE_PARAMETER_BOUND!>B<!>, F: C, N: <!EXPOSED_TYPE_PARAMETER_BOUND, INVISIBLE_REFERENCE!>C.D<!>, M: E>
+public interface Test8<T: <!EXPOSED_TYPE_PARAMETER_BOUND!>A<!>, P: <!EXPOSED_TYPE_PARAMETER_BOUND!>B<!>, F: C, N: <!EXPOSED_TYPE_PARAMETER_BOUND!>C.<!INVISIBLE_REFERENCE!>D<!><!>, M: E>

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

@@ -91,6 +91,7 @@ private fun ConeDiagnostic.toKtDiagnostic(
         )
     }
 
+    is ConeTypeVisibilityError -> symbol.toInvisibleReferenceDiagnostic(smallestUnresolvablePrefix.last().source)
     is ConeVisibilityError -> symbol.toInvisibleReferenceDiagnostic(source)
     is ConeInapplicableWrongReceiver -> FirErrors.UNRESOLVED_REFERENCE_WRONG_RECEIVER.createOn(source, this.candidateSymbols)
     is ConeNoCompanionObject -> FirErrors.NO_COMPANION_OBJECT.createOn(source, this.candidateSymbol as FirClassLikeSymbol<*>)
@@ -175,7 +176,7 @@ private val KtFakeSourceElementKind.canBeIgnored: Boolean
     get() = this == KtFakeSourceElementKind.DelegatingConstructorCall
             || this == KtFakeSourceElementKind.ErrorTypeRef
 
-fun FirBasedSymbol<*>.toInvisibleReferenceDiagnostic(source: KtSourceElement?): KtDiagnostic? = when (val symbol = this) {
+fun FirBasedSymbol<*>.toInvisibleReferenceDiagnostic(source: KtSourceElement?): KtDiagnostic = when (val symbol = this) {
     is FirCallableSymbol<*> -> FirErrors.INVISIBLE_REFERENCE.createOn(source, symbol, symbol.visibility, symbol.callableId.classId)
     is FirClassLikeSymbol<*> -> FirErrors.INVISIBLE_REFERENCE.createOn(source, symbol, symbol.visibility, symbol.classId.outerClassId)
     else -> shouldNotBeCalled("Unexpected receiver $javaClass")

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt

@@ -20,8 +20,10 @@ import org.jetbrains.kotlin.fir.recordTypeLookup
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.FirTypeResolutionResult
 import org.jetbrains.kotlin.fir.resolve.SupertypeSupplier
+import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeTypeVisibilityError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedTypeQualifierError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnsupportedDefaultValueInFunctionType
+import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeVisibilityError
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
 import org.jetbrains.kotlin.fir.resolve.typeResolver
@@ -148,16 +150,10 @@ class FirSpecificTypeResolverTransformer(
     ): FirResolvedTypeRef {
         return when {
             resolvedType is ConeErrorType -> {
-                buildErrorType(typeRef, resolvedType, scopeClassDeclaration)
+                buildErrorType(typeRef, resolvedType, resolvedType.diagnostic, scopeClassDeclaration)
             }
             diagnostic != null -> {
-                buildErrorTypeRef {
+                buildErrorType(typeRef, resolvedType, diagnostic, scopeClassDeclaration)
-                    source = typeRef.source
-                    this.diagnostic = diagnostic
-                    type = resolvedType
-                    delegatedTypeRef = typeRef
-                    partiallyResolvedTypeRef = tryCalculatingPartiallyResolvedTypeRef(typeRef, scopeClassDeclaration)
-                }
             }
             else -> {
                 buildResolvedTypeRef {
@@ -172,11 +168,11 @@ class FirSpecificTypeResolverTransformer(
 
     private fun buildErrorType(
         typeRef: FirTypeRef,
-        resolvedType: ConeErrorType,
+        resolvedType: ConeKotlinType,
+        diagnostic: ConeDiagnostic,
         scopeClassDeclaration: ScopeClassDeclaration,
     ): FirErrorTypeRef {
         return buildErrorTypeRef {
-            var diagnostic = resolvedType.diagnostic
             val typeRefSourceKind = typeRef.source?.kind
             val diagnosticSource = (diagnostic as? ConeUnexpectedTypeArgumentsError)?.source
 
@@ -192,22 +188,45 @@ class FirSpecificTypeResolverTransformer(
 
             delegatedTypeRef = typeRef
             type = resolvedType
+
             val partiallyResolvedTypeRef = tryCalculatingPartiallyResolvedTypeRef(typeRef, scopeClassDeclaration)
             this.partiallyResolvedTypeRef = partiallyResolvedTypeRef
 
-            if (diagnostic is ConeUnresolvedTypeQualifierError) {
+            this.diagnostic = when {
-                val totalQualifierCount = diagnostic.qualifiers.size
+                diagnostic is ConeUnresolvedTypeQualifierError -> {
-                val resolvedQualifierCount = (partiallyResolvedTypeRef?.delegatedTypeRef as? FirUserTypeRef)?.qualifier?.size
+                    ConeUnresolvedTypeQualifierError(smallestUnresolvablePrefix(diagnostic.qualifiers, partiallyResolvedTypeRef), diagnostic.isNullable)
-                    ?: calculatePartiallyResolvablePackageSegments(diagnostic.qualifiers)
-
-                val unresolvedQualifierCount = totalQualifierCount - resolvedQualifierCount
-
-                if (unresolvedQualifierCount > 1) {
-                    diagnostic = ConeUnresolvedTypeQualifierError(diagnostic.qualifiers.dropLast(unresolvedQualifierCount - 1), false)
                 }
+                diagnostic is ConeVisibilityError && typeRef is FirUserTypeRef -> {
+                    ConeTypeVisibilityError(diagnostic.symbol, smallestUnresolvablePrefix(typeRef.qualifier, partiallyResolvedTypeRef))
+                }
+                else -> diagnostic
             }
+        }
+    }
 
-            this.diagnostic = diagnostic
+    /**
+     * Returns the smallest non-resolvable prefix of the given [qualifiers].
+     *
+     * Examples:
+     *
+     * - Given `A.B.C` and `A.B` can be resolved, then `A.B.C` will be returned
+     * - Given `A.B.C` and `A` cannot be resolved, then `A` will be returned
+     * - Given `a.b.C` and package `a` exists but package `a.b` doesn't exist, `a.b.` will be returned.
+     */
+    private fun smallestUnresolvablePrefix(
+        qualifiers: List<FirQualifierPart>,
+        partiallyResolvedTypeRef: FirResolvedTypeRef?,
+    ): List<FirQualifierPart> {
+        val totalQualifierCount = qualifiers.size
+        val resolvedQualifierCount = (partiallyResolvedTypeRef?.delegatedTypeRef as? FirUserTypeRef)?.qualifier?.size
+            ?: calculatePartiallyResolvablePackageSegments(qualifiers)
+
+        val unresolvedQualifierCount = totalQualifierCount - resolvedQualifierCount
+
+        return if (unresolvedQualifierCount > 1) {
+            qualifiers.dropLast(unresolvedQualifierCount - 1)
+        } else {
+            qualifiers
         }
     }
 

compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/diagnostics/ConeDiagnostics.kt

@@ -104,12 +104,17 @@ class ConeHiddenCandidateError(
     override val reason: String get() = "HIDDEN: ${describeSymbol(candidateSymbol)} is deprecated with DeprecationLevel.HIDDEN"
 }
 
-class ConeVisibilityError(
+open class ConeVisibilityError(
     override val symbol: FirBasedSymbol<*>
 ) : ConeDiagnosticWithSymbol<FirBasedSymbol<*>> {
     override val reason: String get() = "HIDDEN: ${describeSymbol(symbol)} is invisible"
 }
 
+class ConeTypeVisibilityError(
+    symbol: FirBasedSymbol<*>,
+    val smallestUnresolvablePrefix: List<FirQualifierPart>,
+) : ConeVisibilityError(symbol)
+
 class ConeInapplicableWrongReceiver(override val candidates: Collection<AbstractCandidate>) : ConeDiagnosticWithCandidates {
     override val reason: String
         get() = "None of the following candidates is applicable because of receiver type mismatch: ${

compiler/testData/diagnostics/tests/imports/ImportProtectedClass.fir.kt

@@ -1,14 +0,0 @@
-package p
-
-import p.Foo.Nested
-
-open class Foo {
-    protected class Nested
-}
-
-class Bar: Foo() {
-    protected fun foo(): Nested? = null
-}
-
-private fun foo(): <!INVISIBLE_REFERENCE!>Nested<!>? = null
-private fun bar(): <!INVISIBLE_REFERENCE!>p.Foo.Nested<!>? = null

compiler/testData/diagnostics/tests/imports/ImportProtectedClass.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package p
 
 import p.Foo.Nested

compiler/testData/diagnostics/tests/inference/upperBounds/typeParameterAsUpperBound.fir.kt

@@ -1,7 +1,7 @@
 // !CHECK_TYPE
 
 
-@<!INVISIBLE_REFERENCE!>kotlin.internal.<!INVISIBLE_REFERENCE!>InlineOnly<!><!>
+@kotlin.internal.<!INVISIBLE_REFERENCE, INVISIBLE_REFERENCE!>InlineOnly<!>
 public inline fun <C, R> C.ifEmpty(f: () -> R): R where C : Collection<*>, C : R = if (isEmpty()) f() else this
 
 public fun <T> listOf(t: T): List<T> = TODO()

compiler/testData/diagnostics/tests/j+k/innerNestedClassFromJava.fir.kt

@@ -1,32 +0,0 @@
-// FILE: a/M.java
-package a;
-
-public class M {
-    public class Inner {
-
-    }
-
-    public static class Nested {
-
-    }
-
-    private class PrInner {
-
-    }
-
-    private static class PrNested {
-
-    }
-}
-
-// FILE: b.kt
-package b
-
-fun f() {
-  val c1: a.M.Inner
-  val c2: a.M.Nested
-  val c3: <!INVISIBLE_REFERENCE!>a.M.PrInner<!>
-  val c4: <!INVISIBLE_REFERENCE!>a.M.PrNested<!>
-
-}
-

compiler/testData/diagnostics/tests/j+k/innerNestedClassFromJava.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: a/M.java
 package a;
 

compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.fir.kt

@@ -1,19 +0,0 @@
-// FILE: p/Foo.java
-package p;
-
-public class Foo {
-   protected static class Nested {} 
-}
-
-// FILE: foo.kt
-package a
-
-import p.Foo
-import p.Foo.Nested
-
-class Bar : Foo() {
-    protected fun foo(): Nested? = null
-}
-
-private fun foo(): <!INVISIBLE_REFERENCE!>Nested<!>? = null
-private fun bar(): <!INVISIBLE_REFERENCE!>p.Foo.Nested<!>? = null

compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: p/Foo.java
 package p;
 

compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.fir.kt

@@ -16,4 +16,4 @@ class Bar : <!EXPOSED_SUPER_CLASS, INVISIBLE_REFERENCE, INVISIBLE_REFERENCE!>Foo
 }
 
 private fun foo(): <!INVISIBLE_REFERENCE!>Nested<!>? = null
-private fun bar(): <!INVISIBLE_REFERENCE!>p.Foo.Nested<!>? = null
+private fun bar(): p.<!INVISIBLE_REFERENCE!>Foo<!>.Nested? = null

compiler/testData/diagnostics/tests/scopes/visibility2.fir.kt

@@ -30,7 +30,7 @@ fun test() {
     <!INVISIBLE_REFERENCE!>foo<!>()
 
     val u : <!INVISIBLE_REFERENCE!>A<!> = <!INVISIBLE_REFERENCE!>A<!>()
-    val a : <!INVISIBLE_REFERENCE!>java.util.Arrays.ArrayList<Int><!>;
+    val a : java.util.Arrays.<!INVISIBLE_REFERENCE!>ArrayList<!><Int>;
 
     val po = <!INVISIBLE_REFERENCE!>PO<!>
 }

compiler/testData/diagnostics/tests/typealias/constructorCallThroughPrivateAlias.fir.kt

@@ -30,5 +30,5 @@ fun baz() {
 
     a.A3("") checkType { _<String>() }
 
-    val x: <!INVISIBLE_REFERENCE!>a.A2<!> = B("") // A2 is unresolved because it's private in file, OK
+    val x: a.<!INVISIBLE_REFERENCE!>A2<!> = B("") // A2 is unresolved because it's private in file, OK
 }

compiler/testData/diagnostics/tests/typealias/privateInFile.fir.kt

@@ -6,7 +6,7 @@ private class C {
 private typealias TA = C
 
 private val test1: <!INVISIBLE_REFERENCE!>C<!> = <!INVISIBLE_REFERENCE!>C<!>()
-private val test1co: <!INVISIBLE_REFERENCE!>C.Companion<!> = <!INITIALIZER_TYPE_MISMATCH, INVISIBLE_REFERENCE, NO_COMPANION_OBJECT!>C<!>
+private val test1co: <!INVISIBLE_REFERENCE!>C<!>.Companion = <!INITIALIZER_TYPE_MISMATCH, INVISIBLE_REFERENCE, NO_COMPANION_OBJECT!>C<!>
 
 private val test2: <!INVISIBLE_REFERENCE!>TA<!> = <!INVISIBLE_REFERENCE!>TA<!>()
 private val test2co = <!INVISIBLE_REFERENCE!>TA<!>

compiler/testData/diagnostics/tests/typealias/privateInFile.ll.kt

@@ -18,7 +18,7 @@ private val test2co = TA
 
 // FILE: file2.kt
 private val test1: <!INVISIBLE_REFERENCE!>C<!> = <!INVISIBLE_REFERENCE!>C<!>()
-private val test1co: <!INVISIBLE_REFERENCE!>C.Companion<!> = <!INVISIBLE_REFERENCE!>C<!>
+private val test1co: <!INVISIBLE_REFERENCE!>C<!>.Companion = <!INVISIBLE_REFERENCE!>C<!>
 
 private val test2: <!INVISIBLE_REFERENCE!>TA<!> = <!INVISIBLE_REFERENCE!>TA<!>()
 private val test2co = <!INVISIBLE_REFERENCE!>TA<!>

compiler/testData/diagnostics/tests/visibility/privateDeclarationInAnotherFile.fir.kt

@@ -8,6 +8,6 @@ private class Private {
 
 import <!INVISIBLE_REFERENCE!>Private<!>.Public
 
-private fun test_1(x: <!INVISIBLE_REFERENCE!>Private.Public<!>, y: <!INVISIBLE_REFERENCE!>Public<!>) {
+private fun test_1(x: <!INVISIBLE_REFERENCE!>Private<!>.Public, y: <!INVISIBLE_REFERENCE!>Public<!>) {
 
 }

compiler/testData/diagnostics/testsWithStdLib/InaccessibleInternalClass.fir.kt

@@ -1,15 +0,0 @@
-// SKIP_TXT
-// FILE: a.kt
-package p
-
-class FilteringSequence
-
-// FILE: b.kt
-package kotlin.sequences
-
-import p.*
-
-interface I {
-    val v1: FilteringSequence
-    val <!EXPOSED_PROPERTY_TYPE!>v2<!>: <!INVISIBLE_REFERENCE!>IndexingSequence<String><!>
-}

compiler/testData/diagnostics/testsWithStdLib/InaccessibleInternalClass.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // SKIP_TXT
 // FILE: a.kt
 package p