@Override
protected void setUp() throws Exception {
  super.setUp();

  myFindModel = new FindModel();

  myOutputStream = new ByteArrayOutputStream();
  LivePreview.ourTestOutput = new PrintStream(myOutputStream);
  EditorHintListener listener = new EditorHintListener() {
    @Override
    public void hintShown(Project project,LightweightHint hint,int flags) {
      LivePreview.processNotFound();
    }
  };
  ApplicationManager.getApplication().getMessageBus().connect(myTestRootdisposable).subscribe(EditorHintListener.TOPIC,listener);
}

public void showTooltip(@NotNull Editor editor,@NotNull Point p,@NotNull TooltipRenderer tooltipRenderer,boolean alignToRight,@NotNull TooltipGroup group,@NotNull HintHint hintInfo) {
  if (myCurrentTooltip == null || !myCurrentTooltip.isVisible()) {
    myCurrentTooltipObject = null;
  }

  if (Comparing.equal(tooltipRenderer,myCurrentTooltipObject)) {
    IdetooltipManager.getInstance().cancelAutoHide();
    return;
  }
  if (myCurrentTooltipGroup != null && group.compareto(myCurrentTooltipGroup) < 0) return;

  p = new Point(p);
  hideCurrentTooltip();

  LightweightHint hint = tooltipRenderer.show(editor,p,alignToRight,group,hintInfo);

  myCurrentTooltipGroup = group;
  myCurrentTooltip = hint;
  myCurrentTooltipObject = tooltipRenderer;
}

private static void showLookupEditorHint(Object[] descriptors,final Editor editor,final Project project,ParameterInfoHandler handler) {
  ParameterInfoComponent component = new ParameterInfoComponent(descriptors,editor,handler);
  component.update();

  final LightweightHint hint = new LightweightHint(component);
  hint.setSelectingHint(true);
  final HintManagerImpl hintManager = HintManagerImpl.getInstanceImpl();
  final Pair<Point,Short> pos = ShowParameterInfoContext.chooseBestHintPosition(project,-1,hint,true,HintManager.DEFAULT);
  ApplicationManager.getApplication().invokelater(new Runnable() {
    @Override
    public void run() {
      if (!editor.getComponent().isShowing()) return;
      hintManager.showEditorHint(hint,pos.getFirst(),HintManager.HIDE_BY_ANY_KEY | HintManager.HIDE_BY_LOOKUP_ITEM_CHANGE | HintManager.UPDATE_BY_SCROLLING,false,pos.getSecond());
    }
  });
}

protected void handleEmptyLookup(final boolean awaitSecondInvocation) {
  if (isAutopopupCompletion() && ApplicationManager.getApplication().isUnitTestMode()) {
    return;
  }

  LOG.assertTrue(!isAutopopupCompletion());

  if (ApplicationManager.getApplication().isUnitTestMode() || !myHandler.invokedExplicitly) {
    CompletionServiceImpl.setCompletionPhase(CompletionPhase.NoCompletion);
    return;
  }

  for (final CompletionContributor contributor : CompletionContributor.forParameters(getParameters())) {
    final String text = contributor.handleEmptyLookup(getParameters(),getEditor());
    if (StringUtil.isNotEmpty(text)) {
      LightweightHint hint = showErrorHint(getProject(),getEditor(),text);
      CompletionServiceImpl.setCompletionPhase(
        awaitSecondInvocation ? new CompletionPhase.NoSuggestionsHint(hint,this) : CompletionPhase.NoCompletion);
      return;
    }
  }
  CompletionServiceImpl.setCompletionPhase(CompletionPhase.NoCompletion);
}

@Override
public void hyperlinkUpdate(@NotNull HyperlinkEvent e) {
  if (e.getEventType() != HyperlinkEvent.EventType.ACTIVATED) {
    return;
  }

  String description = e.getDescription();
  if (StringUtil.isEmpty(description) || !description.startsWith(DocumentationManagerProtocol.PSI_ELEMENT_PROTOCOL)) {
    return;
  }

  String elementName = e.getDescription().substring(DocumentationManagerProtocol.PSI_ELEMENT_PROTOCOL.length());

  final PsiElement targetElement = myProvider.getDocumentationElementForLink(PsiManager.getInstance(myProject),elementName,myContext);
  if (targetElement != null) {
    LightweightHint hint = myHint;
    if (hint != null) {
      hint.hide(true);
    }
    myDocumentationManager.showJavaDocInfo(targetElement,myContext,null);
  }
}

@Override
public LightweightHint show(@NotNull Editor editor,@NotNull HintHint hintHint) {
  myTrafficLightRenderer = (TrafficLightRenderer)((EditorMarkupModelImpl)editor.getMarkupModel()).getErrorStripeRenderer();
  myPanel = new TrafficProgresspanel(myTrafficLightRenderer,hintHint);
  repaintTooltipwindow();
  LinetooltipRenderer.correctLocation(editor,myPanel,myPanel.getMinWidth());
  LightweightHint hint = new LightweightHint(myPanel);

  HintManagerImpl hintManager = (HintManagerImpl)HintManager.getInstance();
  hintManager.showEditorHint(hint,HintManager.HIDE_BY_ANY_KEY | HintManager.HIDE_BY_TEXT_CHANGE | HintManager.HIDE_BY_OTHER_HINT |
                             HintManager.HIDE_BY_SCROLLING,hintHint);
  hint.addHintListener(new HintListener() {
    @Override
    public void hintHidden(EventObject event) {
      if (myPanel == null) return; //double hide?
      myPanel = null;
      onHide.run();
    }
  });
  return hint;
}

@Nullable
private static LightweightHint getHint(@NotNull PsiElement element) {
  for (PreviewHintProvider hintProvider : Extensions.getExtensions(PreviewHintProvider.EP_NAME)) {
    JComponent preview;
    try {
      preview = hintProvider.getPreviewComponent(element);
    }
    catch (Exception e) {
      LOG.error(e);
      continue;
    }
    if (preview != null) {
      return new LightweightHint(preview);
    }
  }
  return null;
}

private void queueRevalidate(@Nullable final Runnable after) {
  queue(new AfterModelUpdate(ID.REVALIDATE) {
    @Override
    protected void after() {
      final LightweightHint hint = myPanel.getHint();
      if (hint != null) {
        myPanel.getHintContainerShowPoint().doWhenDone(new Consumer<RelativePoint>() {
          @Override
          public void consume(final RelativePoint relativePoint) {
            hint.setSize(myPanel.getPreferredSize());
            hint.setLocation(relativePoint);
            if (after != null) {
              after.run();
            }
          }
        });
      }
      else {
        if (after != null) {
          after.run();
        }
      }
    }
  });
}

public void showTooltip(@NotNull Editor editor,hintInfo);

  myCurrentTooltipGroup = group;
  myCurrentTooltip = hint;
  myCurrentTooltipObject = tooltipRenderer;
}

private static void showLookupEditorHint(Object[] descriptors,pos.getSecond());
    }
  });
}

protected void handleEmptyLookup(final boolean awaitSecondInvocation) {
  LOG.assertTrue(!isAutopopupCompletion());

  if (ApplicationManager.getApplication().isUnitTestMode() || !myHandler.invokedExplicitly) {
    CompletionServiceImpl.setCompletionPhase(CompletionPhase.NoCompletion);
    return;
  }

  for (final CompletionContributor contributor : CompletionContributor.forParameters(getParameters())) {
    final String text = contributor.handleEmptyLookup(getParameters(),this) : CompletionPhase.NoCompletion);
      return;
    }
  }
  CompletionServiceImpl.setCompletionPhase(CompletionPhase.NoCompletion);
}

@Override
public void hyperlinkUpdate(@NotNull HyperlinkEvent e) {
  if (e.getEventType() != HyperlinkEvent.EventType.ACTIVATED) {
    return;
  }

  String description = e.getDescription();
  if (StringUtil.isEmpty(description) || !description.startsWith(DocumentationManager.PSI_ELEMENT_PROTOCOL)) {
    return;
  }

  String elementName = e.getDescription().substring(DocumentationManager.PSI_ELEMENT_PROTOCOL.length());

  final PsiElement targetElement = myProvider.getDocumentationElementForLink(PsiManager.getInstance(myProject),null);
  }
}

@Override
public LightweightHint show(@NotNull Editor editor,hintHint);
  LinetooltipRenderer.correctLocation(editor,-1);
  LightweightHint hint = new LightweightHint(myPanel);

  HintManagerImpl hintManager = (HintManagerImpl)HintManager.getInstance();
  hintManager.showEditorHint(hint,hintHint);
  hint.addHintListener(new HintListener() {
    @Override
    public void hintHidden(EventObject event) {
      if (myPanel == null) return; //double hide?
      myPanel = null;
      onHide.run();
    }
  });
  repaintTooltipwindow();
  return hint;
}

@Nullable
private static LightweightHint getHint(@NotNull PsiElement element) {
  for (PreviewHintProvider hintProvider : Extensions.getExtensions(PreviewHintProvider.EP_NAME)) {
    JComponent preview;
    try {
      preview = hintProvider.getPreviewComponent(element);
    }
    catch (Exception e) {
      LOG.error(e);
      continue;
    }
    if (preview != null) {
      return new LightweightHint(preview);
    }
  }
  return null;
}

private void queueRevalidate(@Nullable final Runnable after) {
  queue(new AfterModelUpdate(ID.REVALIDATE) {
    @Override
    protected void after() {
      final LightweightHint hint = myPanel.getHint();
      if (hint != null) {
        myPanel.getHintContainerShowPoint().doWhenDone(new AsyncResult.Handler<RelativePoint>() {
          @Override
          public void run(final RelativePoint relativePoint) {
            hint.setSize(myPanel.getPreferredSize());
            hint.setLocation(relativePoint);
            if (after != null) {
              after.run();
            }
          }
        });
      }
      else {
        if (after != null) {
          after.run();
        }
      }
    }
  });
}

public void showTooltip(@Nonnull Editor editor,@Nonnull Point p,@Nonnull TooltipRenderer tooltipRenderer,@Nonnull TooltipGroup group,@Nonnull HintHint hintInfo) {
  if (myCurrentTooltip == null || !myCurrentTooltip.isVisible()) {
    myCurrentTooltipObject = null;
  }

  if (Comparing.equal(tooltipRenderer,hintInfo);

  myCurrentTooltipGroup = group;
  myCurrentTooltip = hint;
  myCurrentTooltipObject = tooltipRenderer;
}

private static void showLookupEditorHint(Object[] descriptors,ParameterInfoHandler handler,boolean requestFocus) {
  ParameterInfoComponent component = new ParameterInfoComponent(descriptors,handler,requestFocus);
  component.update();

  final LightweightHint hint = new LightweightHint(component);
  hint.setSelectingHint(true);
  final HintManagerImpl hintManager = HintManagerImpl.getInstanceImpl();
  final Pair<Point,pos.getSecond());
    }
  });
}

protected void handleEmptyLookup(final boolean awaitSecondInvocation) {
  if (isAutopopupCompletion() && ApplicationManager.getApplication().isUnitTestMode()) {
    return;
  }

  LOG.assertTrue(!isAutopopupCompletion());

  if (ApplicationManager.getApplication().isUnitTestMode() || !myHandler.invokedExplicitly) {
    CompletionServiceImpl.setCompletionPhase(CompletionPhase.NoCompletion);
    return;
  }

  for (final CompletionContributor contributor : CompletionContributor.forParameters(getParameters())) {
    final String text = contributor.handleEmptyLookup(getParameters(),text);
      CompletionServiceImpl.setCompletionPhase(
              awaitSecondInvocation ? new CompletionPhase.NoSuggestionsHint(hint,this) : CompletionPhase.NoCompletion);
      return;
    }
  }
  CompletionServiceImpl.setCompletionPhase(CompletionPhase.NoCompletion);
}

@Override
public void hyperlinkUpdate(@Nonnull HyperlinkEvent e) {
  if (e.getEventType() != HyperlinkEvent.EventType.ACTIVATED) {
    return;
  }

  String description = e.getDescription();
  if (StringUtil.isEmpty(description) || !description.startsWith(DocumentationManagerProtocol.PSI_ELEMENT_PROTOCOL)) {
    return;
  }

  String elementName = e.getDescription().substring(DocumentationManagerProtocol.PSI_ELEMENT_PROTOCOL.length());

  final PsiElement targetElement = myProvider.getDocumentationElementForLink(PsiManager.getInstance(myProject),null);
  }
}

private void showMessageIfNeeded() {
  if (myWarning != null) {
    myEditor.getScrollingModel().disableAnimation();
    myEditor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
    myEditor.getScrollingModel().enableAnimation();

    LogicalPosition hintPosition = myCaret.getLogicalPosition();
    if (myWarningLocation != null) {
      LogicalPosition targetPosition = myEditor.offsetToLogicalPosition(myWarningLocation.getStartOffset());
      Point targetPoint = myEditor.logicalPositionToXY(targetPosition);
      if (myEditor.getScrollingModel().getVisibleArea().contains(targetPoint)) {
        hintPosition = targetPosition;
      }
    }
    LightweightHint hint = new LightweightHint(HintUtil.createinformationLabel(myWarning));
    Point p = HintManagerImpl.getHintPosition(hint,myEditor,hintPosition,HintManager.ABOVE);
    HintManagerImpl.getInstanceImpl().showEditorHint(hint,false);
  }
}

@Override
public LightweightHint show(@Nonnull Editor editor,@Nonnull HintHint hintHint) {
  myTrafficLightRenderer = (TrafficLightRenderer)((EditorMarkupModelImpl)editor.getMarkupModel()).getErrorStripeRenderer();
  myPanel = new TrafficProgresspanel(myTrafficLightRenderer,hintHint);
  hint.addHintListener(new HintListener() {
    @Override
    public void hintHidden(EventObject event) {
      if (myPanel == null) return; //double hide?
      myPanel = null;
      onHide.run();
    }
  });
  return hint;
}

@Nullable
private static LightweightHint getHint(@Nonnull PsiElement element) {
  for (PreviewHintProvider hintProvider : Extensions.getExtensions(PreviewHintProvider.EP_NAME)) {
    JComponent preview;
    try {
      preview = hintProvider.getPreviewComponent(element);
    }
    catch (Exception e) {
      LOG.error(e);
      continue;
    }
    if (preview != null) {
      return new LightweightHint(preview);
    }
  }
  return null;
}

private void queueRevalidate(@Nullable final Runnable after) {
  queue(new AfterModelUpdate(ID.REVALIDATE) {
    @Override
    protected void after() {
      final LightweightHint hint = myPanel.getHint();
      if (hint != null) {
        myPanel.getHintContainerShowPoint().doWhenDone((Consumer<RelativePoint>)relativePoint -> {
          hint.setSize(myPanel.getPreferredSize());
          hint.setLocation(relativePoint);
          if (after != null) {
            after.run();
          }
        });
      }
      else {
        if (after != null) {
          after.run();
        }
      }
    }
  });
}

public void showTooltipByMouseMove(@NotNull final Editor editor,@NotNull final RelativePoint point,final TooltipRenderer tooltipObject,final boolean alignToRight,@NotNull final TooltipGroup group,@NotNull HintHint hintHint) {
  LightweightHint currentTooltip = myCurrentTooltip;
  if (currentTooltip == null || !currentTooltip.isVisible()) {
    if (currentTooltip != null) {
      if (!IdetooltipManager.getInstance().isQueuedToShow(currentTooltip.getCurrentIdetooltip())) {
        myCurrentTooltipObject = null;
      }
    }
    else {
      myCurrentTooltipObject = null;
    }
  }

  if (Comparing.equal(tooltipObject,myCurrentTooltipObject)) {
    IdetooltipManager.getInstance().cancelAutoHide();
    return;
  }
  hideCurrentTooltip();

  if (tooltipObject != null) {
    final Point p = point.getPointOn(editor.getComponent().getRootPane().getlayeredPane()).getPoint();
    if (!hintHint.isAwtTooltip()) {
      p.x += alignToRight ? -10 : 10;
    }

    Project project = editor.getProject();
    if (project != null && !project.isopen()) return;
    if (editor.getContentComponent().isShowing()) {
      showTooltip(editor,tooltipObject,hintHint);
    }
  }
}

private void hideCurrentTooltip() {
  if (myCurrentTooltip != null) {
    LightweightHint currentTooltip = myCurrentTooltip;
    myCurrentTooltip = null;
    currentTooltip.hide();
    myCurrentTooltipGroup = null;
    IdetooltipManager.getInstance().hide(null);
  }
}

@Nullable
public static LightweightHint showEditorFragmentHint(Editor editor,TextRange range,boolean showFolding,boolean hideByAnyKey){
  if (!(editor instanceof EditorEx)) return null;
  JRootPane rootPane = editor.getComponent().getRootPane();
  if (rootPane == null) return null;
  JlayeredPane layeredPane = rootPane.getlayeredPane();
  int lineHeight = editor.getLineHeight();
  int overhang = editor.getScrollingModel().getVisibleArea().y -
          editor.logicalPositionToXY(editor.offsetToLogicalPosition(range.getEndOffset())).y;
  int yRelative = overhang > 0 && overhang < lineHeight ? 
                  lineHeight - overhang + JBUI.scale(LINE_BORDER_THICKnesS + EMPTY_BORDER_THICKnesS) : 0;
  Point point = SwingUtilities.convertPoint(((EditorEx)editor).getScrollPane().getViewport(),-2,yRelative,layeredPane);
  return showEditorFragmentHintAt(editor,range,point.y,showFolding,hideByAnyKey,false);
}

private void expand(@NotNull LightweightHint hint,@NotNull Editor editor,@NotNull JEditorPane pane,@NotNull HintHint hintHint) {
  hint.hide();
  if (myCurrentWidth > 0) {
    stripDescription();
  }
  TooltipController.getInstance().showTooltip(editor,new Point(p.x - 3,p.y - 3),createRenderer(myText,myCurrentWidth > 0 ? 0 : pane.getWidth()),hintHint);
}

@Override
public void setUp() throws Exception {
  super.setUp();
  EditorHintListener listener = new EditorHintListener() {
    @Override
    public void hintShown(Project project,int flags) {
      hintCount++;
    }
  };
  ApplicationManager.getApplication().getMessageBus().connect(myTestRootdisposable).subscribe(EditorHintListener.TOPIC,listener);
}

@Override
@NotNull
public Pair<Point,Short> getBestPointPosition(LightweightHint hint,final PsiElement list,int offset,final boolean awtTooltip,short preferredPosition) {
  final TextRange textRange = list.getTextRange();
  offset = textRange.contains(offset) ? offset:textRange.getStartOffset() + 1;
  if (prevIoUsOffset == offset) return Pair.create(prevIoUsBestPoint,prevIoUsBestPosition);

  String listText = list.getText();
  final boolean isMultiline = listText.indexOf('\n') >= 0 || listText.indexOf('\r') >= 0;
  final LogicalPosition pos = myEditor.offsetToLogicalPosition(offset);
  Pair<Point,Short> position;

  if (!isMultiline) {
    position = chooseBestHintPosition(myEditor.getProject(),pos.line,pos.column,awtTooltip,preferredPosition);
  }
  else {
    Point p = HintManagerImpl.getHintPosition(hint,pos,HintManager.ABOVE);
    position = new Pair<Point,Short>(p,HintManager.ABOVE);
  }
  prevIoUsBestPoint = position.getFirst();
  prevIoUsBestPosition = position.getSecond();
  prevIoUsOffset = offset;
  return position;
}

private static LightweightHint showErrorHint(Project project,Editor editor,String text) {
  final LightweightHint[] result = {null};
  final EditorHintListener listener = new EditorHintListener() {
    @Override
    public void hintShown(final Project project,final LightweightHint hint,final int flags) {
      result[0] = hint;
    }
  };
  final MessageBusConnection connection = project.getMessageBus().connect();
  connection.subscribe(EditorHintListener.TOPIC,listener);
  assert text != null;
  HintManager.getInstance().showErrorHint(editor,text,HintManager.UNDER);
  connection.disconnect();
  return result[0];
}

private void showScopeHint(final int lbraceStart,final int lbraceEnd) {
  LogicalPosition bracePosition = myEditor.offsetToLogicalPosition(lbraceStart);
  Point braceLocation = myEditor.logicalPositionToXY(bracePosition);
  final int y = braceLocation.y;
  myAlarm.addRequest(
      new Runnable() {
        @Override
        public void run() {
          if (!myEditor.getComponent().isShowing()) return;
          Rectangle viewRect = myEditor.getScrollingModel().getVisibleArea();
          if (y < viewRect.y) {
            int start = lbraceStart;
            if (!(myPsiFile instanceof PsiPlainTextFile) && myPsiFile.isValid()) {
              PsiDocumentManager.getInstance(myProject).commitAllDocuments();
              start = BraceMatchingUtil.getBraceMatcher(getFileTypeByOffset(lbraceStart),PsiUtilCore
                .getLanguageAtOffset(myPsiFile,lbraceStart)).getCodeConstructStart(myPsiFile,lbraceStart);
            }
            TextRange range = new TextRange(start,lbraceEnd);
            int line1 = myDocument.getLineNumber(range.getStartOffset());
            int line2 = myDocument.getLineNumber(range.getEndOffset());
            line1 = Math.max(line1,line2 - 5);
            range = new TextRange(myDocument.getLinestartOffset(line1),range.getEndOffset());
            LightweightHint hint = EditorFragmentComponent.showEditorFragmentHint(myEditor,true);
            myEditor.putUserData(HINT_IN_EDITOR_KEY,hint);
          }
        }
      },300,ModalityState.stateForComponent(myEditor.getComponent()));
}

void clearBraceHighlighters() {
  List<RangeHighlighter> Highlighters = getHighlightersList();
  for (final RangeHighlighter Highlighter : Highlighters) {
    Highlighter.dispose();
  }
  Highlighters.clear();

  LightweightHint hint = myEditor.getUserData(HINT_IN_EDITOR_KEY);
  if (hint != null) {
    hint.hide();
    myEditor.putUserData(HINT_IN_EDITOR_KEY,null);
  }
}

@Nullable
private Rectangle getHintBounds() {
  LightweightHint hint = myHint;
  if (hint == null) {
    return null;
  }
  JComponent hintComponent = hint.getComponent();
  if (!hintComponent.isShowing()) {
    return null;
  }
  return new Rectangle(hintComponent.getLocationOnScreen(),hintComponent.getSize());
}

public void showHint(@NotNull LightweightHint hint) {
  final HintManagerImpl hintManager = HintManagerImpl.getInstanceImpl();
  Point p = HintManagerImpl.getHintPosition(hint,myPosition,HintManager.ABOVE);
  hintManager.showEditorHint(hint,HintManager.HIDE_BY_ANY_KEY | HintManager.HIDE_BY_TEXT_CHANGE | HintManager.HIDE_BY_SCROLLING,HintManagerImpl.createHintHint(myEditor,HintManager.ABOVE).setContentActive(false));
}

public static void showHint(@NotNull Editor editor,@NotNull String info,@Nullable HyperlinkListener hyperlinkListener) {
  JComponent component = HintUtil.createinformationLabel(info,hyperlinkListener,null,null);
  LightweightHint hint = new LightweightHint(component);
  HintManagerImpl.getInstanceImpl().showEditorHint(hint,HintManager.UNDER,HintManager.HIDE_BY_ANY_KEY |
                                                   HintManager.HIDE_BY_TEXT_CHANGE |
                                                   HintManager.HIDE_BY_SCROLLING,false);
}

public static void showReadOnlyViewWarning(Editor editor) {
  if (ApplicationManager.getApplication().isHeadlessEnvironment()) return;

  JComponent component = HintUtil.createinformationLabel("This view is read-only");
  final LightweightHint hint = new LightweightHint(component);
  HintManagerImpl.getInstanceImpl().showEditorHint(hint,false);
}

@Override
public void show(@NotNull PsiElement element,@NotNull Point point,boolean keyTriggered) {
  LightweightHint newHint = getHint(element);
  hideCurrentHintIfAny();
  if (newHint == null) {
    return;
  }

  hint = newHint;
  HintManagerImpl.getInstanceImpl().showEditorHint(newHint,getHintPosition(newHint,editor.xyToLogicalPosition(point),HintManager.RIGHT_UNDER),HINT_HIDE_FLAGS,false);
}

protected static void showHint(final Editor editor) {
  String message = FindBundle.message("select.next.occurence.not.found.message");
  final LightweightHint hint = new LightweightHint(HintUtil.createinformationLabel(message));
  HintManagerImpl.getInstanceImpl().showEditorHint(hint,HintManager.HIDE_BY_TEXT_CHANGE | HintManager.HIDE_BY_SCROLLING,false);
}

private static void showEditorHint(String message,final Editor editor) {
  JComponent component = HintUtil.createinformationLabel(message);
  final LightweightHint hint = new LightweightHint(component);
  HintManagerImpl.getInstanceImpl().showEditorHint(hint,false);
}

/**
 * Shows intention hint (light bulb) if it's not visible yet.
 */
final void showIntentionHint(){
  if(!myComponent.isShowing() || !IJSwingUtilities.hasFocus(myComponent)){
    hideIntentionHint();
    return;
  }

  // 1. Hide prevIoUs hint (if any)
  hideIntentionHint();

  // 2. Found error (if any)
  final ErrorInfo[] errorInfos = getErrorInfos();
  if(!haveFixes(errorInfos)) {
    hideIntentionHint();
    return;
  }

  // 3. Determine position where this hint should be shown
  final Rectangle bounds = getErrorBounds();
  if(bounds == null){
    return;
  }

  // 4. Show light bulb to fix this error
  final LightBulbComponentImpl lightBulbComponent = new LightBulbComponentImpl(this,AllIcons.Actions.IntentionBulb);
  myHint = new LightweightHint(lightBulbComponent);
  myLastHintBounds = bounds;
  myHint.show(myComponent,bounds.x - AllIcons.Actions.IntentionBulb.getIconWidth() - 4,bounds.y,myComponent,new HintHint(myComponent,bounds.getLocation()));
}

@Override
public void annotate(@NotNull PsiElement psiElement,@NotNull AnnotationHolder holder) {
  if (psiElement instanceof Header) {
    Header header = (Header)psiElement;
    String name = header.getName();
    if (!isValidName(name)) {
      holder.createAnnotation(HighlightSeverity.ERROR,header.getNameElement().getTextRange(),ManifestBundle.message("header.name.invalid"));
    }
    else {
      HeaderParser headerParser = myRepository.getHeaderParser(name);
      if (headerParser != null) {
        headerParser.annotate(header,holder);
      }
    }
  }
}

@NotNull
public FileFixture waitForCodeAnalysisHighlightCount(@NotNull final HighlightSeverity severity,final int expected) {
  final Document document = getNotNullDocument();
  pause(new Condition("Waiting for code analysis " + severity + " count to reach " + expected) {
    @Override
    public boolean test() {
      Collection<HighlightInfo> highlightInfos = execute(new GuiQuery<Collection<HighlightInfo>>() {
        @Override
        protected Collection<HighlightInfo> executeInEDT() throws Throwable {
          CommonProcessors.CollectProcessor<HighlightInfo> processor = new CommonProcessors.CollectProcessor<HighlightInfo>();
          DaemonCodeAnalyzerEx.processHighlights(document,myProject,severity,document.getTextLength(),processor);
          return processor.getResults();
        }
      });
      assertNotNull(highlightInfos);
      return highlightInfos.size() == expected;
    }
  },SHORT_TIMEOUT);

  return this;
}

@NotNull
public static List<HighlightInfo.IntentionActionDescriptor> getAvailableActions(@NotNull final Editor editor,@NotNull final PsiFile file,final int passId) {
  final int offset = ((EditorEx)editor).getExpectedCaretoffset();
  final Project project = file.getProject();

  final List<HighlightInfo.IntentionActionDescriptor> result = new ArrayList<HighlightInfo.IntentionActionDescriptor>();
  DaemonCodeAnalyzerImpl.processHighlightsNearOffset(editor.getDocument(),project,HighlightSeverity.informatION,offset,true,new Processor<HighlightInfo>() {
    @Override
    public boolean process(HighlightInfo info) {
      addAvailableActionsForGroups(info,editor,file,result,passId,offset);
      return true;
    }
  });
  return result;
}

protected HighlightSeverity getSeverity(@NotNull RefElement element) {
  final PsiElement psiElement = element.getPointer().getContainingFile();
  if (psiElement != null) {
    final GlobalinspectionContextImpl context = getContext();
    final String shortName = getSeverityDelegateName();
    final Tools tools = context.getTools().get(shortName);
    if (tools != null) {
      for (ScopetoolState state : tools.getTools()) {
        inspectionToolWrapper toolWrapper = state.getTool();
        if (toolWrapper == getToolWrapper()) {
          return context.getCurrentProfile().getErrorLevel(HighlightdisplayKey.find(shortName),psiElement).getSeverity();
        }
      }
    }

    final inspectionProfile profile = inspectionProjectProfileManager.getInstance(context.getProject()).getinspectionProfile();
    final HighlightdisplayLevel level = profile.getErrorLevel(HighlightdisplayKey.find(shortName),psiElement);
    return level.getSeverity();
  }
  return null;
}

static boolean processHighlightsOverlappingOutside(@NotNull Document document,@NotNull Project project,@Nullable("null means all") final HighlightSeverity minSeverity,final int startOffset,final int endOffset,@NotNull final Processor<HighlightInfo> processor) {
  LOG.assertTrue(ApplicationManager.getApplication().isReadAccessAllowed());

  final SeverityRegistrar severityRegistrar = SeverityRegistrar.getSeverityRegistrar(project);
  MarkupModelEx model = (MarkupModelEx)DocumentMarkupModel.forDocument(document,true);
  return model.processRangeHighlightersOutside(startOffset,endOffset,new Processor<RangeHighlighterEx>() {
    @Override
    public boolean process(@NotNull RangeHighlighterEx marker) {
      Object tt = marker.getErrorStripetooltip();
      if (!(tt instanceof HighlightInfo)) return true;
      HighlightInfo info = (HighlightInfo)tt;
      return minSeverity != null && severityRegistrar.compare(info.getSeverity(),minSeverity) < 0
             || info.Highlighter == null
             || processor.process(info);
    }
  });
}

@Override
public boolean process(Trinity<ProblemDescriptor,LocalinspectionToolWrapper,ProgressIndicator> trinity) {
  ProgressIndicator indicator = trinity.getThird();
  if (indicator.isCanceled()) {
    return false;
  }

  ProblemDescriptor descriptor = trinity.first;
  LocalinspectionToolWrapper tool = trinity.second;
  PsiElement psiElement = descriptor.getPsiElement();
  if (psiElement == null) return true;
  PsiFile file = psiElement.getContainingFile();
  Document thisDocument = documentManager.getDocument(file);

  HighlightSeverity severity = inspectionProfile.getErrorLevel(HighlightdisplayKey.find(tool.getShortName()),file).getSeverity();

  infos.clear();
  createHighlightsForDescriptor(infos,emptyActionRegistered,ilManager,thisDocument,tool,descriptor,psiElement);
  for (HighlightInfo info : infos) {
    final EditorColoRSScheme coloRSScheme = getColoRSScheme();
    UpdateHighlightersUtil.addHighlighterToEditorIncrementally(myProject,myDocument,getFile(),myRestrictRange.getStartOffset(),myRestrictRange.getEndOffset(),info,coloRSScheme,getId(),ranges2markersCache);
  }

  return true;
}

@Nullable
public static Annotation createAnnotation(final DomElementProblemDescriptor problemDescriptor) {

  return createProblemDescriptors(problemDescriptor,new Function<Pair<TextRange,PsiElement>,Annotation>() {
    @Override
    public Annotation fun(final Pair<TextRange,PsiElement> s) {
      String text = problemDescriptor.getDescriptionTemplate();
      if (StringUtil.isEmpty(text)) text = null;
      final HighlightSeverity severity = problemDescriptor.getHighlightSeverity();

      TextRange range = s.first;
      if (text == null) range = TextRange.from(range.getStartOffset(),0);
      range = range.shiftRight(s.second.getTextRange().getStartOffset());
      final Annotation annotation = createAnnotation(severity,range,text);

      if (problemDescriptor instanceof DomElementResolveProblemDescriptor) {
        annotation.setTextAttributes(CodeInsightColors.WRONG_REFERENCES_ATTRIBUTES);
      }

      for(LocalQuickFix fix:problemDescriptor.getFixes()) {
        if (fix instanceof IntentionAction) annotation.registerFix((IntentionAction)fix);
      }
      return annotation;
    }
  });
}

private static String toProblemType(int severityValue) {
  if (severityValue < HighlightSeverity.WARNING.myVal) {
    return Problem.INFO;
  } else if (severityValue < HighlightSeverity.ERROR.myVal) {
    return Problem.WARNING;
  } else {
    return Problem.ERROR;
  }
}

public merlinErrorAnnotator() {
    severities.put(merlinErrorType.error,HighlightSeverity.ERROR);
    severities.put(merlinErrorType.type,HighlightSeverity.ERROR);
    severities.put(merlinErrorType.parser,HighlightSeverity.ERROR);
    severities.put(merlinErrorType.env,HighlightSeverity.ERROR);
    severities.put(merlinErrorType.warning,HighlightSeverity.WARNING);
    severities.put(merlinErrorType.unkNown,HighlightSeverity.informatION);
}

public void testHighlights() throws Exception
{
  myFixture.configureByFile( "json/highlight/MyError.json" );
  List<HighlightInfo> highlightInfos = myFixture.doHighlighting( HighlightSeverity.WARNING );
  assertEquals( 1,highlightInfos.size() );
  assertEquals( "Invalid URI fragment: /deFinitions/crawlStepTyp",highlightInfos.get( 0 ).getDescription() );
  assertEquals( "\"#/deFinitions/crawlStepTyp\"",highlightInfos.get( 0 ).getText() );
}

@Override
public void apply(@NotNull PsiFile file,RamlValidationResult annotationResult,@NotNull AnnotationHolder holder)
{
    final List<ErrorNode> errorNodes = annotationResult.getErrorNodes();
    for (ErrorNode errorNode : errorNodes)
    {
        if (file.getVirtualFile().getPath().endsWith(errorNode.getStartPosition().getPath()))
        {
            holder.createAnnotation(HighlightSeverity.ERROR,new TextRange(errorNode.getStartPosition().getIndex(),errorNode.getEndPosition().getIndex()),errorNode.getErrorMessage());
        }
    }

}

/**
 * Annotates the given comment so that tags like @command,@bis,and @fnc (Arma Intellij Plugin specific tags) are properly annotated
 *
 * @param annotator the annotator
 * @param comment   the comment
 */
public static void annotateDocumentationWithArmaPluginTags(@NotNull AnnotationHolder annotator,@NotNull PsiComment comment) {
    List<String> allowedTags = new ArrayList<>(3);
    allowedTags.add("command");
    allowedTags.add("bis");
    allowedTags.add("fnc");
    Pattern patternTag = Pattern.compile("@([a-zA-Z]+) ([a-zA-Z_0-9]+)");
    Matcher matcher = patternTag.matcher(comment.getText());
    String tag;
    Annotation annotation;
    int startTag,endTag,startArg,endArg;
    while (matcher.find()) {
        if (matcher.groupCount() < 2) {
            continue;
        }
        tag = matcher.group(1);
        if (!allowedTags.contains(tag)) {
            continue;
        }
        startTag = matcher.start(1);
        endTag = matcher.end(1);
        startArg = matcher.start(2);
        endArg = matcher.end(2);
        annotation = annotator.createAnnotation(HighlightSeverity.informatION,TextRange.create(comment.getTextOffset() + startTag - 1,comment.getTextOffset() + endTag),null);
        annotation.setTextAttributes(DefaultLanguageHighlighterColors.DOC_COMMENT_TAG);
        annotation = annotator.createAnnotation(HighlightSeverity.informatION,TextRange.create(comment.getTextOffset() + startArg,comment.getTextOffset() + endArg),null);
        annotation.setTextAttributes(DefaultLanguageHighlighterColors.DOC_COMMENT_TAG_VALUE);
    }
}

@Test
public void testWarningForDeprecatedFormat() {
  BuildFile file =
      createBuildFile(
          new WorkspacePath("java/com/google/BUILD"),"load('/tools/ide/build_test.bzl','build_test')");
  assertHasAnnotation(
      file,"Deprecated load Syntax; loaded Skylark module should by in label format.",HighlightSeverity.WARNING);
}

@NotNull
@Override
public List<HighlightInfo> doHighlighting(@NotNull final HighlightSeverity minimalSeverity) {
  return ContainerUtil.filter(doHighlighting(),new Condition<HighlightInfo>() {
    @Override
    public boolean value(HighlightInfo info) {
      return info.getSeverity().compareto(minimalSeverity) >= 0;
    }
  });
}

@NotNull
public static TextAttributes getTextAttributes(@Nullable EditorColoRSScheme editorColoRSScheme,@NotNull SeverityRegistrar severityRegistrar,@NotNull HighlightSeverity severity) {
    TextAttributes textAttributes = severityRegistrar.getTextAttributesBySeverity(severity);
    if (textAttributes != null) {
        return textAttributes;
    }
    EditorColoRSScheme coloRSScheme = getColoRSScheme(editorColoRSScheme);
    HighlightInfoType.HighlightInfoTypeImpl infoType = severityRegistrar.getHighlightInfoTypeBySeverity(severity);
    TextAttributesKey key = infoType.getAttributesKey();
    return coloRSScheme.getAttributes(key);
}

public void testAnnotatorProducerOnly() {
    myFixture.configureByText("AnnotatorTestData.java",getJavaProducerOnlyTestData());
    myFixture.checkHighlighting(false,false,true);

    List<HighlightInfo> list = myFixture.doHighlighting();

    // find the warning from the highlights as checkWarning cannot do that for us for warnings
    boolean found = list.stream().anyMatch(i -> i.getText().equals("delete")
        && i.getDescription().equals("Option not applicable in producer only mode")
        && i.getSeverity().equals(HighlightSeverity.WARNING));
    assertTrue("Should find the warning",found);
}

private void assertHasAnnotation(BuildFile file,String message,HighlightSeverity type) {
  assertthat(
          validateFile(file)
              .stream()
              .filter(ann -> ann.getSeverity().equals(type))
              .map(Annotation::getMessage)
              .collect(Collectors.toList()))
      .contains(message);
}

@Nullable
    private static Annotation createAnnotation(@NotNull AnnotationHolder holder,@NotNull PsiFile file,@NotNull Document document,@NotNull SassLint.Issue warn,@NotNull HighlightSeverity severity,@Nullable TextAttributes forcedTextAttributes,boolean showErrorOnWholeLine) {
        int line = warn.line - 1;
//        int column = warn.column /*- 1*/;

        if (line < 0 || line >= document.getLineCount()) {
            return null;
        }
        int lineEndOffset = document.getLineEndOffset(line);
        int linestartOffset = document.getLinestartOffset(line);

//        int errorLinestartOffset = StringUtil.lineColToOffset(document.getChaRSSequence(),line,column);
//        int errorLinestartOffset = PsiUtil.calcErrorStartOffsetInDocument(document,linestartOffset,lineEndOffset,column,tab);

//        if (errorLinestartOffset == -1) {
//            return null;
//        }
//        PsiElement element = file.findElementAt(errorLinestartOffset);
        TextRange range;
//        if (showErrorOnWholeLine) {
            range = new TextRange(linestartOffset,lineEndOffset);
//        } else {
////            int offset = StringUtil.lineColToOffset(document.getText(),warn.line - 1,warn.column);
//            PsiElement lit = PsiUtil.getElementAtOffset(file,errorLinestartOffset);
//            range = lit.getTextRange();
//            range = new TextRange(errorLinestartOffset,errorLinestartOffset + 1);
//        }

        Annotation annotation = inspectionUtil.createAnnotation(holder,forcedTextAttributes,MESSAGE_PREFIX + warn.message.trim() + " (" + warn.source + ')');
//        if (annotation != null) {
//            annotation.setAfterEndOfLine(errorLinestartOffset == lineEndOffset);
//        }
        return annotation;
    }

private void convertErrorsAndWarnings(@NotNull Collection<HighlightInfo> highlights,@NotNull List<CodeSmellInfo> result,@NotNull Document document) {
  for (HighlightInfo highlightInfo : highlights) {
    final HighlightSeverity severity = highlightInfo.getSeverity();
    if (SeverityRegistrar.getSeverityRegistrar(myProject).compare(severity,HighlightSeverity.WARNING) >= 0) {
      result.add(new CodeSmellInfo(document,getDescription(highlightInfo),new TextRange(highlightInfo.startOffset,highlightInfo.endOffset),severity));
    }
  }
}

/**
 * We can't find generated resources. If a layout uses them,the layout won't render correctly.
 */
private void reportGeneratedResources(
    AndroidResourceModule resourceModule,TargetMap targetMap,ArtifactLocationDecoder decoder) {
  Map<String,Throwable> brokenClasses = logger.getbrokenClasses();
  if (brokenClasses == null || brokenClasses.isEmpty()) {
    return;
  }

  // Sorted entries for deterministic error message.
  SortedMap<ArtifactLocation,TargetIdeInfo> generatedResources =
      Maps.newTreeMap(getGeneratedResources(targetMap.get(resourceModule.targetKey)));

  for (TargetKey dependency : resourceModule.transitiveResourceDependencies) {
    generatedResources.putAll(getGeneratedResources(targetMap.get(dependency)));
  }

  if (generatedResources.isEmpty()) {
    return;
  }

  HtmlBuilder builder = new HtmlBuilder();
  builder.add("Generated resources will not be discovered by the IDE:");
  builder.beginList();
  for (Map.Entry<ArtifactLocation,TargetIdeInfo> entry : generatedResources.entrySet()) {
    ArtifactLocation resource = entry.getKey();
    TargetIdeInfo target = entry.getValue();
    builder.listItem().add(resource.getRelativePath()).add(" from ");
    addTargetLink(builder,target,decoder);
  }
  builder
      .endList()
      .add("Please avoid using generated resources,")
      .addLink("then ","sync the project"," ",getLinkManager().createSyncProjectUrl())
      .addLink("and ","refresh the layout",".",getLinkManager().createRefreshRenderUrl());
  addissue()
      .setSeverity(HighlightSeverity.ERROR,HIGH_PRIORITY + 1) // Reported above broken classes
      .setSummary("Generated resources")
      .setHtmlContent(builder)
      .build();
}

protected static String getTextAttributeKey(@NotNull Project project,@NotNull ProblemHighlightType highlightType) {
  if (highlightType == ProblemHighlightType.LIKE_DEPRECATED) {
    return HighlightInfoType.DEPRECATED.getAttributesKey().getExternalName();
  }
  if (highlightType == ProblemHighlightType.LIKE_UNKNowN_SYMBOL && severity == HighlightSeverity.ERROR) {
    return HighlightInfoType.WRONG_REF.getAttributesKey().getExternalName();
  }
  if (highlightType == ProblemHighlightType.LIKE_UNUSED_SYMBOL) {
    return HighlightInfoType.UNUSED_SYMBOL.getAttributesKey().getExternalName();
  }
  SeverityRegistrar registrar = inspectionProjectProfileManagerImpl.getInstanceImpl(project).getSeverityRegistrar();
  return registrar.getHighlightInfoTypeBySeverity(severity).getAttributesKey().getExternalName();
}

@Override
public DomElementProblemDescriptor createProblem(@NotNull final DomElement domElement,final HighlightSeverity highlightType,final String message,final TextRange textRange,final LocalQuickFix... fixes) {
  return addProblem(new DomElementProblemDescriptorImpl(domElement,message,highlightType,textRange,null,fixes));
}

private static void checkManagedDependencies(@NotNull MavendomProjectModel projectModel,@NotNull DomElementAnnotationHolder holder) {
  MultiMap<DependencyConflictId,MavendomDependency> duplicates = MultiMap.createSet();
  collect(duplicates,projectModel.getDependencyManagement().getDependencies());

  for (Map.Entry<DependencyConflictId,Collection<MavendomDependency>> entry : duplicates.entrySet()) {
    Collection<MavendomDependency> set = entry.getValue();
    if (set.size() <= 1) continue;

    for (MavendomDependency dependency : set) {
      holder.createProblem(dependency,HighlightSeverity.WARNING,"Duplicated dependency");
    }
  }
}

public static void registerSeverity(@NotNull HighlightSeverity severity,@NotNull TextAttributesKey key,@Nullable Icon icon) {
  Icon severityIcon = icon != null ? icon : createIconByKey(key);
  final HighlightdisplayLevel level = ourMap.get(severity);
  if (level == null) {
    new HighlightdisplayLevel(severity,severityIcon);
  }
  else {
    level.myIcon = severityIcon;
  }
}

@NotNull
public Set<HighlightSeverity> getUsedSeverities() {
  LOG.assertTrue(myInitialized);
  final Set<HighlightSeverity> result = new HashSet<HighlightSeverity>();
  for (Tools tools : myTools.values()) {
    for (ScopetoolState state : tools.getTools()) {
      result.add(state.getLevel().getSeverity());
    }
  }
  return result;
}

public SeverityAndOccurrences incOccurrences(final String toolName,final HighlightSeverity severity) {
  if (myPrimarySeverity == null) {
    myPrimarySeverity = severity;
  } else if (!Comparing.equal(severity,myPrimarySeverity)) {
    myPrimarySeverity = ScopesAndSeveritiesTable.MIXED_FAKE_SEVERITY;
  }
  myOccurrences.put(toolName,severity);
  return this;
}

@NotNull
private static ProblemDescriptor[] convertToProblemDescriptors(@NotNull final List<Annotation> annotations,@NotNull final inspectionManager manager,@NotNull final PsiFile file) {
  if (annotations.isEmpty()) {
    return ProblemDescriptor.EMPTY_ARRAY;
  }

  List<ProblemDescriptor> problems = ContainerUtil.newArrayListWithCapacity(annotations.size());
  IdentityHashMap<IntentionAction,LocalQuickFix> quickFixMappingCache = ContainerUtil.newIdentityHashMap();
  for (Annotation annotation : annotations) {
    if (annotation.getSeverity() == HighlightSeverity.informatION ||
        annotation.getStartOffset() == annotation.getEndOffset()) {
      continue;
    }

    final PsiElement startElement = file.findElementAt(annotation.getStartOffset());
    final PsiElement endElement = file.findElementAt(annotation.getEndOffset() - 1);
    if (startElement == null || endElement == null) {
      continue;
    }

    LocalQuickFix[] quickFixes = toLocalQuickFixes(annotation.getQuickFixes(),quickFixMappingCache);
    ProblemDescriptor descriptor = manager.createProblemDescriptor(startElement,endElement,annotation.getMessage(),ProblemHighlightType.GENERIC_ERROR_OR_WARNING,quickFixes);
    problems.add(descriptor);
  }
  return problems.toArray(new ProblemDescriptor[problems.size()]);
}

/**
 * Waits until the editor has the given number of errors at the given severity.
 * Typically used when you want to invoke an intention action,but need to wait until
 * the code analyzer has found an error it needs to resolve first.
 *
 * @param severity the severity of the issues you want to count
 * @param expected the expected count
 * @return this
 */
@NotNull
public EditorFixture waitForCodeAnalysisHighlightCount(@NotNull final HighlightSeverity severity,int expected) {
  VirtualFile currentFile = getCurrentFile();
  assertNotNull("Expected a file to be open",currentFile);
  FileFixture file = new FileFixture(myFrame.getProject(),currentFile);
  file.waitForCodeAnalysisHighlightCount(severity,expected);

  return this;
}

public static SeverityRenderer create(final inspectionProfileImpl inspectionProfile,@Nullable final Runnable onClose) {
  final SortedSet<HighlightSeverity> severities =
    LevelChooserAction.getSeverities(((SeverityProvider)inspectionProfile.getProfileManager()).getownSeverityRegistrar());
  return new SeverityRenderer(ContainerUtil.map2Array(severities,new SeverityState[severities.size()],new Function<HighlightSeverity,SeverityState>() {
    @Override
    public SeverityState fun(HighlightSeverity severity) {
      return new SeverityState(severity,false);
    }
  }),onClose);
}

@NotNull
public static HighlightSeverity getSeverity(final List<ScopetoolState> scopetoolStates) {
  HighlightSeverity prevIoUsValue = null;
  for (final ScopetoolState scopetoolState : scopetoolStates) {
    final HighlightSeverity currentValue = scopetoolState.getLevel().getSeverity();
    if (prevIoUsValue == null) {
      prevIoUsValue = currentValue;
    } else if (!prevIoUsValue.equals(currentValue)){
      return MIXED_FAKE_SEVERITY;
    }
  }
  return prevIoUsValue;
}

@Nullable
@Override
public HighlightInfo create() {
  HighlightInfo info = createUnconditionally();
  LOG.assertTrue(psiElement != null || severity == HighlightInfoType.SYMBOL_TYPE_SEVERITY || severity == HighlightInfoType.INJECTED_FRAGMENT_SEVERITY || ArrayUtilRt.find(HighlightSeverity.DEFAULT_SEVERITIES,severity) != -1,"Custom type requires not-null element to detect its text attributes");

  if (!isAcceptedByFilters(info,psiElement)) return null;

  return info;
}

@NotNull
public static HighlightInfoType convertSeverity(@NotNull HighlightSeverity severity) {
  return severity == HighlightSeverity.ERROR? HighlightInfoType.ERROR :
         severity == HighlightSeverity.WARNING ? HighlightInfoType.WARNING :
         severity == HighlightSeverity.INFO ? HighlightInfoType.INFO :
         severity == HighlightSeverity.WEAK_WARNING ? HighlightInfoType.WEAK_WARNING :
         severity ==HighlightSeverity.GENERIC_SERVER_ERROR_OR_WARNING ? HighlightInfoType.GENERIC_WARNINGS_OR_ERRORS_FROM_SERVER :
         HighlightInfoType.informatION;
}

private jpopupmenu compoundPopup() {
  final DefaultActionGroup group = new DefaultActionGroup();
  final SeverityRegistrar severityRegistrar = ((SeverityProvider)mySelectedProfile.getProfileManager()).getownSeverityRegistrar();
  TreeSet<HighlightSeverity> severities = new TreeSet<HighlightSeverity>(severityRegistrar);
  severities.add(HighlightSeverity.ERROR);
  severities.add(HighlightSeverity.WARNING);
  severities.add(HighlightSeverity.WEAK_WARNING);
  final Collection<SeverityRegistrar.SeverityBasedTextAttributes> infoTypes =
    SeverityUtil.getRegisteredHighlightingInfoTypes(severityRegistrar);
  for (SeverityRegistrar.SeverityBasedTextAttributes info : infoTypes) {
    severities.add(info.getSeverity());
  }
  for (HighlightSeverity severity : severities) {
    final HighlightdisplayLevel level = HighlightdisplayLevel.find(severity);
    group.add(new AnAction(renderSeverity(severity),renderSeverity(severity),level.getIcon()) {
      @Override
      public void actionPerformed(@NotNull AnActionEvent e) {
        setNewHighlightingLevel(level);
      }

      @Override
      public boolean isDumbAware() {
        return true;
      }
    });
  }
  group.add(Separator.getInstance());
  ActionPopupMenu menu = ActionManager.getInstance().createActionPopupMenu(ActionPlaces.UNKNowN,group);
  return menu.getComponent();
}

private void incErrorCount(RangeHighlighter Highlighter,int delta) {
  Object o = Highlighter.getErrorStripetooltip();
  if (!(o instanceof HighlightInfo)) return;
  HighlightInfo info = (HighlightInfo)o;
  HighlightSeverity infoSeverity = info.getSeverity();
  final int severityIdx = mySeverityRegistrar.getSeverityIdx(infoSeverity);
  if (severityIdx != -1) {
    errorCount[severityIdx] += delta;
  }
}

private static void appendTag(StringBuilder sb,HighlightInfo cur,boolean opening,final boolean compact) {
  sb.append("<");
  if (!opening) sb.append("/");
  if (cur.isAfterEndOfLine()) {
    sb.append(cur.getSeverity() == HighlightSeverity.WARNING ? "EOLWarning" : "EOLError");
  }
  else {
    sb.append(cur.getSeverity() == HighlightSeverity.WARNING ? "warning" : "error");
  }
  if (opening && !compact) {
    sb.append(" descr=\"").append(cur.getDescription()).append("\"");

  }
  sb.append(">");
}

@Override
public void checkFileElement(DomFileElement<MavendomProjectModel> domFileElement,DomElementAnnotationHolder holder) {
  MavendomProjectModel projectModel = domFileElement.getRootElement();

  MultiMap<Pair<String,String>,MavendomPlugin> duplicates = MultiMap.createSet();

  for (MavendomPlugin plugin : projectModel.getBuild().getPlugins().getPlugins()) {
    String groupId = plugin.getGroupId().getStringValue();
    String artifactId = plugin.getArtifactId().getStringValue();

    if (StringUtil.isEmptyOrSpaces(artifactId)) continue;

    if ("".equals(groupId) || "org.apache.maven.plugins".equals(groupId) || "org.codehaus.mojo".equals(groupId)) {
      groupId = null;
    }

    duplicates.putValue(Pair.create(groupId,artifactId),plugin);
  }

  for (Map.Entry<Pair<String,Collection<MavendomPlugin>> entry : duplicates.entrySet()) {
    Collection<MavendomPlugin> set = entry.getValue();
    if (set.size() <= 1) continue;

    for (MavendomPlugin dependency : set) {
      holder.createProblem(dependency,"Duplicated plugin declaration");
    }
  }
}

protected Deferred(@NotNull HighlightSeverity severity,@Nullable String tag,@NotNull String text,@Nullable Throwable throwable) {
  //noinspection AssignmentToStaticFieldFromInstanceMethod
  super(severity,ourNextOrdinaL++);
  mytag = tag;
  myText = text;
  throwable(throwable);
}

@Override
@NotNull
public HighlightSeverity getSeverity(final PsiElement psiElement) {
  inspectionProfile profile = psiElement == null
                              ? (inspectionProfile)inspectionProfileManager.getInstance().getRootProfile()
                              : inspectionProjectProfileManager.getInstance(psiElement.getProject()).getinspectionProfile();
  HighlightdisplayLevel level = profile.getErrorLevel(myToolKey,psiElement);
  LOG.assertTrue(level != HighlightdisplayLevel.DO_NOT_SHOW);
  return level.getSeverity();
}

private static int collectErrors(final List<CodeSmellInfo> codeSmells) {
  int result = 0;
  for (CodeSmellInfo codeSmellInfo : codeSmells) {
    if (codeSmellInfo.getSeverity() == HighlightSeverity.ERROR) result++;
  }
  return result;
}

private void gotoNextError(Project project,Editor editor,PsiFile file,int caretoffset) {
  final SeverityRegistrar severityRegistrar = SeverityRegistrar.getSeverityRegistrar(project);
  DaemonCodeAnalyzerSettings settings = DaemonCodeAnalyzerSettings.getInstance();
  int maxSeverity = settings.NEXT_ERROR_ACTION_GOES_TO_ERRORS_FirsT ? severityRegistrar.getSeveritiesCount() - 1 : 0;

  for (int idx = maxSeverity; idx >= 0; idx--) {
    final HighlightSeverity minSeverity = severityRegistrar.getSeverityByIndex(idx);
    HighlightInfo infoToGo = findInfo(project,caretoffset,minSeverity);
    if (infoToGo != null) {
      navigatetoError(project,infoToGo);
      return;
    }
  }
  showMessageWhenNoHighlights(project,editor);
}

@NotNull
@Override
public JSHighlighter getSyntaxHighlighter()
{
    return new JSHighlighter(myDialectOptionHolder);
}

@NotNull
@Override
public JSHighlighter getSyntaxHighlighter()
{
    return new JSHighlighter(myDialectOptionHolder);
}

@NotNull
@Override
public JSHighlighter getSyntaxHighlighter()
{
    return new JSHighlighter(myDialectOptionHolder);
}

@Override
public PsiNameValuePairstub createStub(LighteraST tree,LighteraSTNode node,StubElement parentStub) {
  String name = null;
  String value = null;
  List<LighteraSTNode> children = tree.getChildren(node);
  for (LighteraSTNode child : children) {
    if (child.getTokenType() == JavaTokenType.IDENTIFIER) {
      name = RecordUtil.intern(tree.getCharTable(),child);
    }
    else if (child.getTokenType() == JavaElementType.LIteraL_EXPRESSION) {
      value = RecordUtil.intern(tree.getCharTable(),tree.getChildren(child).get(0));
      value = StringUtil.unquoteString(value);
    }
  }
  return new PsiNameValuePairstubImpl(parentStub,StringRef.fromString(name),StringRef.fromString(value));
}

@Override
public PsiImportStatementStub createStub(LighteraST tree,StubElement parentStub) {
  boolean isondemand = false;
  String refText = null;

  for (LighteraSTNode child : tree.getChildren(node)) {
    IElementType type = child.getTokenType();
    if (type == JavaElementType.JAVA_CODE_REFERENCE || type == JavaElementType.IMPORT_STATIC_REFERENCE) {
      refText = JavaSourceUtil.getReferenceText(tree,child);
    }
    else if (type == JavaTokenType.ASTERISK) {
      isondemand = true;
    }
  }

  byte flags = PsiImportStatementStubImpl.packFlags(isondemand,node.getTokenType() == JavaElementType.IMPORT_STATIC_STATEMENT);
  return new PsiImportStatementStubImpl(parentStub,refText,flags);
}

public static boolean isDeprecatedByAnnotation(@NotNull LighteraST tree,@NotNull LighteraSTNode modList) {
  for (final LighteraSTNode child : tree.getChildren(modList)) {
    if (child.getTokenType() == JavaElementType.ANNOTATION) {
      final LighteraSTNode ref = LightTreeUtil.firstChildOfType(tree,child,JavaElementType.JAVA_CODE_REFERENCE);
      if (ref != null) {
        final LighteraSTNode id = LightTreeUtil.firstChildOfType(tree,ref,JavaTokenType.IDENTIFIER);
        if (id != null) {
          final String name = intern(tree.getCharTable(),id);
          if (DEPRECATED_ANNOTATION_NAME.equals(name)) return true;
        }
      }
    }
  }

  return false;
}

@NotNull
@Override
protected StubElement createStubForFile(@NotNull PsiFile file,@NotNull LighteraST tree) {
  if (!(file instanceof PsiJavaFile)) {
    return super.createStubForFile(file,tree);
  }

  String refText = "";
  LighteraSTNode pkg = LightTreeUtil.firstChildOfType(tree,tree.getRoot(),JavaElementType.PACKAGE_STATEMENT);
  if (pkg != null) {
    LighteraSTNode ref = LightTreeUtil.firstChildOfType(tree,pkg,JavaElementType.JAVA_CODE_REFERENCE);
    if (ref != null) {
      refText = JavaSourceUtil.getReferenceText(tree,ref);
    }
  }
  return new PsiJavaFileStubImpl((PsiJavaFile)file,StringRef.fromString(refText),false);
}

public static void toBuffer(@NotNull LighteraST tree,@NotNull LighteraSTNode node,@NotNull StringBuilder buffer,@Nullable TokenSet skipTypes) {
  if (skipTypes != null && skipTypes.contains(node.getTokenType())) {
    return;
  }

  if (node instanceof LighteraSTTokenNode) {
    buffer.append(((LighteraSTTokenNode)node).getText());
    return;
  }

  if (node instanceof LighterLazyParseableNode) {
    buffer.append(((LighterLazyParseableNode)node).getText());
    return;
  }

  List<LighteraSTNode> children = tree.getChildren(node);
  for (int i = 0,size = children.size(); i < size; ++i) {
    toBuffer(tree,children.get(i),buffer,skipTypes);
  }
  tree.disposeChildren(children);
}

@Override
public PsiNameValuePairstub createStub(LighteraST tree,tree.getChildren(child).get(0));
      value = StringUtil.stripQuotesAroundValue(value);
    }
  }
  return new PsiNameValuePairstubImpl(parentStub,StringRef.fromString(value));
}

@Override
public PsiImportStatementStub createStub(LighteraST tree,StubElement parentStub) {
  boolean isondemand = false;
  String refText = null;

  for (LighteraSTNode child : tree.getChildren(node)) {
    IElementType type = child.getTokenType();
    if (type == JavaElementType.JAVA_CODE_REFERENCE || type == JavaElementType.IMPORT_STATIC_REFERENCE) {
      refText = SourceUtil.getReferenceText(tree,flags);
}

public static boolean isDeprecatedByAnnotation(@NotNull LighteraST tree,id);
          if (DEPRECATED_ANNOTATION_NAME.equals(name)) return true;
        }
      }
    }
  }

  return false;
}

@NotNull
@Override
protected StubElement createStubForFile(@NotNull PsiFile file,JavaElementType.JAVA_CODE_REFERENCE);
    if (ref != null) {
      refText = SourceUtil.getReferenceText(tree,false);
}

public static void toBuffer(@NotNull LighteraST tree,@Nullable TokenSet skipTypes) {
  if (skipTypes != null && skipTypes.contains(node.getTokenType())) return;

  if (node instanceof LighteraSTTokenNode) {
    buffer.append(((LighteraSTTokenNode)node).getText());
    return;
  }

  if (node instanceof LighterLazyParseableNode) {
    buffer.append(((LighterLazyParseableNode)node).getText());
    return;
  }

  List<LighteraSTNode> children = tree.getChildren(node);
  for (int i = 0,skipTypes);
  }
}

public static void toBuffer(@Nonnull LighteraST tree,@Nonnull LighteraSTNode node,@Nonnull StringBuilder buffer,skipTypes);
  }
}

@Override
public PsiNameValuePairstub createStub(LighteraST tree,StringRef.fromString(value));
}

private static void formatParameter(@NotNull LighteraST tree,@NotNull LighteraSTNode parameter,StringBuilder buf)
{
    final List<LighteraSTNode> children = tree.getChildren(parameter);
    for(LighteraSTNode node : children)
    {
        final IElementType tokenType = node.getTokenType();
        if(tokenType == JavaElementType.TYPE)
        {
            formatType(tree,node,buf);
            buf.append(' ');
        }
        else if(tokenType == JavaTokenType.IDENTIFIER)
        {
            buf.append(RecordUtil.intern(tree.getCharTable(),node));
        }
    }
}

private static void formatTypeParameters(LighteraST tree,LighteraSTNode typeParameters,StringBuilder buf)
{
    final List<LighteraSTNode> children = LightTreeUtil.getChildrenOfType(tree,typeParameters,JavaElementType.TYPE);
    if(children.isEmpty())
    {
        return;
    }
    buf.append('<');
    for(int i = 0; i < children.size(); i++)
    {
        LighteraSTNode child = children.get(i);
        formatType(tree,buf);
        if(i != children.size() - 1)
        {
            buf.append(",");
        }
    }
    buf.append('>');
}

@Override
public PsiImportStatementStub createStub(LighteraST tree,StubElement parentStub)
{
    boolean isondemand = false;
    String refText = null;

    for(LighteraSTNode child : tree.getChildren(node))
    {
        IElementType type = child.getTokenType();
        if(type == JavaElementType.JAVA_CODE_REFERENCE || type == JavaElementType.IMPORT_STATIC_REFERENCE)
        {
            refText = JavaSourceUtil.getReferenceText(tree,child);
        }
        else if(type == JavaTokenType.ASTERISK)
        {
            isondemand = true;
        }
    }

    byte flags = PsiImportStatementStubImpl.packFlags(isondemand,node.getTokenType() == JavaElementType.IMPORT_STATIC_STATEMENT);
    return new PsiImportStatementStubImpl(parentStub,flags);
}

@Override
public PsiPackageAccessibilityStatementStub createStub(LighteraST tree,StubElement parentStub)
{
    String refText = null;
    List<String> to = ContainerUtil.newSmartList();

    for(LighteraSTNode child : tree.getChildren(node))
    {
        IElementType type = child.getTokenType();
        if(type == JavaElementType.JAVA_CODE_REFERENCE)
        {
            refText = JavaSourceUtil.getReferenceText(tree,child);
        }
        else if(type == JavaElementType.MODULE_REFERENCE)
        {
            to.add(JavaSourceUtil.getReferenceText(tree,child));
        }
    }

    return new PsiPackageAccessibilityStatementStubImpl(parentStub,this,to);
}

public static boolean isDeprecatedByAnnotation(@NotNull LighteraST tree,@NotNull LighteraSTNode modList)
{
    for(final LighteraSTNode child : tree.getChildren(modList))
    {
        if(child.getTokenType() == JavaElementType.ANNOTATION)
        {
            final LighteraSTNode ref = LightTreeUtil.firstChildOfType(tree,JavaElementType.JAVA_CODE_REFERENCE);
            if(ref != null)
            {
                final LighteraSTNode id = LightTreeUtil.firstChildOfType(tree,JavaTokenType.IDENTIFIER);
                if(id != null)
                {
                    final String name = intern(tree.getCharTable(),id);
                    if(DEPRECATED_ANNOTATION_NAME.equals(name))
                    {
                        return true;
                    }
                }
            }
        }
    }

    return false;
}

public static boolean isDeprecatedByDocComment(@NotNull LighteraST tree,@NotNull LighteraSTNode comment)
{
    String text = LightTreeUtil.toFilteredString(tree,comment,null);
    if(text.contains(DEPRECATED_TAG))
    {
        JavaDocLexer lexer = new JavaDocLexer(LanguageLevel.HIGHEST);
        lexer.start(text);
        IElementType token;
        while((token = lexer.getTokenType()) != null)
        {
            if(token == JavaDocTokenType.DOC_TAG_NAME && DEPRECATED_TAG.equals(lexer.getTokenText()))
            {
                return true;
            }
            lexer.advance();
        }
    }

    return false;
}

@NotNull
@Override
protected StubElement createStubForFile(@NotNull PsiFile file,@NotNull LighteraST tree)
{
    if(!(file instanceof PsiJavaFile))
    {
        return super.createStubForFile(file,tree);
    }

    String refText = "";
    LighteraSTNode pkg = LightTreeUtil.firstChildOfType(tree,JavaElementType.PACKAGE_STATEMENT);
    if(pkg != null)
    {
        LighteraSTNode ref = LightTreeUtil.firstChildOfType(tree,JavaElementType.JAVA_CODE_REFERENCE);
        if(ref != null)
        {
            refText = JavaSourceUtil.getReferenceText(tree,ref);
        }
    }
    return new PsiJavaFileStubImpl((PsiJavaFile) file,null,false);
}

@Nullable
private static MethodData calcData(LighteraST tree,LighteraSTNode method)
{
    LighteraSTNode body = LightTreeUtil.firstChildOfType(tree,method,JavaElementType.CODE_BLOCK);
    if(body == null)
    {
        return null;
    }
    List<LighteraSTNode> statements = ContractInferenceInterpreter.getStatements(body,tree);
    List<PreContract> contracts = new ContractInferenceInterpreter(tree,body).inferContracts(statements);
    NullityInference.NullityInferenceVisitor nullityVisitor = new NullityInference.NullityInferenceVisitor(tree,body);
    purityInference.purityInferenceVisitor purityVisitor = new purityInference.purityInferenceVisitor(tree,body);

    for(LighteraSTNode statement : statements)
    {
        walkMethodBody(tree,statement,it ->
        {
            nullityVisitor.visitNode(it);
            purityVisitor.visitNode(it);
        });
    }
    return createData(body,contracts,nullityVisitor.getResult(),purityVisitor.getResult());
}

private static void walkMethodBody(LighteraST tree,LighteraSTNode root,Consumer<LighteraSTNode> processor)
{
    new RecursiveLighteraSTNodeWalkingVisitor(tree)
    {
        @Override
        public void visitNode(@NotNull LighteraSTNode element)
        {
            IElementType type = element.getTokenType();
            if(type == JavaElementType.CLASS || type == JavaElementType.FIELD || type == JavaElementType.METHOD || type == JavaElementType.ANNOTATION_METHOD || type == JavaElementType
                    .LAMBDA_EXPRESSION)
            {
                return;
            }
            processor.accept(element);
            super.visitNode(element);
        }
    }.visitNode(root);
}

@NotNull
private static Set<LighteraSTNode> findCallsWithNulls(LighteraST lighterast,int[] nullOffsets)
{
    Set<LighteraSTNode> calls = new HashSet<>();
    for(int offset : nullOffsets)
    {
        LighteraSTNode leaf = LightTreeUtil.findLeafElementAt(lighterast,offset);
        LighteraSTNode literal = leaf == null ? null : lighterast.getParent(leaf);
        if(isNullLiteral(lighterast,literal))
        {
            LighteraSTNode exprList = lighterast.getParent(literal);
            if(exprList != null && exprList.getTokenType() == EXPRESSION_LIST)
            {
                ContainerUtil.addIfNotNull(calls,LightTreeUtil.getParentOfType(lighterast,exprList,CALL_TYPES,ElementType.MEMBER_BIT_SET));
            }
        }
    }
    return calls;
}

@Nullable
private static IntArrayList getNullParameterIndices(LighteraST lighterast,@NotNull LighteraSTNode methodCall)
{
    final LighteraSTNode node = LightTreeUtil.firstChildOfType(lighterast,methodCall,EXPRESSION_LIST);
    if(node == null)
    {
        return null;
    }
    final List<LighteraSTNode> parameters = JavaLightTreeUtil.getExpressionChildren(lighterast,node);
    IntArrayList indices = new IntArrayList(1);
    for(int idx = 0; idx < parameters.size(); idx++)
    {
        if(isNullLiteral(lighterast,parameters.get(idx)))
        {
            indices.add(idx);
        }
    }
    return indices;
}

@Nullable
private static String getmethodName(LighteraST lighterast,@NotNull LighteraSTNode call,IElementType elementType)
{
    if(elementType == NEW_EXPRESSION || elementType == ANONYMOUS_CLASS)
    {
        final List<LighteraSTNode> refs = LightTreeUtil.getChildrenOfType(lighterast,call,JAVA_CODE_REFERENCE);
        if(refs.isEmpty())
        {
            return null;
        }
        final LighteraSTNode lastRef = refs.get(refs.size() - 1);
        return JavaLightTreeUtil.getNameIdentifierText(lighterast,lastRef);
    }

    LOG.assertTrue(elementType == METHOD_CALL_EXPRESSION);
    final LighteraSTNode methodReference = lighterast.getChildren(call).get(0);
    if(methodReference.getTokenType() == REFERENCE_EXPRESSION)
    {
        return JavaLightTreeUtil.getNameIdentifierText(lighterast,methodReference);
    }
    return null;
}

@Override
public PsiFieldStub createStub(final LighteraST tree,final LighteraSTNode node,final StubElement parentStub) {
  final TypeInfo typeInfo = TypeInfo.create(tree,parentStub);

  boolean isDeprecatedByComment = false;
  boolean hasDeprecatedAnnotation = false;
  boolean hasDocComment = false;
  String name = null;
  String initializer = null;

  boolean expectingInit = false;
  for (final LighteraSTNode child : tree.getChildren(node)) {
    final IElementType type = child.getTokenType();
    if (type == JavaDocElementType.DOC_COMMENT) {
      hasDocComment = true;
      isDeprecatedByComment = RecordUtil.isDeprecatedByDocComment(tree,child);
    }
    else if (type == JavaElementType.MODIFIER_LIST) {
      hasDeprecatedAnnotation = RecordUtil.isDeprecatedByAnnotation(tree,child);
    }
    else if (type == JavaTokenType.IDENTIFIER) {
      name = RecordUtil.intern(tree.getCharTable(),child);
    }
    else if (type == JavaTokenType.EQ) {
      expectingInit = true;
    }
    else if (expectingInit && !ElementType.JAVA_COMMENT_OR_WHITESPACE_BIT_SET.contains(type) && type != JavaTokenType.SEMICOLON) {
      initializer = encodeInitializer(tree,child);
      break;
    }
  }

  final boolean isEnumConst = node.getTokenType() == JavaElementType.ENUM_CONSTANT;
  final byte flags = PsiFieldStubImpl.packFlags(isEnumConst,isDeprecatedByComment,hasDeprecatedAnnotation,hasDocComment);

  return new PsiFieldStubImpl(parentStub,name,typeInfo,initializer,flags);
}

private static String encodeInitializer(final LighteraST tree,final LighteraSTNode initializer) {
  final IElementType type = initializer.getTokenType();
  if (type == JavaElementType.NEW_EXPRESSION || type == JavaElementType.METHOD_CALL_EXPRESSION) {
    return PsiFieldStub.INITIALIZER_NOT_STORED;
  }

  if (initializer.getEndOffset() - initializer.getStartOffset() > INITIALIZER_LENGTH_LIMIT) {
    return PsiFieldStub.INITIALIZER_TOO_LONG;
  }

  return LightTreeUtil.toFilteredString(tree,null);
}

private static String[] getTexts(LighteraST tree,LighteraSTNode node) {
  List<LighteraSTNode> refs = LightTreeUtil.getChildrenOfType(tree,JavaElementType.JAVA_CODE_REFERENCE);
  String[] texts = ArrayUtil.newStringArray(refs.size());
  for (int i = 0; i < refs.size(); i++) {
    texts[i] = LightTreeUtil.toFilteredString(tree,refs.get(i),null);
  }
  return texts;
}

@Override
public PsiParameterStub createStub(LighteraST tree,StubElement parentStub) {
  TypeInfo typeInfo = TypeInfo.create(tree,parentStub);
  LighteraSTNode id = LightTreeUtil.requiredChildOfType(tree,JavaTokenType.IDENTIFIER);
  String name = RecordUtil.intern(tree.getCharTable(),id);
  return new PsiParameterStubImpl(parentStub,typeInfo.isEllipsis);
}

@Override
protected boolean skipChildProcessingWhenBuildingStubs(@NotNull LighteraST tree,@NotNull LighteraSTNode parent,@NotNull LighteraSTNode node) {
  IElementType parentType = parent.getTokenType();
  IElementType nodeType = node.getTokenType();

  if (checkByTypes(parentType,nodeType)) return true;

  if (nodeType == JavaElementType.CODE_BLOCK) {
    CodeBlockVisitor visitor = new CodeBlockVisitor();
    ((LighterLazyParseableNode)node).accept(visitor);
    return visitor.result;
  }

  return false;
}

@NotNull
public static List<LighteraSTNode> getChildrenOfType(@NotNull LighteraST tree,@NotNull IElementType type) {
  List<LighteraSTNode> result = null;

  List<LighteraSTNode> children = tree.getChildren(node);
  for (int i = 0,size = children.size(); i < size; ++i) {
    LighteraSTNode child = children.get(i);
    if (child.getTokenType() == type) {
      if (result == null) result = new SmartList<LighteraSTNode>();
      result.add(child);
    }
  }

  return result != null ? result: Collections.<LighteraSTNode>emptyList();
}

@NotNull
public static List<LighteraSTNode> getChildrenOfType(@NotNull LighteraST tree,@NotNull TokenSet types) {
  List<LighteraSTNode> result = null;

  List<LighteraSTNode> children = tree.getChildren(node);
  for (int i = 0,size = children.size(); i < size; ++i) {
    LighteraSTNode child = children.get(i);
    if (types.contains(child.getTokenType())) {
      if (result == null) result = new SmartList<LighteraSTNode>();
      result.add(child);
    }
  }

  return result != null ? result: Collections.<LighteraSTNode>emptyList();
}

@NotNull
public static String toFilteredString(@NotNull LighteraST tree,@Nullable TokenSet skipTypes) {
  int length = node.getEndOffset() - node.getStartOffset();
  if (length < 0) {
    length = 0;
    Logger.getInstance(LightTreeUtil.class).error("tree=" + tree + " node=" + node);
  }
  StringBuilder buffer = new StringBuilder(length);
  toBuffer(tree,skipTypes);
  return buffer.toString();
}

protected RecursiveLighteraSTNodeWalkingVisitor(@NotNull final LighteraST ast) {
  this.ast = ast;

  myWalkingState = new WalkingState<IndexedLighteraSTNode>(new LighteraSTGuide()) {
    @Override
    public void elementFinished(@NotNull IndexedLighteraSTNode element) {
      RecursiveLighteraSTNodeWalkingVisitor.this.elementFinished(element.node);

      if (parentStack.peek() == element) { // getFirstChild returned nothing. otherwise getFirstChild() was not called,i.e. super.visitNode() was not called i.e. just ignore
        IndexedLighteraSTNode[] children = childrenStack.pop();
        List<LighteraSTNode> list = children.length == 0 ? Collections.<LighteraSTNode>emptyList() : ContainerUtil.map(children,new Function<IndexedLighteraSTNode,LighteraSTNode>() {
          @Override
          public LighteraSTNode fun(IndexedLighteraSTNode node) {
            return node.node;
          }
        });
        ast.disposeChildren(list);
        parentStack.pop();
      }
    }

    @Override
    public void visit(@NotNull IndexedLighteraSTNode iNode) {
      LighteraSTNode element = iNode.node;
      RecursiveLighteraSTNodeWalkingVisitor visitor = RecursiveLighteraSTNodeWalkingVisitor.this;
      if (element instanceof LighterLazyParseableNode) {
        visitor.visitLazyParseableNode((LighterLazyParseableNode)element);
      }
      else if (element instanceof LighteraSTTokenNode) {
        visitor.visitTokenNode((LighteraSTTokenNode)element);
      }
      else {
        visitor.visitNode(element);
      }
    }
  };
}

public @NotNull LighteraST getLighteraSTForPsiDependentIndex() {
  LighteraST lighteraST = getUserData(IndexingDataKeys.LIGHTER_AST_NODE_KEY);
  if (lighteraST == null) {
    lighteraST = getPsiFileForPsiDependentIndex().getNode().getLighteraST();
    assert lighteraST != null;
    putUserData(IndexingDataKeys.LIGHTER_AST_NODE_KEY,lighteraST);
  }
  return lighteraST;
}

@Override
public PsiFieldStub createStub(final LighteraST tree,parentStub);

  boolean isDeprecatedByComment = false;
  boolean hasDeprecatedAnnotation = false;
  String name = null;
  String initializer = null;

  boolean expectingInit = false;
  for (final LighteraSTNode child : tree.getChildren(node)) {
    final IElementType type = child.getTokenType();
    if (type == JavaDocElementType.DOC_COMMENT) {
      isDeprecatedByComment = RecordUtil.isDeprecatedByDocComment(tree,hasDeprecatedAnnotation);

  return new PsiFieldStubImpl(parentStub,flags);
}

private static String encodeInitializer(final LighteraST tree,null);
}

private static String[] getTexts(LighteraST tree,null);
  }
  return texts;
}

@Override
public PsiParameterStub createStub(LighteraST tree,ID_TYPES);
  String name = RecordUtil.intern(tree.getCharTable(),typeInfo.isEllipsis);
}

@Override
protected boolean skipChildProcessingWhenBuildingStubs(@NotNull LighteraST tree,nodeType)) return true;

  if (nodeType == JavaElementType.CODE_BLOCK && node instanceof LighterLazyParseableNode) {
    CodeBlockVisitor visitor = new CodeBlockVisitor();
    ((LighterLazyParseableNode)node).accept(visitor);
    return visitor.result;
  }

  return false;
}

@Nullable
public static LighteraSTNode firstChildOfType(@NotNull LighteraST tree,@NotNull IElementType type) {
  List<LighteraSTNode> children = tree.getChildren(node);
  for (int i = 0,size = children.size(); i < size; ++i) {
    LighteraSTNode child = children.get(i);
    if (child.getTokenType() == type) return child;
  }

  return null;
}

public UnifiedEditorRangeHighlighter(@Nullable Project project,@NotNull Document document) {
  ApplicationManager.getApplication().assertReadAccessAllowed();

  MarkupModelEx model = (MarkupModelEx)DocumentMarkupModel.forDocument(document,project,false);
  if (model == null) return;

  model.processRangeHighlightersOverlappingWith(0,document.getTextLength(),new Processor<RangeHighlighterEx>() {
    @Override
    public boolean process(RangeHighlighterEx marker) {
      int newStart = marker.getStartOffset();
      int newEnd = marker.getEndOffset();

      myPieces.add(new Element(marker,newStart,newEnd));

      return true;
    }
  });
}

private void processRange(@NotNull MarkupModelEx model,@NotNull HighlightRange range) {
  final TextRange base = range.getBase();
  final TextRange changed = range.getChanged();
  final int changedLength = changed.getEndOffset() - changed.getStartOffset();

  model.processRangeHighlightersOverlappingWith(changed.getStartOffset(),changed.getEndOffset(),new Processor<RangeHighlighterEx>() {
    @Override
    public boolean process(RangeHighlighterEx marker) {
      int relativeStart = Math.max(marker.getStartOffset() - changed.getStartOffset(),0);
      int relativeEnd = Math.min(marker.getEndOffset() - changed.getStartOffset(),changedLength);

      int newStart = base.getStartOffset() + relativeStart;
      int newEnd = base.getStartOffset() + relativeEnd;

      if (newEnd - newStart <= 0) return true;

      myPieces.add(new Element(marker,newEnd));

      return true;
    }
  });
}

public void apply(@Nullable Project project,@NotNull Document document) {
  MarkupModel model = DocumentMarkupModel.forDocument(document,true);

  for (Element piece : myPieces) {
    RangeHighlighterEx delegate = piece.getDelegate();
    if (!delegate.isValid()) continue;

    RangeHighlighter Highlighter = model
      .addRangeHighlighter(piece.getStart(),piece.getEnd(),delegate.getLayer(),delegate.getTextAttributes(),delegate.getTargetArea());
    Highlighter.setEditorFilter(delegate.getEditorFilter());
    Highlighter.setCustomrenderer(delegate.getCustomrenderer());
    Highlighter.setErrorStripeMarkColor(delegate.getErrorStripeMarkColor());
    Highlighter.setErrorStripetooltip(delegate.getErrorStripetooltip());
    Highlighter.setGutterIconRenderer(delegate.getGutterIconRenderer());
    Highlighter.setLineMarkerRenderer(delegate.getLineMarkerRenderer());
    Highlighter.setLineseparatorColor(delegate.getLineseparatorColor());
    Highlighter.setThinErrorStripeMark(delegate.isThinErrorStripeMark());
    Highlighter.setLineseparatorPlacement(delegate.getLineseparatorPlacement());
    Highlighter.setLineseparatorRenderer(delegate.getLineseparatorRenderer());
  }
}

@NotNull
ChangeResult changeAttributesNoEvents(@NotNull Consumer<RangeHighlighterEx> change) {
  assert !isFlagSet(IN_BATCH_CHANGE_MASK);
  assert !isFlagSet(CHANGED_MASK);
  setFlag(IN_BATCH_CHANGE_MASK,true);
  setFlag(RENDERERS_CHANGED_MASK,false);
  ChangeResult result;
  try {
    change.consume(this);
  }
  finally {
    setFlag(IN_BATCH_CHANGE_MASK,false);
    boolean changed = isFlagSet(CHANGED_MASK);
    boolean renderersChanged = isFlagSet(RENDERERS_CHANGED_MASK);
    result = changed ? renderersChanged ? ChangeResult.RENDERERS_CHANGED : ChangeResult.MInor_CHANGE : ChangeResult.NOT_CHANGED;
    setFlag(CHANGED_MASK,false);
    setFlag(RENDERERS_CHANGED_MASK,false);
  }
  return result;
}

public static boolean processHighlights(@NotNull Document document,@NotNull Project project,@Nullable("null means all") final HighlightSeverity minSeverity,final int startOffset,final int endOffset,@NotNull final Processor<HighlightInfo> processor) {
  LOG.assertTrue(ApplicationManager.getApplication().isReadAccessAllowed());

  final SeverityRegistrar severityRegistrar = SeverityRegistrar.getSeverityRegistrar(project);
  MarkupModelEx model = (MarkupModelEx)DocumentMarkupModel.forDocument(document,true);
  return model.processRangeHighlightersOverlappingWith(startOffset,endOffset,new Processor<RangeHighlighterEx>() {
    @Override
    public boolean process(@NotNull RangeHighlighterEx marker) {
      Object tt = marker.getErrorStripetooltip();
      if (!(tt instanceof HighlightInfo)) return true;
      HighlightInfo info = (HighlightInfo)tt;
      return minSeverity != null && severityRegistrar.compare(info.getSeverity(),minSeverity) < 0
             || info.Highlighter == null
             || processor.process(info);
    }
  });
}

static boolean processHighlightsOverlappingOutside(@NotNull Document document,true);
  return model.processRangeHighlightersOutside(startOffset,minSeverity) < 0
             || info.Highlighter == null
             || processor.process(info);
    }
  });
}

private void paintHighlighterAfterEndOfLine(Graphics2D g,RangeHighlighterEx Highlighter) {
  if (!Highlighter.isAfterEndOfLine()) {
    return;
  }
  int startOffset = Highlighter.getStartOffset();
  int lineEndOffset = myDocument.getLineEndOffset(myDocument.getLineNumber(startOffset));
  if (myEditor.getFoldingModel().isOffsetCollapsed(lineEndOffset)) return;
  Point lineEnd = myView.offsetToXY(lineEndOffset,true,false);
  int x = lineEnd.x;
  int y = lineEnd.y;
  TextAttributes attributes = Highlighter.getTextAttributes();
  paintBackground(g,attributes,x,y,myView.getPlainSpaceWidth());
  if (attributes != null && hasTextEffect(attributes.getEffectColor(),attributes.getEffectType())) {
    paintTextEffect(g,x + myView.getPlainSpaceWidth() - 1,y + myView.getAscent(),attributes.getEffectColor(),attributes.getEffectType());
  }
}

private void paintBorderEffect(final Graphics2D g,final ClipDetector clipDetector,MarkupModelEx markupModel,int clipStartOffset,int clipEndOffset) {
  markupModel.processRangeHighlightersOverlappingWith(clipStartOffset,clipEndOffset,new Processor<RangeHighlighterEx>() {
    @Override
    public boolean process(RangeHighlighterEx rangeHighlighter) {
      if (rangeHighlighter.getEditorFilter().avaliableIn(myEditor)) {
        TextAttributes attributes = rangeHighlighter.getTextAttributes();
        if (isBorder(attributes)) {
          paintBorderEffect(g,clipDetector,rangeHighlighter.getAffectedAreaStartOffset(),rangeHighlighter.getAffectedAreaEndOffset(),attributes);
        }
      }
      return true;
    }
  });
}

public static List<RangeHighlighter> getHyperlinks(int startOffset,int endOffset,final Editor editor) {
  final MarkupModelEx markupModel = (MarkupModelEx)editor.getMarkupModel();
  final CommonProcessors.CollectProcessor<RangeHighlighterEx> processor = new CommonProcessors.CollectProcessor<RangeHighlighterEx>();
  markupModel.processRangeHighlightersOverlappingWith(startOffset,new FilteringProcessor<RangeHighlighterEx>(new Condition<RangeHighlighterEx>() {
                                                        @Override
                                                        public boolean value(RangeHighlighterEx rangeHighlighterEx) {
                                                          return rangeHighlighterEx.getEditorFilter().avaliableIn(editor) &&
                                                                 HYPERLINK_LAYER == rangeHighlighterEx.getLayer() &&
                                                                 rangeHighlighterEx.isValid() &&
                                                                 getHyperlinkInfo(rangeHighlighterEx) != null;
                                                        }
                                                      },processor)
  );
  return new ArrayList<RangeHighlighter>(processor.getResults());
}

public void testRangeHighlighterLinesInRangeForLongLinePerformance() throws Exception {
  final int N = 50000;
  Document document = EditorFactory.getInstance().createDocument(StringUtil.repeatSymbol('x',2 * N));

  final MarkupModelEx markupModel = (MarkupModelEx)DocumentMarkupModel.forDocument(document,ourProject,true);
  for (int i=0; i<N-1;i++) {
    markupModel.addRangeHighlighter(2*i,2*i+1,null,HighlighterTargetArea.EXACT_RANGE);
  }
  markupModel.addRangeHighlighter(N / 2,N / 2 + 1,HighlighterTargetArea.LInes_IN_RANGE);

  PlatformTestUtil.startPerformanceTest("slow Highlighters lookup",(int)(N*Math.log(N)/1000),new ThrowableRunnable() {
    @Override
    public void run() {
      List<RangeHighlighterEx> list = new ArrayList<RangeHighlighterEx>();
      CommonProcessors.CollectProcessor<RangeHighlighterEx> coll = new CommonProcessors.CollectProcessor<RangeHighlighterEx>(list);
      for (int i=0; i<N-1;i++) {
        list.clear();
        markupModel.processRangeHighlightersOverlappingWith(2*i,coll);
        assertEquals(2,list.size());  // 1 line plus one exact range marker
      }
    }
  }).assertTiming();
}

private static boolean isOffsetInsideHighlightInfo(int offset,@NotNull HighlightInfo info,boolean includeFixrange) {
  RangeHighlighterEx Highlighter = info.Highlighter;
  if (Highlighter == null || !Highlighter.isValid()) return false;
  int startOffset = Highlighter.getStartOffset();
  int endOffset = Highlighter.getEndOffset();
  if (startOffset <= offset && offset <= endOffset) {
    return true;
  }
  if (!includeFixrange) return false;
  RangeMarker fixMarker = info.fixMarker;
  if (fixMarker != null) {  // null means its range is the same as Highlighter
    if (!fixMarker.isValid()) return false;
    startOffset = fixMarker.getStartOffset();
    endOffset = fixMarker.getEndOffset();
    return startOffset <= offset && offset <= endOffset;
  }
  return false;
}

/**
 * Gets highlighted information from test console. Some parts of output (like file links) may be highlighted,and you need to check them.
 *
 * @return pair of [[ranges],[texts]] where range is [from,to] in doc. for each region,and "text" is text extracted from this region.
 * For example assume that in document "spam eggs ham" words "ham" and "spam" are highlighted.
 * You should have 2 ranges (0,4) and (10,13) and 2 strings (spam and ham)
 */
@NotNull
public Pair<List<Pair<Integer,Integer>>,List<String>> getHighlightedStringsInConsole() {
  final List<String> resultStrings = new ArrayList<String>();
  final List<Pair<Integer,Integer>> resultRanges = new ArrayList<Pair<Integer,Integer>>();
  ApplicationManager.getApplication().invokeAndWait(new Runnable() {
    @Override
    public void run() {
      myConsole.flushDeferredText();
      final Editor editor = myConsole.getEditor();
      for (final RangeHighlighter Highlighter : editor.getMarkupModel().getAllHighlighters()) {
        if (Highlighter instanceof RangeHighlighterEx) {
          final int start = ((RangeHighlighterEx)Highlighter).getAffectedAreaStartOffset();
          final int end = ((RangeHighlighterEx)Highlighter).getAffectedAreaEndOffset();
          resultRanges.add(Pair.create(start,end));
          resultStrings.add(editor.getDocument().getText().substring(start,end));
        }
      }
    }
  },ModalityState.NON_MODAL);
  return Pair.create(resultRanges,resultStrings);
}

RangeHighlighterImpl(@NotNull MarkupModel model,int start,int end,int layer,@NotNull HighlighterTargetArea target,TextAttributes textAttributes,boolean greedyToLeft,boolean greedyToRight) {
  super((DocumentEx)model.getDocument(),start,end,false);

  data = new RangeHighlighterData(model,target,textAttributes) {
    @NotNull
    @Override
    public RangeHighlighterEx getRangeHighlighter() {
      return RangeHighlighterImpl.this;
    }
  };

  registerInTree(start,greedyToLeft,greedyToRight,layer);
}

@Override
public RangeHighlighterEx addRangeHighlighterAndChangeAttributes(int startOffset,@NotNull HighlighterTargetArea targetArea,boolean isPersistent,@Nullable Consumer<RangeHighlighterEx> changeAttributesAction) {
  ApplicationManager.getApplication().assertIsdispatchThread();
  RangeHighlighterEx Highlighter = isPersistent
                                   ? new PersistentRangeHighlighterImpl(this,startOffset,layer,targetArea,textAttributes)
                                   : new RangeHighlighterImpl(this,textAttributes,false,false);

  myCachedHighlighters = null;
  if (changeAttributesAction != null) {
    ((RangeHighlighterImpl)Highlighter).changeAttributesNoEvents(changeAttributesAction);
  }
  fireAfteradded(Highlighter);
  return Highlighter;
}

public static boolean processHighlights(@NotNull Document document,@NotNull final Processor<HighlightInfo> processor) {
  LOG.assertTrue(ApplicationManager.getApplication().isReadAccessAllowed());

  final SeverityRegistrar severityRegistrar = SeverityUtil.getSeverityRegistrar(project);
  MarkupModelEx model = (MarkupModelEx)DocumentMarkupModel.forDocument(document,minSeverity) < 0
             || info.Highlighter == null
             || processor.process(info);
    }
  });
}

static boolean processHighlightsOverlappingOutside(@NotNull Document document,minSeverity) < 0
             || info.Highlighter == null
             || processor.process(info);
    }
  });
}

private static boolean isOffsetInsideHighlightInfo(int offset,boolean includeFixrange) {
  RangeHighlighterEx Highlighter = info.Highlighter;
  if (Highlighter == null || !Highlighter.isValid()) return false;
  int startOffset = Highlighter.getStartOffset();
  int endOffset = Highlighter.getEndOffset();
  if (startOffset <= offset && offset <= endOffset) {
    return true;
  }
  if (!includeFixrange) return false;
  RangeMarker fixMarker = info.fixMarker;
  if (fixMarker != null) {  // null means its range is the same as Highlighter
    if (!fixMarker.isValid()) return false;
    startOffset = fixMarker.getStartOffset();
    endOffset = fixMarker.getEndOffset();
    return startOffset <= offset && offset <= endOffset;
  }
  return false;
}

private static void duplicateHighlighters(MarkupModel to,MarkupModel from,int offset,TextRange textRange) {
  for (RangeHighlighter rangeHighlighter : from.getAllHighlighters()) {
    if (!rangeHighlighter.isValid()) continue;
    Object tooltip = rangeHighlighter.getErrorStripetooltip();
    HighlightInfo highlightInfo = tooltip instanceof HighlightInfo? (HighlightInfo)tooltip : null;
    if (highlightInfo != null) {
      if (highlightInfo.getSeverity() != HighlightSeverity.informatION) continue;
      if (highlightInfo.type.getAttributesKey() == EditorColors.IDENTIFIER_UNDER_CARET_ATTRIBUTES) continue;
    }
    final int localOffset = textRange.getStartOffset();
    final int start = Math.max(rangeHighlighter.getStartOffset(),localOffset) - localOffset;
    final int end = Math.min(rangeHighlighter.getEndOffset(),textRange.getEndOffset()) - localOffset;
    if (start > end) continue;
    final RangeHighlighter h = to.addRangeHighlighter(
      start + offset,end + offset,rangeHighlighter.getLayer(),rangeHighlighter.getTextAttributes(),rangeHighlighter.getTargetArea());
    ((RangeHighlighterEx)h).setAfterEndOfLine(((RangeHighlighterEx)rangeHighlighter).isAfterEndOfLine());
  }
}

public UnifiedEditorRangeHighlighter(@Nullable Project project,@Nonnull Document document) {
  ApplicationManager.getApplication().assertReadAccessAllowed();

  MarkupModelEx model = (MarkupModelEx)DocumentMarkupModel.forDocument(document,newEnd));

      return true;
    }
  });
}

private void processRange(@Nonnull MarkupModelEx model,@Nonnull HighlightRange range) {
  final TextRange base = range.getBase();
  final TextRange changed = range.getChanged();
  final int changedLength = changed.getEndOffset() - changed.getStartOffset();

  model.processRangeHighlightersOverlappingWith(changed.getStartOffset(),newEnd));

      return true;
    }
  });
}

public void apply(@Nullable Project project,@Nonnull Document document) {
  MarkupModel model = DocumentMarkupModel.forDocument(document,true);

  for (Element piece : myPieces) {
    RangeHighlighterEx delegate = piece.getDelegate();
    if (!delegate.isValid()) continue;

    RangeHighlighter Highlighter = model
            .addRangeHighlighter(piece.getStart(),delegate.getTargetArea());
    Highlighter.setEditorFilter(delegate.getEditorFilter());
    Highlighter.setCustomrenderer(delegate.getCustomrenderer());
    Highlighter.setErrorStripeMarkColor(delegate.getErrorStripeMarkColor());
    Highlighter.setErrorStripetooltip(delegate.getErrorStripetooltip());
    Highlighter.setGutterIconRenderer(delegate.getGutterIconRenderer());
    Highlighter.setLineMarkerRenderer(delegate.getLineMarkerRenderer());
    Highlighter.setLineseparatorColor(delegate.getLineseparatorColor());
    Highlighter.setThinErrorStripeMark(delegate.isThinErrorStripeMark());
    Highlighter.setLineseparatorPlacement(delegate.getLineseparatorPlacement());
    Highlighter.setLineseparatorRenderer(delegate.getLineseparatorRenderer());
  }
}

@ChangeStatus
byte changeAttributesNoEvents(@Nonnull Consumer<RangeHighlighterEx> change) {
  assert !isFlagSet(IN_BATCH_CHANGE_MASK);
  assert !isFlagSet(CHANGED_MASK);
  setFlag(IN_BATCH_CHANGE_MASK,false);
  setFlag(FONT_STYLE_OR_COLOR_CHANGED_MASK,false);
  byte result = 0;
  try {
    change.consume(this);
  }
  finally {
    setFlag(IN_BATCH_CHANGE_MASK,false);
    if (isFlagSet(CHANGED_MASK)) {
      result |= CHANGED_MASK;
      if (isFlagSet(RENDERERS_CHANGED_MASK)) result |= RENDERERS_CHANGED_MASK;
      if (isFlagSet(FONT_STYLE_OR_COLOR_CHANGED_MASK)) result |= FONT_STYLE_OR_COLOR_CHANGED_MASK;
    }
    setFlag(CHANGED_MASK,false);
    setFlag(FONT_STYLE_OR_COLOR_CHANGED_MASK,false);
  }
  return result;
}

public void testRangeHighlighterLinesInRangeForLongLinePerformance() throws Exception {
  final int N = 50000;
  Document document = EditorFactory.getInstance().createDocument(StringUtil.repeatSymbol('x',list.size());  // 1 line plus one exact range marker
      }
    }
  }).assertTiming();
}

private void paintHighlighterAfterEndOfLine(Graphics2D g,RangeHighlighterEx Highlighter) {
  if (!Highlighter.isAfterEndOfLine()) {
    return;
  }
  int startOffset = Highlighter.getStartOffset();
  int lineEndOffset = myDocument.getLineEndOffset(myDocument.getLineNumber(startOffset));
  if (myEditor.getFoldingModel().isOffsetCollapsed(lineEndOffset)) return;
  Point2D lineEnd = myView.offsetToXY(lineEndOffset,false);
  float x = (float)lineEnd.getX();
  int y = (int)lineEnd.getY();
  TextAttributes attributes = Highlighter.getTextAttributes();
  paintBackground(g,attributes.getEffectType(),false)) {
    paintTextEffect(g,false);
  }
}

private static boolean isOffsetInsideHighlightInfo(int offset,@Nonnull HighlightInfo info,boolean includeFixrange) {
  RangeHighlighterEx Highlighter = info.getHighlighter();
  if (Highlighter == null || !Highlighter.isValid()) return false;
  int startOffset = Highlighter.getStartOffset();
  int endOffset = Highlighter.getEndOffset();
  if (startOffset <= offset && offset <= endOffset) {
    return true;
  }
  if (!includeFixrange) return false;
  RangeMarker fixMarker = info.fixMarker;
  if (fixMarker != null) {  // null means its range is the same as Highlighter
    if (!fixMarker.isValid()) return false;
    startOffset = fixMarker.getStartOffset();
    endOffset = fixMarker.getEndOffset();
    return startOffset <= offset && offset <= endOffset;
  }
  return false;
}

private static void addActions(@Nonnull Project project,@Nonnull RangeHighlighterEx info,@Nonnull List<HighlightInfo.IntentionActionDescriptor> descriptors,@Nonnull AnActionEvent event) {
  final GutterIconRenderer r = info.getGutterIconRenderer();
  if (r == null || DumbService.isDumb(project) && !DumbService.isDumbAware(r)) {
    return;
  }
  List<HighlightInfo.IntentionActionDescriptor> list = new ArrayList<>();
  for (AnAction action : ar(r.getClickAction(),r.getMiddleButtonClickAction(),r.getRightButtonClickAction(),r.getPopupMenuActions())) {
    if (action != null) {
      addActions(action,list,r,event);
    }
  }

  if (list.isEmpty()) return;
  if (list.size() == 1) {
    descriptors.addAll(list);
  }
  else {
    HighlightInfo.IntentionActionDescriptor first = list.get(0);
    List<IntentionAction> options = ContainerUtil.map(list.subList(1,list.size()),HighlightInfo.IntentionActionDescriptor::getAction);
    descriptors.add(new HighlightInfo.IntentionActionDescriptor(first.getAction(),options,first.getIcon()));
  }
}

@NotNull
@Override
public RangeHighlighterEx addRangeHighlighterAndChangeAttributes(int startOffset,Consumer<RangeHighlighterEx> changeAttributesAction) {
  throw new ProcessCanceledException();
}

@Override
@Nullable
public RangeHighlighterEx addPersistentLineHighlighter(int lineNumber,TextAttributes textAttributes) {
  if (isNotValidLine(lineNumber)) {
    return null;
  }

  int offset = DocumentUtil.getFirstNonSpaceCharOffset(getDocument(),lineNumber);
  return addRangeHighlighter(PersistentRangeHighlighterImpl.create(this,offset,HighlighterTargetArea.LInes_IN_RANGE,false),null);
}

@Override
@NotNull
public RangeHighlighter[] getAllHighlighters() {
  ApplicationManager.getApplication().assertIsdispatchThread();
  if (myCachedHighlighters == null) {
    int size = myHighlighterTree.size() + myHighlighterTreeForLines.size();
    if (size == 0) return RangeHighlighter.EMPTY_ARRAY;
    List<RangeHighlighterEx> list = new ArrayList<RangeHighlighterEx>(size);
    CommonProcessors.CollectProcessor<RangeHighlighterEx> collectProcessor = new CommonProcessors.CollectProcessor<RangeHighlighterEx>(list);
    myHighlighterTree.process(collectProcessor);
    myHighlighterTreeForLines.process(collectProcessor);
    myCachedHighlighters = list.toArray(new RangeHighlighter[list.size()]);
  }
  return myCachedHighlighters;
}

@NotNull
@Override
public RangeHighlighterEx addRangeHighlighterAndChangeAttributes(int startOffset,@Nullable Consumer<RangeHighlighterEx> changeAttributesAction) {
  return addRangeHighlighter(isPersistent
                             ? PersistentRangeHighlighterImpl.create(this,true)
                             : new RangeHighlighterImpl(this,changeAttributesAction);
}

@NotNull
private RangeHighlighterEx addRangeHighlighter(@NotNull RangeHighlighterImpl Highlighter,@Nullable Consumer<RangeHighlighterEx> changeAttributesAction) {
  ApplicationManager.getApplication().assertIsdispatchThread();
  myCachedHighlighters = null;
  if (changeAttributesAction != null) {
    Highlighter.changeAttributesNoEvents(changeAttributesAction);
  }
  fireAfteradded(Highlighter);
  return Highlighter;
}

@Override
public void changeAttributesInBatch(@NotNull RangeHighlighterEx Highlighter,@NotNull Consumer<RangeHighlighterEx> changeAttributesAction) {
  ApplicationManager.getApplication().assertIsdispatchThread();
  RangeHighlighterImpl.ChangeResult changed = ((RangeHighlighterImpl)Highlighter).changeAttributesNoEvents(changeAttributesAction);
  if (changed != RangeHighlighterImpl.ChangeResult.NOT_CHANGED) {
    fireAttributesChanged(Highlighter,changed == RangeHighlighterImpl.ChangeResult.RENDERERS_CHANGED);
  }
}

@Override
public void addRangeHighlighter(@NotNull RangeHighlighterEx marker,boolean greedyToRight,int layer) {
  ApplicationManager.getApplication().assertIsdispatchThread();
  treeFor(marker).addInterval(marker,layer);
}

@Override
public void removeHighlighter(@NotNull RangeHighlighter segmentHighlighter) {
  ApplicationManager.getApplication().assertIsdispatchThread();
  myCachedHighlighters = null;
  if (!segmentHighlighter.isValid()) return;

  boolean removed = treeFor(segmentHighlighter).removeInterval((RangeHighlighterEx)segmentHighlighter);
  LOG.assertTrue(removed);
}

@Override
public boolean containsHighlighter(@NotNull final RangeHighlighter Highlighter) {
  ApplicationManager.getApplication().assertIsdispatchThread();
  Processor<RangeHighlighterEx> equalId = new Processor<RangeHighlighterEx>() {
    @Override
    public boolean process(RangeHighlighterEx h) {
      return h.getId() != ((RangeHighlighterEx)Highlighter).getId();
    }
  };
  return !treeFor(Highlighter).processOverlappingWith(Highlighter.getStartOffset(),Highlighter.getEndOffset(),equalId);
}

@Override
public boolean processRangeHighlightersOverlappingWith(int start,@NotNull Processor<? super RangeHighlighterEx> processor) {
  disposableIterator<RangeHighlighterEx> iterator = overlappingIterator(start,end);
  try {
    while (iterator.hasNext()) {
      if (!processor.process(iterator.next())) {
        return false;
      }
    }
    return true;
  }
  finally {
    iterator.dispose();
  }
}

@Override
@NotNull
public IntervalTreeImpl.PeekableIterator<RangeHighlighterEx> overlappingIterator(int startOffset,int endOffset) {
  startOffset = Math.max(0,startOffset);
  endOffset = Math.max(startOffset,endOffset);
  return IntervalTreeImpl
    .mergingOverlappingIterator(myHighlighterTree,new TextRangeInterval(startOffset,endOffset),myHighlighterTreeForLines,roundToLineBoundaries(startOffset,RangeHighlighterEx.BY_AFFECTED_START_OFFSET);
}

@Override
protected int compareEqualStartIntervals(@NotNull IntervalNode<RangeHighlighterEx> i1,@NotNull IntervalNode<RangeHighlighterEx> i2) {
  RHNode o1 = (RHNode)i1;
  RHNode o2 = (RHNode)i2;
  int d = o2.myLayer - o1.myLayer;
  if (d != 0) {
    return d;
  }
  return super.compareEqualStartIntervals(i1,i2);
}

public RHNode(@NotNull RangeHighlighterTree rangeMarkerTree,@NotNull final RangeHighlighterEx key,int layer) {
  super(rangeMarkerTree,key,greedyToRight);
  myLayer = layer;
}

@NotNull
@Override
public RangeHighlighterEx addRangeHighlighterAndChangeAttributes(int startOffset,Consumer<RangeHighlighterEx> changeAttributesAction) {
  TextRange hostRange = myDocument.injectedToHost(new ProperTextRange(startOffset,endOffset));
  return myHostModel.addRangeHighlighterAndChangeAttributes(hostRange.getStartOffset(),hostRange.getEndOffset(),isPersistent,changeAttributesAction);
}