[FIR] Implement super resolve as a particular tower resolver case

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.references.FirSuperReference
 import org.jetbrains.kotlin.fir.references.FirThisReference
 import org.jetbrains.kotlin.fir.resolve.calls.ConeInferenceContext
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
+import org.jetbrains.kotlin.fir.resolve.calls.isSuperReferenceExpression
 import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedNameError
 import org.jetbrains.kotlin.fir.resolve.substitution.AbstractConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
@@ -371,8 +372,10 @@ fun <T : FirResolvable> BodyResolveComponents.typeFromCallee(access: T): FirReso
             val receiverResultType = explicitReceiver.resultType
             if (receiverResultType is FirResolvedTypeRef) {
                 receiverResultType.type.isNullable
-            } else {
+            } else if (receiverResultType !is FirComposedSuperTypeRef || !explicitReceiver.isSuperReferenceExpression()){
                 throw AssertionError("Receiver ${explicitReceiver.render()} type is unresolved: ${receiverResultType.render()}")
+            } else {
+                false
             }
         } else {
             false

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirTowerResolver.kt

@@ -13,17 +13,20 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl
 import org.jetbrains.kotlin.fir.declarations.isCompanion
 import org.jetbrains.kotlin.fir.declarations.isInner
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
+import org.jetbrains.kotlin.fir.references.FirSuperReference
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
+import org.jetbrains.kotlin.fir.resolve.scope
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
+import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirExplicitSimpleImportingScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirStaticScope
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
-import org.jetbrains.kotlin.fir.types.ConeIntegerLiteralType
+import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.coneTypeSafe
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
@@ -348,6 +351,27 @@ class FirTowerResolver(
         return collector
     }
 
+    private fun runResolverForSuperReceiver(
+        info: CallInfo,
+        collector: CandidateCollector,
+        superTypeRef: FirTypeRef,
+        manager: TowerResolveManager
+    ): CandidateCollector {
+        val scope = when (superTypeRef) {
+            is FirResolvedTypeRef -> superTypeRef.type.scope(session, components.scopeSession)
+            is FirComposedSuperTypeRef -> FirCompositeScope(
+                superTypeRef.superTypeRefs.mapNotNullTo(mutableListOf()) { it.type.scope(session, components.scopeSession) }
+            )
+            else -> null
+        } ?: return collector
+        manager.processLevel(
+            ScopeTowerLevel(
+                session, components, scope
+            ), info, TowerGroup.Member, explicitReceiverKind = ExplicitReceiverKind.DISPATCH_RECEIVER
+        )
+        return collector
+    }
+
     internal fun enqueueResolverForInvoke(
         info: CallInfo,
         invokeReceiverValue: ExpressionReceiverValue,
@@ -459,7 +483,15 @@ class FirTowerResolver(
         return when (val receiver = info.explicitReceiver) {
             is FirResolvedQualifier -> runResolverForQualifierReceiver(info, collector, receiver, manager)
             null -> runResolverForNoReceiver(info, collector, manager)
-            else -> runResolverForExpressionReceiver(info, collector, receiver, manager)
+            else -> {
+                if (receiver is FirQualifiedAccessExpression) {
+                    val calleeReference = receiver.calleeReference
+                    if (calleeReference is FirSuperReference) {
+                        return runResolverForSuperReceiver(info, collector, receiver.typeRef, manager)
+                    }
+                }
+                runResolverForExpressionReceiver(info, collector, receiver, manager)
+            }
         }
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolverParts.kt

@@ -8,7 +8,10 @@ package org.jetbrains.kotlin.fir.resolve.calls
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
+import org.jetbrains.kotlin.fir.references.FirSuperReference
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
@@ -33,6 +36,13 @@ abstract class ResolutionStage {
 
 abstract class CheckerStage : ResolutionStage()
 
+internal fun FirExpression.isSuperReferenceExpression(): Boolean {
+    return if (this is FirQualifiedAccessExpression) {
+        val calleeReference = calleeReference
+        calleeReference is FirSuperReference
+    } else false
+}
+
 internal object CheckExplicitReceiverConsistency : ResolutionStage() {
     override suspend fun check(candidate: Candidate, sink: CheckerSink, callInfo: CallInfo) {
         val receiverKind = candidate.explicitReceiverKind
@@ -40,7 +50,7 @@ internal object CheckExplicitReceiverConsistency : ResolutionStage() {
         // TODO: add invoke cases
         when (receiverKind) {
             NO_EXPLICIT_RECEIVER -> {
-                if (explicitReceiver != null && explicitReceiver !is FirResolvedQualifier) {
+                if (explicitReceiver != null && explicitReceiver !is FirResolvedQualifier && !explicitReceiver.isSuperReferenceExpression()) {
                     return sink.yieldApplicability(CandidateApplicability.WRONG_RECEIVER)
                 }
             }
@@ -106,7 +116,10 @@ internal sealed class CheckReceivers : ResolutionStage() {
         val explicitReceiverKind = candidate.explicitReceiverKind
 
         if (expectedReceiverType != null) {
-            if (explicitReceiverExpression != null && explicitReceiverKind.shouldBeCheckedAgainstExplicit()) {
+            if (explicitReceiverExpression != null &&
+                explicitReceiverKind.shouldBeCheckedAgainstExplicit() &&
+                !explicitReceiverExpression.isSuperReferenceExpression()
+            ) {
                 candidate.resolveArgumentExpression(
                     candidate.csBuilder,
                     argument = explicitReceiverExpression,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt

@@ -89,13 +89,24 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                         qualifiedAccessExpression.resultType = callee.superTypeRef
                     }
                     else -> {
-                        val superTypeRefFromStack = implicitReceiverStack.lastDispatchReceiver()
+                        val superTypeRefs = implicitReceiverStack.lastDispatchReceiver()?.boundSymbol?.phasedFir?.superTypeRefs
-                            ?.boundSymbol?.phasedFir?.superTypeRefs?.firstOrNull()
+                        val resultType = when {
-                            ?: FirErrorTypeRefImpl(
+                            superTypeRefs?.isNotEmpty() != true -> {
-                                qualifiedAccessExpression.source, FirSimpleDiagnostic("No super type", DiagnosticKind.NoSupertype)
+                                FirErrorTypeRefImpl(
-                            )
+                                    qualifiedAccessExpression.source, FirSimpleDiagnostic("No super type", DiagnosticKind.NoSupertype)
-                        qualifiedAccessExpression.resultType = superTypeRefFromStack
+                                )
-                        callee.replaceSuperTypeRef(superTypeRefFromStack)
+                            }
+                            superTypeRefs.size == 1 -> {
+                                superTypeRefs.single()
+                            }
+                            else -> {
+                                FirComposedSuperTypeRefImpl(qualifiedAccessExpression.source).apply {
+                                    this.superTypeRefs += superTypeRefs.map { it as FirResolvedTypeRef }
+                                }
+                            }
+                        }
+                        qualifiedAccessExpression.resultType = resultType
+                        callee.replaceSuperTypeRef(resultType)
                     }
                 }
                 qualifiedAccessExpression

compiler/fir/resolve/testData/resolve/problems/incorrectSuperCall.kt

@@ -9,8 +9,8 @@ open class B {
 
 class C : A, B() {
     override fun foo() {
-        super.<!UNRESOLVED_REFERENCE!>foo<!>()
+        super.foo()
 
-        super.bar() // should be ambiguity
+        super.<!AMBIGUITY!>bar<!>() // should be ambiguity (NB: really we should have overridden bar in C)
     }
 }

compiler/fir/resolve/testData/resolve/problems/incorrectSuperCall.txt

@@ -22,8 +22,8 @@ FILE: incorrectSuperCall.kt
         }
 
         public final override fun foo(): R|kotlin/Unit| {
-            super<R|A|>.<Unresolved name: foo>#()
+            super<R|A|R|B|>.R|/B.foo|()
-            super<R|A|>.R|/A.bar|()
+            super<R|A|R|B|>.<Ambiguity: bar, [/A.bar, /B.bar]>#()
         }
 
     }

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt

@@ -268,6 +268,8 @@ class FirResolveBench(val withProgress: Boolean) {
                         visitTypeRef(implicitTypeRef)
                     }
 
+                    override fun visitComposedSuperTypeRef(composedSuperTypeRef: FirComposedSuperTypeRef) {}
+
                     override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) {
                         resolvedTypes++
                         val type = resolvedTypeRef.type

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/FirComposedSuperTypeRef.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.types
+
+import org.jetbrains.kotlin.fir.FirPureAbstractElement
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+abstract class FirComposedSuperTypeRef : FirPureAbstractElement(), FirTypeRef {
+    abstract override val source: FirSourceElement?
+    abstract override val annotations: List<FirAnnotationCall>
+    abstract val superTypeRefs: List<FirResolvedTypeRef>
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitComposedSuperTypeRef(this, data)
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/impl/FirComposedSuperTypeRefImpl.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.types.impl
+
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.types.FirComposedSuperTypeRef
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+class FirComposedSuperTypeRefImpl(
+    override val source: FirSourceElement?
+) : FirComposedSuperTypeRef(), FirAbstractAnnotatedElement {
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    override val superTypeRefs: MutableList<FirResolvedTypeRef> = mutableListOf()
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        annotations.forEach { it.accept(visitor, data) }
+        superTypeRefs.forEach { it.accept(visitor, data) }
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirComposedSuperTypeRefImpl {
+        annotations.transformInplace(transformer, data)
+        superTypeRefs.transformInplace(transformer, data)
+        return this
+    }
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt

@@ -116,6 +116,7 @@ import org.jetbrains.kotlin.fir.types.FirDynamicTypeRef
 import org.jetbrains.kotlin.fir.types.FirFunctionTypeRef
 import org.jetbrains.kotlin.fir.types.FirResolvedFunctionTypeRef
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
+import org.jetbrains.kotlin.fir.types.FirComposedSuperTypeRef
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 
@@ -568,6 +569,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformElement(implicitTypeRef, data)
     }
 
+    open fun transformComposedSuperTypeRef(composedSuperTypeRef: FirComposedSuperTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformElement(composedSuperTypeRef, data)
+    }
+
     open fun transformContractDescription(contractDescription: FirContractDescription, data: D): CompositeTransformResult<FirContractDescription> {
         return transformElement(contractDescription, data)
     }
@@ -1016,6 +1021,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformImplicitTypeRef(implicitTypeRef, data)
     }
 
+    final override fun visitComposedSuperTypeRef(composedSuperTypeRef: FirComposedSuperTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformComposedSuperTypeRef(composedSuperTypeRef, data)
+    }
+
     final override fun visitContractDescription(contractDescription: FirContractDescription, data: D): CompositeTransformResult<FirContractDescription> {
         return transformContractDescription(contractDescription, data)
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt

@@ -116,6 +116,7 @@ import org.jetbrains.kotlin.fir.types.FirDynamicTypeRef
 import org.jetbrains.kotlin.fir.types.FirFunctionTypeRef
 import org.jetbrains.kotlin.fir.types.FirResolvedFunctionTypeRef
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
+import org.jetbrains.kotlin.fir.types.FirComposedSuperTypeRef
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
 
 /*
@@ -346,6 +347,8 @@ abstract class FirVisitor<out R, in D> {
 
     open fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): R  = visitElement(implicitTypeRef, data)
 
+    open fun visitComposedSuperTypeRef(composedSuperTypeRef: FirComposedSuperTypeRef, data: D): R  = visitElement(composedSuperTypeRef, data)
+
     open fun visitContractDescription(contractDescription: FirContractDescription, data: D): R  = visitElement(contractDescription, data)
 
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt

@@ -116,6 +116,7 @@ import org.jetbrains.kotlin.fir.types.FirDynamicTypeRef
 import org.jetbrains.kotlin.fir.types.FirFunctionTypeRef
 import org.jetbrains.kotlin.fir.types.FirResolvedFunctionTypeRef
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
+import org.jetbrains.kotlin.fir.types.FirComposedSuperTypeRef
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
 
 /*
@@ -566,6 +567,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(implicitTypeRef)
     }
 
+    open fun visitComposedSuperTypeRef(composedSuperTypeRef: FirComposedSuperTypeRef) {
+        visitElement(composedSuperTypeRef)
+    }
+
     open fun visitContractDescription(contractDescription: FirContractDescription) {
         visitElement(contractDescription)
     }
@@ -1014,6 +1019,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitImplicitTypeRef(implicitTypeRef)
     }
 
+    final override fun visitComposedSuperTypeRef(composedSuperTypeRef: FirComposedSuperTypeRef, data: Nothing?) {
+        visitComposedSuperTypeRef(composedSuperTypeRef)
+    }
+
     final override fun visitContractDescription(contractDescription: FirContractDescription, data: Nothing?) {
         visitContractDescription(contractDescription)
     }

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt

@@ -137,6 +137,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val functionTypeRef = element("FunctionTypeRef", TypeRef, typeRefWithNullability)
     val resolvedFunctionTypeRef = element("ResolvedFunctionTypeRef", TypeRef, resolvedTypeRef, functionTypeRef)
     val implicitTypeRef = element("ImplicitTypeRef", TypeRef, typeRef)
+    val composedSuperTypeRef = element("ComposedSuperTypeRef", TypeRef, typeRef)
 
     val contractDescription = element("ContractDescription", Contracts)
 }

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt

@@ -513,6 +513,8 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
             defaultEmptyList("annotations")
         }
 
+        impl(composedSuperTypeRef)
+
         impl(reference, "FirStubReference") {
             default("source") {
                 value = "null"

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -521,6 +521,10 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
             +returnTypeRef
         }
 
+        composedSuperTypeRef.configure {
+            +fieldList("superTypeRefs", resolvedTypeRef)
+        }
+
         thisReceiverExpression.configure {
             +field("calleeReference", thisReference)
         }

compiler/testData/codegen/box/javaInterop/objectMethods/cloneCallsSuperAndModifies.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // IGNORE_BACKEND: JS_IR
 // TODO: muted automatically, investigate should it be ran for JS or not
 // IGNORE_BACKEND: JS, NATIVE

compiler/testData/codegen/box/javaInterop/objectMethods/cloneHierarchy.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 
 open class A : Cloneable {

compiler/testData/codegen/box/jvm8/defaults/kt14243_prop.kt

@@ -1,5 +1,4 @@
 // !JVM_DEFAULT_MODE: enable
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 // JVM_TARGET: 1.8
 // WITH_RUNTIME

compiler/testData/codegen/box/jvm8/kt14243_prop.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 // JVM_TARGET: 1.8
 

compiler/testData/codegen/box/jvmField/superCall.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 
 // WITH_RUNTIME

compiler/testData/codegen/box/jvmField/superCall2.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 
 // WITH_RUNTIME

compiler/testData/codegen/box/mangling/internalOverrideSuperCall.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 open class A {
     internal open val field = "F"
 

compiler/testData/codegen/box/mangling/publicOverrideSuperCall.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 open class A {
     internal open val field = "F"
 

compiler/testData/codegen/box/super/kt14243_prop.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 interface Z<T> {
     val value: T
 

compiler/testData/diagnostics/tests/enum/kt8972_cloneNotAllowed.fir.kt

@@ -2,6 +2,6 @@
 enum class E : Cloneable {
     A;
     override fun clone(): Any {
-        return super.clone()
+        return super.<!AMBIGUITY!>clone<!>()
     }
 }

compiler/testData/diagnostics/tests/extensions/ExtensionsCalledOnSuper.fir.kt

@@ -14,9 +14,9 @@ class C : T {
         fun T.buzz() {}
         fun T.buzz1() {}
         super.foo() // OK
-        super.bar() // Error
+        super.<!UNRESOLVED_REFERENCE!>bar<!>() // Error
         super.buzz() // OK, resolved to a member
-        super.buzz1() // Resolved to an extension
+        super.<!INAPPLICABLE_CANDIDATE!>buzz1<!>() // Resolved to an extension
         super.<!INAPPLICABLE_CANDIDATE!>buzz1<!>("") // Resolved to a member
     }
 }

compiler/testData/diagnostics/tests/thisAndSuper/Super.fir.kt

@@ -12,7 +12,7 @@ class A<E>() : C(), T {
     fun test() {
         super
         super<T>
-        super.<!UNRESOLVED_REFERENCE!>foo<!>()
+        super.foo()
         super<T>.foo()
         super<C>.bar()
         super<T>@A.foo()

compiler/testData/diagnostics/tests/thisAndSuper/superInExtensionFunctionCall.fir.kt

@@ -4,6 +4,6 @@ fun Any.extension(arg: Any?) {}
 
 class A1 {
     fun test() {
-        super.extension(null) // Call to an extension function
+        super.<!UNRESOLVED_REFERENCE!>extension<!>(null) // Call to an extension function
     }
 }

compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/ambiguousSuperWithGenerics.fir.kt

@@ -11,28 +11,28 @@ interface GenericBaseInterface<T> {
 
 class GenericDerivedClass<T> : GenericBaseClass<T>(), GenericBaseInterface<T> {
     override fun foo(x: T): T = super.foo(x)
-    override fun bar(x: T): T = super.<!UNRESOLVED_REFERENCE!>bar<!>(x)
+    override fun bar(x: T): T = super.bar(x)
 
     override fun ambiguous(x: T): T =
-            super.ambiguous(x)
+            super.<!AMBIGUITY!>ambiguous<!>(x)
 }
 
 class SpecializedDerivedClass : GenericBaseClass<Int>(), GenericBaseInterface<String> {
     override fun foo(x: Int): Int = super.foo(x)
-    override fun bar(x: String): String = super.<!UNRESOLVED_REFERENCE!>bar<!>(x)
+    override fun bar(x: String): String = super.bar(x)
 
     override fun ambiguous(x: String): String =
-            super.<!INAPPLICABLE_CANDIDATE!>ambiguous<!>(x)
+            super.ambiguous(x)
     override fun ambiguous(x: Int): Int =
             super.ambiguous(x)
 }
 
 class MixedDerivedClass<T> : GenericBaseClass<Int>(), GenericBaseInterface<T> {
     override fun foo(x: Int): Int = super.foo(x)
-    override fun bar(x: T): T = super.<!UNRESOLVED_REFERENCE!>bar<!>(x)
+    override fun bar(x: T): T = super.bar(x)
 
     override fun ambiguous(x: Int): Int =
             super.ambiguous(x)
     override fun ambiguous(x: T): T =
-            super.<!INAPPLICABLE_CANDIDATE!>ambiguous<!>(x)
+            super.ambiguous(x)
 }

compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuper.fir.kt

@@ -45,13 +45,13 @@ class Derived : Base(), Interface {
             super.prop
 
     fun getAmbiguousSuperProp(): Int =
-            super.ambiguousProp
+            super.<!AMBIGUITY!>ambiguousProp<!>
 
     fun callsFunFromSuperInterface() {
-        super.<!UNRESOLVED_REFERENCE!>bar<!>()
+        super.bar()
     }
 
     fun callsAmbiguousSuperFun() {
-        super.ambiguous()
+        super.<!AMBIGUITY!>ambiguous<!>()
     }
 }

compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithAbstractMembers.fir.kt

@@ -22,18 +22,18 @@ interface I {
 
 class B : A(), I {
     override val x: Int = 12345
-    override val y: Int = super.y
+    override val y: Int = super.<!AMBIGUITY!>y<!>
 
     override fun foo(): Int {
         super.foo()
-        return super.<!UNRESOLVED_REFERENCE!>x<!>
+        return super.x
     }
 
     override fun bar() {
-        super.bar()
+        super.<!AMBIGUITY!>bar<!>()
     }
 
     override fun qux() {
-        super.qux()
+        super.<!AMBIGUITY!>qux<!>()
     }
 }

compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithDeeperHierarchies.fir.kt

@@ -43,8 +43,8 @@ class DeepDerived : DeepBase(), DeepInterface {
             super.deeperBaseProp
 
     fun callsSuperInterfaceFuns() {
-        super.<!UNRESOLVED_REFERENCE!>deeperInterfaceFun<!>()
+        super.deeperInterfaceFun()
-        super.<!UNRESOLVED_REFERENCE!>deepInterfaceFun<!>()
+        super.deepInterfaceFun()
         super<DeepInterface>.deeperInterfaceFun()
         super<DeepInterface>.deepInterfaceFun()
     }

compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithGenerics.fir.kt

@@ -8,15 +8,15 @@ interface GenericBaseInterface<T> {
 
 class GenericDerivedClass<T> : GenericBaseClass<T>(), GenericBaseInterface<T> {
     override fun foo(x: T): T = super.foo(x)
-    override fun bar(x: T): T = super.<!UNRESOLVED_REFERENCE!>bar<!>(x)
+    override fun bar(x: T): T = super.bar(x)
 }
 
 class SpecializedDerivedClass : GenericBaseClass<Int>(), GenericBaseInterface<String> {
     override fun foo(x: Int): Int = super.foo(x)
-    override fun bar(x: String): String = super.<!UNRESOLVED_REFERENCE!>bar<!>(x)
+    override fun bar(x: String): String = super.bar(x)
 }
 
 class MixedDerivedClass<T> : GenericBaseClass<Int>(), GenericBaseInterface<T> {
     override fun foo(x: Int): Int = super.foo(x)
-    override fun bar(x: T): T = super.<!UNRESOLVED_REFERENCE!>bar<!>(x)
+    override fun bar(x: T): T = super.bar(x)
 }

compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithInnerClass.fir.kt

@@ -16,7 +16,7 @@ class C : A(), B {
     }
 
     override fun bar() {
-        super@C.<!UNRESOLVED_REFERENCE!>bar<!>()
+        super@C.bar()
     }
 
     inner class D : A(), Q {
@@ -26,8 +26,8 @@ class C : A(), B {
         }
 
         override fun qux() {
-            super@C.<!UNRESOLVED_REFERENCE!>qux<!>()
+            super@C.qux()
-            super@D.<!UNRESOLVED_REFERENCE!>qux<!>()
+            super@D.qux()
         }
     }
 }

compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithInterfaces.fir.kt

@@ -20,9 +20,9 @@ interface AnotherInterface {
 interface DerivedInterface: Interface, AnotherInterface {
     override fun foo() { super.foo() }
     override fun ambiguous() {
-        super.ambiguous()
+        super.<!AMBIGUITY!>ambiguous<!>()
     }
     override val ambiguousProp: Int
-        get() = super.ambiguousProp
+        get() = super.<!AMBIGUITY!>ambiguousProp<!>
 }
 

compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithUnresolvedBase.fir.kt

@@ -41,13 +41,13 @@ class ClassDerivedFromUnresolved : Base(), Interface, Unresolved {
             super.prop
 
     fun getAmbiguousSuperProp(): Int =
-    super.ambiguousProp
+    super.<!AMBIGUITY!>ambiguousProp<!>
 
     fun callsFunFromSuperInterface() {
-        super.<!UNRESOLVED_REFERENCE!>bar<!>()
+        super.bar()
     }
 
     fun callsAmbiguousSuperFun() {
-        super.ambiguous()
+        super.<!AMBIGUITY!>ambiguous<!>()
     }
 }

compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/withMethodOverriddenInAnotherSupertype.fir.kt

@@ -15,7 +15,7 @@ class Test1 : C(), A {
         // Abstract 'foo' defined in 'C' wins against non-abstract 'foo' defined in 'A',
         // because 'C' is a subclass of 'A' (and 'C::foo' overrides 'A::foo'),
         // even though 'A' is explicitly listed in supertypes list for 'D'.
-        super.foo()
+        super.<!AMBIGUITY!>foo<!>()
     }
 }
 
@@ -23,7 +23,7 @@ class Test2 : C(), A, Unrelated {
     override fun foo() {
         // This is ok, because there's a non-abstract 'foo' in 'Unrelated',
         // which is not overridden by abstract 'foo' in 'C'.
-        super.foo()
+        super.<!AMBIGUITY!>foo<!>()
         super<Unrelated>.foo()
     }
 }

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCall.fir.kt

@@ -49,7 +49,7 @@ class ManySupers2: Foo2(), C {
     fun foo() {
         super<Foo2>.test()
         super<C>.test()
-        super.test()
+        super.<!AMBIGUITY!>test<!>()
     }
 }
 
@@ -57,6 +57,6 @@ class ManySupers3: Bar2(), C {
     fun foo() {
         super<Bar2>.test()
         super<C>.test()
-        super.test()
+        super.<!AMBIGUITY!>test<!>()
     }
 }

compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns/blackListed.fir.kt

@@ -3,7 +3,7 @@
 
 abstract class A : MutableList<String> {
     override fun sort(/*0*/ p0: java.util.Comparator<in String>) {
-        super.sort(p0)
+        super.<!UNRESOLVED_REFERENCE!>sort<!>(p0)
     }
 }
 

compiler/testData/ir/irText/classes/enumWithMultipleCtors.fir.txt

@@ -22,7 +22,7 @@ FILE fqName:<root> fileName:/enumWithMultipleCtors.kt
             RETURN type=kotlin.Nothing from='public final fun f (): kotlin.String declared in <root>.A.Y'
               CALL 'public final fun plus (other: kotlin.Any?): kotlin.String [operator] declared in kotlin.String' type=kotlin.String origin=null
                 $this: CALL 'public open fun f (): kotlin.String declared in <root>.A' type=kotlin.String origin=null
-                  $this: ERROR_CALL 'Unresolved reference: super<R|A|>' type=<root>.A
+                  $this: GET_VAR '<this>: <uninitialized parent>.<anonymous> declared in <no parent>.<anonymous>' type=<uninitialized parent>.<anonymous> origin=null
                 other: CONST String type=kotlin.String value="#Y"
     ENUM_ENTRY name:Z
       class: CLASS ENUM_ENTRY name:Z modality:FINAL visibility:local superTypes:[<root>.A]

compiler/testData/ir/irText/classes/implicitNotNullOnDelegatedImplementation.fir.txt

@@ -50,7 +50,7 @@ FILE fqName:<root> fileName:/implicitNotNullOnDelegatedImplementation.kt
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun foo (): kotlin.String declared in <root>.K2'
           CALL 'public open fun foo (): kotlin.String [operator] declared in <root>.JFoo' type=kotlin.String origin=null
-            $this: ERROR_CALL 'Unresolved reference: super<R|JFoo|>' type=<root>.JFoo
+            $this: GET_VAR '<this>: <root>.K2 declared in <root>.K2.foo' type=<root>.K2 origin=null
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]
       overridden:
         public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any
@@ -93,12 +93,12 @@ FILE fqName:<root> fileName:/implicitNotNullOnDelegatedImplementation.kt
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in <root>.JUnrelatedFoo'
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:K4 modality:FINAL visibility:public superTypes:[<root>.JUnrelatedFoo; <root>.IFoo]'
-    FUN name:foo visibility:public modality:FINAL <> ($this:<root>.K4) returnType:kotlin.String?
+    FUN name:foo visibility:public modality:FINAL <> ($this:<root>.K4) returnType:kotlin.String
       $this: VALUE_PARAMETER name:<this> type:<root>.K4
       BLOCK_BODY
-        RETURN type=kotlin.Nothing from='public final fun foo (): kotlin.String? declared in <root>.K4'
+        RETURN type=kotlin.Nothing from='public final fun foo (): kotlin.String declared in <root>.K4'
-          CALL 'public open fun foo (): kotlin.String? [operator] declared in <root>.JUnrelatedFoo' type=kotlin.String? origin=null
+          CALL 'public abstract fun foo (): kotlin.String declared in <root>.IFoo' type=kotlin.String origin=null
-            $this: ERROR_CALL 'Unresolved reference: super<R|JUnrelatedFoo|>' type=<root>.JUnrelatedFoo
+            $this: GET_VAR '<this>: <root>.K4 declared in <root>.K4.foo' type=<root>.K4 origin=null
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]
       overridden:
         public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any

compiler/testData/ir/irText/classes/superCalls.fir.txt

@@ -24,7 +24,7 @@ FILE fqName:<root> fileName:/superCalls.kt
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public open fun hashCode (): kotlin.Int declared in <root>.Base'
           CALL 'public open fun hashCode (): kotlin.Int declared in kotlin.Any' type=kotlin.Int origin=null
-            $this: ERROR_CALL 'Unresolved reference: super<R|kotlin/Any|>' type=kotlin.Any
+            $this: GET_VAR '<this>: <root>.Base declared in <root>.Base.hashCode' type=<root>.Base origin=null
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]
       overridden:
         public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any
@@ -44,7 +44,7 @@ FILE fqName:<root> fileName:/superCalls.kt
       $this: VALUE_PARAMETER name:<this> type:<root>.Derived
       BLOCK_BODY
         CALL 'public open fun foo (): kotlin.Unit declared in <root>.Base' type=kotlin.Unit origin=null
-          $this: ERROR_CALL 'Unresolved reference: super<R|Base|>' type=<root>.Base
+          $this: GET_VAR '<this>: <root>.Derived declared in <root>.Derived.foo' type=<root>.Derived origin=null
     PROPERTY name:bar visibility:public modality:FINAL [val]
       FUN name:<get-bar> visibility:public modality:FINAL <> ($this:<root>.Derived) returnType:kotlin.String
         correspondingProperty: PROPERTY name:bar visibility:public modality:FINAL [val]
@@ -52,7 +52,7 @@ FILE fqName:<root> fileName:/superCalls.kt
         BLOCK_BODY
           RETURN type=kotlin.Nothing from='public final fun <get-bar> (): kotlin.String declared in <root>.Derived'
             CALL 'public open fun <get-bar> (): kotlin.String declared in <root>.Base' type=kotlin.String origin=null
-              $this: ERROR_CALL 'Unresolved reference: super<R|Base|>' type=<root>.Base
+              $this: GET_VAR '<this>: <root>.Derived declared in <root>.Derived.<get-bar>' type=<root>.Derived origin=null
     FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:<root>.Base) returnType:kotlin.Int [fake_override]
       overridden:
         public open fun hashCode (): kotlin.Int declared in <root>.Base