FIR: Preparation for resolve to classifiers

compiler/fir/cones/src/org/jetbrains/kotlin/fir/symbols/ConeLookupTags.kt

@@ -8,18 +8,23 @@ package org.jetbrains.kotlin.fir.symbols
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
-interface ConeClassifierLookupTag
+interface ConeClassifierLookupTag {
+    val name: Name
+}
 
 interface ConeClassifierLookupTagWithFixedSymbol {
     val symbol: ConeClassifierSymbol
 }
 
 interface ConeTypeParameterLookupTag : ConeClassifierLookupTag {
-    val name: Name
+    override val name: Name
 
 }
 interface ConeClassLikeLookupTag : ConeClassifierLookupTag {
     val classId: ClassId
+
+    override val name: Name
+        get() = classId.shortClassName
 }
 
 interface ConeTypeAliasLookupTag : ConeClassLikeLookupTag

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

@@ -16,10 +16,8 @@ import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
 import org.jetbrains.kotlin.fir.references.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.*
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.*
-import org.jetbrains.kotlin.fir.scopes.lookupSuperTypes
 import org.jetbrains.kotlin.fir.symbols.*
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
@@ -181,7 +179,7 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
     abstract class ApplicabilityChecker {
 
         val groupNumbers = mutableListOf<Int>()
-        val candidates = mutableListOf<ConeCallableSymbol>()
+        val candidates = mutableListOf<ConeSymbol>()
 
 
         var currentApplicability = CandidateApplicability.HIDDEN
@@ -205,7 +203,7 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
         }
 
 
-        protected open fun getApplicability(group: Int, symbol: ConeCallableSymbol): CandidateApplicability {
+        protected open fun getApplicability(group: Int, symbol: ConeSymbol): CandidateApplicability {
             val declaration = (symbol as? FirBasedSymbol<*>)?.fir
                 ?: return CandidateApplicability.HIDDEN
             declaration as FirDeclaration
@@ -217,7 +215,7 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
             return CandidateApplicability.RESOLVED
         }
 
-        open fun consumeCandidate(group: Int, symbol: ConeCallableSymbol) {
+        open fun consumeCandidate(group: Int, symbol: ConeSymbol) {
             val applicability = getApplicability(group, symbol)
 
             if (applicability > currentApplicability) {
@@ -235,13 +233,13 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
 
         abstract fun updateNames(names: LinkedHashSet<Name>)
 
-        open fun isSuccessful(index: Int, candidate: ConeCallableSymbol): Boolean {
+        open fun isSuccessful(index: Int, candidate: ConeSymbol): Boolean {
             return true
         }
 
-        open fun successCandidates(): List<ConeCallableSymbol> {
+        open fun successCandidates(): List<ConeSymbol> {
             if (groupNumbers.isEmpty()) return emptyList()
-            val result = mutableListOf<ConeCallableSymbol>()
+            val result = mutableListOf<ConeSymbol>()
             var bestGroup = groupNumbers.first()
             for ((index, candidate) in candidates.withIndex()) {
                 val group = groupNumbers[index]
@@ -263,7 +261,7 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
             names.add(name)
         }
 
-        override fun consumeCandidate(group: Int, symbol: ConeCallableSymbol) {
+        override fun consumeCandidate(group: Int, symbol: ConeSymbol) {
             if (symbol !is ConeVariableSymbol) return
             if (symbol.callableId.callableName != name) return
             super.consumeCandidate(group, symbol)
@@ -273,7 +271,7 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
     inner class VariableInvokeApplicabilityChecker(val variableName: Name) : FunctionApplicabilityChecker(invoke) {
 
         val variableChecker = object : VariableApplicabilityChecker(variableName) {
-            override fun isSuccessful(index: Int, candidate: ConeCallableSymbol): Boolean {
+            override fun isSuccessful(index: Int, candidate: ConeSymbol): Boolean {
                 return matchedProperties[index]
             }
         }
@@ -287,12 +285,13 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
             }
         }
 
-        private fun isInvokeApplicableOn(propertySymbol: ConeCallableSymbol, invokeSymbol: ConeCallableSymbol): Boolean {
+        private fun isInvokeApplicableOn(propertySymbol: ConeSymbol, invokeSymbol: ConeCallableSymbol): Boolean {
             return true //TODO: Actual type-check here
         }
 
-        override fun getApplicability(group: Int, symbol: ConeCallableSymbol): CandidateApplicability {
+        override fun getApplicability(group: Int, symbol: ConeSymbol): CandidateApplicability {
 
+            symbol as ConeCallableSymbol
             val declaration = (symbol as? FirBasedSymbol<*>)?.fir
                 ?: return CandidateApplicability.HIDDEN
             declaration as FirDeclaration
@@ -303,7 +302,7 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
 
             var applicable = false
 
-            fun processCandidates(candidates: Iterable<IndexedValue<ConeCallableSymbol>>) {
+            fun processCandidates(candidates: Iterable<IndexedValue<ConeSymbol>>) {
                 for ((index, candidate) in candidates) {
                     val invokeApplicableOn = isInvokeApplicableOn(candidate, symbol)
                     if (invokeApplicableOn) {
@@ -330,8 +329,8 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
             return currentApplicability == CandidateApplicability.RESOLVED
         }
 
-        override fun consumeCandidate(group: Int, symbol: ConeCallableSymbol) {
+        override fun consumeCandidate(group: Int, symbol: ConeSymbol) {
-            if (symbol.callableId.callableName == variableName) {
+            if (symbol is ConeVariableSymbol && symbol.callableId.callableName == variableName) {
                 variableChecker.consumeCandidate(group, symbol)
 
                 val lastCandidate = variableChecker.candidates.lastOrNull()
@@ -369,6 +368,19 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
         val invoke = Name.identifier("invoke")
     }
 
+    class ClassifierApplicabilityChecker(val name: Name) : ApplicabilityChecker() {
+        override fun updateNames(names: LinkedHashSet<Name>) {
+            names.add(name)
+        }
+
+        override fun consumeCandidate(group: Int, symbol: ConeSymbol) {
+            if (symbol !is ConeClassifierSymbol) return
+            if (symbol.toLookupTag().name != name) return
+            super.consumeCandidate(group, symbol)
+        }
+
+    }
+
     open class FunctionApplicabilityChecker(val name: Name) : ApplicabilityChecker() {
 
         var parameterCount = 0
@@ -377,7 +389,7 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
             names.add(name)
         }
 
-        override fun getApplicability(group: Int, symbol: ConeCallableSymbol): CandidateApplicability {
+        override fun getApplicability(group: Int, symbol: ConeSymbol): CandidateApplicability {
             val declaration = (symbol as FirBasedSymbol<*>).fir
 
             if (declaration is FirFunction) {
@@ -386,7 +398,7 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
             return super.getApplicability(group, symbol)
         }
 
-        override fun consumeCandidate(group: Int, symbol: ConeCallableSymbol) {
+        override fun consumeCandidate(group: Int, symbol: ConeSymbol) {
             if (symbol !is ConeFunctionSymbol) return
             if (symbol.callableId.callableName != name) return
             super.consumeCandidate(group, symbol)
@@ -413,13 +425,14 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
             processedScopes.add(scope)
 
             names.forEach { name ->
-                fun process(symbol: ConeCallableSymbol): ProcessorAction {
+                fun process(symbol: ConeSymbol): ProcessorAction {
                     for (checker in checkers) {
                         checker.consumeCandidate(index, symbol)
                     }
                     return ProcessorAction.NEXT
                 }
 
+                scope.processClassifiersByNameWithAction(name, FirPosition.OTHER, ::process)
                 scope.processPropertiesByName(name, ::process)
                 scope.processFunctionsByName(name, ::process)
             }
@@ -515,7 +528,7 @@ class FirBodyResolveTransformer(val session: FirSession) : FirTransformer<Any?>(
                         FirQualifiedAccessExpressionImpl(functionCall.session, functionCall.calleeReference.psi, functionCall.safe).apply {
                             calleeReference = createResolvedNamedReference(
                                 functionCall.calleeReference,
-                                result.variableChecker.successCandidates()
+                                result.variableChecker.successCandidates() as List<ConeCallableSymbol>
                             )
                             explicitReceiver = functionCall.explicitReceiver
                         }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt

@@ -6,12 +6,17 @@
 package org.jetbrains.kotlin.fir.scopes
 
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT
+import org.jetbrains.kotlin.fir.scopes.ProcessorAction.STOP
 import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol
 import org.jetbrains.kotlin.name.Name
 
 interface FirScope {
+    @Deprecated(
+        "obsolete",
+        replaceWith = ReplaceWith("processClassifiersByNameWithAction(name, position) { if (processor()) ProcessorAction.NEXT else ProcessorAction.STOP }.next()")
+    )
     fun processClassifiersByName(
         name: Name,
         position: FirPosition,
@@ -29,6 +34,18 @@ interface FirScope {
     ): ProcessorAction = NEXT
 }
 
+
+inline fun FirScope.processClassifiersByNameWithAction(
+    name: Name,
+    position: FirPosition,
+    crossinline processor: (ConeClassifierSymbol) -> ProcessorAction
+): ProcessorAction {
+    val result = processClassifiersByName(name, position) {
+        processor(it).next()
+    }
+    return if (result) NEXT else STOP
+}
+
 enum class FirPosition(val allowTypeParameters: Boolean = true) {
     SUPER_TYPE_OR_EXPANSION(allowTypeParameters = false),
     OTHER