[FIR] Additional errors to distinguish resolution to classifier cases

When a call is resolved to a classifier, only a single error message was
being used for multiple cases. This lead to confusion as the default
message may not be applicable to a given error case. Added additional
errors and messages to distinguish between these error cases.

#KT-57251 Fixed

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt

@@ -389,6 +389,27 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
+    add(FirErrors.INTERFACE_AS_FUNCTION) { firDiagnostic ->
+        InterfaceAsFunctionImpl(
+            firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a),
+            firDiagnostic as KtPsiDiagnostic,
+            token,
+        )
+    }
+    add(FirErrors.EXPECT_CLASS_AS_FUNCTION) { firDiagnostic ->
+        ExpectClassAsFunctionImpl(
+            firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a),
+            firDiagnostic as KtPsiDiagnostic,
+            token,
+        )
+    }
+    add(FirErrors.INNER_CLASS_CONSTRUCTOR_NO_RECEIVER) { firDiagnostic ->
+        InnerClassConstructorNoReceiverImpl(
+            firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a),
+            firDiagnostic as KtPsiDiagnostic,
+            token,
+        )
+    }
     add(FirErrors.RESOLUTION_TO_CLASSIFIER) { firDiagnostic ->
         ResolutionToClassifierImpl(
             firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a),

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt

@@ -313,6 +313,21 @@ sealed interface KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI> {
         val type: KtType
     }
 
+    interface InterfaceAsFunction : KtFirDiagnostic<PsiElement> {
+        override val diagnosticClass get() = InterfaceAsFunction::class
+        val classSymbol: KtClassLikeSymbol
+    }
+
+    interface ExpectClassAsFunction : KtFirDiagnostic<PsiElement> {
+        override val diagnosticClass get() = ExpectClassAsFunction::class
+        val classSymbol: KtClassLikeSymbol
+    }
+
+    interface InnerClassConstructorNoReceiver : KtFirDiagnostic<PsiElement> {
+        override val diagnosticClass get() = InnerClassConstructorNoReceiver::class
+        val classSymbol: KtClassLikeSymbol
+    }
+
     interface ResolutionToClassifier : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ResolutionToClassifier::class
         val classSymbol: KtClassLikeSymbol

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt

@@ -361,6 +361,24 @@ internal class FunctionExpectedImpl(
     token: KtLifetimeToken,
 ) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.FunctionExpected
 
+internal class InterfaceAsFunctionImpl(
+    override val classSymbol: KtClassLikeSymbol,
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InterfaceAsFunction
+
+internal class ExpectClassAsFunctionImpl(
+    override val classSymbol: KtClassLikeSymbol,
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ExpectClassAsFunction
+
+internal class InnerClassConstructorNoReceiverImpl(
+    override val classSymbol: KtClassLikeSymbol,
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InnerClassConstructorNoReceiver
+
 internal class ResolutionToClassifierImpl(
     override val classSymbol: KtClassLikeSymbol,
     firDiagnostic: KtPsiDiagnostic,

compiler/fir/analysis-tests/testData/resolve/innerClasses/inner.kt

@@ -31,7 +31,7 @@ class Owner {
 fun test() {
     val o = Owner()
     o.foo()
-    val err = Owner.<!RESOLUTION_TO_CLASSIFIER!>Inner<!>()
+    val err = Owner.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>()
     err.<!UNRESOLVED_REFERENCE!>baz<!>()
     val i = o.Inner()
     i.gau()

compiler/fir/analysis-tests/testData/resolve/references/incorrectReferenceOnInnerClassMember.kt

@@ -9,6 +9,6 @@ class Outer<T> {
 }
 
 fun test() {
-    foo.Outer<Int>.<!RESOLUTION_TO_CLASSIFIER!>Inner<!>(42)
-    foo.Outer<Int>.<!RESOLUTION_TO_CLASSIFIER!>Inner<!>(42)::<!UNRESOLVED_REFERENCE!>method<!>
+    foo.Outer<Int>.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>(42)
+    foo.Outer<Int>.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>(42)::<!UNRESOLVED_REFERENCE!>method<!>
 }

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

@@ -159,6 +159,15 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
             parameter<String>("expression")
             parameter<ConeKotlinType>("type")
         }
+        val INTERFACE_AS_FUNCTION by error<PsiElement> {
+            parameter<FirRegularClassSymbol>("classSymbol")
+        }
+        val EXPECT_CLASS_AS_FUNCTION by error<PsiElement> {
+            parameter<FirRegularClassSymbol>("classSymbol")
+        }
+        val INNER_CLASS_CONSTRUCTOR_NO_RECEIVER by error<PsiElement> {
+            parameter<FirRegularClassSymbol>("classSymbol")
+        }
         val RESOLUTION_TO_CLASSIFIER by error<PsiElement> {
             parameter<FirRegularClassSymbol>("classSymbol")
         }

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

@@ -168,6 +168,9 @@ object FirErrors {
     val ILLEGAL_SELECTOR by error0<PsiElement>()
     val NO_RECEIVER_ALLOWED by error0<PsiElement>()
     val FUNCTION_EXPECTED by error2<PsiElement, String, ConeKotlinType>(SourceElementPositioningStrategies.REFERENCED_NAME_BY_QUALIFIED)
+    val INTERFACE_AS_FUNCTION by error1<PsiElement, FirRegularClassSymbol>()
+    val EXPECT_CLASS_AS_FUNCTION by error1<PsiElement, FirRegularClassSymbol>()
+    val INNER_CLASS_CONSTRUCTOR_NO_RECEIVER by error1<PsiElement, FirRegularClassSymbol>()
     val RESOLUTION_TO_CLASSIFIER by error1<PsiElement, FirRegularClassSymbol>()
     val AMBIGUOUS_ALTERED_ASSIGN by error1<PsiElement, List<String?>>()
     val FORBIDDEN_BINARY_MOD by error2<PsiElement, FirBasedSymbol<*>, String>(SourceElementPositioningStrategies.OPERATOR_MODIFIER)

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

@@ -228,6 +228,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_PROPERTY_
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATED_IDENTITY_EQUALS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPECTED_EXTERNAL_DECLARATION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPECTED_TAILREC_FUNCTION
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPECT_CLASS_AS_FUNCTION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.FORBIDDEN_BINARY_MOD
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.FORBIDDEN_IDENTITY_EQUALS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.FORBIDDEN_IDENTITY_EQUALS_WARNING
@@ -295,9 +296,11 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INITIALIZER_TYPE_
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INLINE_CLASS_CONSTRUCTOR_WRONG_PARAMETERS_SIZE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INLINE_PROPERTY_WITH_BACKING_FIELD
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INLINE_SUSPEND_FUNCTION_TYPE_UNSUPPORTED
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INNER_CLASS_CONSTRUCTOR_NO_RECEIVER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INNER_CLASS_INSIDE_VALUE_CLASS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INNER_CLASS_OF_GENERIC_THROWABLE_SUBCLASS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INSTANCE_ACCESS_BEFORE_SUPER_CALL
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INTERFACE_AS_FUNCTION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INTERFACE_WITH_SUPERCLASS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INT_LITERAL_OUT_OF_RANGE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INVALID_CHARACTERS
@@ -737,11 +740,14 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() {
             FUNCTION_EXPECTED,
             "Expression ''{0}'' of type {1} cannot be invoked as a function. The function ''invoke()'' is not found", TO_STRING, RENDER_TYPE
         )
+        map.put(INTERFACE_AS_FUNCTION, "Interface ''{0}'' does not have constructors.", SYMBOL)
+        map.put(EXPECT_CLASS_AS_FUNCTION, "Expected class ''{0}'' does not have default constructor.", SYMBOL)
         map.put(
-            RESOLUTION_TO_CLASSIFIER,
-            "Constructor of the inner class {0} can only be called with a receiver of the containing class",
+            INNER_CLASS_CONSTRUCTOR_NO_RECEIVER,
+            "Constructor of the inner class ''{0}'' can only be called with a receiver of the containing class",
             SYMBOL
         )
+        map.put(RESOLUTION_TO_CLASSIFIER, "Resolution to the classifier ''{0}'' is not appropriate here.", SYMBOL)
         map.put(
             AMBIGUOUS_ALTERED_ASSIGN,
             "Multiple extensions tried to alter this assignment at the same time. Extensions: {0}",

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

@@ -8,12 +8,15 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics
 import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.KtSourceElement
+import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.isLocalMember
 import org.jetbrains.kotlin.fir.analysis.getChild
 import org.jetbrains.kotlin.fir.builder.FirSyntaxErrors
+import org.jetbrains.kotlin.fir.declarations.utils.isExpect
 import org.jetbrains.kotlin.fir.declarations.utils.isInfix
+import org.jetbrains.kotlin.fir.declarations.utils.isInner
 import org.jetbrains.kotlin.fir.declarations.utils.isOperator
 import org.jetbrains.kotlin.fir.diagnostics.*
 import org.jetbrains.kotlin.fir.resolve.calls.*
@@ -52,7 +55,15 @@ private fun ConeDiagnostic.toKtDiagnostic(
     is ConeUnresolvedTypeQualifierError -> FirErrors.UNRESOLVED_REFERENCE.createOn(source, this.qualifier)
     is ConeFunctionCallExpectedError -> FirErrors.FUNCTION_CALL_EXPECTED.createOn(source, this.name.asString(), this.hasValueParameters)
     is ConeFunctionExpectedError -> FirErrors.FUNCTION_EXPECTED.createOn(source, this.expression, this.type)
-    is ConeResolutionToClassifierError -> FirErrors.RESOLUTION_TO_CLASSIFIER.createOn(source, this.candidateSymbol)
+    is ConeResolutionToClassifierError -> when (this.candidateSymbol.classKind) {
+        ClassKind.INTERFACE -> FirErrors.INTERFACE_AS_FUNCTION.createOn(source, this.candidateSymbol)
+        ClassKind.CLASS -> when {
+            this.candidateSymbol.isInner -> FirErrors.INNER_CLASS_CONSTRUCTOR_NO_RECEIVER.createOn(source, this.candidateSymbol)
+            this.candidateSymbol.isExpect -> FirErrors.EXPECT_CLASS_AS_FUNCTION.createOn(source, this.candidateSymbol)
+            else -> FirErrors.RESOLUTION_TO_CLASSIFIER.createOn(source, this.candidateSymbol)
+        }
+        else -> FirErrors.RESOLUTION_TO_CLASSIFIER.createOn(source, this.candidateSymbol)
+    }
     is ConeHiddenCandidateError -> {
         // Usages of callables with @Deprecated(DeprecationLevel.HIDDEN) should look like unresolved references.
         // See: https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-deprecated/

compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughEnum_after.fir.kt

@@ -43,7 +43,7 @@ fun f() {
     C.O
     C.O.InO
     C.A()
-    C.<!RESOLUTION_TO_CLASSIFIER!>B<!>()
+    C.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>B<!>()
 
     C.E3.<!UNRESOLVED_REFERENCE!>O_O<!>
     C.E3.<!UNRESOLVED_REFERENCE!>G<!>()

compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughEnum_before.fir.kt

@@ -43,7 +43,7 @@ fun f() {
     C.O
     C.O.InO
     C.A()
-    C.<!RESOLUTION_TO_CLASSIFIER!>B<!>()
+    C.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>B<!>()
 
     C.E3.<!UNRESOLVED_REFERENCE!>O_O<!>
     C.E3.<!UNRESOLVED_REFERENCE!>G<!>()

compiler/testData/diagnostics/tests/funInterface/resolveFunInterfaceWithoutMainMethod.fir.kt

@@ -6,7 +6,7 @@ typealias FunAlias = IsolatedFunFace
 fun referIsolatedFunFace(iff: IsolatedFunFace) {}
 
 fun callIsolatedFunFace() {
-    referIsolatedFunFace(<!RESOLUTION_TO_CLASSIFIER!>IsolatedFunFace<!> {})
-    referIsolatedFunFace(<!RESOLUTION_TO_CLASSIFIER!>FunAlias<!> {})
+    referIsolatedFunFace(<!INTERFACE_AS_FUNCTION!>IsolatedFunFace<!> {})
+    referIsolatedFunFace(<!INTERFACE_AS_FUNCTION!>FunAlias<!> {})
     referIsolatedFunFace(<!ARGUMENT_TYPE_MISMATCH!>{}<!>)
 }

compiler/testData/diagnostics/tests/inner/constructorAccess.fir.kt

@@ -0,0 +1,32 @@
+class Outer1 {
+    class Nested
+
+    class C1 { val b = Nested() }
+    class C2(val b: Any = Nested())
+    inner class C3 { val b = Nested() }
+    inner class C4(val b: Any = Nested())
+
+    inner class Inner
+
+    class C5 { val b = <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>() }
+    class C6(val b: Any = <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>())
+    inner class C7 { val b = Inner() }
+    inner class C8(val b: Any = Inner())
+}
+
+
+class Outer2 {
+    class Nested {
+        fun foo() = Outer2()
+        fun bar() = <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>()
+    }
+    inner class Inner {
+        fun foo() = Outer2()
+        fun bar() = Nested()
+    }
+
+    fun foo() {
+        Nested()
+        Inner()
+    }
+}

compiler/testData/diagnostics/tests/inner/constructorAccess.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 class Outer1 {
     class Nested
 

compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiers.fir.kt

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+// FILE: Outer.kt
+package abc
+class Outer {
+    inner class Inner() {
+        constructor(x: Int) : this() {}
+    }
+
+    companion object {
+
+        fun baz() {
+            <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>()
+            <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>(1)
+        }
+    }
+}
+
+fun foo() {
+    Outer.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>()
+    Outer.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>(1)
+}
+
+// FILE: imported.kt
+import abc.Outer
+import abc.Outer.Inner
+
+fun bar() {
+    <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>()
+    <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>(1)
+
+    with(Outer()) {
+        Inner()
+        Inner(1)
+    }
+}

compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiers.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 // SKIP_TXT
 // FILE: Outer.kt

compiler/testData/diagnostics/tests/inner/innerErrorForClassObjects.fir.kt

@@ -10,7 +10,7 @@ class Test {
         }
 
         fun more(): InnerClass {
-            val b = <!RESOLUTION_TO_CLASSIFIER!>InnerClass<!>()
+            val b = <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>InnerClass<!>()
 
             val testVal = <!UNRESOLVED_REFERENCE!>inClass<!>
             <!UNRESOLVED_REFERENCE!>foo<!>()

compiler/testData/diagnostics/tests/inner/innerErrorForObjects.fir.kt

@@ -10,7 +10,7 @@ class Test {
         }
 
         fun more(): InnerClass {
-            val b = <!RESOLUTION_TO_CLASSIFIER!>InnerClass<!>()
+            val b = <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>InnerClass<!>()
 
             val testVal = <!UNRESOLVED_REFERENCE!>inClass<!>
             <!UNRESOLVED_REFERENCE!>foo<!>()

compiler/testData/diagnostics/tests/inner/qualifiedExpression/constructNestedClass.fir.kt

@@ -0,0 +1,17 @@
+class Outer {
+    class Nested {
+        class NestedNested
+    }
+
+    inner class Inner {
+        inner class InnerInner
+    }
+}
+
+fun f1() = Outer()
+fun f2() = Outer.Nested()
+fun f3() = Outer.Nested.NestedNested()
+fun f4() = Outer.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>()
+fun f5() = Outer.Inner.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>InnerInner<!>()
+fun f6() = Outer().Inner()
+fun f7() = Outer().Inner().InnerInner()

compiler/testData/diagnostics/tests/inner/qualifiedExpression/constructNestedClass.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 class Outer {
     class Nested {
         class NestedNested

compiler/testData/diagnostics/tests/multiplatform/headerClass/expectClassWithoutConstructor.fir.kt

@@ -0,0 +1,24 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+expect class Foo
+expect class Bar()
+expect class Baz constructor()
+expect class FooBar {
+    constructor()
+}
+
+fun test() {
+    <!EXPECT_CLASS_AS_FUNCTION!>Foo<!>()
+    Bar()
+    Baz()
+    FooBar()
+}
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+
+actual class Foo
+actual class Bar
+actual class Baz
+actual class FooBar

compiler/testData/diagnostics/tests/multiplatform/headerClass/expectClassWithoutConstructor.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // MODULE: m1-common
 // FILE: common.kt
 

compiler/testData/diagnostics/tests/multiplatform/hmpp/kt57320.fir.kt

@@ -34,7 +34,7 @@ interface KotlinXStringDemoInterface {
 // FILE: StringDemoInterface.kt
 actual typealias StringDemoInterface = KotlinXStringDemoInterface
 
-<!ACTUAL_WITHOUT_EXPECT("actual  fun StringDemoInterface.plusK(): <ERROR TYPE REF: Unresolved name: value>; The following declaration is incompatible:    expect fun StringDemoInterface.plusK(): String")!>actual fun StringDemoIn<!INCOMPATIBLE_MATCHING!>terface.plusK() = <!RESOLUTION_TO_CLASSIFIER!>StringValue<!>(value).plus("K")<!>.<!UNRESOLVED_REFERENCE!>value<!><!>
+<!ACTUAL_WITHOUT_EXPECT("actual  fun StringDemoInterface.plusK(): <ERROR TYPE REF: Unresolved name: value>; The following declaration is incompatible:    expect fun StringDemoInterface.plusK(): String")!>actual fun StringDemoIn<!INCOMPATIBLE_MATCHING!>terface.plusK() = <!EXPECT_CLASS_AS_FUNCTION!>StringValue<!>(value).plus("K")<!>.<!UNRESOLVED_REFERENCE!>value<!><!>
 
 // FILE: main.kt
 class StringDemo(override val value: String) : StringDemoInterface

compiler/testData/diagnostics/tests/regressions/kt4827.fir.kt

@@ -0,0 +1,16 @@
+// KT-4827 UOE at PackageType.throwException()
+// EA-53605
+
+public interface TestInterface {
+}
+
+class C {
+    inner class I {
+
+    }
+}
+
+fun f() {
+    <!INTERFACE_AS_FUNCTION!>TestInterface<!>()
+    C.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>I<!>()
+}

compiler/testData/diagnostics/tests/regressions/kt4827.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // KT-4827 UOE at PackageType.throwException()
 // EA-53605
 

compiler/testData/diagnostics/tests/resolve/noCandidates/kt2787.fir.kt

@@ -0,0 +1,6 @@
+interface MutableMatrix<T> {
+}
+
+fun <T> toMutableMatrix(): MutableMatrix<T> {
+    return <!INTERFACE_AS_FUNCTION!>MutableMatrix<!><T>()
+}

compiler/testData/diagnostics/tests/resolve/noCandidates/kt2787.kt

@@ -1,7 +1,6 @@
-// FIR_IDENTICAL
 interface MutableMatrix<T> {
 }
 
 fun <T> toMutableMatrix(): MutableMatrix<T> {
     return <!RESOLUTION_TO_CLASSIFIER!>MutableMatrix<!><T>()
-}
+}

compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifier.fir.kt

@@ -6,7 +6,7 @@ object B
 class C
 
 fun test() {
-    val interface_as_fun = <!RESOLUTION_TO_CLASSIFIER!>A<!>()
+    val interface_as_fun = <!INTERFACE_AS_FUNCTION!>A<!>()
     val interface_as_val = <!NO_COMPANION_OBJECT!>A<!>
 
     val object_as_fun = <!UNRESOLVED_REFERENCE!>B<!>()

compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifierWithReceiver.fir.kt

@@ -8,7 +8,7 @@ object X {
 }
 
 fun testX() {
-    val interface_as_fun = X.<!RESOLUTION_TO_CLASSIFIER!>A<!>()
+    val interface_as_fun = X.<!INTERFACE_AS_FUNCTION!>A<!>()
     val interface_as_val = X.<!NO_COMPANION_OBJECT!>A<!>
 
     val object_as_fun = X.<!UNRESOLVED_REFERENCE!>B<!>()
@@ -23,7 +23,7 @@ class Y {
 }
 
 fun testY() {
-    val interface_as_fun = Y.<!RESOLUTION_TO_CLASSIFIER!>A<!>()
+    val interface_as_fun = Y.<!INTERFACE_AS_FUNCTION!>A<!>()
     val interface_as_val = Y.<!NO_COMPANION_OBJECT!>A<!>
 
     val object_as_fun = Y.<!UNRESOLVED_REFERENCE!>B<!>()

compiler/testData/diagnostics/tests/scopes/classHeader/constructors.fir.kt

@@ -0,0 +1,65 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class A(
+        n: Nested = foo(),
+        n2: Nested = Nested(),
+        inn: Inner = null!!,
+        inn2: Inner = <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>(),
+        i: Interface = null!!,
+        c: Int = CONST,
+        cc: Int = Companion.CONST,
+        cn: Int = Nested.CONST,
+        ci: Int = Interface.CONST,
+        t1: Int = <!UNRESOLVED_REFERENCE!>a<!>,
+        t2: Int = <!UNRESOLVED_REFERENCE!>b<!>()
+) {
+
+    constructor(
+            dummy: Int,
+            n: Nested = foo(),
+            n2: Nested = Nested(),
+            inn: Inner = null!!,
+            inn2: Inner = <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>Inner<!>(),
+            i: Interface = null!!,
+            c: Int = CONST,
+            cc: Int = Companion.CONST,
+            cn: Int = Nested.CONST,
+            ci: Int = Interface.CONST,
+            t1: Int = <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>a<!>,
+            t2: Int = <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>b<!>()
+    ) : this(
+        foo(),
+        Nested(),
+        inn,
+        <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>Inner<!>(),
+        i,
+        CONST,
+        Companion.CONST,
+        Nested.CONST,
+        Interface.CONST,
+        <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>a<!>,
+        <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>b<!>()
+    )
+
+    class Nested {
+        companion object {
+            const val CONST = 2
+        }
+    }
+
+    inner class Inner
+
+    interface Interface {
+        companion object {
+            const val CONST = 3
+        }
+    }
+
+    val a = 1
+    fun b() = 2
+
+    companion object {
+        const val CONST = 1
+        fun foo(): Nested = null!!
+    }
+}

compiler/testData/diagnostics/tests/scopes/classHeader/constructors.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 class A(

compiler/testData/diagnostics/tests/scopes/classHeader/delegation.fir.kt

@@ -0,0 +1,50 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+interface I
+
+open class S(
+        n: A.Nested,
+        n2: A.Nested,
+        inn: A.Inner,
+        c: Int,
+        cc: Int,
+        cn: Int,
+        ci: Int,
+        t1: Int,
+        t2: Int
+) : I
+
+class A : I by S(
+        foo(),
+        Nested(),
+        <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>(),
+        CONST,
+        Companion.CONST,
+        Nested.CONST,
+        Interface.CONST,
+        <!UNRESOLVED_REFERENCE!>a<!>,
+        <!UNRESOLVED_REFERENCE!>b<!>()
+) {
+
+    class Nested {
+        companion object {
+            const val CONST = 2
+        }
+    }
+
+    inner class Inner
+
+    interface Interface {
+        companion object {
+            const val CONST = 3
+        }
+    }
+
+    val a = 1
+    fun b() = 2
+
+    companion object {
+        const val CONST = 1
+        fun foo(): Nested = null!!
+    }
+}

compiler/testData/diagnostics/tests/scopes/classHeader/delegation.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 interface I

compiler/testData/diagnostics/tests/scopes/classHeader/superConstructorArguments.fir.kt

@@ -0,0 +1,48 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+open class S(
+        n: A.Nested,
+        n2: A.Nested,
+        inn: A.Inner,
+        c: Int,
+        cc: Int,
+        cn: Int,
+        ci: Int,
+        t1: Int,
+        t2: Int
+)
+
+class A : S (
+    foo(),
+    Nested(),
+    <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>(),
+    CONST,
+    Companion.CONST,
+    Nested.CONST,
+    Interface.CONST,
+    <!UNRESOLVED_REFERENCE!>a<!>,
+    <!UNRESOLVED_REFERENCE!>b<!>()
+) {
+
+    class Nested {
+        companion object {
+            const val CONST = 2
+        }
+    }
+
+    inner class Inner
+
+    interface Interface {
+        companion object {
+            const val CONST = 3
+        }
+    }
+
+    val a = 1
+    fun b() = 2
+
+    companion object {
+        const val CONST = 1
+        fun foo(): Nested = null!!
+    }
+}

compiler/testData/diagnostics/tests/scopes/classHeader/superConstructorArguments.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 open class S(

compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.fir.kt

@@ -35,10 +35,10 @@ class E: A() {
 
     object Z {
         init {
-            <!RESOLUTION_TO_CLASSIFIER!>B<!>().<!UNRESOLVED_REFERENCE!>foo<!>()
-            <!RESOLUTION_TO_CLASSIFIER!>B<!>().<!UNRESOLVED_REFERENCE!>bar<!>()
+            <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>B<!>().<!UNRESOLVED_REFERENCE!>foo<!>()
+            <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>B<!>().<!UNRESOLVED_REFERENCE!>bar<!>()
 
-            <!RESOLUTION_TO_CLASSIFIER!>D<!>()
+            <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>D<!>()
             <!UNRESOLVED_REFERENCE!>C<!>()
         }
     }
@@ -60,7 +60,7 @@ class F: A() {
     companion object {
         init {
             B().fas()
-            <!RESOLUTION_TO_CLASSIFIER!>D<!>().<!UNRESOLVED_REFERENCE!>f<!>()
+            <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>D<!>().<!UNRESOLVED_REFERENCE!>f<!>()
         }
     }
 }

compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJava.fir.kt

@@ -0,0 +1,90 @@
+// FILE: A.java
+public interface A {
+    public class A_S { // static
+
+    }
+}
+
+// FILE: B.java
+public class B {
+    public static class B_S {
+
+    }
+    public class B_ {
+
+    }
+}
+
+// FILE: C.java
+public class C extends B implements A {
+
+}
+
+// FILE: 1.kt
+
+class X: A {
+    val a_s: <!UNRESOLVED_REFERENCE!>A_S<!> = null!!
+
+    init {
+        <!UNRESOLVED_REFERENCE!>A_S<!>()
+        A.A_S()
+        X.<!UNRESOLVED_REFERENCE!>A_S<!>()
+    }
+
+    object xD {
+        val a_: <!UNRESOLVED_REFERENCE!>A_S<!> = null!!
+
+        init {
+            <!UNRESOLVED_REFERENCE!>A_S<!>()
+        }
+    }
+}
+
+class Y: B() {
+    val b_: B_ = null!!
+    val b_s: B_S = null!!
+
+    init {
+        B_()
+        B.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>B_<!>()
+        Y.<!UNRESOLVED_REFERENCE!>B_<!>()
+
+        B_S()
+        B.B_S()
+        Y.<!UNRESOLVED_REFERENCE!>B_S<!>()
+    }
+
+    object X {
+        val b_: B_ = null!!
+        val b_s: B_S = null!!
+
+        init {
+            <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>B_<!>()
+            B_S()
+        }
+    }
+}
+
+class Z: C() {
+    val a_s: <!UNRESOLVED_REFERENCE!>A_S<!> = null!!
+    val b_: B_ = null!!
+    val b_s: B_S = null!!
+
+    init {
+        <!UNRESOLVED_REFERENCE!>A_S<!>()
+        B_()
+        B_S()
+    }
+
+    object X {
+        val a_s: <!UNRESOLVED_REFERENCE!>A_S<!> = null!!
+        val b_: B_ = null!!
+        val b_s: B_S = null!!
+
+        init {
+            <!UNRESOLVED_REFERENCE!>A_S<!>()
+            <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>B_<!>()
+            B_S()
+        }
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJava.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // FILE: A.java
 public interface A {
     public class A_S { // static

compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJavaAfterKotlin.fir.kt

@@ -0,0 +1,82 @@
+// FILE: A.java
+public interface A {
+    class A_S {
+
+    }
+}
+
+// FILE: B.java
+public class B {
+    static class B_S {
+
+    }
+    class B_ {
+
+    }
+}
+
+// FILE: C.java
+public class C extends B implements A {
+
+}
+
+// FILE: 1.kt
+interface E {
+    class E_S
+}
+
+open class D: C(), E
+
+// FILE: F.java
+public class F extends D {
+
+}
+
+// FILE: 2.kt
+class X: D() {
+    init {
+        B_()
+        B.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>B_<!>()
+        C.<!UNRESOLVED_REFERENCE!>B_<!>()
+        D.<!UNRESOLVED_REFERENCE!>B_<!>()
+        X.<!UNRESOLVED_REFERENCE!>B_<!>()
+
+        <!UNRESOLVED_REFERENCE!>A_S<!>()
+        A.A_S()
+        C.<!UNRESOLVED_REFERENCE!>A_S<!>()
+        D.<!UNRESOLVED_REFERENCE!>A_S<!>()
+        X.<!UNRESOLVED_REFERENCE!>A_S<!>()
+
+        B_S()
+        B.B_S()
+        C.<!UNRESOLVED_REFERENCE!>B_S<!>()
+        D.<!UNRESOLVED_REFERENCE!>B_S<!>()
+        X.<!UNRESOLVED_REFERENCE!>B_S<!>()
+
+        <!UNRESOLVED_REFERENCE!>E_S<!>()
+        E.E_S()
+        D.<!UNRESOLVED_REFERENCE!>E_S<!>()
+        X.<!UNRESOLVED_REFERENCE!>E_S<!>()
+    }
+}
+
+class Y: F() {
+    init {
+
+        B_()
+        F.<!UNRESOLVED_REFERENCE!>B_<!>()
+        Y.<!UNRESOLVED_REFERENCE!>B_<!>()
+
+        <!UNRESOLVED_REFERENCE!>A_S<!>()
+        F.<!UNRESOLVED_REFERENCE!>A_S<!>()
+        Y.<!UNRESOLVED_REFERENCE!>A_S<!>()
+
+        B_S()
+        F.<!UNRESOLVED_REFERENCE!>B_S<!>()
+        Y.<!UNRESOLVED_REFERENCE!>B_S<!>()
+
+        <!UNRESOLVED_REFERENCE!>E_S<!>()
+        F.<!UNRESOLVED_REFERENCE!>E_S<!>()
+        Y.<!UNRESOLVED_REFERENCE!>E_S<!>()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJavaAfterKotlin.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // FILE: A.java
 public interface A {
     class A_S {

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

@@ -17,8 +17,8 @@ typealias TI = Interface
 object AnObject
 typealias TO = AnObject
 
-val test6 = <!RESOLUTION_TO_CLASSIFIER!>TI<!>()
-val test6a = <!RESOLUTION_TO_CLASSIFIER!>Interface<!>()
+val test6 = <!INTERFACE_AS_FUNCTION!>TI<!>()
+val test6a = <!INTERFACE_AS_FUNCTION!>Interface<!>()
 
 val test7 = <!UNRESOLVED_REFERENCE!>TO<!>()
 val test7a = <!UNRESOLVED_REFERENCE!>AnObject<!>()

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

@@ -0,0 +1,6 @@
+interface IFoo
+
+typealias Test = IFoo
+
+val testAsFunction = <!INTERFACE_AS_FUNCTION!>Test<!>()
+val testAsValue = <!NO_COMPANION_OBJECT!>Test<!>

compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForInterface.kt

@@ -1,7 +1,6 @@
-// FIR_IDENTICAL
 interface IFoo
 
 typealias Test = IFoo
 
 val testAsFunction = <!RESOLUTION_TO_CLASSIFIER!>Test<!>()
-val testAsValue = <!NO_COMPANION_OBJECT!>Test<!>
+val testAsValue = <!NO_COMPANION_OBJECT!>Test<!>

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

@@ -26,9 +26,9 @@ class Outer {
 }
 typealias Test5 = Outer.Inner
 
-val test5 = <!RESOLUTION_TO_CLASSIFIER!>Test5<!>()
-val test5a = Outer.<!RESOLUTION_TO_CLASSIFIER!>Inner<!>()
-val test5b = Outer.<!RESOLUTION_TO_CLASSIFIER!>TestInner<!>()
+val test5 = <!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Test5<!>()
+val test5a = Outer.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>Inner<!>()
+val test5b = Outer.<!INNER_CLASS_CONSTRUCTOR_NO_RECEIVER!>TestInner<!>()
 val test5c = Outer().<!UNRESOLVED_REFERENCE!>TestInner<!>()
 val test5d = Outer().Inner()
 val test5e = Outer().Test5()