com.intellij.psi.SmartPointerManager Java Examples

public UsageHolder(PsiElement element, UsageInfo[] usageInfos) {
  Project project = element.getProject();
  myElementPointer = SmartPointerManager.getInstance(project).createSmartPsiElementPointer(element);

  GeneratedSourcesFilter[] filters = GeneratedSourcesFilter.EP_NAME.getExtensions();
  for (UsageInfo usageInfo : usageInfos) {
    if (!(usageInfo instanceof SafeDeleteReferenceUsageInfo)) continue;
    final SafeDeleteReferenceUsageInfo usage = (SafeDeleteReferenceUsageInfo)usageInfo;
    if (usage.getReferencedElement() != element) continue;

    if (!usage.isSafeDelete()) {
      myUnsafeUsages++;
      if (usage.isNonCodeUsage || isInGeneratedCode(usage, project, filters)) {
        myNonCodeUnsafeUsages++;
      }
    }
  }
}
 

public LocalQuickFixOnPsiElement(PsiElement startElement, PsiElement endElement) {
  if (startElement == null || endElement == null) {
    myStartElement = myEndElement = null;
    return;
  }
  LOG.assertTrue(startElement.isValid());
  PsiFile startContainingFile = startElement.getContainingFile();
  PsiFile endContainingFile = startElement == endElement ? startContainingFile : endElement.getContainingFile();
  if (startElement != endElement) {
    LOG.assertTrue(endElement.isValid());
    LOG.assertTrue(startContainingFile == endContainingFile, "Both elements must be from the same file");
  }
  Project project = startContainingFile == null ? startElement.getProject() : startContainingFile.getProject(); // containingFile can be null for a directory
  myStartElement = SmartPointerManager.getInstance(project).createSmartPsiElementPointer(startElement, startContainingFile);
  myEndElement = endElement == startElement ? null : SmartPointerManager.getInstance(project).createSmartPsiElementPointer(endElement, endContainingFile);
}
 

/**
 * Creates a line marker info for the element.
 *
 * @param element         the element for which the line marker is created.
 * @param range           the range (relative to beginning of file) with which the marker is associated
 * @param icon            the icon to show in the gutter for the line marker
 * @param updatePass      the ID of the daemon pass during which the marker should be recalculated
 * @param tooltipProvider the callback to calculate the tooltip for the gutter icon
 * @param navHandler      the handler executed when the gutter icon is clicked
 */
public LineMarkerInfo(@Nonnull T element,
                      @Nonnull TextRange range,
                      Image icon,
                      int updatePass,
                      @Nullable Function<? super T, String> tooltipProvider,
                      @Nullable GutterIconNavigationHandler<T> navHandler,
                      @Nonnull GutterIconRenderer.Alignment alignment) {
  myIcon = icon;
  myTooltipProvider = tooltipProvider;
  myIconAlignment = alignment;
  elementRef = SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element);
  myNavigationHandler = navHandler;
  startOffset = range.getStartOffset();
  endOffset = range.getEndOffset();
  this.updatePass = 11; //Pass.LINE_MARKERS;
}
 

public PsiElement[] tryCreate(@Nonnull final String inputString) {
  if (inputString.length() == 0) {
    Messages.showMessageDialog(myProject, IdeBundle.message("error.name.should.be.specified"), CommonBundle.getErrorTitle(), Messages.getErrorIcon());
    return PsiElement.EMPTY_ARRAY;
  }

  Ref<List<SmartPsiElementPointer>> createdElements = Ref.create();
  Exception exception = executeCommand(getActionName(inputString), () -> {
    PsiElement[] psiElements = create(inputString);
    SmartPointerManager manager = SmartPointerManager.getInstance(myProject);
    createdElements.set(ContainerUtil.map(psiElements, manager::createSmartPsiElementPointer));
  });
  if (exception != null) {
    handleException(exception);
    return PsiElement.EMPTY_ARRAY;
  }

  return ContainerUtil.mapNotNull(createdElements.get(), SmartPsiElementPointer::getElement).toArray(PsiElement.EMPTY_ARRAY);
}
 

public MyIntroduceLookupExpression(final String initialName,
                                   final LinkedHashSet<String> names,
                                   final PsiNamedElement elementToRename,
                                   final boolean shouldSelectAll,
                                   final String advertisementText) {
  super(initialName, names, elementToRename, elementToRename, shouldSelectAll, advertisementText);
  myPointer = SmartPointerManager.getInstance(elementToRename.getProject()).createSmartPsiElementPointer(elementToRename);
}
 

public ReplaceTypeQuickFix(@Nonnull DotNetType type, @Nonnull DotNetTypeRef typeRef)
{
	myPointer = SmartPointerManager.getInstance(type.getProject()).createSmartPsiElementPointer(type);

	myTypeText = CSharpTypeRefPresentationUtil.buildShortText(typeRef, type);
	setText("Replace '" + type.getText() + "' by '" + myTypeText + "'");
}
 

public PsiElementUsageGroupBase(@Nonnull T element, Image icon) {
  String myName = element.getName();
  if (myName == null) myName = "<anonymous>";
  this.myName = myName;
  myElementPointer = SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element);

  myIcon = icon;
}
 

@Nonnull
private static List<SmartPsiElementPointer<PsiElement>> convertToSmartPointers(@Nonnull PsiElement[] primaryElements) {
  if (primaryElements.length == 0) return Collections.emptyList();

  final SmartPointerManager smartPointerManager = SmartPointerManager.getInstance(primaryElements[0].getProject());
  return ContainerUtil.mapNotNull(primaryElements, new Function<PsiElement, SmartPsiElementPointer<PsiElement>>() {
    @Override
    public SmartPsiElementPointer<PsiElement> fun(final PsiElement s) {
      return smartPointerManager.createSmartPsiElementPointer(s);
    }
  });
}
 

@Nullable
private SmartPsiElementPointer<SqlSelectStatement> getStatementPointer(final @NotNull Project project,
                                                                       final @NotNull PsiElement psiElement) {
    final SqlSelectStatement sqlSelectStatement =
            PsiTreeUtil.getParentOfType(psiElement.getContainingFile().findElementAt(psiElement.getTextOffset()),
                                        SqlSelectStatement.class);
    SmartPsiElementPointer<SqlSelectStatement> pointer = null;
    if (sqlSelectStatement != null) {
        pointer = SmartPointerManager.getInstance(project)
                                     .createSmartPsiElementPointer(sqlSelectStatement);
    }
    return pointer;
}
 

public BasePsiNode(final T element) {
  super(element.getProject());
  if (element.isValid()) {
    myPsiElementPointer = SmartPointerManager.getInstance(myProject).createSmartPsiElementPointer(element);
  }
  else {
    myPsiElementPointer = null;
  }
}
 

public void setData(@Nullable PsiElement element, @Nonnull String text, @Nullable String effectiveExternalUrl, @Nullable String ref, @Nullable DocumentationProvider provider) {
  pushHistory();
  myExternalUrl = effectiveExternalUrl;
  myProvider = provider;

  SmartPsiElementPointer<PsiElement> pointer = null;
  if (element != null && element.isValid()) {
    pointer = SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element);
  }
  setDataInternal(pointer, text, new Rectangle(0, 0), ref);
}
 

@Nonnull
@Override
public Object createAnchor(@Nonnull Object element) {
  if (element instanceof PsiElement) {
    PsiElement psi = (PsiElement)element;
    return ReadAction.compute(() -> {
      if (!psi.isValid()) return psi;
      return SmartPointerManager.getInstance(psi.getProject()).createSmartPsiElementPointer(psi);
    });
  }
  return super.createAnchor(element);
}
 

@Override
public void freeAnchor(final Object element) {
  if (element instanceof SmartPsiElementPointer) {
    ApplicationManager.getApplication().runReadAction(() -> {
      SmartPsiElementPointer pointer = (SmartPsiElementPointer)element;
      Project project = pointer.getProject();
      if (!project.isDisposed()) {
        SmartPointerManager.getInstance(project).removePointer(pointer);
      }
    });
  }
}
 

private MyNavigationGutterIconRenderer createGutterIconRenderer(@Nonnull Project project) {
  checkBuilt();
  final SmartPointerManager manager = SmartPointerManager.getInstance(project);

  NotNullLazyValue<List<SmartPsiElementPointer>> pointers = new NotNullLazyValue<List<SmartPsiElementPointer>>() {
    @Override
    @Nonnull
    public List<SmartPsiElementPointer> compute() {
      Set<PsiElement> elements = new THashSet<PsiElement>();
      Collection<? extends T> targets = myTargets.getValue();
      final List<SmartPsiElementPointer> list = new ArrayList<SmartPsiElementPointer>(targets.size());
      for (final T target : targets) {
        for (final PsiElement psiElement : myConverter.fun(target)) {
          if (elements.add(psiElement) && psiElement.isValid()) {
            list.add(manager.createSmartPsiElementPointer(psiElement));
          }
        }
      }
      return list;
    }
  };

  final boolean empty = isEmpty();

  if (myTooltipText == null && !myLazy) {
    final SortedSet<String> names = new TreeSet<String>();
    for (T t : myTargets.getValue()) {
      final String text = myNamer.fun(t);
      if (text != null) {
        names.add(MessageFormat.format(PATTERN, text));
      }
    }
    @NonNls StringBuilder sb = new StringBuilder("<html><body>");
    if (myTooltipTitle != null) {
      sb.append(myTooltipTitle).append("<br>");
    }
    for (String name : names) {
      sb.append(name).append("<br>");
    }
    sb.append("</body></html>");
    myTooltipText = sb.toString();
  }

  Computable<PsiElementListCellRenderer> renderer =
    myCellRenderer == null ? new Computable<PsiElementListCellRenderer>() {
      @Override
      public PsiElementListCellRenderer compute() {
        return new DefaultPsiElementCellRenderer();
      }
    } : myCellRenderer;
  return new MyNavigationGutterIconRenderer(this, myAlignment, myIcon, myTooltipText, pointers, renderer, empty);
}
 

private List<FoldRegion> addNewRegions(@Nonnull EditorFoldingInfo info,
                                       @Nonnull FoldingModelEx foldingModel,
                                       @Nonnull Map<TextRange, Boolean> rangeToExpandStatusMap,
                                       @Nonnull Map<FoldRegion, Boolean> shouldExpand,
                                       @Nonnull Map<FoldingGroup, Boolean> groupExpand) {
  List<FoldRegion> newRegions = new ArrayList<>();
  SmartPointerManager smartPointerManager = SmartPointerManager.getInstance(myProject);
  for (FoldingUpdate.RegionInfo regionInfo : myRegionInfos) {
    ProgressManager.checkCanceled();
    FoldingDescriptor descriptor = regionInfo.descriptor;
    FoldingGroup group = descriptor.getGroup();
    TextRange range = descriptor.getRange();
    String placeholder = null;
    try {
      placeholder = descriptor.getPlaceholderText();
    }
    catch (IndexNotReadyException ignore) {
    }
    if (range.getEndOffset() > myEditor.getDocument().getTextLength()) {
      LOG.error(String.format("Invalid folding descriptor detected (%s). It ends beyond the document range (%d)", descriptor, myEditor.getDocument().getTextLength()));
      continue;
    }
    FoldRegion region = foldingModel.createFoldRegion(range.getStartOffset(), range.getEndOffset(), placeholder == null ? "..." : placeholder, group, descriptor.isNonExpandable());
    if (region == null) continue;

    if (descriptor.isNonExpandable()) region.putUserData(FoldingModelImpl.SELECT_REGION_ON_CARET_NEARBY, Boolean.TRUE);

    PsiElement psi = descriptor.getElement().getPsi();

    if (psi == null || !psi.isValid() || !myFile.isValid()) {
      region.dispose();
      continue;
    }

    region.setGutterMarkEnabledForSingleLine(descriptor.isGutterMarkEnabledForSingleLine());

    if (descriptor.canBeRemovedWhenCollapsed()) region.putUserData(CAN_BE_REMOVED_WHEN_COLLAPSED, Boolean.TRUE);
    region.putUserData(COLLAPSED_BY_DEFAULT, regionInfo.collapsedByDefault);
    region.putUserData(SIGNATURE, ObjectUtils.chooseNotNull(regionInfo.signature, NO_SIGNATURE));

    info.addRegion(region, smartPointerManager.createSmartPsiElementPointer(psi));
    newRegions.add(region);

    boolean expandStatus = !descriptor.isNonExpandable() && shouldExpandNewRegion(range, rangeToExpandStatusMap, regionInfo.collapsedByDefault);
    if (group == null) {
      shouldExpand.put(region, expandStatus);
    }
    else {
      final Boolean alreadyExpanded = groupExpand.get(group);
      groupExpand.put(group, alreadyExpanded == null ? expandStatus : alreadyExpanded.booleanValue() || expandStatus);
    }
  }

  return newRegions;
}
 

public static LookupElementBuilder createWithSmartPointer(@Nonnull String lookupString, @Nonnull PsiElement element) {
  PsiUtilCore.ensureValid(element);
  return new LookupElementBuilder(lookupString, SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element));
}
 

public ElementIconRequest(PsiElement element, @Iconable.IconFlags int flags) {
  myPointer = SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element);
  myFlags = flags;
}
 

protected RefElementImpl(@Nonnull String name, @Nonnull PsiElement element, @Nonnull RefManager manager) {
  super(name, manager);
  myID = SmartPointerManager.getInstance(manager.getProject()).createSmartPsiElementPointer(element);
  myFlags = 0;
}
 

public DefaultChooseByNameItemProvider(@Nullable PsiElement context) {
  myContext = context == null ? null : SmartPointerManager.getInstance(context.getProject()).createSmartPsiElementPointer(context);
}
 

public static void setContext(final PsiFile psiFile, final PsiElement context) {
  if (context != null) {
    psiFile.putUserData(FileContextUtil.INJECTED_IN_ELEMENT, SmartPointerManager.getInstance(context.getProject()).createSmartPsiElementPointer(context));
  }
}
 

public DeleteQuestMarkQuickFix(CSharpNullableType nullableType)
{
	myPointer = SmartPointerManager.getInstance(nullableType.getProject()).createSmartPsiElementPointer(nullableType);
	setText("Remove '?'");
}
 

public CreateMethodQuickFix(@NotNull PhpClass phpClass, @NotNull String functionName, @NotNull InsertStringInterface stringInterface) {
    this.smartPhpClass = SmartPointerManager.getInstance(phpClass.getProject()).createSmartPsiElementPointer(phpClass);
    this.functionName = functionName;
    this.stringInterface = stringInterface;
}
 

public RenameQuickFix(@Nonnull String newName, @Nonnull PsiNamedElement namedElement)
{
	myNewName = newName;
	myPointer = SmartPointerManager.getInstance(namedElement.getProject()).createSmartPsiElementPointer(namedElement);
	setText("Rename '" + namedElement.getName() + "' to '" + myNewName + "'");
}
 

public SmartElementDescriptor(@Nonnull Project project, NodeDescriptor parentDescriptor, @Nonnull PsiElement element) {
  super(project, parentDescriptor);
  mySmartPointer = SmartPointerManager.getInstance(myProject).createSmartPsiElementPointer(element);
}
 

public CastExpressionToTypeRef(@Nonnull DotNetExpression expression, @Nonnull DotNetTypeRef expectedTypeRef)
{
	myExpressionPointer = SmartPointerManager.getInstance(expression.getProject()).createSmartPsiElementPointer(expression);
	myExpectedTypeRef = expectedTypeRef;
}
 

public CamelCaseFixAction(@NotNull SQFPsiCommand command) {
	this.commandPointer = SmartPointerManager.getInstance(command.getProject()).createSmartPsiElementPointer(command);
}
 

public CamelCaseFixAction(@NotNull SQFPsiCommand command) {
	this.commandPointer = SmartPointerManager.getInstance(command.getProject()).createSmartPsiElementPointer(command);
}
 

public RegisterShebangCommandQuickfix(FixShebangInspection fixShebangInspection, BashShebang shebang) {
    this.inspection = fixShebangInspection;

    Project project = shebang.getProject();
    this.shebang = SmartPointerManager.getInstance(project).createSmartPsiElementPointer(shebang);
}
 

public ReferenceDiagramDataModel(Project project, DiagramProvider<PsiElement> provider) {
    super(project, provider);
    this.spManager = SmartPointerManager.getInstance(getProject());
}
 

public ConvertNamedToSimpleArgumentFix(CSharpNamedCallArgument element)
{
	setText("Convert to simple argument");
	myPointer = SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element);
}