[LL FIR] drop ability to enable global phase lock

Also, this commit adds the missing global lock for `IMPORTS` phase.

This commit doesn't change any logic for the case with disabled lock
(the default case), only updates the case with enabled lock.

^KT-66306 Fixed

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/builder/LLFirLockProvider.kt

@@ -30,8 +30,6 @@ import java.util.concurrent.locks.ReentrantLock
 internal class LLFirLockProvider(private val checker: LLFirLazyResolveContractChecker) {
     private val globalLock = ReentrantLock()
 
-    private val implicitTypesLock = ReentrantLock()
-
     inline fun <R> withGlobalLock(
         lockingIntervalMs: Long = DEFAULT_LOCKING_INTERVAL,
         action: () -> R,
@@ -41,24 +39,6 @@ internal class LLFirLockProvider(private val checker: LLFirLazyResolveContractCh
         return globalLock.lockWithPCECheck(lockingIntervalMs, action)
     }
 
-    fun withGlobalPhaseLock(
-        phase: FirResolvePhase,
-        action: () -> Unit,
-    ) {
-        if (!implicitPhaseLockEnabled) return action()
-
-        val lock = when (phase) {
-            FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE -> implicitTypesLock
-            else -> null
-        }
-
-        if (lock == null) {
-            action()
-        } else {
-            lock.lockWithPCECheck(DEFAULT_LOCKING_INTERVAL, action)
-        }
-    }
-
     /**
      * A contract violation check to be sure that we won't request a violated phase later.
      * This is useful to catch a contract violation for jumping phases because they may encounter infinite recursion.
@@ -400,10 +380,6 @@ private val globalLockEnabled: Boolean by lazy(LazyThreadSafetyMode.PUBLICATION)
     Registry.`is`("kotlin.parallel.resolve.under.global.lock", false)
 }
 
-private val implicitPhaseLockEnabled: Boolean by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    Registry.`is`("kotlin.implicit.resolve.phase.under.global.lock", false)
-}
-
 private const val DEFAULT_LOCKING_INTERVAL = 50L
 
 /**

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt

@@ -110,8 +110,11 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
     }
 
     private fun resolveFileToImportsWithLock(firFile: FirFile) {
-        moduleComponents.globalResolveComponents.lockProvider.withWriteLock(firFile, FirResolvePhase.IMPORTS) {
-            firFile.transformSingle(FirImportResolveTransformer(firFile.moduleData.session), null)
+        val lockProvider = moduleComponents.globalResolveComponents.lockProvider
+        lockProvider.withGlobalLock {
+            lockProvider.withWriteLock(firFile, FirResolvePhase.IMPORTS) {
+                firFile.transformSingle(FirImportResolveTransformer(firFile.moduleData.session), null)
+            }
         }
     }
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolverRunner.kt

@@ -25,11 +25,8 @@ internal object LLFirLazyResolverRunner {
      */
     fun runLazyResolverByPhase(phase: FirResolvePhase, target: LLFirResolveTarget) {
         val lazyResolver = LLFirLazyPhaseResolverByPhase.getByPhase(phase)
-        val lockProvider = LLFirGlobalResolveComponents.getInstance(target.session).lockProvider
-        lockProvider.withGlobalLock {
-            lockProvider.withGlobalPhaseLock(phase) {
-                lazyResolver.resolve(target)
-            }
+        LLFirGlobalResolveComponents.getInstance(target.session).lockProvider.withGlobalLock {
+            lazyResolver.resolve(target)
         }
 
         lazyResolver.checkIsResolved(target)

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirReturnTypeCalculatorWithJump.kt

@@ -5,10 +5,8 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder
 
-import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirGlobalResolveComponents
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.asResolveTarget
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.session
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirImplicitBodyTargetResolver
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirImplicitTypesLazyResolver
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLImplicitBodyResolveComputationSession
@@ -37,9 +35,7 @@ internal class LLFirReturnTypeCalculatorWithJump(
             llImplicitBodyResolveComputationSessionParameter = computationSession,
         )
 
-        LLFirGlobalResolveComponents.getInstance(designation.session).lockProvider.withGlobalPhaseLock(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) {
-            resolver.resolveDesignation()
-        }
+        resolver.resolveDesignation()
 
         // Report recursion error if we found cycle during resolution
         if (computationSession.popCycledSymbolIfExists() == declaration.symbol) {