[LL FIR] add ability to suppress contract violation exception

^KT-56543

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

@@ -5,7 +5,9 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve
 
+import com.intellij.openapi.diagnostic.Logger
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.symbols.FirLazyResolveContractViolationException
 
 internal class LLFirLazyResolveContractChecker {
     private val currentTransformerPhase = ThreadLocal.withInitial<FirResolvePhase?> { null }
@@ -26,12 +28,16 @@ internal class LLFirLazyResolveContractChecker {
         val currentPhase = currentTransformerPhase.get() ?: return
 
         if (requestedPhase >= currentPhase) {
-            error(
+            val exception = FirLazyResolveContractViolationException(currentPhase = currentPhase, requestedPhase = requestedPhase)
-                """`lazyResolveToPhase($requestedPhase)` cannot be called from a transformer with a phase $currentPhase.
+            if (System.getProperty("kotlin.suppress.lazy.resolve.contract.violation") != null) {
-                    `lazyResolveToPhase` can be called only from a transformer with a phase which is strictly greater than a requested phase;
+                LoggerHolder.LOG.warn(exception)
-                     i.e., `lazyResolveToPhase(A)` may be only called from a lazy transformer with a phase B, where A < B. This is a contract of lazy resolve""".trimIndent()
+            } else {
-            )
+                throw exception
+            }
         }
     }
-}
 
+    private object LoggerHolder {
+        val LOG = Logger.getInstance(LLFirLazyResolveContractChecker::class.java)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirLazyDeclarationResolver.kt

@@ -44,6 +44,17 @@ abstract class FirLazyDeclarationResolver : FirSessionComponent {
     abstract fun lazyResolveToPhaseWithCallableMembers(symbol: FirClassSymbol<*>, toPhase: FirResolvePhase)
 }
 
+class FirLazyResolveContractViolationException(
+    currentPhase: FirResolvePhase,
+    requestedPhase: FirResolvePhase,
+) : IllegalStateException(
+    """
+        `lazyResolveToPhase($requestedPhase)` cannot be called from a transformer with a phase $currentPhase.
+        `lazyResolveToPhase` can be called only from a transformer with a phase which is strictly greater than a requested phase;
+         i.e., `lazyResolveToPhase(A)` may be only called from a lazy transformer with a phase B, where A < B. This is a contract of lazy resolve
+     """.trimIndent()
+)
+
 val FirSession.lazyDeclarationResolver: FirLazyDeclarationResolver by FirSession.sessionComponentAccessor()
 
 private val FirDeclaration.lazyDeclarationResolver get() = moduleData.session.lazyDeclarationResolver

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirCompilerLazyDeclarationResolverWithPhaseChecking.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.test.frontend.fir.handlers
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.FirLazyDeclarationResolver
+import org.jetbrains.kotlin.fir.symbols.FirLazyResolveContractViolationException
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 
 
@@ -20,11 +21,11 @@ class FirCompilerLazyDeclarationResolverWithPhaseChecking : FirLazyDeclarationRe
         exceptions
 
     override fun lazyResolveToPhase(symbol: FirBasedSymbol<*>, toPhase: FirResolvePhase) {
-        checkIfCanLazyResolveToPhase(symbol, toPhase)
+        checkIfCanLazyResolveToPhase(toPhase)
     }
 
     override fun lazyResolveToPhaseWithCallableMembers(symbol: FirClassSymbol<*>, toPhase: FirResolvePhase) {
-        checkIfCanLazyResolveToPhase(symbol, toPhase)
+        checkIfCanLazyResolveToPhase(toPhase)
     }
 
     override fun startResolvingPhase(phase: FirResolvePhase) {
@@ -37,7 +38,7 @@ class FirCompilerLazyDeclarationResolverWithPhaseChecking : FirLazyDeclarationRe
         currentTransformerPhase = null
     }
 
-    private fun checkIfCanLazyResolveToPhase(symbol: FirBasedSymbol<*>, requestedPhase: FirResolvePhase) {
+    private fun checkIfCanLazyResolveToPhase(requestedPhase: FirResolvePhase) {
         if (!lazyResolveContractChecksEnabled) return
 
         val currentPhase = currentTransformerPhase
@@ -50,13 +51,9 @@ class FirCompilerLazyDeclarationResolverWithPhaseChecking : FirLazyDeclarationRe
         // but due to usage of already resolved stdlib classes we don't see it
         if (requestedPhase >= currentPhase) {
             exceptions += FirLazyResolveContractViolationException(
-                """`lazyResolveToPhase($requestedPhase)` cannot be called from a transformer with a phase $currentPhase.
+                currentPhase = currentPhase,
-                    lazyResolveToPhase was called on a $symbol.
+                requestedPhase = requestedPhase,
-                    `lazyResolveToPhase` can be called only from a transformer with a phase which is strictly greater than a requested phase;
-                     i.e., `lazyResolveToPhase(A)` may be only called from a lazy transformer with a phase B, where A < B. This is a contract of lazy resolve""".trimIndent()
             )
         }
     }
 }
-
-class FirLazyResolveContractViolationException(message: String) : IllegalStateException(message)