[rd debugger] IJPL-219714 Replace breakpoint asProxy usages with XDebuggerEntityConverter

GitOrigin-RevId: 1080b04eda89ebb28505f811629a6a476728aa5e

java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointManager.java

@@ -38,6 +38,8 @@ import com.intellij.openapi.util.JDOMUtil;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.VirtualFileManager;
+import com.intellij.platform.debugger.impl.shared.proxy.XLineBreakpointProxy;
+import com.intellij.platform.debugger.impl.ui.XDebuggerEntityConverter;
 import com.intellij.psi.PsiField;
 import com.intellij.util.CoroutineScopeKt;
 import com.intellij.util.EventDispatcher;
@@ -60,8 +62,6 @@ import com.intellij.xdebugger.impl.actions.EditBreakpointAction;
 import com.intellij.xdebugger.impl.breakpoints.XBreakpointBase;
 import com.intellij.xdebugger.impl.breakpoints.XBreakpointManagerImpl;
 import com.intellij.xdebugger.impl.breakpoints.XDependentBreakpointManager;
-import com.intellij.xdebugger.impl.breakpoints.XLineBreakpointImpl;
-import com.intellij.xdebugger.impl.proxy.MonolithBreakpointProxyKt;
 import com.jetbrains.jdi.EventRequestManagerImpl;
 import com.sun.jdi.InternalException;
 import com.sun.jdi.ThreadReference;
@@ -166,12 +166,13 @@ public class BreakpointManager {
   public void editBreakpoint(final Breakpoint breakpoint, final Editor editor) {
     DebuggerInvocationUtil.invokeLaterAnyModality(myProject, () -> {
       XBreakpoint xBreakpoint = breakpoint.myXBreakpoint;
-      if (xBreakpoint instanceof XLineBreakpointImpl<?> xLineBreakpoint) {
-        RangeHighlighter highlighter = xLineBreakpoint.getHighlighter();
+      var breakpointProxy = XDebuggerEntityConverter.asProxy(xBreakpoint);
+      if (breakpointProxy instanceof XLineBreakpointProxy lineBreakpointProxy) {
+        RangeHighlighter highlighter = lineBreakpointProxy.getHighlighter();
         if (highlighter != null) {
           GutterIconRenderer renderer = highlighter.getGutterIconRenderer();
           if (renderer != null) {
-            EditBreakpointAction.HANDLER.editBreakpoint(myProject, editor, MonolithBreakpointProxyKt.asProxy(xLineBreakpoint), renderer);
+            EditBreakpointAction.HANDLER.editBreakpoint(myProject, editor, lineBreakpointProxy, renderer);
           }
         }
       }

platform/xdebugger-impl/shared/src/com/intellij/platform/debugger/impl/shared/XDebuggerMonolithAccessPoint.kt

@@ -4,6 +4,7 @@ package com.intellij.platform.debugger.impl.shared
 import com.intellij.openapi.extensions.ExtensionPointName
 import com.intellij.platform.debugger.impl.rpc.XBreakpointId
 import com.intellij.platform.debugger.impl.rpc.XValueId
+import com.intellij.platform.debugger.impl.shared.proxy.XBreakpointProxy
 import com.intellij.platform.debugger.impl.shared.proxy.XDebugSessionProxy
 import com.intellij.xdebugger.XDebugSession
 import com.intellij.xdebugger.breakpoints.XBreakpoint
@@ -19,6 +20,8 @@ interface XDebuggerMonolithAccessPoint {
   fun getValue(valueId: XValueId): XValue?
   fun getBreakpointType(typeId: String): XBreakpointType<*, *>?
   fun getBreakpoint(breakpointId: XBreakpointId): XBreakpoint<*>?
+  fun getBreakpointId(breakpoint: XBreakpoint<*>): XBreakpointId?
+  fun asProxy(breakpoint: XBreakpoint<*>): XBreakpointProxy?
 
   companion object {
     internal val EP_NAME = ExtensionPointName<XDebuggerMonolithAccessPoint>("com.intellij.xdebugger.monolithAccessPoint")

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

@@ -17,6 +17,7 @@ import com.intellij.platform.debugger.impl.rpc.XBreakpointId;
 import com.intellij.platform.debugger.impl.shared.proxy.XBreakpointManagerProxy;
 import com.intellij.platform.debugger.impl.shared.proxy.XBreakpointProxy;
 import com.intellij.platform.debugger.impl.shared.proxy.XLineBreakpointTypeProxy;
+import com.intellij.platform.debugger.impl.ui.XDebuggerEntityConverter;
 import com.intellij.pom.Navigatable;
 import com.intellij.ui.ColorUtil;
 import com.intellij.ui.ColoredListCellRenderer;
@@ -25,6 +26,7 @@ import com.intellij.ui.SimpleColoredComponent;
 import com.intellij.ui.SimpleTextAttributes;
 import com.intellij.ui.popup.util.DetailView;
 import com.intellij.util.concurrency.AppExecutorUtil;
+import com.intellij.xdebugger.breakpoints.XBreakpoint;
 import com.intellij.xdebugger.impl.breakpoints.ui.BreakpointItem;
 import com.intellij.xdebugger.impl.breakpoints.ui.XLightBreakpointPropertiesPanel;
 import com.intellij.xdebugger.ui.DebuggerColors;
@@ -35,16 +37,14 @@ import org.jetbrains.annotations.Nullable;
 import javax.swing.Icon;
 import java.awt.Color;
 
-import static com.intellij.xdebugger.impl.proxy.MonolithBreakpointProxyKt.asProxy;
-
 @ApiStatus.Internal
 public class XBreakpointItem extends BreakpointItem {
   private final XBreakpointProxy myBreakpointProxy;
   private final XBreakpointManagerProxy myBreakpointManagerProxy;
   private XLightBreakpointPropertiesPanel myPropertiesPanel;
 
-  public XBreakpointItem(XBreakpointBase<?, ?, ?> breakpoint, XBreakpointManagerProxy breakpointManagerProxy) {
-    myBreakpointProxy = asProxy(breakpoint);
+  public XBreakpointItem(XBreakpoint<?> breakpoint, XBreakpointManagerProxy breakpointManagerProxy) {
+    myBreakpointProxy = XDebuggerEntityConverter.asProxy(breakpoint);
     myBreakpointManagerProxy = breakpointManagerProxy;
   }
 

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

@@ -49,6 +49,7 @@ import com.intellij.platform.debugger.impl.shared.proxy.XLightLineBreakpointProx
 import com.intellij.platform.debugger.impl.shared.proxy.XLineBreakpointHighlighterRange
 import com.intellij.platform.debugger.impl.shared.proxy.XLineBreakpointManagerProxy
 import com.intellij.platform.debugger.impl.shared.proxy.XLineBreakpointProxy
+import com.intellij.platform.debugger.impl.ui.XDebuggerEntityConverter
 import com.intellij.platform.util.coroutines.childScope
 import com.intellij.psi.PsiDocumentManager
 import com.intellij.ui.ExperimentalUI.Companion.isNewUI
@@ -65,7 +66,6 @@ import com.intellij.xdebugger.XDebuggerUtil
 import com.intellij.xdebugger.breakpoints.XBreakpoint
 import com.intellij.xdebugger.impl.actions.ToggleLineBreakpointAction
 import com.intellij.xdebugger.impl.proxy.MonolithLineBreakpointProxy
-import com.intellij.xdebugger.impl.proxy.asProxy
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.cancel
 import org.jetbrains.annotations.ApiStatus
@@ -157,7 +157,10 @@ class XLineBreakpointManager(
 
   @Deprecated("Use {@link #registerBreakpoint(XLineBreakpointProxy, boolean)} instead")
   fun registerBreakpoint(breakpoint: XLineBreakpointImpl<*>, initUI: Boolean) {
-    registerBreakpoint(breakpoint.asProxy(), initUI)
+    val proxy = XDebuggerEntityConverter.asProxy(breakpoint) as? XLineBreakpointProxy
+    if (proxy != null) {
+      registerBreakpoint(proxy, initUI)
+    }
   }
 
   fun registerBreakpoint(breakpoint: XLineBreakpointProxy, initUI: Boolean) {
@@ -266,9 +269,9 @@ class XLineBreakpointManager(
 
   @JvmOverloads
   fun queueBreakpointUpdate(slave: XBreakpoint<*>?, callOnUpdate: Runnable? = null) {
-    if (slave is XLineBreakpointImpl<*>) {
-      queueBreakpointUpdate(slave.asProxy(), callOnUpdate)
-    }
+    if (slave == null) return
+    val proxy = XDebuggerEntityConverter.asProxy(slave) as? XLineBreakpointProxy ?: return
+    queueBreakpointUpdate(proxy, callOnUpdate)
   }
 
   @Deprecated("Use queueBreakpointUpdateCallback(XLightLineBreakpointProxy, Runnable)")

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/ui/BreakpointsDialogFactory.kt

@@ -12,12 +12,12 @@ import com.intellij.openapi.util.Disposer
 import com.intellij.platform.debugger.impl.rpc.XBreakpointId
 import com.intellij.platform.debugger.impl.shared.proxy.XBreakpointProxy
 import com.intellij.platform.debugger.impl.shared.proxy.XDebugManagerProxy
+import com.intellij.platform.debugger.impl.ui.XDebuggerEntityConverter
 import com.intellij.platform.rpc.topics.sendToClient
 import com.intellij.xdebugger.SplitDebuggerMode
 import com.intellij.xdebugger.breakpoints.XBreakpoint
 import com.intellij.xdebugger.impl.breakpoints.SHOW_BREAKPOINT_DIALOG_REMOTE_TOPIC
 import com.intellij.xdebugger.impl.breakpoints.ShowBreakpointDialogRequest
-import com.intellij.xdebugger.impl.breakpoints.XBreakpointBase
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -54,7 +54,12 @@ class BreakpointsDialogFactory(private val project: Project, private val scope:
   }
 
   fun showDialog(initialBreakpoint: XBreakpoint<*>?) {
-    val initialBreakpointId = (initialBreakpoint as? XBreakpointBase<*, *, *>)?.breakpointId
+    val initialBreakpointId = if (initialBreakpoint != null) {
+      XDebuggerEntityConverter.getBreakpointId(initialBreakpoint)
+    }
+    else {
+      null
+    }
     showDialog(initialBreakpointId)
   }
 

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

@@ -50,8 +50,6 @@ import java.awt.event.FocusEvent;
 import java.util.ArrayList;
 import java.util.List;
 
-import static com.intellij.xdebugger.impl.proxy.MonolithBreakpointProxyKt.asProxy;
-
 @ApiStatus.Internal
 public class XLightBreakpointPropertiesPanel implements XSuspendPolicyPanel.Delegate {
   public static final String CONDITION_HISTORY_ID = "breakpointCondition";
@@ -145,7 +143,7 @@ public class XLightBreakpointPropertiesPanel implements XSuspendPolicyPanel.Dele
   public XLightBreakpointPropertiesPanel(Project project, XBreakpointManager breakpointManager, XBreakpointBase breakpoint,
                                          boolean showActionOptions, boolean showAllOptions, boolean isEditorBalloon) {
     this(project, MonolithBreakpointManagerKt.asProxy((XBreakpointManagerImpl)breakpointManager),
-         asProxy(breakpoint), showActionOptions, showAllOptions, isEditorBalloon);
+         XDebuggerEntityConverter.asProxy(breakpoint), showActionOptions, showAllOptions, isEditorBalloon);
   }
 
   private final @NotNull XBreakpointManagerProxy myBreakpointManager;

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/ui/grouping/XBreakpointGroupingUtil.kt

@@ -2,16 +2,16 @@
 package com.intellij.xdebugger.impl.breakpoints.ui.grouping
 
 import com.intellij.platform.debugger.impl.shared.proxy.XBreakpointProxy
-import com.intellij.xdebugger.impl.breakpoints.XBreakpointBase
-import com.intellij.xdebugger.impl.proxy.asProxy
+import com.intellij.platform.debugger.impl.ui.XDebuggerEntityConverter
+import com.intellij.xdebugger.breakpoints.XBreakpoint
 
 internal fun Any.asBreakpointProxyOrNull(): XBreakpointProxy? {
   val breakpoint = this
   if (breakpoint is XBreakpointProxy) {
     return breakpoint
   }
-  if (breakpoint is XBreakpointBase<*, *, *>) {
-    return breakpoint.asProxy()
+  if (breakpoint is XBreakpoint<*>) {
+    return XDebuggerEntityConverter.asProxy(breakpoint)
   }
   return null
 }

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/proxy/MonolithBreakpointProxy.kt

@@ -206,8 +206,7 @@ fun <B : XBreakpoint<P>, P : XBreakpointProperties<*>> getEditorsProvider(
 ): XDebuggerEditorsProvider? = breakpointType.getEditorsProvider(breakpoint as B, project)
 
 @Suppress("DEPRECATION")
-@ApiStatus.Internal
-fun <T : XBreakpointBase<*, *, *>> T.asProxy(): XBreakpointProxy {
+internal fun <T : XBreakpointBase<*, *, *>> T.asProxy(): XBreakpointProxy {
   return if (this is XLineBreakpointImpl<*>) {
     this.asProxy()
   }
@@ -217,5 +216,4 @@ fun <T : XBreakpointBase<*, *, *>> T.asProxy(): XBreakpointProxy {
 }
 
 @Suppress("DEPRECATION")
-@ApiStatus.Internal
-fun <T : XLineBreakpointImpl<*>> T.asProxy(): XLineBreakpointProxy = MonolithLineBreakpointProxy(this)
+internal fun <T : XLineBreakpointImpl<*>> T.asProxy(): XLineBreakpointProxy = MonolithLineBreakpointProxy(this)

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/proxy/MonolithSessionProxy.kt

@@ -350,4 +350,12 @@ internal class XDebuggerMonolithAccessPointImpl : XDebuggerMonolithAccessPoint {
   override fun getBreakpoint(breakpointId: XBreakpointId): XBreakpoint<*>? {
     return breakpointId.findValue()
   }
+
+  override fun getBreakpointId(breakpoint: XBreakpoint<*>): XBreakpointId? {
+    return (breakpoint as? XBreakpointBase<*, *, *>)?.breakpointId
+  }
+
+  override fun asProxy(breakpoint: XBreakpoint<*>): XBreakpointProxy? {
+    return (breakpoint as? XBreakpointBase<*, *, *>)?.asProxy()
+  }
 }

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

@@ -43,6 +43,7 @@ import com.intellij.platform.debugger.impl.shared.proxy.XBreakpointManagerProxy;
 import com.intellij.platform.debugger.impl.shared.proxy.XBreakpointProxy;
 import com.intellij.platform.debugger.impl.shared.proxy.XDebugManagerProxy;
 import com.intellij.platform.debugger.impl.shared.proxy.XDebugSessionProxy;
+import com.intellij.platform.debugger.impl.ui.XDebuggerEntityConverter;
 import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiManager;
 import com.intellij.testFramework.LightVirtualFile;
@@ -65,7 +66,6 @@ import com.intellij.xdebugger.breakpoints.XBreakpointListener;
 import com.intellij.xdebugger.frame.XFullValueEvaluator;
 import com.intellij.xdebugger.frame.XValue;
 import com.intellij.xdebugger.frame.XValueModifier;
-import com.intellij.xdebugger.impl.breakpoints.XBreakpointBase;
 import com.intellij.xdebugger.impl.breakpoints.ui.BreakpointsDialogFactory;
 import com.intellij.xdebugger.impl.breakpoints.ui.XLightBreakpointPropertiesPanel;
 import com.intellij.xdebugger.impl.frame.XWatchesView;
@@ -98,7 +98,6 @@ import java.awt.event.HierarchyEvent;
 import java.awt.event.MouseEvent;
 
 import static com.intellij.openapi.wm.IdeFocusManager.getGlobalInstance;
-import static com.intellij.xdebugger.impl.proxy.MonolithBreakpointProxyKt.asProxy;
 
 public final class DebuggerUIUtil {
   public static final @NonNls String FULL_VALUE_POPUP_DIMENSION_KEY = "XDebugger.FullValuePopup";
@@ -270,8 +269,9 @@ public final class DebuggerUIUtil {
                                                   final JComponent component,
                                                   final boolean showAllOptions,
                                                   final @NotNull XBreakpoint breakpoint) {
-    if (breakpoint instanceof XBreakpointBase<?, ?, ?> breakpointBase) {
-      showXBreakpointEditorBalloon(project, point, component, showAllOptions, asProxy(breakpointBase));
+    XBreakpointProxy breakpointProxy = XDebuggerEntityConverter.asProxy(breakpoint);
+    if (breakpointProxy != null) {
+      showXBreakpointEditorBalloon(project, point, component, showAllOptions, breakpointProxy);
     }
   }
 
@@ -291,8 +291,9 @@ public final class DebuggerUIUtil {
                                                   final boolean showActionOptions,
                                                   final boolean showAllOptions,
                                                   final @NotNull XBreakpoint breakpoint) {
-    if (breakpoint instanceof XBreakpointBase<?, ?, ?> breakpointBase) {
-      showXBreakpointEditorBalloon(project, point, component, showActionOptions, showAllOptions, asProxy(breakpointBase));
+    XBreakpointProxy breakpointProxy = XDebuggerEntityConverter.asProxy(breakpoint);
+    if (breakpointProxy != null) {
+      showXBreakpointEditorBalloon(project, point, component, showActionOptions, showAllOptions, breakpointProxy);
     }
   }
 
@@ -358,8 +359,8 @@ public final class DebuggerUIUtil {
     project.getMessageBus().connect(disposable).subscribe(XBreakpointListener.TOPIC, new XBreakpointListener<>() {
       @Override
       public void breakpointRemoved(@NotNull XBreakpoint<?> removedBreakpoint) {
-        if (removedBreakpoint instanceof XBreakpointBase<?, ?, ?> breakpointBase &&
-            asProxy(breakpointBase).equals(breakpoint)) {
+        XBreakpointProxy removedBreakpointProxy = XDebuggerEntityConverter.asProxy(removedBreakpoint);
+        if (removedBreakpointProxy != null && removedBreakpointProxy.equals(breakpoint)) {
           balloon.hide();
         }
       }

platform/xdebugger-impl/ui/src/com/intellij/platform/debugger/impl/ui/XDebuggerEntityConverter.kt

@@ -4,6 +4,7 @@ package com.intellij.platform.debugger.impl.ui
 import com.intellij.platform.debugger.impl.rpc.XBreakpointId
 import com.intellij.platform.debugger.impl.rpc.XValueId
 import com.intellij.platform.debugger.impl.shared.XDebuggerMonolithAccessPoint
+import com.intellij.platform.debugger.impl.shared.proxy.XBreakpointProxy
 import com.intellij.platform.debugger.impl.shared.proxy.XDebugSessionProxy
 import com.intellij.xdebugger.XDebugSession
 import com.intellij.xdebugger.breakpoints.XBreakpoint
@@ -84,4 +85,30 @@ object XDebuggerEntityConverter {
   fun getBreakpoint(breakpointId: XBreakpointId): XBreakpoint<*>? {
     return XDebuggerMonolithAccessPoint.find { it.getBreakpoint(breakpointId) }
   }
+
+  /**
+   * For a given [XBreakpoint] returns the corresponding [XBreakpointId].
+   *
+   * Returns `null` if the breakpoint is not a backend implementation instance.
+   *
+   * Use this method to convert breakpoints to IDs for UI operations.
+   */
+  @ApiStatus.Internal
+  @JvmStatic
+  fun getBreakpointId(breakpoint: XBreakpoint<*>): XBreakpointId? {
+    return XDebuggerMonolithAccessPoint.find { it.getBreakpointId(breakpoint) }
+  }
+
+  /**
+   * For a given [XBreakpoint] returns the corresponding [XBreakpointProxy].
+   *
+   * Returns `null` if the breakpoint is not a backend implementation instance.
+   *
+   * Use this method to convert breakpoints to proxies for UI operations.
+   */
+  @ApiStatus.Internal
+  @JvmStatic
+  fun asProxy(breakpoint: XBreakpoint<*>): XBreakpointProxy? {
+    return XDebuggerMonolithAccessPoint.find { it.asProxy(breakpoint) }
+  }
 }