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 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++;
      }
    }
  }
}
 

@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 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);
    }
  });
}
 

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);
      }
    });
  }
}
 

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

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 CreateInjectorQuickFix(@NotNull PhpDocTag element) {
    this.element = SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element);
}
 

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);
}
 

public RemoveVariableInitializer(DotNetVariable variable)
{
	myPointer = SmartPointerManager.getInstance(variable.getProject()).createSmartPsiElementPointer(variable);
	setText(variable instanceof DotNetParameter ? "Remove initializer" : "Remove default value");
}
 

public ChangeVariableToTypeRefFix(@Nonnull DotNetVariable element, @Nonnull DotNetTypeRef toTypeRef)
{
	myVariablePointer = SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element);
	myToTypeRef = toTypeRef;
}
 

public BaseModifierFix(DotNetModifier[] modifiers, DotNetModifierListOwner parent)
{
	myModifiers = modifiers;
	myModifierElementOwnerPointer = SmartPointerManager.getInstance(parent.getProject()).createSmartPsiElementPointer(parent);
}
 

public ChangeReturnToTypeRefFix(@Nonnull DotNetLikeMethodDeclaration element, @Nonnull DotNetTypeRef toTypeRef)
{
	myMethodPointer = SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element);
	myToTypeRef = toTypeRef;
}
 

public UsingNamespaceFix(@Nonnull CSharpReferenceExpression ref)
{
	myRefPointer = SmartPointerManager.getInstance(ref.getProject()).createSmartPsiElementPointer(ref);
}
 

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

public CSharpBaseGroupingRule(T pointer)
{
	myPointer = SmartPointerManager.getInstance(pointer.getProject()).createSmartPsiElementPointer(pointer);
}
 

public RemoveConstKeywordFix(DotNetVariable element)
{
	myVariablePointer = SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element);
	setText("Remove 'const' keyword");
}
 

public InitializeConstantFix(DotNetVariable element)
{
	myVariablePointer = SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element);
}
 

public BaseUseTypeFix(CSharpReferenceExpressionEx referenceExpression, CSharpTypeDeclaration typeDeclaration)
{
	myPointer = SmartPointerManager.getInstance(referenceExpression.getProject()).createSmartPsiElementPointer(referenceExpression);

	setText("Use '" + typeDeclaration.getPresentableQName() + "'");
}
 

public ReplaceConstraintFix(CSharpGenericConstraintTypeValue declaration, String keywordForReplace)
{
	myKeywordForReplace = keywordForReplace;
	myPointer = SmartPointerManager.getInstance(declaration.getProject()).createSmartPsiElementPointer(declaration);
}