com.intellij.xdebugger.frame.XSuspendContext Java Examples

/** Blocks waiting for a response from the debugger, so must be called on a worker thread. */
private void doStartStepping(@Nullable XSuspendContext context, Stepping stepping) {
  long threadId = getThreadId(context);
  if (threadId == 0 && stepping != Stepping.NONE) {
    // TODO(brendandouglas): cache suspended threads here, and apply stepping behavior to all?
    return;
  }
  transport.sendRequest(
      DebugRequest.newBuilder()
          .setContinueExecution(
              ContinueExecutionRequest.newBuilder()
                  .setThreadId(threadId)
                  .setStepping(stepping)
                  .build()));

  currentlySteppingThreadId = threadId;

  // this is necessary because we yet aren't reliably informed of thread death. If the thread
  // finishes without triggering the stepping condition, we need to remind the debugger that there
  // could still be suspended threads remaining.
  scheduleWakeupIfNecessary(2000);
}
 

@Nullable
private XSuspendContext doResume() {
  if (!myPaused.getAndSet(false)) {
    return null;
  }

  myDispatcher.getMulticaster().beforeSessionResume();
  XSuspendContext context = mySuspendContext;
  mySuspendContext = null;
  myCurrentExecutionStack = null;
  myCurrentStackFrame = null;
  myTopFramePosition = null;
  myActiveNonLineBreakpoint = null;
  updateExecutionPosition();
  UIUtil.invokeLaterIfNeeded(() -> {
    if (mySessionTab != null) {
      mySessionTab.getUi().clearAttractionBy(XDebuggerUIConstants.LAYOUT_VIEW_BREAKPOINT_CONDITION);
    }
  });
  myDispatcher.getMulticaster().sessionResumed();
  return context;
}
 

@Nullable
public static XDebuggerEvaluator getEvaluator(final XSuspendContext suspendContext) {
  XExecutionStack executionStack = suspendContext.getActiveExecutionStack();
  if (executionStack != null) {
    XStackFrame stackFrame = executionStack.getTopFrame();
    if (stackFrame != null) {
      return stackFrame.getEvaluator();
    }
  }
  return null;
}
 

private void startStepping(@Nullable XSuspendContext context, Stepping stepping) {
  if (!isConnected()) {
    return;
  }
  ApplicationManager.getApplication()
      .executeOnPooledThread(() -> doStartStepping(context, stepping));
}
 

@Override
public void runToPosition(@NotNull XSourcePosition position, @Nullable XSuspendContext context) {
  if (myLatestCurrentIsolateId != null && mySuspendedIsolateIds.containsKey(myLatestCurrentIsolateId)) {
    // Set a temporary breakpoint and resume.
    myVmServiceWrapper.addTemporaryBreakpoint(position, myLatestCurrentIsolateId);
    myVmServiceWrapper.resumeIsolate(myLatestCurrentIsolateId, null);
  }
}
 

@Override
public void runToPosition(@NotNull XSourcePosition position, XSuspendContext context) {
    String fileURL = XQueryBreakpointHandler.getFileUrl(position);
    int lineNumber = XQueryBreakpointHandler.getActualLineNumber(position.getLine());
    dbgpIde.breakpointSet(aLineBreakpoint(fileURL, lineNumber).withTemporary(true).build());
    dbgpIde.run();
}
 

@Override
public void startStepOver(@Nullable XSuspendContext context) {
  if (myLatestCurrentIsolateId != null && mySuspendedIsolateIds.containsKey(myLatestCurrentIsolateId)) {
    final DartVmServiceSuspendContext suspendContext = (DartVmServiceSuspendContext)context;
    final StepOption stepOption = suspendContext != null && suspendContext.getAtAsyncSuspension() ? StepOption.OverAsyncSuspension
                                                                                                  : StepOption.Over;
    myVmServiceWrapper.resumeIsolate(myLatestCurrentIsolateId, stepOption);
  }
}
 

@Override
public void runToPosition(@NotNull XSourcePosition position, @Nullable XSuspendContext context) {
  if (myLatestCurrentIsolateId != null && mySuspendedIsolateIds.containsKey(myLatestCurrentIsolateId)) {
    // Set a temporary breakpoint and resume.
    myVmServiceWrapper.addTemporaryBreakpoint(position, myLatestCurrentIsolateId);
    myVmServiceWrapper.resumeIsolate(myLatestCurrentIsolateId, null);
  }
}
 

@Override
public void startStepOver(@Nullable XSuspendContext context) {
  if (myLatestCurrentIsolateId != null && mySuspendedIsolateIds.containsKey(myLatestCurrentIsolateId)) {
    final DartVmServiceSuspendContext suspendContext = (DartVmServiceSuspendContext)context;
    final StepOption stepOption = suspendContext != null && suspendContext.getAtAsyncSuspension() ? StepOption.OverAsyncSuspension
                                                                                                  : StepOption.Over;
    myVmServiceWrapper.resumeIsolate(myLatestCurrentIsolateId, stepOption);
  }
}
 

@Override
public <V extends XSmartStepIntoVariant> void smartStepInto(XSmartStepIntoHandler<V> handler, V variant) {
  if (!myDebugProcess.checkCanPerformCommands()) return;

  final XSuspendContext context = doResume();
  handler.startStepInto(variant, context);
}
 

private boolean breakpointReached(@Nonnull final XBreakpoint<?> breakpoint, @Nullable String evaluatedLogExpression,
                                  @Nonnull XSuspendContext suspendContext, boolean doProcessing) {
  if (doProcessing) {
    if (breakpoint.isLogMessage()) {
      XSourcePosition position = breakpoint.getSourcePosition();
      OpenFileHyperlinkInfo hyperlinkInfo =
              position != null ? new OpenFileHyperlinkInfo(myProject, position.getFile(), position.getLine()) : null;
      printMessage(XDebuggerBundle.message("xbreakpoint.reached.text") + " ", XBreakpointUtil.getShortText(breakpoint), hyperlinkInfo);
    }

    if (evaluatedLogExpression != null) {
      printMessage(evaluatedLogExpression, null, null);
    }

    processDependencies(breakpoint);

    if (breakpoint.getSuspendPolicy() == SuspendPolicy.NONE) {
      return false;
    }
  }

  myActiveNonLineBreakpoint =
          (!(breakpoint instanceof XLineBreakpoint) || ((XLineBreakpoint)breakpoint).getType().canBeHitInOtherPlaces()) ? breakpoint : null;

  // set this session active on breakpoint, update execution position will be called inside positionReached
  myDebuggerManager.setCurrentSession(this);

  positionReachedInternal(suspendContext, true);

  if (doProcessing && breakpoint instanceof XLineBreakpoint<?> && ((XLineBreakpoint)breakpoint).isTemporary()) {
    handleTemporaryBreakpointHit(breakpoint);
  }
  return true;
}
 

private XSuspendContext prepareContext(DBGpIde dbgpIde) {
    return new XQuerySuspendContext(dbgpIde, session.getProject());
}
 

@Override
public void processSessionEvent(@Nonnull SessionEvent event, @Nonnull XDebugSession session) {
  myRefresh = event == SessionEvent.SETTINGS_CHANGED;

  if (event == SessionEvent.BEFORE_RESUME) {
    return;
  }

  XExecutionStack currentExecutionStack = ((XDebugSessionImpl)session).getCurrentExecutionStack();
  XStackFrame currentStackFrame = session.getCurrentStackFrame();
  XSuspendContext suspendContext = session.getSuspendContext();

  if (event == SessionEvent.FRAME_CHANGED && Objects.equals(mySelectedStack, currentExecutionStack)) {
    ApplicationManager.getApplication().assertIsDispatchThread();
    if (currentStackFrame != null) {
      myFramesList.setSelectedValue(currentStackFrame, true);
      mySelectedFrameIndex = myFramesList.getSelectedIndex();
      myExecutionStacksWithSelection.put(mySelectedStack, mySelectedFrameIndex);
    }
    return;
  }

  EdtExecutorService.getInstance().execute(() -> {
    if (event != SessionEvent.SETTINGS_CHANGED) {
      mySelectedFrameIndex = 0;
      mySelectedStack = null;
      myVisibleRect = null;
    }
    else {
      myVisibleRect = myFramesList.getVisibleRect();
    }

    myListenersEnabled = false;
    myBuilders.values().forEach(StackFramesListBuilder::dispose);
    myBuilders.clear();

    if (suspendContext == null) {
      requestClear();
      return;
    }

    if (event == SessionEvent.PAUSED) {
      // clear immediately
      cancelClear();
      clear();
    }

    XExecutionStack activeExecutionStack = mySelectedStack != null ? mySelectedStack : currentExecutionStack;
    addExecutionStacks(Collections.singletonList(activeExecutionStack));

    XExecutionStack[] executionStacks = suspendContext.getExecutionStacks();
    addExecutionStacks(Arrays.asList(executionStacks));

    myThreadComboBox.setSelectedItem(activeExecutionStack);
    myThreadsPanel.removeAll();
    myThreadsPanel.add(myToolbar.getComponent(), BorderLayout.EAST);
    final boolean invisible = executionStacks.length == 1 && StringUtil.isEmpty(executionStacks[0].getDisplayName());
    if (!invisible) {
      myThreadsPanel.add(myThreadComboBox, BorderLayout.CENTER);
    }
    updateFrames(activeExecutionStack, session, event == SessionEvent.FRAME_CHANGED ? currentStackFrame : null);
  });
}
 

public void positionReached(@Nonnull XSuspendContext suspendContext, boolean attract) {
  myActiveNonLineBreakpoint = null;
  positionReachedInternal(suspendContext, attract);
}
 

@Override
public void startStepOver(@Nullable XSuspendContext context) {
  muleDebuggerSession.nextStep();
}
 

@Override
public void startStepInto(XSuspendContext context) {
    dbgpIde.stepInto();
}
 

@Override
public void startStepOut(XSuspendContext context) {
    dbgpIde.stepOut();
}
 

@Override
public void resume(XSuspendContext context) {
    dbgpIde.run();
}
 

@Override
public void positionReached(@Nonnull final XSuspendContext suspendContext) {
  positionReached(suspendContext, false);
}
 

private void positionReachedInternal(@Nonnull final XSuspendContext suspendContext, boolean attract) {
  enableBreakpoints();
  mySuspendContext = suspendContext;
  myCurrentExecutionStack = suspendContext.getActiveExecutionStack();
  myCurrentStackFrame = myCurrentExecutionStack != null ? myCurrentExecutionStack.getTopFrame() : null;
  myIsTopFrame = true;
  myTopFramePosition = myCurrentStackFrame != null ? myCurrentStackFrame.getSourcePosition() : null;

  myPaused.set(true);

  updateExecutionPosition();

  final boolean showOnSuspend = myShowTabOnSuspend.compareAndSet(true, false);
  if (showOnSuspend || attract) {
    AppUIUtil.invokeLaterIfProjectAlive(myProject, () -> {
      if (showOnSuspend) {
        initSessionTab(null);
        showSessionTab();
      }

      // user attractions should only be made if event happens independently (e.g. program paused/suspended)
      // and should not be made when user steps in the code
      if (attract) {
        if (mySessionTab == null) {
          LOG.debug("Cannot request focus because Session Tab is not initialized yet");
          return;
        }

        if (XDebuggerSettingManagerImpl.getInstanceImpl().getGeneralSettings().isShowDebuggerOnBreakpoint()) {
          mySessionTab.toFront(true, this::updateExecutionPosition);
        }

        if (myTopFramePosition == null) {
          // if there is no source position available, we should somehow tell the user that session is stopped.
          // the best way is to show the stack frames.
          XDebugSessionTab.showFramesView(this);
        }

        mySessionTab.getUi().attractBy(XDebuggerUIConstants.LAYOUT_VIEW_BREAKPOINT_CONDITION);
      }
    });
  }

  myDispatcher.getMulticaster().sessionPaused();
}
 

@Override
public boolean breakpointReached(@Nonnull final XBreakpoint<?> breakpoint, @Nonnull final XSuspendContext suspendContext) {
  return breakpointReached(breakpoint, null, suspendContext);
}
 

public void startStepInto(@Nonnull Variant variant, @Nullable XSuspendContext context) {
  startStepInto(variant);
}
 

public void breakpointReachedNoProcessing(@Nonnull final XBreakpoint<?> breakpoint, @Nonnull XSuspendContext suspendContext) {
  breakpointReached(breakpoint, null, suspendContext, false);
}
 

/**
 * Resume execution.
 * Do not call this method directly. Use {@link XDebugSession#resume} instead
 */
public void resume(@Nullable XSuspendContext context) {
  //noinspection deprecation
  resume();
}
 

@Override
public void startStepOver(XSuspendContext context) {
    dbgpIde.stepOver();
}
 

@Override
public XSuspendContext getSuspendContext() {
  return mySuspendContext;
}
 

@Override
public boolean breakpointReached(@Nonnull final XBreakpoint<?> breakpoint, @Nullable String evaluatedLogExpression,
                                 @Nonnull XSuspendContext suspendContext) {
  return breakpointReached(breakpoint, evaluatedLogExpression, suspendContext, true);
}
 

@Override
public void resume(@Nullable XSuspendContext context) {
  // unpausing only a single thread isn't well supported by the debugging API, so pass through a
  // null suspect context, indicating all threads should be unpaused
  startStepping(null, Stepping.NONE);
}
 

@Override
public void startStepInto(@Nullable XSuspendContext context) {
  muleDebuggerSession.nextStep();
}
 

@Override
public void startStepOut(@Nullable XSuspendContext context) {
  muleDebuggerSession.nextStep();
}