com.intellij.psi.search.GlobalSearchScopes#com.intellij.xdebugger.XDebuggerUtil源码实例Demo

/**
 * Given a token id, returns the source position to display to the user.
 * <p>
 * If no local file was provided, uses the snapshot if available. (However, in that
 * case, breakpoints won't work.)
 */
@Nullable
XSourcePosition createPosition(@Nullable VirtualFile local, int tokenPos) {
  final VirtualFile fileToUse = local == null ? snapshot : local;
  if (fileToUse == null) return null;

  if (positionMap == null) {
    return null;
  }

  final Position pos = positionMap.get(tokenPos);
  if (pos == null) {
    return XDebuggerUtil.getInstance().createPositionByOffset(fileToUse, 0);
  }
  return XDebuggerUtil.getInstance().createPosition(fileToUse, pos.line, pos.column);
}
 

/**
 * Given a token id, returns the source position to display to the user.
 * <p>
 * If no local file was provided, uses the snapshot if available. (However, in that
 * case, breakpoints won't work.)
 */
@Nullable
XSourcePosition createPosition(@Nullable VirtualFile local, int tokenPos) {
  final VirtualFile fileToUse = local == null ? snapshot : local;
  if (fileToUse == null) return null;

  if (positionMap == null) {
    return null;
  }

  final Position pos = positionMap.get(tokenPos);
  if (pos == null) {
    return XDebuggerUtil.getInstance().createPositionByOffset(fileToUse, 0);
  }
  return XDebuggerUtil.getInstance().createPosition(fileToUse, pos.line, pos.column);
}
 

public XValueHint(@Nonnull Project project, @Nonnull Editor editor, @Nonnull Point point, @Nonnull ValueHintType type,
                  @Nonnull ExpressionInfo expressionInfo, @Nonnull XDebuggerEvaluator evaluator,
                  @Nonnull XDebugSession session) {
  super(project, editor, point, type, expressionInfo.getTextRange());

  myEvaluator = evaluator;
  myDebugSession = session;
  myExpression = XDebuggerEvaluateActionHandler.getExpressionText(expressionInfo, editor.getDocument());
  myValueName = XDebuggerEvaluateActionHandler.getDisplayText(expressionInfo, editor.getDocument());
  myExpressionInfo = expressionInfo;

  VirtualFile file;
  ConsoleView consoleView = ConsoleViewImpl.CONSOLE_VIEW_IN_EDITOR_VIEW.get(editor);
  if (consoleView instanceof LanguageConsoleView) {
    LanguageConsoleView console = ((LanguageConsoleView)consoleView);
    file = console.getHistoryViewer() == editor ? console.getVirtualFile() : null;
  }
  else {
    file = FileDocumentManager.getInstance().getFile(editor.getDocument());
  }

  myExpressionPosition = file != null ? XDebuggerUtil.getInstance().createPositionByOffset(file, expressionInfo.getTextRange().getStartOffset()) : null;
}
 

@Override
public boolean isEnabled(@Nonnull final Project project, final AnActionEvent event) {
  XLineBreakpointType<?>[] breakpointTypes = XDebuggerUtil.getInstance().getLineBreakpointTypes();
  final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
  for (XSourcePosition position : XDebuggerUtilImpl.getAllCaretsPositions(project, event.getDataContext())) {
    for (XLineBreakpointType<?> breakpointType : breakpointTypes) {
      final VirtualFile file = position.getFile();
      final int line = position.getLine();
      if (XLineBreakpointResolverTypeExtension.INSTANCE.resolveBreakpointType(project, file, line) != null ||
          breakpointManager.findBreakpointAtLine(breakpointType, file, line) != null) {
        return true;
      }
    }
  }
  return false;
}
 

@Override
@Nullable
public XBreakpoint<?> findBreakpoint(@Nonnull final Project project, @Nonnull final Document document, final int offset) {
  XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
  int line = document.getLineNumber(offset);
  VirtualFile file = FileDocumentManager.getInstance().getFile(document);
  if (file == null) {
    return null;
  }
  for (XLineBreakpointType<?> type : XDebuggerUtil.getInstance().getLineBreakpointTypes()) {
    XLineBreakpoint<? extends XBreakpointProperties> breakpoint = breakpointManager.findBreakpointAtLine(type, file, line);
    if (breakpoint != null) {
      return breakpoint;
    }
  }

  return null;
}
 

@Override
public boolean canPutAt(@NotNull VirtualFile file, int line, @NotNull Project project) {
    FileType fileType = file.getFileType();
    if (FileHelper.isOCaml(fileType) || FileHelper.isReason(fileType)) {
        Document document = FileDocumentManager.getInstance().getDocument(file);
        if (document != null) {
            LineBreakpointAvailabilityProcessor canPutAtChecker = new LineBreakpointAvailabilityProcessor(
                    FileHelper.isOCaml(fileType) ? OclTypes.INSTANCE : RmlTypes.INSTANCE);
            XDebuggerUtil.getInstance().iterateLine(project, document, line, canPutAtChecker);
            return canPutAtChecker.isLineBreakpointAvailable();
        }
    }

    return false;
}
 

@Override
public boolean canPutAt(@NotNull VirtualFile file, int line, @NotNull Project project)
{
    final Document document = FileDocumentManager.getInstance().getDocument(file);
    if (document != null)
    {
        final PsiFile psiFile = PsiDocumentManager.getInstance(project).getPsiFile(document);
        if (psiFile != null)
        {
            final boolean isMuleAndXml = MuleConfigUtils.isMuleFile(psiFile);
            if (isMuleAndXml)
            {
                final XmlTag xmlTagAt = MuleConfigUtils.getXmlTagAt(project, XDebuggerUtil.getInstance().createPosition(file, line));
                if (xmlTagAt != null)
                {
                    return MuleConfigUtils.getMuleElementTypeFromXmlElement(xmlTagAt) == MuleElementType.MESSAGE_PROCESSOR;
                }
                else
                {
                    final PsiElement firstWeaveElement = WeavePsiUtils.getFirstWeaveElement(project, document, line);
                    if (firstWeaveElement != null)
                    {
                        PsiLanguageInjectionHost parent = PsiTreeUtil.getParentOfType(firstWeaveElement, PsiLanguageInjectionHost.class);
                        if (parent != null)
                        {
                            final PsiElement elementInInjected = InjectedLanguageUtil.findElementInInjected(parent, line);
                            final Language language = elementInInjected.getLanguage();
                            return language == WeaveLanguage.getInstance();
                        }
                    }
                }
            }
        }
    }
    return false;
}
 

@Nullable
public static PsiElement getFirstWeaveElement(Project project, Document document, int line) {
    final Ref<PsiElement> result = Ref.create();
    XDebuggerUtil.getInstance().iterateLine(project, document, line, element -> {
        if (!(element instanceof PsiWhiteSpace)) {
            result.set(element);
            return false;
        }
        return true;
    });
    return result.get();
}
 

DocumentFileLocationMapper(@Nullable Document document, Project project) {
  this.document = document;

  if (document != null) {
    psiFile = PsiDocumentManager.getInstance(project).getPsiFile(document);
    virtualFile = psiFile != null ? psiFile.getVirtualFile() : null;
    debuggerUtil = XDebuggerUtil.getInstance();
  }
  else {
    psiFile = null;
    virtualFile = null;
    debuggerUtil = null;
  }
}
 

DocumentFileLocationMapper(@Nullable Document document, Project project) {
  this.document = document;

  if (document != null) {
    psiFile = PsiDocumentManager.getInstance(project).getPsiFile(document);
    virtualFile = psiFile != null ? psiFile.getVirtualFile() : null;
    debuggerUtil = XDebuggerUtil.getInstance();
  }
  else {
    psiFile = null;
    virtualFile = null;
    debuggerUtil = null;
  }
}
 

@Nullable
private static XSourcePosition createXSourcePosition(@Nullable VirtualFile vFile, int line) {
  if (vFile != null) {
    return XDebuggerUtil.getInstance()
        .createPosition(vFile, convertRemoteLineToLocal(vFile, line));
  } else {
    return null;
  }
}
 

/** Converts between source location formats used by the IDE and the Skylark debug server. */
@Nullable
static XSourcePosition fromLocationProto(Location location) {
  VirtualFile vf =
      VfsUtils.resolveVirtualFile(new File(location.getPath()), /* refreshIfNeeded= */ true);
  if (vf == null) {
    return null;
  }
  return XDebuggerUtil.getInstance().createPosition(vf, location.getLineNumber() - 1);
}
 

@Override
public List<XBreakpointGroupingRule<XLineBreakpoint<XBreakpointProperties>, ?>> getGroupingRules() {
  XBreakpointGroupingRule<XLineBreakpoint<XBreakpointProperties>, ?> byFile = XDebuggerUtil.getInstance().getGroupingByFileRule();
  List<XBreakpointGroupingRule<XLineBreakpoint<XBreakpointProperties>, ?>> rules =
    new ArrayList<XBreakpointGroupingRule<XLineBreakpoint<XBreakpointProperties>, ?>>();
  rules.add(byFile);
  return rules;
}
 

private boolean hasAnExpression(Project project, Document document, int line) {
    final Ref<Boolean> isPartOfExpression = Ref.create(Boolean.FALSE);
    XDebuggerUtil.getInstance().iterateLine(project, document, line, new Processor<PsiElement>() {
        @Override
        public boolean process(PsiElement psiElement) {
            if (PsiTreeUtil.getParentOfType(psiElement, XQueryExprSingle.class, false) != null) {
                isPartOfExpression.set(Boolean.TRUE);
                return false;
            } else {
                return true;
            }
        }
    });
    return isPartOfExpression.get();
}
 

/**
 * Asynchronously calculates expression which evaluates to the current value
 */
@Nonnull
public AsyncResult<XExpression> calculateEvaluationExpression() {
  String expression = getEvaluationExpression();
  XExpression res =
          expression != null ? XDebuggerUtil.getInstance().createExpression(expression, null, null, EvaluationMode.EXPRESSION) : null;
  return AsyncResult.done(res);
}
 

@Nonnull
@Override
public <B extends XBreakpoint<?>> Collection<? extends B> getBreakpoints(@Nonnull Class<? extends XBreakpointType<B, ?>> typeClass) {
  XBreakpointType<B, ?> type = XDebuggerUtil.getInstance().findBreakpointType(typeClass);
  LOG.assertTrue(type != null, "Unregistered breakpoint type " + typeClass);
  return getBreakpoints(type);
}
 

@Override
public XSourcePosition getSourcePosition() {
  if (mySourcePosition != null) {
    return mySourcePosition;
  }
  mySourcePosition = super.getSourcePosition();
  if (mySourcePosition == null) {
    mySourcePosition = XDebuggerUtil.getInstance().createPosition(getFile(), getLine());
  }
  return mySourcePosition;
}
 

@Nullable
private static PsiElement getContextElement(
    VirtualFile virtualFile, int offset, Project project) {
  return XDebuggerUtil.getInstance().findContextElement(virtualFile, offset, project, false);
}
 

@Nonnull
public XExpression createExpression(@Nonnull Project project, @Nonnull Document document, @javax.annotation.Nullable Language language, @Nonnull EvaluationMode mode) {
  return XDebuggerUtil.getInstance().createExpression(document.getText(), language, null, mode);
}
 

@Nullable
protected PsiElement getContextElement(@Nonnull VirtualFile virtualFile, int offset, @Nonnull Project project) {
  return XDebuggerUtil.getInstance().findContextElement(virtualFile, offset, project, false);
}
 

protected static <S extends XDebuggerSettings<?>> S getInstance(Class<S> aClass) {
  return XDebuggerUtil.getInstance().getDebuggerSettings(aClass);
}
 

public void actionPerformed(final AnActionEvent e) {
  XDebuggerUtil.getInstance().removeBreakpoint(myBreakpoint.getProject(), myBreakpoint);
}
 

/**
 * Toggle line breakpoint with editor support:
 * - unfolds folded block on the line
 * - if folded, checks if line breakpoints could be toggled inside folded text
 */
@Nonnull
public static AsyncResult<XLineBreakpoint> toggleLineBreakpoint(@Nonnull Project project,
                                                                @Nonnull XSourcePosition position,
                                                                @Nullable Editor editor,
                                                                boolean temporary,
                                                                boolean moveCaret) {
  int lineStart = position.getLine();
  VirtualFile file = position.getFile();
  // for folded text check each line and find out type with the biggest priority
  int linesEnd = lineStart;
  if (editor != null) {
    FoldRegion region = FoldingUtil.findFoldRegionStartingAtLine(editor, lineStart);
    if (region != null && !region.isExpanded()) {
      linesEnd = region.getDocument().getLineNumber(region.getEndOffset());
    }
  }

  final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
  XLineBreakpointType<?>[] lineTypes = XDebuggerUtil.getInstance().getLineBreakpointTypes();
  XLineBreakpointType<?> typeWinner = null;
  int lineWinner = -1;
  for (int line = lineStart; line <= linesEnd; line++) {
    for (XLineBreakpointType<?> type : lineTypes) {
      final XLineBreakpoint<? extends XBreakpointProperties> breakpoint = breakpointManager.findBreakpointAtLine(type, file, line);
      if (breakpoint != null && temporary && !breakpoint.isTemporary()) {
        breakpoint.setTemporary(true);
      }
      else if(breakpoint != null) {
        typeWinner = type;
        lineWinner = line;
        break;
      }
    }

    XLineBreakpointType<?> breakpointType = XLineBreakpointResolverTypeExtension.INSTANCE.resolveBreakpointType(project, file, line);
    if(breakpointType != null) {
      typeWinner = breakpointType;
      lineWinner = line;
    }

    // already found max priority type - stop
    if (typeWinner != null) {
      break;
    }
  }

  if (typeWinner != null) {
    XSourcePosition winPosition = (lineStart == lineWinner) ? position : XSourcePositionImpl.create(file, lineWinner);
    if (winPosition != null) {
      AsyncResult<XLineBreakpoint> res =
              XDebuggerUtilImpl.toggleAndReturnLineBreakpoint(project, typeWinner, winPosition, temporary, editor);

      if (editor != null && lineStart != lineWinner) {
        int offset = editor.getDocument().getLineStartOffset(lineWinner);
        ExpandRegionAction.expandRegionAtOffset(project, editor, offset);
        if (moveCaret) {
          editor.getCaretModel().moveToOffset(offset);
        }
      }
      return res;
    }
  }

  return AsyncResult.rejected();
}