[rd debugger] Refactor: rename entities & simplify split flag usages

GitOrigin-RevId: 7915309cb9de527ded37e98b41d463cd5611f66b

java/debugger/impl/src/com/intellij/debugger/actions/monolithJavaValueUtils.kt

@@ -2,22 +2,24 @@
 package com.intellij.debugger.actions
 
 import com.intellij.debugger.engine.JavaValue
+import com.intellij.frontend.FrontendApplicationInfo
+import com.intellij.frontend.FrontendType
 import com.intellij.xdebugger.frame.XValue
 import com.intellij.xdebugger.impl.frame.XDebugManagerProxy
 import com.intellij.xdebugger.impl.frame.XDebugSessionProxy
-import com.intellij.xdebugger.impl.util.MonolithUtils
+import com.intellij.xdebugger.impl.util.XDebugMonolithUtils
 import kotlinx.coroutines.runBlocking
 
 internal fun findJavaValue(xValue: XValue, sessionProxy: XDebugSessionProxy): JavaValue? {
   if (xValue is JavaValue) return xValue
   if (!XDebugSessionProxy.useFeProxy()) return null // should be a JavaValue otherwise
-  if (!MonolithUtils.isMonolith()) return null
+  if (FrontendApplicationInfo.getFrontendType() is FrontendType.Remote) return null
   val managerProxy = XDebugManagerProxy.getInstance()
   if (!managerProxy.hasBackendCounterpart(xValue)) return null
   @Suppress("RAW_RUN_BLOCKING") // no actual suspend inside runBlocking
   return runBlocking {
     managerProxy.withId(xValue, sessionProxy) { xValueId ->
-      MonolithUtils.findXValueById(xValueId) as? JavaValue
+      XDebugMonolithUtils.findXValueById(xValueId) as? JavaValue
     }
   }
 }

java/debugger/shared/src/com/intellij/java/debugger/impl/shared/SharedJavaDebuggerManager.kt

@@ -6,7 +6,7 @@ import com.intellij.openapi.components.Service
 import com.intellij.openapi.components.service
 import com.intellij.openapi.project.Project
 import com.intellij.platform.util.coroutines.childScope
-import com.intellij.xdebugger.impl.FrontendXDebuggerManagerListener
+import com.intellij.xdebugger.impl.XDebuggerManagerProxyListener
 import com.intellij.xdebugger.impl.frame.XDebugManagerProxy
 import com.intellij.xdebugger.impl.frame.XDebugSessionProxy
 import com.intellij.xdebugger.impl.rpc.XDebugSessionId
@@ -36,7 +36,7 @@ internal class SharedJavaDebuggerManager(private val project: Project, private v
         }
       }
     }
-    project.messageBus.connect(cs).subscribe(FrontendXDebuggerManagerListener.TOPIC, object : FrontendXDebuggerManagerListener {
+    project.messageBus.connect(cs).subscribe(XDebuggerManagerProxyListener.TOPIC, object : XDebuggerManagerProxyListener {
       override fun sessionStopped(session: XDebugSessionProxy) {
         synchronousExecutor.trySend {
           debugSessions.remove(session.id)?.close()

platform/xdebugger-impl/frontend/src/com/intellij/platform/debugger/impl/frontend/FrontendXBreakpointManager.kt

@@ -18,7 +18,7 @@ import com.intellij.platform.util.coroutines.childScope
 import com.intellij.xdebugger.impl.XLineBreakpointInstallationInfo
 import com.intellij.xdebugger.impl.breakpoints.*
 import com.intellij.xdebugger.impl.breakpoints.ui.BreakpointItem
-import com.intellij.xdebugger.impl.frame.XDebugSessionProxy.Companion.useFeLineBreakpointProxy
+import com.intellij.xdebugger.impl.frame.XDebugSessionProxy.Companion.useFeProxy
 import com.intellij.xdebugger.impl.rpc.XBreakpointId
 import fleet.rpc.client.RpcClientException
 import kotlinx.coroutines.*
@@ -45,7 +45,7 @@ class FrontendXBreakpointManager(private val project: Project, private val cs: C
 
   private var _breakpointsDialogSettings: XBreakpointsDialogState? = null
 
-  private val lineBreakpointManager = XLineBreakpointManager(project, cs, isEnabled = useFeLineBreakpointProxy())
+  private val lineBreakpointManager = XLineBreakpointManager(project, cs, isEnabled = useFeProxy())
 
   private val lightBreakpoints: ConcurrentMap<LightBreakpointPosition, FrontendXLightLineBreakpoint> = ConcurrentCollectionFactory.createConcurrentMap()
 

platform/xdebugger-impl/frontend/src/com/intellij/platform/debugger/impl/frontend/FrontendXBreakpointType.kt

@@ -20,7 +20,7 @@ import com.intellij.xdebugger.impl.breakpoints.XBreakpointProxy
 import com.intellij.xdebugger.impl.breakpoints.XBreakpointTypeProxy
 import com.intellij.xdebugger.impl.breakpoints.XLineBreakpointTypeProxy
 import com.intellij.xdebugger.impl.frame.XDebugManagerProxy
-import com.intellij.xdebugger.impl.util.MonolithUtils
+import com.intellij.xdebugger.impl.util.XDebugMonolithUtils
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import javax.swing.Icon
@@ -122,28 +122,28 @@ private open class FrontendXBreakpointType(
   @Suppress("UNCHECKED_CAST")
   override fun createCustomPropertiesPanel(project: Project): XBreakpointCustomPropertiesPanel<XBreakpoint<*>>? {
     // TODO Custom panels are only supported in monolith
-    val monolithType = MonolithUtils.findBreakpointTypeById(id) ?: return null
+    val monolithType = XDebugMonolithUtils.findBreakpointTypeById(id) ?: return null
     return monolithType.createCustomPropertiesPanel(project) as XBreakpointCustomPropertiesPanel<XBreakpoint<*>>?
   }
 
   @Suppress("UNCHECKED_CAST")
   override fun createCustomConditionsPanel(): XBreakpointCustomPropertiesPanel<XBreakpoint<*>>? {
     // TODO Custom panels are only supported in monolith
-    val monolithType = MonolithUtils.findBreakpointTypeById(id) ?: return null
+    val monolithType = XDebugMonolithUtils.findBreakpointTypeById(id) ?: return null
     return monolithType.createCustomConditionsPanel() as XBreakpointCustomPropertiesPanel<XBreakpoint<*>>?
   }
 
   @Suppress("UNCHECKED_CAST")
   override fun createCustomRightPropertiesPanel(project: Project): XBreakpointCustomPropertiesPanel<XBreakpoint<*>>? {
     // TODO Custom panels are only supported in monolith
-    val monolithType = MonolithUtils.findBreakpointTypeById(id) ?: return null
+    val monolithType = XDebugMonolithUtils.findBreakpointTypeById(id) ?: return null
     return monolithType.createCustomRightPropertiesPanel(project) as XBreakpointCustomPropertiesPanel<XBreakpoint<*>>?
   }
 
   @Suppress("UNCHECKED_CAST")
   override fun createCustomTopPropertiesPanel(project: Project): XBreakpointCustomPropertiesPanel<XBreakpoint<*>>? {
     // TODO Custom panels are only supported in monolith
-    val monolithType = MonolithUtils.findBreakpointTypeById(id) ?: return null
+    val monolithType = XDebugMonolithUtils.findBreakpointTypeById(id) ?: return null
     return monolithType.createCustomTopPropertiesPanel(project) as XBreakpointCustomPropertiesPanel<XBreakpoint<*>>?
   }
 

platform/xdebugger-impl/frontend/src/com/intellij/platform/debugger/impl/frontend/FrontendXDebuggerManager.kt

@@ -19,7 +19,7 @@ import com.intellij.platform.project.projectId
 import com.intellij.ui.content.ContentManagerEvent
 import com.intellij.ui.content.ContentManagerListener
 import com.intellij.util.asDisposable
-import com.intellij.xdebugger.impl.FrontendXDebuggerManagerListener
+import com.intellij.xdebugger.impl.XDebuggerManagerProxyListener
 import com.intellij.xdebugger.impl.frame.XDebugSessionProxy
 import com.intellij.xdebugger.impl.rpc.XDebugSessionId
 import kotlinx.coroutines.CoroutineScope
@@ -105,7 +105,7 @@ class FrontendXDebuggerManager(private val project: Project, private val cs: Cor
             synchronousExecutor.trySend {
               val session = createDebuggerSession(event.sessionDto)
               if (shouldTriggerListener) {
-                project.messageBus.syncPublisher(FrontendXDebuggerManagerListener.TOPIC).sessionStarted(session)
+                project.messageBus.syncPublisher(XDebuggerManagerProxyListener.TOPIC).sessionStarted(session)
               }
             }
           }
@@ -115,7 +115,7 @@ class FrontendXDebuggerManager(private val project: Project, private val cs: Cor
                 val sessionToRemove = sessions.firstOrNull { it.id == event.sessionId }
                 if (sessionToRemove != null) {
                   if (shouldTriggerListener) {
-                    project.messageBus.syncPublisher(FrontendXDebuggerManagerListener.TOPIC).sessionStopped(sessionToRemove)
+                    project.messageBus.syncPublisher(XDebuggerManagerProxyListener.TOPIC).sessionStopped(sessionToRemove)
                   }
                   sessions - sessionToRemove
                 }
@@ -131,7 +131,7 @@ class FrontendXDebuggerManager(private val project: Project, private val cs: Cor
               val previousSession = sessions.firstOrNull { it.id == event.previousSession }
               val currentSession = sessions.firstOrNull { it.id == event.currentSession }
               if (shouldTriggerListener) {
-                project.messageBus.syncPublisher(FrontendXDebuggerManagerListener.TOPIC).activeSessionChanged(previousSession, currentSession)
+                project.messageBus.syncPublisher(XDebuggerManagerProxyListener.TOPIC).activeSessionChanged(previousSession, currentSession)
               }
             }
           }
@@ -142,7 +142,7 @@ class FrontendXDebuggerManager(private val project: Project, private val cs: Cor
         sessionsFlow.update { currentSessions ->
           if (shouldTriggerListener) {
             for (session in currentSessions) {
-              project.messageBus.syncPublisher(FrontendXDebuggerManagerListener.TOPIC).sessionStopped(session)
+              project.messageBus.syncPublisher(XDebuggerManagerProxyListener.TOPIC).sessionStopped(session)
             }
           }
           listOf()

platform/xdebugger-impl/frontend/src/com/intellij/platform/debugger/impl/frontend/FrontendXDebuggerSession.kt

@@ -43,7 +43,7 @@ import com.intellij.xdebugger.impl.rpc.*
 import com.intellij.xdebugger.impl.ui.SplitDebuggerUIUtil
 import com.intellij.xdebugger.impl.ui.XDebugSessionData
 import com.intellij.xdebugger.impl.ui.XDebugSessionTab
-import com.intellij.xdebugger.impl.util.MonolithUtils
+import com.intellij.xdebugger.impl.util.XDebugMonolithUtils
 import com.intellij.xdebugger.ui.XDebugTabLayouter
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.BufferOverflow
@@ -391,7 +391,7 @@ class FrontendXDebuggerSession private constructor(
 
   override fun createTabLayouter(): XDebugTabLayouter {
     // Additional tabs are not supported in RemDev
-    val monolithLayouter = MonolithUtils.findSessionById(id)?.debugProcess?.createTabLayouter()
+    val monolithLayouter = XDebugMonolithUtils.findSessionById(id)?.debugProcess?.createTabLayouter()
     return monolithLayouter ?: object : XDebugTabLayouter() {} // TODO support additional tabs in RemDev
   }
 
@@ -407,7 +407,7 @@ class FrontendXDebuggerSession private constructor(
 
   override fun registerAdditionalActions(leftToolbar: DefaultActionGroup, topLeftToolbar: DefaultActionGroup, settings: DefaultActionGroup) {
     // TODO: addittional actions are not registered in RemDev
-    MonolithUtils.findSessionById(id)?.debugProcess?.registerAdditionalActions(leftToolbar, topLeftToolbar, settings)
+    XDebugMonolithUtils.findSessionById(id)?.debugProcess?.registerAdditionalActions(leftToolbar, topLeftToolbar, settings)
   }
 
   override fun putKey(sink: DataSink) {

platform/xdebugger-impl/frontend/src/com/intellij/platform/debugger/impl/frontend/FrontendXLightLineBreakpoint.kt

@@ -4,12 +4,11 @@ package com.intellij.platform.debugger.impl.frontend
 import com.intellij.openapi.application.EDT
 import com.intellij.openapi.editor.markup.GutterIconRenderer
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.util.TextRange
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.platform.util.coroutines.childScope
 import com.intellij.xdebugger.impl.XLineBreakpointInstallationInfo
 import com.intellij.xdebugger.impl.breakpoints.*
-import com.intellij.xdebugger.impl.frame.XDebugSessionProxy.Companion.useFeLineBreakpointProxy
+import com.intellij.xdebugger.impl.frame.XDebugSessionProxy.Companion.useFeProxy
 import kotlinx.coroutines.*
 import javax.swing.Icon
 
@@ -22,7 +21,7 @@ internal class FrontendXLightLineBreakpoint(
 ) : XLightLineBreakpointProxy {
   private val cs = parentCs.childScope("FrontendXLightLineBreakpoint")
 
-  private val visualRepresentation = XBreakpointVisualRepresentation(cs, this, useFeLineBreakpointProxy(), breakpointManager)
+  private val visualRepresentation = XBreakpointVisualRepresentation(cs, this, useFeProxy(), breakpointManager)
 
   init {
     // TODO IJPL-185322: let's add loading icon if light breakpoint is alive for more than ~300ms

platform/xdebugger-impl/frontend/src/com/intellij/platform/debugger/impl/frontend/FrontendXLineBreakpointProxy.kt

@@ -20,7 +20,7 @@ import com.intellij.platform.debugger.impl.rpc.XLineBreakpointInfo
 import com.intellij.xdebugger.XDebuggerUtil
 import com.intellij.xdebugger.XSourcePosition
 import com.intellij.xdebugger.impl.breakpoints.*
-import com.intellij.xdebugger.impl.frame.XDebugSessionProxy.Companion.useFeLineBreakpointProxy
+import com.intellij.xdebugger.impl.frame.XDebugSessionProxy.Companion.useFeProxy
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.collectLatest
@@ -102,7 +102,7 @@ internal class FrontendXLineBreakpointProxy(
 
   private var lineSourcePosition: XSourcePosition? = null
 
-  private val visualRepresentation = XBreakpointVisualRepresentation(cs, this, useFeLineBreakpointProxy(), manager)
+  private val visualRepresentation = XBreakpointVisualRepresentation(cs, this, useFeProxy(), manager)
 
   private val lineBreakpointInfo: XLineBreakpointInfo
     get() = currentState.lineBreakpointInfo!!

platform/xdebugger-impl/frontend/src/com/intellij/platform/debugger/impl/frontend/evaluate/quick/FrontendXValue.kt

@@ -21,7 +21,7 @@ import com.intellij.xdebugger.impl.pinned.items.PinToTopParentValue
 import com.intellij.xdebugger.impl.ui.XValueTextProvider
 import com.intellij.xdebugger.impl.ui.tree.XValueExtendedPresentation
 import com.intellij.xdebugger.impl.ui.tree.nodes.XValueNodeEx
-import com.intellij.xdebugger.impl.util.MonolithUtils
+import com.intellij.xdebugger.impl.util.XDebugMonolithUtils
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.future.asCompletableFuture
@@ -223,7 +223,7 @@ class FrontendXValue private constructor(
 
   override fun getReferrersProvider(): XReferrersProvider? {
     // TODO referrersProvider is only supported in monolith
-    return MonolithUtils.findXValueById(xValueDto.id)?.referrersProvider
+    return XDebugMonolithUtils.findXValueById(xValueDto.id)?.referrersProvider
   }
 
   override fun shouldShowTextValue(): Boolean = textProvider?.value?.shouldShowTextValue ?: false

platform/xdebugger-impl/resources/META-INF/xdebugger.xml

@@ -261,6 +261,6 @@
     <listener class="com.intellij.xdebugger.impl.MonolithListenerAdapter"
               topic="com.intellij.xdebugger.XDebuggerManagerListener"/>
     <listener class="com.intellij.xdebugger.impl.ExecutionPointManagerChangeListener"
-              topic="com.intellij.xdebugger.impl.FrontendXDebuggerManagerListener"/>
+              topic="com.intellij.xdebugger.impl.XDebuggerManagerProxyListener"/>
   </projectListeners>
 </idea-plugin>

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ExecutionPointManagerChangeListener.kt

@@ -8,11 +8,11 @@ import com.intellij.xdebugger.XDebugSessionListener
 import com.intellij.xdebugger.impl.breakpoints.XBreakpointProxy
 import com.intellij.xdebugger.impl.frame.XDebugManagerProxy
 import com.intellij.xdebugger.impl.frame.XDebugSessionProxy
-import com.intellij.xdebugger.impl.util.MonolithUtils
+import com.intellij.xdebugger.impl.util.XDebugMonolithUtils
 import kotlinx.coroutines.launch
 
 
-private class ExecutionPointManagerChangeListener(val project: Project) : FrontendXDebuggerManagerListener {
+private class ExecutionPointManagerChangeListener(val project: Project) : XDebuggerManagerProxyListener {
   init {
     val breakpointsManager = XDebugManagerProxy.getInstance().getBreakpointManagerProxy(project)
 
@@ -59,7 +59,7 @@ private fun updateAfterActiveSessionChanged(
 ) {
   val executionPointManager = XDebugManagerProxy.getInstance().getDebuggerExecutionPointManager(project) ?: return
   if (currentSession != null) {
-    val xDebugSession = MonolithUtils.findSessionById(currentSession.id)
+    val xDebugSession = XDebugMonolithUtils.findSessionById(currentSession.id)
     if (xDebugSession != null) {
       executionPointManager.alternativeSourceKindFlow = xDebugSession.alternativeSourceKindState
       updateExecutionPosition(project, xDebugSession.currentSourceKind)

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/MonolithXDebugManagerProxy.kt

@@ -10,6 +10,7 @@ import com.intellij.xdebugger.frame.XExecutionStack
 import com.intellij.xdebugger.frame.XValue
 import com.intellij.xdebugger.impl.breakpoints.XBreakpointManagerImpl
 import com.intellij.xdebugger.impl.breakpoints.XBreakpointManagerProxy
+import com.intellij.xdebugger.impl.breakpoints.asProxy
 import com.intellij.xdebugger.impl.frame.XDebugManagerProxy
 import com.intellij.xdebugger.impl.frame.XDebugSessionProxy
 import com.intellij.xdebugger.impl.frame.asProxy
@@ -33,7 +34,7 @@ private class MonolithXDebugManagerProxy : XDebugManagerProxy {
   }
 
   override suspend fun <T> withId(value: XValue, session: XDebugSessionProxy, block: suspend (XValueId) -> T): T {
-    val sessionImpl = (session as XDebugSessionProxy.Monolith).session as XDebugSessionImpl
+    val sessionImpl = (session as XDebugSessionProxy.Monolith).session
     return withCoroutineScopeForId(block) { scope ->
       BackendXValueModel(scope, sessionImpl, value, precomputePresentation = false).id
     }
@@ -43,7 +44,7 @@ private class MonolithXDebugManagerProxy : XDebugManagerProxy {
   override fun getXValueId(value: XValue): XValueId? = null
 
   override suspend fun <T> withId(stack: XExecutionStack, session: XDebugSessionProxy, block: suspend (XExecutionStackId) -> T): T {
-    val sessionImpl = (session as XDebugSessionProxy.Monolith).session as XDebugSessionImpl
+    val sessionImpl = (session as XDebugSessionProxy.Monolith).session
     return withCoroutineScopeForId(block) { scope ->
       stack.getOrStoreGlobally(scope, sessionImpl)
     }
@@ -60,7 +61,8 @@ private class MonolithXDebugManagerProxy : XDebugManagerProxy {
   }
 
   override fun getBreakpointManagerProxy(project: Project): XBreakpointManagerProxy {
-    return XBreakpointManagerProxy.Monolith(XDebuggerManager.getInstance(project).breakpointManager as XBreakpointManagerImpl)
+    val manager = XDebuggerManager.getInstance(project).breakpointManager as XBreakpointManagerImpl
+    return manager.asProxy()
   }
 
   override fun getDebuggerExecutionPointManager(project: Project): XDebuggerExecutionPointManager? {

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/XDebugSessionImpl.kt

@@ -61,7 +61,6 @@ import com.intellij.xdebugger.impl.breakpoints.XLineBreakpointImpl
 import com.intellij.xdebugger.impl.evaluate.ValueLookupManagerController
 import com.intellij.xdebugger.impl.frame.*
 import com.intellij.xdebugger.impl.frame.XDebugSessionProxy.Companion.showFeWarnings
-import com.intellij.xdebugger.impl.frame.XDebugSessionProxy.Companion.useFeLineBreakpointProxy
 import com.intellij.xdebugger.impl.frame.XDebugSessionProxy.Companion.useFeProxy
 import com.intellij.xdebugger.impl.inline.DebuggerInlayListener
 import com.intellij.xdebugger.impl.inline.InlineDebugRenderer
@@ -209,7 +208,7 @@ class XDebugSessionImpl @JvmOverloads constructor(
     get() = myTabInitDataFlow.filterNotNull()
 
   override fun getRunContentDescriptor(): RunContentDescriptor {
-    if (useFeProxy() && showFeWarnings()) {
+    if (showFeWarnings()) {
       LOG.error("RunContentDescriptor should not be used in split mode from XDebugSession")
     }
     return getInitializedRunContentDescriptor()
@@ -429,7 +428,7 @@ class XDebugSessionImpl @JvmOverloads constructor(
   @OptIn(ExperimentalCoroutinesApi::class)
   val sessionTab: XDebugSessionTab?
     get() {
-      if (useFeProxy() && showFeWarnings()) {
+      if (showFeWarnings()) {
         // See "TODO [Debugger.sessionTab]" to see usages which are not yet properly migrated.
         LOG.error("Debug tab should not be used in split mode from XDebugSession")
       }
@@ -874,8 +873,8 @@ class XDebugSessionImpl @JvmOverloads constructor(
       }
     }
     val debuggerManager = myDebuggerManager.breakpointManager
-    if (useFeLineBreakpointProxy() && breakpoint is XLineBreakpointImpl<*>) {
-      // for useFeLineBreakpointProxy we call update directly since visual presentation is disabled on the backend
+    if (useFeProxy() && breakpoint is XLineBreakpointImpl<*>) {
+      // for useFeProxy we call update directly since visual presentation is disabled on the backend
       breakpoint.fireBreakpointPresentationUpdated(this)
     }
     else {

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/XDebuggerManagerProxyListener.kt

@@ -12,10 +12,10 @@ import com.intellij.xdebugger.impl.frame.asProxy
 import org.jetbrains.annotations.ApiStatus
 
 /**
- * Frontend-side analogue of [com.intellij.xdebugger.XDebuggerManagerListener]
+ * [XDebugSessionProxy] analogue of [com.intellij.xdebugger.XDebuggerManagerListener]
  */
 @ApiStatus.Internal
-interface FrontendXDebuggerManagerListener {
+interface XDebuggerManagerProxyListener {
   fun sessionStarted(session: XDebugSessionProxy) {}
   fun sessionStopped(session: XDebugSessionProxy) {}
   fun activeSessionChanged(previousSession: XDebugSessionProxy?, currentSession: XDebugSessionProxy?) {}
@@ -23,8 +23,8 @@ interface FrontendXDebuggerManagerListener {
   companion object {
     @JvmField
     @Topic.ProjectLevel
-    val TOPIC: Topic<FrontendXDebuggerManagerListener> =
-      Topic("FrontendXDebuggerManager events", FrontendXDebuggerManagerListener::class.java)
+    val TOPIC: Topic<XDebuggerManagerProxyListener> =
+      Topic("XDebuggerManagerListener proxy events", XDebuggerManagerProxyListener::class.java)
   }
 }
 
@@ -38,19 +38,19 @@ private class MonolithListenerAdapter : XDebuggerManagerListener {
   override fun processStarted(debugProcess: XDebugProcess) {
     if (!shouldTriggerListener) return
     val session = debugProcess.session
-    session.project.messageBus.syncPublisher(FrontendXDebuggerManagerListener.TOPIC).sessionStarted(session.asProxy())
+    session.project.messageBus.syncPublisher(XDebuggerManagerProxyListener.TOPIC).sessionStarted(session.asProxy())
   }
 
   override fun processStopped(debugProcess: XDebugProcess) {
     if (!shouldTriggerListener) return
     val session = debugProcess.session
-    session.project.messageBus.syncPublisher(FrontendXDebuggerManagerListener.TOPIC).sessionStopped(session.asProxy())
+    session.project.messageBus.syncPublisher(XDebuggerManagerProxyListener.TOPIC).sessionStopped(session.asProxy())
   }
 
   override fun currentSessionChanged(previousSession: XDebugSession?, currentSession: XDebugSession?) {
     if (!shouldTriggerListener) return
     val project = previousSession?.project ?: currentSession?.project ?: return
-    project.messageBus.syncPublisher(FrontendXDebuggerManagerListener.TOPIC).activeSessionChanged(previousSession?.asProxy(),
-                                                                                                  currentSession?.asProxy())
+    project.messageBus.syncPublisher(XDebuggerManagerProxyListener.TOPIC).activeSessionChanged(previousSession?.asProxy(),
+                                                                                               currentSession?.asProxy())
   }
 }

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/BreakpointGutterIconRenderer.java

@@ -13,7 +13,7 @@ import com.intellij.xdebugger.impl.XDebugSessionImpl;
 import com.intellij.xdebugger.impl.actions.EditBreakpointAction;
 import com.intellij.xdebugger.impl.frame.XDebugManagerProxy;
 import com.intellij.xdebugger.impl.frame.XDebugSessionProxy;
-import com.intellij.xdebugger.impl.util.MonolithUtils;
+import com.intellij.xdebugger.impl.util.XDebugMonolithUtils;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -71,8 +71,8 @@ public final class BreakpointGutterIconRenderer extends CommonBreakpointGutterIc
   public @Nullable ActionGroup getPopupMenuActions() {
     XDebugSessionProxy currentSessionProxy = XDebugManagerProxy.getInstance().getCurrentSessionProxy(myBreakpoint.getProject());
     if (currentSessionProxy != null) {
-      XDebugSessionImpl debugSession = MonolithUtils.findSessionById(currentSessionProxy.getId());
-      XBreakpointBase<?, ?, ?> breakpoint = MonolithUtils.findBreakpointById(myBreakpoint.getId());
+      XDebugSessionImpl debugSession = XDebugMonolithUtils.findSessionById(currentSessionProxy.getId());
+      XBreakpointBase<?, ?, ?> breakpoint = XDebugMonolithUtils.findBreakpointById(myBreakpoint.getId());
       if (debugSession != null && breakpoint != null) {
         return new DefaultActionGroup(breakpoint.getAdditionalPopupMenuActions(debugSession));
       }

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointManagerImpl.java

@@ -46,7 +46,7 @@ import java.util.function.Function;
 
 import static com.intellij.util.progress.CancellationUtil.withLockMaybeCancellable;
 import static com.intellij.xdebugger.impl.breakpoints.XBreakpointProxyKt.asProxy;
-import static com.intellij.xdebugger.impl.frame.XDebugSessionProxy.useFeLineBreakpointProxy;
+import static com.intellij.xdebugger.impl.frame.XDebugSessionProxy.useFeProxy;
 
 @ApiStatus.Internal
 public final class XBreakpointManagerImpl implements XBreakpointManager {
@@ -79,7 +79,7 @@ public final class XBreakpointManagerImpl implements XBreakpointManager {
     myDebuggerManager = debuggerManager;
     myCoroutineScope = coroutineScope;
     myDependentBreakpointManager = new XDependentBreakpointManager(this, messageBusConnection);
-    myLineBreakpointManager = new XLineBreakpointManager(project, coroutineScope, !useFeLineBreakpointProxy());
+    myLineBreakpointManager = new XLineBreakpointManager(project, coroutineScope, !useFeProxy());
 
     XBreakpointType.EXTENSION_POINT_NAME.addExtensionPointListener(new ExtensionPointListener<>() {
       @SuppressWarnings("unchecked")

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointManagerProxy.kt

@@ -3,7 +3,6 @@ package com.intellij.xdebugger.impl.breakpoints
 
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.WriteAction
-import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.util.ThrowableRunnable
@@ -13,8 +12,6 @@ import com.intellij.xdebugger.impl.breakpoints.ui.BreakpointItem
 import com.intellij.xdebugger.impl.rpc.XBreakpointId
 import org.jetbrains.annotations.ApiStatus
 
-private val LOG = logger<XBreakpointManagerProxy>()
-
 @ApiStatus.Internal
 interface XBreakpointManagerProxy {
   val breakpointsDialogSettings: XBreakpointsDialogState?
@@ -55,7 +52,11 @@ interface XBreakpointManagerProxy {
 
   suspend fun <T> withLightBreakpointIfPossible(editor: Editor?, info: XLineBreakpointInstallationInfo, block: suspend () -> T): T
 
-  class Monolith(val breakpointManager: XBreakpointManagerImpl) : XBreakpointManagerProxy {
+  companion object {
+    internal fun asProxy(breakpointManager: XBreakpointManagerImpl): XBreakpointManagerProxy = Monolith(breakpointManager)
+  }
+
+  private class Monolith(val breakpointManager: XBreakpointManagerImpl) : XBreakpointManagerProxy {
     override val breakpointsDialogSettings: XBreakpointsDialogState?
       get() = breakpointManager.breakpointsDialogSettings
 
@@ -165,4 +166,6 @@ interface XBreakpointManagerProxy {
       return block()
     }
   }
-}
+}
+
+internal fun XBreakpointManagerImpl.asProxy(): XBreakpointManagerProxy = XBreakpointManagerProxy.asProxy(this)

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XLineBreakpointImpl.java

@@ -22,13 +22,13 @@ import org.jetbrains.annotations.Nullable;
 import java.io.File;
 
 import static com.intellij.xdebugger.impl.breakpoints.XBreakpointProxyKt.asProxy;
-import static com.intellij.xdebugger.impl.frame.XDebugSessionProxy.useFeLineBreakpointProxy;
+import static com.intellij.xdebugger.impl.frame.XDebugSessionProxy.useFeProxy;
 
 @ApiStatus.Internal
 public final class XLineBreakpointImpl<P extends XBreakpointProperties> extends XBreakpointBase<XLineBreakpoint<P>, P, LineBreakpointState>
   implements XLineBreakpoint<P> {
 
-  // TODO IJPL-185322 move to some external manager
+  // for monolith compatibility only
   private final XBreakpointVisualRepresentation myVisualRepresentation;
 
   private final XLineBreakpointType<P> myType;
@@ -39,11 +39,14 @@ public final class XLineBreakpointImpl<P extends XBreakpointProperties> extends
                              final @Nullable P properties, LineBreakpointState state) {
     super(type, breakpointManager, properties, state);
     myType = type;
-    myVisualRepresentation = new XBreakpointVisualRepresentation(getCoroutineScope(), asProxy(this), !useFeLineBreakpointProxy(),
-                                                                 new XBreakpointManagerProxy.Monolith(breakpointManager));
+    myVisualRepresentation = new XBreakpointVisualRepresentation(getCoroutineScope(), asProxy(this), !useFeProxy(),
+                                                                 XBreakpointManagerProxyKt.asProxy(breakpointManager));
   }
 
-  // TODO IJPL-185322 migrate to backend -> frontend rpc flow notification
+  /**
+   * @deprecated The platform handles Breakpoint UI update on the frontend
+   */
+  @Deprecated
   public void updateUI() {
     myVisualRepresentation.updateUI();
   }

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/ui/XLightBreakpointPropertiesPanel.java

@@ -25,7 +25,7 @@ import com.intellij.xdebugger.impl.XDebuggerUtilImpl;
 import com.intellij.xdebugger.impl.breakpoints.*;
 import com.intellij.xdebugger.impl.ui.DebuggerUIUtil;
 import com.intellij.xdebugger.impl.ui.XDebuggerExpressionComboBox;
-import com.intellij.xdebugger.impl.util.MonolithUtils;
+import com.intellij.xdebugger.impl.util.XDebugMonolithUtils;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Nls;
 import org.jetbrains.annotations.NotNull;
@@ -126,9 +126,13 @@ public class XLightBreakpointPropertiesPanel implements XSuspendPolicyPanel.Dele
     this(project, breakpointManager, breakpoint, showAllOptions, showAllOptions, isEditorBalloon);
   }
 
+  /**
+   * @deprecated Use the proxy option instead
+   */
+  @Deprecated
   public XLightBreakpointPropertiesPanel(Project project, XBreakpointManager breakpointManager, XBreakpointBase breakpoint,
                                          boolean showActionOptions, boolean showAllOptions, boolean isEditorBalloon) {
-    this(project, new XBreakpointManagerProxy.Monolith((XBreakpointManagerImpl)breakpointManager),
+    this(project, XBreakpointManagerProxyKt.asProxy((XBreakpointManagerImpl)breakpointManager),
          asProxy(breakpoint), showActionOptions, showAllOptions, isEditorBalloon);
   }
 
@@ -214,7 +218,7 @@ public class XLightBreakpointPropertiesPanel implements XSuspendPolicyPanel.Dele
     XBreakpointCustomPropertiesPanel customRightConditionPanel = breakpointType.createCustomRightPropertiesPanel(project);
     boolean isVisibleOnPopup = false;
     if (customRightConditionPanel != null) {
-      XBreakpointBase<?, ?, ?> monolithBreakpoint = MonolithUtils.findBreakpointById(myBreakpoint.getId());
+      XBreakpointBase<?, ?, ?> monolithBreakpoint = XDebugMonolithUtils.findBreakpointById(myBreakpoint.getId());
       if (monolithBreakpoint != null) {
         isVisibleOnPopup = customRightConditionPanel.isVisibleOnPopup(monolithBreakpoint);
       }
@@ -298,7 +302,7 @@ public class XLightBreakpointPropertiesPanel implements XSuspendPolicyPanel.Dele
       myConditionComboBox.saveTextInHistory();
     }
 
-    XBreakpointBase<?, ?, ?> monolithBreakpoint = MonolithUtils.findBreakpointById(myBreakpoint.getId());
+    XBreakpointBase<?, ?, ?> monolithBreakpoint = XDebugMonolithUtils.findBreakpointById(myBreakpoint.getId());
     if (monolithBreakpoint != null) {
       for (XBreakpointCustomPropertiesPanel customPanel : myCustomPanels) {
         customPanel.saveTo(monolithBreakpoint);
@@ -331,7 +335,7 @@ public class XLightBreakpointPropertiesPanel implements XSuspendPolicyPanel.Dele
       onCheckboxChanged();
     }
 
-    XBreakpointBase<?, ?, ?> monolithBreakpoint = MonolithUtils.findBreakpointById(myBreakpoint.getId());
+    XBreakpointBase<?, ?, ?> monolithBreakpoint = XDebugMonolithUtils.findBreakpointById(myBreakpoint.getId());
     if (monolithBreakpoint != null) {
       for (XBreakpointCustomPropertiesPanel customPanel : myCustomPanels) {
         customPanel.loadFrom(monolithBreakpoint);

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/frame/XDebugSessionProxy.kt

@@ -126,63 +126,59 @@ interface XDebugSessionProxy {
     }
 
     @JvmStatic
-    fun useFeLineBreakpointProxy(): Boolean = useFeProxy()
-
-    @JvmStatic
-    fun showFeWarnings(): Boolean = Registry.`is`("xdebugger.toolwindow.split.warnings")
+    fun showFeWarnings(): Boolean = useFeProxy() && Registry.`is`("xdebugger.toolwindow.split.warnings")
   }
 
-  // TODO WeakReference<XDebugSession>?
-  class Monolith(val session: XDebugSession) : XDebugSessionProxy {
+  class Monolith internal constructor(val session: XDebugSessionImpl) : XDebugSessionProxy {
     override val runContentDescriptorId: RunContentDescriptorIdImpl?
-      get() = (session as XDebugSessionImpl).getRunContentDescriptorIfInitialized()?.id as RunContentDescriptorIdImpl?
+      get() = session.getRunContentDescriptorIfInitialized()?.id as RunContentDescriptorIdImpl?
 
     override val project: Project
       get() = session.project
     override val id: XDebugSessionId
-      get() = (session as XDebugSessionImpl).id
+      get() = session.id
     override val sessionName: String
       get() = session.sessionName
     override val sessionData: XDebugSessionData
-      get() = (session as XDebugSessionImpl).sessionData
+      get() = session.sessionData
     override val consoleView: ConsoleView?
       get() = session.consoleView
     override val restartActions: List<AnAction>
-      get() = (session as? XDebugSessionImpl)?.restartActions ?: emptyList()
+      get() = session.restartActions
     override val extraActions: List<AnAction>
-      get() = (session as? XDebugSessionImpl)?.extraActions ?: emptyList()
+      get() = session.extraActions
     override val extraStopActions: List<AnAction>
-      get() = (session as? XDebugSessionImpl)?.extraStopActions ?: emptyList()
+      get() = session.extraStopActions
     override val consoleActions: List<AnAction>
       get() = consoleView?.createConsoleActions()?.toList() ?: emptyList()
     override val processHandler: ProcessHandler
       get() = session.debugProcess.processHandler
     override val coroutineScope: CoroutineScope
-      get() = (session as XDebugSessionImpl).coroutineScope
+      get() = session.coroutineScope
     override val editorsProvider: XDebuggerEditorsProvider
       get() = session.debugProcess.editorsProvider
     override val valueMarkers: XValueMarkers<*, *>?
-      get() = (session as? XDebugSessionImpl)?.valueMarkers
+      get() = session.valueMarkers
     override val sessionTab: XDebugSessionTab?
-      get() = (session as? XDebugSessionImpl)?.sessionTab
+      get() = session.sessionTab
     override val sessionTabWhenInitialized: Deferred<XDebugSessionTab>
-      get() = (session as XDebugSessionImpl).sessionTabDeferred
+      get() = session.sessionTabDeferred
     override val isPaused: Boolean
       get() = session.isPaused
     override val isStopped: Boolean
       get() = session.isStopped
     override val isReadOnly: Boolean
-      get() = (session as? XDebugSessionImpl)?.isReadOnly ?: false
+      get() = session.isReadOnly
     override val isSuspended: Boolean
       get() = session.isSuspended
     override val isPauseActionSupported: Boolean
-      get() = (session as? XDebugSessionImpl)?.isPauseActionSupported() ?: false
+      get() = session.isPauseActionSupported()
     override val isStepOverActionAllowed: Boolean
-      get() = (session as? XDebugSessionImpl)?.isStepOverActionAllowed ?: true
+      get() = session.isStepOverActionAllowed
     override val isStepOutActionAllowed: Boolean
-      get() = (session as? XDebugSessionImpl)?.isStepOutActionAllowed ?: true
+      get() = session.isStepOutActionAllowed
     override val isRunToCursorActionAllowed: Boolean
-      get() = (session as? XDebugSessionImpl)?.isRunToCursorActionAllowed ?: true
+      get() = session.isRunToCursorActionAllowed
     override val isLibraryFrameFilterSupported: Boolean
       get() = session.debugProcess.isLibraryFrameFilterSupported
     override val isValuesCustomSorted: Boolean
@@ -205,9 +201,10 @@ interface XDebugSessionProxy {
     }
 
     override val currentSuspendContextCoroutineScope: CoroutineScope?
-      get() = (session as XDebugSessionImpl).currentSuspendCoroutineScope
+      get() = session.currentSuspendCoroutineScope
 
-    override val activeNonLineBreakpointFlow: Flow<XBreakpointProxy?> get() = (session as XDebugSessionImpl)
+    override val activeNonLineBreakpointFlow: Flow<XBreakpointProxy?>
+      get() = session
       .activeNonLineBreakpointFlow.map { (it as? XBreakpointBase<*, *, *>)?.asProxy() }
 
     override fun getCurrentPosition(): XSourcePosition? {
@@ -219,15 +216,15 @@ interface XDebugSessionProxy {
     }
 
     override fun getFrameSourcePosition(frame: XStackFrame): XSourcePosition? {
-      return (session as? XDebugSessionImpl)?.getFrameSourcePosition(frame)
+      return session.getFrameSourcePosition(frame)
     }
 
     override fun getFrameSourcePosition(frame: XStackFrame, sourceKind: XSourceKind): XSourcePosition? {
-      return (session as? XDebugSessionImpl)?.getFrameSourcePosition(frame, sourceKind)
+      return session.getFrameSourcePosition(frame, sourceKind)
     }
 
     override fun getCurrentExecutionStack(): XExecutionStack? {
-      return (session as? XDebugSessionImpl)?.currentExecutionStack
+      return session.currentExecutionStack
     }
 
     override fun getCurrentStackFrame(): XStackFrame? {
@@ -235,11 +232,11 @@ interface XDebugSessionProxy {
     }
 
     override fun setCurrentStackFrame(executionStack: XExecutionStack, frame: XStackFrame, isTopFrame: Boolean) {
-      (session as? XDebugSessionImpl)?.setCurrentStackFrame(executionStack, frame, isTopFrame)
+      session.setCurrentStackFrame(executionStack, frame, isTopFrame)
     }
 
     override fun isTopFrameSelected(): Boolean {
-      return (session as? XDebugSessionImpl)?.isTopFrameSelected ?: false
+      return session.isTopFrameSelected
     }
 
     override fun hasSuspendContext(): Boolean {
@@ -273,7 +270,7 @@ interface XDebugSessionProxy {
     }
 
     override fun createFileColorsCache(framesList: XDebuggerFramesList): XStackFramesListColorsCache {
-      return XStackFramesListColorsCache.Monolith(session as XDebugSessionImpl, framesList)
+      return XStackFramesListColorsCache.Monolith(session, framesList)
     }
 
     override fun areBreakpointsMuted(): Boolean {
@@ -288,7 +285,7 @@ interface XDebugSessionProxy {
       if (breakpoint !is XBreakpointProxy.Monolith) {
         return false
       }
-      return (session as XDebugSessionImpl).isInactiveSlaveBreakpoint(breakpoint.breakpoint)
+      return session.isInactiveSlaveBreakpoint(breakpoint.breakpoint)
     }
 
     override fun getDropFrameHandler(): XDropFrameHandler? {
@@ -296,7 +293,7 @@ interface XDebugSessionProxy {
     }
 
     override fun getActiveNonLineBreakpoint(): XBreakpointProxy? {
-      val breakpoint = (session as XDebugSessionImpl).activeNonLineBreakpoint ?: return null
+      val breakpoint = session.activeNonLineBreakpoint ?: return null
       if (breakpoint !is XBreakpointBase<*, *, *>) return null
       return breakpoint.asProxy()
     }

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/frame/XDebugSessionProxyKeeper.kt

@@ -6,6 +6,7 @@ import com.intellij.openapi.components.service
 import com.intellij.openapi.components.serviceIfCreated
 import com.intellij.openapi.project.Project
 import com.intellij.xdebugger.XDebugSession
+import com.intellij.xdebugger.impl.XDebugSessionImpl
 import org.jetbrains.annotations.ApiStatus
 
 @Service(Service.Level.PROJECT)
@@ -13,6 +14,7 @@ internal class XDebugSessionProxyKeeper {
   private val proxyMap = mutableMapOf<XDebugSession, XDebugSessionProxy>()
 
   fun getOrCreateProxy(session: XDebugSession): XDebugSessionProxy {
+    session as XDebugSessionImpl
     return proxyMap.getOrPut(session) { XDebugSessionProxy.Monolith(session) }
   }
 

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/frame/XVariablesView.java

@@ -111,7 +111,7 @@ public class XVariablesView extends XVariablesViewBase {
                                                      proxy + " of type " + proxy.getClass() + " instead");
       return null;
     }
-    return (XDebugSessionImpl)monolith.getSession();
+    return monolith.getSession();
   }
 
   @ApiStatus.Internal

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/inline/InlineValuePopupProvider.java

@@ -1,7 +1,6 @@
 // Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.xdebugger.impl.inline;
 
-import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.extensions.ExtensionPointName;
 import com.intellij.xdebugger.XDebugSession;
@@ -46,7 +45,7 @@ public interface InlineValuePopupProvider {
       showPopup(xValueNode, monolith.getSession(), position, treeCreator, editor, point, hideRunnable);
     }
     else {
-      Logger.getInstance(InlineValuePopupProvider.class).error("Non-monolith proxy is not supported. Please override this method.");
+      throw new AbstractMethodError("Non-monolith proxy is not supported. Please override this method.");
     }
   }
 }

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/inline/XDebuggerInlayUtil.java

@@ -21,7 +21,7 @@ import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.ui.EDT;
 import com.intellij.xdebugger.XDebuggerUtil;
 import com.intellij.xdebugger.XSourcePosition;
-import com.intellij.xdebugger.impl.FrontendXDebuggerManagerListener;
+import com.intellij.xdebugger.impl.XDebuggerManagerProxyListener;
 import com.intellij.xdebugger.impl.frame.XDebugSessionProxy;
 import com.intellij.xdebugger.impl.frame.XVariablesView;
 import com.intellij.xdebugger.impl.ui.DebuggerUIUtil;
@@ -47,7 +47,7 @@ public final class XDebuggerInlayUtil {
 
   XDebuggerInlayUtil(Project project) {
     myProject = project;
-    project.getMessageBus().connect().subscribe(FrontendXDebuggerManagerListener.TOPIC, new FrontendXDebuggerManagerListener() {
+    project.getMessageBus().connect().subscribe(XDebuggerManagerProxyListener.TOPIC, new XDebuggerManagerProxyListener() {
       @Override
       public void sessionStopped(@NotNull XDebugSessionProxy session) {
         XVariablesView.InlineVariablesInfo.set(session, null);

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ui/DebuggerUIUtil.java

@@ -3,6 +3,8 @@ package com.intellij.xdebugger.impl.ui;
 
 import com.intellij.codeInsight.hint.HintUtil;
 import com.intellij.codeWithMe.ClientId;
+import com.intellij.frontend.FrontendApplicationInfo;
+import com.intellij.frontend.FrontendType;
 import com.intellij.ide.nls.NlsMessages;
 import com.intellij.ide.ui.AntiFlickeringPanel;
 import com.intellij.openapi.Disposable;
@@ -61,7 +63,6 @@ import com.intellij.xdebugger.impl.ui.tree.XDebuggerTree;
 import com.intellij.xdebugger.impl.ui.tree.XDebuggerTreeState;
 import com.intellij.xdebugger.impl.ui.tree.nodes.XValueNodeImpl;
 import com.intellij.xdebugger.impl.ui.visualizedtext.VisualizedTextPopupUtil;
-import com.intellij.xdebugger.impl.util.MonolithUtils;
 import one.util.streamex.StreamEx;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NonNls;
@@ -75,7 +76,6 @@ import java.awt.event.*;
 import static com.intellij.openapi.wm.IdeFocusManager.getGlobalInstance;
 import static com.intellij.xdebugger.impl.breakpoints.XBreakpointProxyKt.asProxy;
 import static com.intellij.xdebugger.impl.frame.XDebugSessionProxy.showFeWarnings;
-import static com.intellij.xdebugger.impl.frame.XDebugSessionProxy.useFeProxy;
 
 public final class DebuggerUIUtil {
   public static final @NonNls String FULL_VALUE_POPUP_DIMENSION_KEY = "XDebugger.FullValuePopup";
@@ -554,7 +554,7 @@ public final class DebuggerUIUtil {
    * Use {@link DebuggerUIUtil#getSessionProxy(AnActionEvent)} instead.
    */
   public static @Nullable XDebugSession getSession(@NotNull AnActionEvent e) {
-    if (showFeWarnings() && useFeProxy() && !MonolithUtils.isMonolith()) {
+    if (showFeWarnings() && FrontendApplicationInfo.INSTANCE.getFrontendType() instanceof FrontendType.Remote) {
       LOG.error("In Split mode DebuggerUIUtil#getSession(AnActionEvent) should not be called from the frontend. " +
                 "Please use DebuggerUIUtil#getSessionProxy(AnActionEvent) instead.");
     }

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ui/XDebugSessionTab3.kt

@@ -52,7 +52,7 @@ class XDebugSessionTab3(
   private fun getWatchesViewImpl(sessionProxy: XDebugSessionProxy, watchesIsVariables: Boolean): XWatchesViewImpl {
     if (sessionProxy is XDebugSessionProxy.Monolith) {
       val session = sessionProxy.session
-      if (session.debugProcess.useSplitterView() && session is XDebugSessionImpl) { // TODO terekhin migrate Immediate window to using new debugger API
+      if (session.debugProcess.useSplitterView()) { // TODO terekhin migrate Immediate window to using new debugger API
         return XSplitterWatchesViewImpl(session, watchesIsVariables, true, withToolbar = false)
       }
     }

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ui/tree/XDebuggerTree.java

@@ -476,7 +476,7 @@ public class XDebuggerTree extends DnDAwareTree implements UiCompatibleDataProvi
   }
 
   public static @NotNull List<XValueNodeImpl> getSelectedNodes(@NotNull DataContext context) {
-    if (showFeWarnings() && useFeProxy() && AppMode.isRemoteDevHost()) {
+    if (showFeWarnings() && AppMode.isRemoteDevHost()) {
       LOG.error("""
         XDebuggerTree.getSelectedNodes should not be called on the backend as it returns frontend node instances (XValueNodeImpl) which are only available on the frontend.
         The action will not work correctly in Split mode. Please use XDebuggerTreeBackendOnlyActionBase to make your action backend-only and operates with XValue instances instead."""

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ui/tree/actions/ShowReferringObjectsAction.java

@@ -17,7 +17,7 @@ import com.intellij.xdebugger.impl.ui.DebuggerUIUtil;
 import com.intellij.xdebugger.impl.ui.tree.XDebuggerTree;
 import com.intellij.xdebugger.impl.ui.tree.XInspectDialog;
 import com.intellij.xdebugger.impl.ui.tree.nodes.XValueNodeImpl;
-import com.intellij.xdebugger.impl.util.MonolithUtils;
+import com.intellij.xdebugger.impl.util.XDebugMonolithUtils;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -70,7 +70,7 @@ public class ShowReferringObjectsAction extends XDebuggerTreeActionBase
       XValue referringObjectsRoot = referrersProvider.getReferringObjectsValue();
       DialogWrapper dialog;
       // TODO ReferrersTreeCustomizer is supported only in monolith
-      XDebugSession xDebugSession = MonolithUtils.findSessionById(session.getId());
+      XDebugSession xDebugSession = XDebugMonolithUtils.findSessionById(session.getId());
       if (xDebugSession != null && referringObjectsRoot instanceof ReferrersTreeCustomizer referrersTreeCustomizer) {
         dialog = referrersTreeCustomizer.getDialog(xDebugSession, nodeName, position, markers);
       }

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/util/XDebugMonolithUtils.kt

@@ -16,9 +16,8 @@ import com.intellij.xdebugger.impl.rpc.models.findValue
 import org.jetbrains.annotations.ApiStatus
 
 @ApiStatus.Internal
-object MonolithUtils {
-  @JvmStatic
-  fun isMonolith(): Boolean = FrontendApplicationInfo.getFrontendType() is FrontendType.Monolith
+object XDebugMonolithUtils {
+  private fun isMonolithOrBackend(): Boolean = FrontendApplicationInfo.getFrontendType() is FrontendType.Monolith
 
   /**
    * Provides access to the backend debug session by its ID.
@@ -27,7 +26,7 @@ object MonolithUtils {
    */
   @JvmStatic
   fun findSessionById(sessionId: XDebugSessionId): XDebugSessionImpl? {
-    if (!isMonolith()) return null
+    if (!isMonolithOrBackend()) return null
     return sessionId.findValue()
   }
 
@@ -37,7 +36,7 @@ object MonolithUtils {
    * Use this method only for components that should be available in monolith only.
    */
   fun findXValueById(xValueId: XValueId): XValue? {
-    if (!isMonolith()) return null
+    if (!isMonolithOrBackend()) return null
     return BackendXValueModel.findById(xValueId)?.xValue
   }
 
@@ -47,7 +46,7 @@ object MonolithUtils {
    * Use this method only for components that should be available in monolith only.
    */
   fun findBreakpointTypeById(id: String): XBreakpointType<*, *>? {
-    if (!isMonolith()) return null
+    if (!isMonolithOrBackend()) return null
     return XBreakpointUtil.findType(id)
   }
 
@@ -58,7 +57,7 @@ object MonolithUtils {
    */
   @JvmStatic
   fun findBreakpointById(breakpointId: XBreakpointId): XBreakpointBase<*, *, *>? {
-    if (!isMonolith()) return null
+    if (!isMonolithOrBackend()) return null
     return breakpointId.findValue()
   }
 }

plugins/kotlin/jvm-debugger/coroutines/src/org/jetbrains/kotlin/idea/debugger/coroutine/DebuggerConnection.kt

@@ -21,9 +21,9 @@ import com.intellij.ui.content.ContentManagerEvent
 import com.intellij.ui.content.ContentManagerListener
 import com.intellij.util.messages.MessageBusConnection
 import com.intellij.xdebugger.XDebugSession
-import com.intellij.xdebugger.impl.FrontendXDebuggerManagerListener
+import com.intellij.xdebugger.impl.XDebuggerManagerProxyListener
 import com.intellij.xdebugger.impl.frame.XDebugSessionProxy
-import com.intellij.xdebugger.impl.util.MonolithUtils
+import com.intellij.xdebugger.impl.util.XDebugMonolithUtils
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import org.jetbrains.kotlin.idea.debugger.coroutine.util.CreateContentParamsProvider
@@ -38,7 +38,7 @@ class DebuggerConnection(
     // Used externally on the Android Studio side
     @Suppress("MemberVisibilityCanBePrivate")
     val alwaysShowPanel: Boolean = false
-) : FrontendXDebuggerManagerListener, Disposable {
+) : XDebuggerManagerProxyListener, Disposable {
     companion object {
         private val log by logger
     }
@@ -57,12 +57,12 @@ class DebuggerConnection(
         }
 
         connection = project.messageBus.connect()
-        connection?.subscribe(FrontendXDebuggerManagerListener.TOPIC, this)
+        connection?.subscribe(XDebuggerManagerProxyListener.TOPIC, this)
     }
 
     override fun sessionStarted(session: XDebugSessionProxy) {
         // Coroutines view is only supported in monolith
-        val monolithSession = MonolithUtils.findSessionById(session.id) ?: return
+        val monolithSession = XDebugMonolithUtils.findSessionById(session.id) ?: return
         session.coroutineScope.launch(Dispatchers.EDT) {
             session.sessionTabWhenInitialized.await()
             val debugProcess = monolithSession.debugProcess

plugins/kotlin/jvm-debugger/coroutines/src/org/jetbrains/kotlin/idea/debugger/coroutine/DisableCoroutineViewListener.kt

@@ -6,10 +6,10 @@ import com.intellij.openapi.application.runInEdt
 import com.intellij.openapi.util.registry.Registry
 import com.intellij.util.asDisposable
 import com.intellij.xdebugger.XDebugSessionListener
-import com.intellij.xdebugger.impl.FrontendXDebuggerManagerListener
+import com.intellij.xdebugger.impl.XDebuggerManagerProxyListener
 import com.intellij.xdebugger.impl.frame.XDebugSessionProxy
 
-private class DisableCoroutineViewListener : FrontendXDebuggerManagerListener {
+private class DisableCoroutineViewListener : XDebuggerManagerProxyListener {
     override fun sessionStarted(session: XDebugSessionProxy) {
         session.addSessionListener(object : XDebugSessionListener {
             private var isFirstTimePaused = true

plugins/kotlin/plugin/common/resources/META-INF/jvm-debugger.xml

@@ -13,7 +13,7 @@
   <projectListeners>
     <listener class="org.jetbrains.kotlin.idea.debugger.evaluate.DropCodeFragmentCacheOnRefreshListener" topic="com.intellij.debugger.impl.DebuggerManagerListener"/>
     <listener class="org.jetbrains.kotlin.idea.debugger.coroutine.DisableCoroutineViewListener"
-              topic="com.intellij.xdebugger.impl.FrontendXDebuggerManagerListener"/>
+              topic="com.intellij.xdebugger.impl.XDebuggerManagerProxyListener"/>
   </projectListeners>
 
   <extensionPoints>

plugins/stream-debugger-core/intellij.debugger.streams.shared/src/com/intellij/debugger/streams/shared/StreamDebuggerManager.kt

@@ -4,7 +4,7 @@ import com.intellij.openapi.components.Service
 import com.intellij.openapi.components.service
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.startup.ProjectActivity
-import com.intellij.xdebugger.impl.FrontendXDebuggerManagerListener
+import com.intellij.xdebugger.impl.XDebuggerManagerProxyListener
 import com.intellij.xdebugger.impl.frame.XDebugSessionProxy
 import com.intellij.xdebugger.impl.rpc.XDebugSessionId
 import kotlinx.coroutines.CoroutineScope
@@ -14,11 +14,11 @@ import kotlinx.coroutines.launch
 import java.util.concurrent.ConcurrentHashMap
 
 @Service(Service.Level.PROJECT)
-internal class StreamDebuggerManager(project: Project) : FrontendXDebuggerManagerListener {
+internal class StreamDebuggerManager(project: Project) : XDebuggerManagerProxyListener {
   private val sessionStates = ConcurrentHashMap<XDebugSessionId, TraceDebuggerStateListener>()
 
   init {
-    project.messageBus.connect().subscribe(FrontendXDebuggerManagerListener.TOPIC, this)
+    project.messageBus.connect().subscribe(XDebuggerManagerProxyListener.TOPIC, this)
   }