[FE] Cleanup: rename areXyzCompatible -> getXyzCompatibility

Review: https://jetbrains.team/p/kt/reviews/11039/timeline

Motivation:
- Functions with prefix "are" must return Boolean. And
  AbstractExpectActualCompatibilityChecker even already contains some
  functions with prefix "are" that return Boolean (e.g.
  `areCompatibleCallableVisibilities`,
  `areCompatibleSupertypesOneByOne`, etc)
- Unification with functions that are prefixed with "are" and return
  Boolean

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualResolver.kt

@@ -71,7 +71,7 @@ object FirExpectActualResolver {
                     candidates.filter { expectSymbol ->
                         actualSymbol != expectSymbol && expectSymbol.isExpect
                     }.groupBy { expectDeclaration ->
-                        AbstractExpectActualCompatibilityChecker.areCompatibleCallables(
+                        AbstractExpectActualCompatibilityChecker.getCallablesCompatibility(
                             expectDeclaration,
                             actualSymbol as CallableSymbolMarker,
                             parentSubstitutor,
@@ -90,7 +90,7 @@ object FirExpectActualResolver {
                 is FirClassLikeSymbol<*> -> {
                     val expectClassSymbol = useSiteSession.dependenciesSymbolProvider
                         .getClassLikeSymbolByClassId(actualSymbol.classId) as? FirRegularClassSymbol ?: return null
-                    val compatibility = AbstractExpectActualCompatibilityChecker.areCompatibleClassifiers(expectClassSymbol, actualSymbol, context)
+                    val compatibility = AbstractExpectActualCompatibilityChecker.getClassifiersCompatibility(expectClassSymbol, actualSymbol, context)
                     mapOf(compatibility to listOf(expectClassSymbol))
                 }
                 else -> null

compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/AbstractExpectActualCompatibilityChecker.kt

@@ -23,19 +23,19 @@ import org.jetbrains.kotlin.utils.keysToMap
 import java.util.*
 
 object AbstractExpectActualCompatibilityChecker {
-    fun <T : DeclarationSymbolMarker> areCompatibleClassifiers(
+    fun <T : DeclarationSymbolMarker> getClassifiersCompatibility(
         expectClassSymbol: RegularClassSymbolMarker,
         actualClassLikeSymbol: ClassLikeSymbolMarker,
         context: ExpectActualMatchingContext<T>,
     ): ExpectActualCompatibility<T> {
         val result = with(context) {
-            areCompatibleClassifiers(expectClassSymbol, actualClassLikeSymbol, parentSubstitutor = null)
+            getClassifiersCompatibility(expectClassSymbol, actualClassLikeSymbol, parentSubstitutor = null)
         }
         @Suppress("UNCHECKED_CAST")
         return result as ExpectActualCompatibility<T>
     }
 
-    fun <T : DeclarationSymbolMarker> areCompatibleCallables(
+    fun <T : DeclarationSymbolMarker> getCallablesCompatibility(
         expectDeclaration: CallableSymbolMarker,
         actualDeclaration: CallableSymbolMarker,
         parentSubstitutor: TypeSubstitutorMarker?,
@@ -44,7 +44,7 @@ object AbstractExpectActualCompatibilityChecker {
         context: ExpectActualMatchingContext<T>,
     ): ExpectActualCompatibility<T> {
         val result = with(context) {
-            areCompatibleCallables(expectDeclaration, actualDeclaration, parentSubstitutor, expectContainingClass, actualContainingClass)
+            getCallablesCompatibility(expectDeclaration, actualDeclaration, parentSubstitutor, expectContainingClass, actualContainingClass)
         }
         @Suppress("UNCHECKED_CAST")
         return result as ExpectActualCompatibility<T>
@@ -69,7 +69,7 @@ object AbstractExpectActualCompatibilityChecker {
 
     context(ExpectActualMatchingContext<*>)
     @Suppress("warnings")
-    private fun areCompatibleClassifiers(
+    private fun getClassifiersCompatibility(
         expectClassSymbol: RegularClassSymbolMarker,
         actualClassLikeSymbol: ClassLikeSymbolMarker,
         parentSubstitutor: TypeSubstitutorMarker?,
@@ -240,7 +240,7 @@ object AbstractExpectActualCompatibilityChecker {
     ) {
         val mapping = actualMembers.keysToMap { actualMember ->
             when (expectMember) {
-                is CallableSymbolMarker -> areCompatibleCallables(
+                is CallableSymbolMarker -> getCallablesCompatibility(
                     expectMember,
                     actualMember as CallableSymbolMarker,
                     substitutor,
@@ -250,7 +250,7 @@ object AbstractExpectActualCompatibilityChecker {
 
                 is RegularClassSymbolMarker -> {
                     val parentSubstitutor = substitutor?.takeIf { !innerClassesCapturesOuterTypeParameters }
-                    areCompatibleClassifiers(
+                    getClassifiersCompatibility(
                         expectMember,
                         actualMember as ClassLikeSymbolMarker,
                         parentSubstitutor
@@ -277,7 +277,7 @@ object AbstractExpectActualCompatibilityChecker {
     }
 
     context(ExpectActualMatchingContext<*>)
-    private fun areCompatibleCallables(
+    private fun getCallablesCompatibility(
         expectDeclaration: CallableSymbolMarker,
         actualDeclaration: CallableSymbolMarker,
         parentSubstitutor: TypeSubstitutorMarker?,

compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectedActualResolver.kt

@@ -29,7 +29,7 @@ object ExpectedActualResolver {
                             // TODO: support non-source definitions (e.g. from Java)
                             actual.couldHaveASource
                 }.groupBy { actual ->
-                    AbstractExpectActualCompatibilityChecker.areCompatibleCallables(
+                    AbstractExpectActualCompatibilityChecker.getCallablesCompatibility(
                         expected,
                         actual,
                         parentSubstitutor = null,
@@ -43,7 +43,7 @@ object ExpectedActualResolver {
                 context.findClassifiersFromModule(expected.classId, platformModule, moduleVisibilityFilter).filter { actual ->
                     expected != actual && !actual.isExpect && actual.couldHaveASource
                 }.groupBy { actual ->
-                    AbstractExpectActualCompatibilityChecker.areCompatibleClassifiers(
+                    AbstractExpectActualCompatibilityChecker.getClassifiersCompatibility(
                         expected,
                         actual,
                         context
@@ -100,7 +100,7 @@ object ExpectedActualResolver {
                             }
                             else -> null
                         }
-                    AbstractExpectActualCompatibilityChecker.areCompatibleCallables(
+                    AbstractExpectActualCompatibilityChecker.getCallablesCompatibility(
                         expectDeclaration = declaration,
                         actualDeclaration = actual,
                         parentSubstitutor = substitutor,
@@ -114,7 +114,7 @@ object ExpectedActualResolver {
                 context.findClassifiersFromModule(actual.classId, actual.module, moduleFilter).filter { declaration ->
                     actual != declaration && declaration is ClassDescriptor && declaration.isExpect
                 }.groupBy { expected ->
-                    AbstractExpectActualCompatibilityChecker.areCompatibleClassifiers(
+                    AbstractExpectActualCompatibilityChecker.getClassifiersCompatibility(
                         expected as ClassDescriptor,
                         actual,
                         context