[FIR] Remove all usages of classes and methods from FE 1.0 from FIR checkers

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.coneType
-import org.jetbrains.kotlin.resolve.SINCE_KOTLIN_FQ_NAME
+import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.resolve.checkers.OptInNames
 
 sealed class FirSinceKotlinAccessibility {
@@ -65,7 +65,7 @@ private fun FirAnnotatedDeclaration.getOwnSinceKotlinVersion(session: FirSession
 
     // TODO: use-site targeted annotations
     fun FirAnnotatedDeclaration.consider() {
-        val sinceKotlinSingleArgument = getAnnotationByFqName(SINCE_KOTLIN_FQ_NAME)?.arguments?.singleOrNull()
+        val sinceKotlinSingleArgument = getAnnotationByClassId(StandardClassIds.SinceKotlin)?.arguments?.singleOrNull()
         val apiVersion = ((sinceKotlinSingleArgument as? FirConstExpression<*>)?.value as? String)?.let(ApiVersion.Companion::parse)
         if (apiVersion != null) {
             // TODO: combine wasExperimentalMarkerClasses in case of several associated declarations with the same maximal API version

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirClassVarianceChecker.kt

@@ -18,8 +18,8 @@ import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.types.EnrichedProjectionKind
 import org.jetbrains.kotlin.types.Variance
-import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure
 
 object FirClassVarianceChecker : FirClassChecker() {
     override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
@@ -148,11 +148,11 @@ object FirClassVarianceChecker : FirClassChecker() {
 
                     val typeArgumentType = typeArgument.type ?: continue
 
-                    val newVariance = when (TypeCheckingProcedure.getEffectiveProjectionKind(paramVariance, argVariance)!!) {
-                        TypeCheckingProcedure.EnrichedProjectionKind.OUT -> variance
-                        TypeCheckingProcedure.EnrichedProjectionKind.IN -> variance.opposite()
-                        TypeCheckingProcedure.EnrichedProjectionKind.INV -> Variance.INVARIANT
-                        TypeCheckingProcedure.EnrichedProjectionKind.STAR -> null // CONFLICTING_PROJECTION error was reported
+                    val newVariance = when (EnrichedProjectionKind.getEffectiveProjectionKind(paramVariance, argVariance)) {
+                        EnrichedProjectionKind.OUT -> variance
+                        EnrichedProjectionKind.IN -> variance.opposite()
+                        EnrichedProjectionKind.INV -> Variance.INVARIANT
+                        EnrichedProjectionKind.STAR -> null // CONFLICTING_PROJECTION error was reported
                     }
 
                     if (newVariance != null) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOperatorModifierChecker.kt

@@ -10,7 +10,6 @@
 
 package org.jetbrains.kotlin.fir.analysis.checkers.declaration
 
-import javaslang.Function2
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.Checks.Returns
@@ -83,12 +82,15 @@ object FirOperatorModifierChecker : FirSimpleFunctionChecker() {
 
 }
 
-interface Check : Function2<CheckerContext, FirSimpleFunction, String?> {
-    override fun apply(t1: CheckerContext, t2: FirSimpleFunction): String? = check(t1, t2)
+private interface Check : (CheckerContext, FirSimpleFunction) -> String? {
+    override fun invoke(p1: CheckerContext, p2: FirSimpleFunction): String? {
+        return check(p1, p2)
+    }
+
     fun check(context: CheckerContext, function: FirSimpleFunction): String?
 }
 
-object Checks {
+private object Checks {
     fun simple(message: String, predicate: (FirSimpleFunction) -> Boolean) = object : Check {
         override fun check(context: CheckerContext, function: FirSimpleFunction): String? = message.takeIf { !predicate(function) }
     }
@@ -156,10 +158,10 @@ object Checks {
 }
 
 @OptIn(ExperimentalStdlibApi::class)
-object OperatorFunctionChecks {
+private object OperatorFunctionChecks {
 
     //reimplementation of org.jetbrains.kotlin.util.OperatorChecks for FIR
-    val checksByName: Map<Name, List<Check>> = buildMap<Name, List<Check>> {
+    val checksByName: Map<Name, List<Check>> = buildMap {
         checkFor(GET, memberOrExtension, ValueParametersCount.atLeast(1))
         checkFor(
             SET,
@@ -218,4 +220,4 @@ object OperatorFunctionChecks {
     private fun MutableList<Pair<Regex, List<Check>>>.checkFor(regex: Regex, vararg checks: Check) {
         add(regex to checks.asList())
     }
-}
+}

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuspendCallChecker.kt

@@ -33,15 +33,13 @@ import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.StandardClassIds
-import org.jetbrains.kotlin.resolve.calls.checkers.COROUTINE_CONTEXT_FQ_NAME
-import org.jetbrains.kotlin.serialization.deserialization.KOTLIN_SUSPEND_BUILT_IN_FUNCTION_FQ_NAME
 import org.jetbrains.kotlin.utils.addToStdlib.lastIsInstanceOrNull
 
 object FirSuspendCallChecker : FirQualifiedAccessExpressionChecker() {
     private val RESTRICTS_SUSPENSION_CLASS_ID =
         ClassId(StandardNames.COROUTINES_PACKAGE_FQ_NAME, Name.identifier("RestrictsSuspension"))
 
-    private val BUILTIN_SUSPEND_NAME = KOTLIN_SUSPEND_BUILT_IN_FUNCTION_FQ_NAME.shortName()
+    private val BUILTIN_SUSPEND_NAME = StandardClassIds.suspend.callableName
 
     internal val KOTLIN_SUSPEND_BUILT_IN_FUNCTION_CALLABLE_ID = CallableId(StandardClassIds.BASE_KOTLIN_PACKAGE, BUILTIN_SUSPEND_NAME)
 
@@ -56,7 +54,7 @@ object FirSuspendCallChecker : FirQualifiedAccessExpressionChecker() {
         if (reference is FirResolvedCallableReference) return
         when (symbol) {
             is FirNamedFunctionSymbol -> if (!symbol.isSuspend) return
-            is FirPropertySymbol -> if (symbol.callableId.asSingleFqName() != COROUTINE_CONTEXT_FQ_NAME) return
+            is FirPropertySymbol -> if (symbol.callableId != StandardClassIds.coroutineContext) return
             else -> return
         }
         val enclosingSuspendFunction = findEnclosingSuspendFunction(context)

compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.resolve.source.getPsi
 import org.jetbrains.kotlin.resolve.typeBinding.TypeBinding
 import org.jetbrains.kotlin.resolve.typeBinding.createTypeBinding
 import org.jetbrains.kotlin.resolve.typeBinding.createTypeBindingForReturnType
+import org.jetbrains.kotlin.types.EnrichedProjectionKind
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.Variance.*
@@ -164,10 +165,10 @@ class VarianceCheckerCore(
 
             val projectionKind = TypeCheckingProcedure.getEffectiveProjectionKind(argument.typeParameter!!, argument.projection)!!
             val newPosition = when (projectionKind) {
-                TypeCheckingProcedure.EnrichedProjectionKind.OUT -> position
-                TypeCheckingProcedure.EnrichedProjectionKind.IN -> position.opposite()
-                TypeCheckingProcedure.EnrichedProjectionKind.INV -> Variance.INVARIANT
-                TypeCheckingProcedure.EnrichedProjectionKind.STAR -> null // CONFLICTING_PROJECTION error was reported
+                EnrichedProjectionKind.OUT -> position
+                EnrichedProjectionKind.IN -> position.opposite()
+                EnrichedProjectionKind.INV -> Variance.INVARIANT
+                EnrichedProjectionKind.STAR -> null // CONFLICTING_PROJECTION error was reported
             }
             if (newPosition != null) {
                 noError = noError and argument.binding.checkTypePosition(containingType, newPosition)