Java Code Examples for com.intellij.psi.PsiElement#replace()

static void maybeUpdateName(@NotNull GradleDslElement element) {
  PsiElement oldName = element.getNameElement().getNamedPsiElement();
  String newName = element.getNameElement().getUnsavedName();
  PsiElement newElement;
  if (newName == null || oldName == null) {
    return;
  }
  if (oldName instanceof PsiNamedElement) {
    PsiNamedElement namedElement = (PsiNamedElement)oldName;
    namedElement.setName(newName);
    newElement = namedElement;
  }
  else {
    PsiElement psiElement = createNameElement(element, newName);
    if (psiElement == null) {
      throw new IllegalStateException("Can't create new GrExpression for name element");
    }
    newElement = oldName.replace(psiElement);
  }
  element.getNameElement().commitNameChange(newElement);
}
 

@RequiredWriteAction
@Override
public void setColorTo(@Nonnull PsiElement element, @Nonnull ColorValue color)
{
	float[] colorComponents = color.toRGB().getFloatValues();

	StringBuilder builder = new StringBuilder();
	builder.append("(");
	for(int i = 0; i < (colorComponents[3] == 1 ? colorComponents.length - 1 : colorComponents.length); i++)
	{
		if(i != 0)
		{
			builder.append(", ");
		}

		builder.append(colorComponents[i]);
	}
	builder.append(")");

	ShaderPropertyValue value = createValue(element.getProject(), builder.toString());

	element.replace(value);
}
 

static void applyDslLiteralOrReference(@NotNull GradleDslSettableExpression expression) {
  PsiElement psiElement = ensureGroovyPsi(expression.getPsiElement());
  if (psiElement == null) {
    return;
  }

  maybeUpdateName(expression);

  GrExpression newLiteral = extractUnsavedExpression(expression);
  if (newLiteral == null) {
    return;
  }
  PsiElement psiExpression = ensureGroovyPsi(expression.getExpression());
  if (psiExpression != null) {
    PsiElement replace = psiExpression.replace(newLiteral);
    if (replace instanceof GrLiteral || replace instanceof GrReferenceExpression || replace instanceof GrIndexProperty) {
      expression.setExpression(replace);
    }
  }
  else {
    // This element has just been created and will currently look like "propertyName =" or "propertyName ". Here we add the value.
    PsiElement added = psiElement.addAfter(newLiteral, psiElement.getLastChild());
    expression.setExpression(added);

    if (expression.getUnsavedConfigBlock() != null) {
      addConfigBlock(expression);
    }
  }

  expression.reset();
  expression.commit();
}
 

@Override
public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
	final PsiElement nameIdentifier = getNameIdentifier();
	if(nameIdentifier != null) {
		final LeafElement renamedLeaf = Factory.createSingleLeafElement(JSGraphQLEndpointTokenTypes.STRING_BODY, name, null, getManager());
		final PsiElement renamedPsiElement = SourceTreeToPsiMap.treeElementToPsi(renamedLeaf);
		if (renamedPsiElement != null) {
			nameIdentifier.replace(renamedPsiElement);
		}
	}
	return this;
}
 

@Override
public void invoke(@NotNull Project project, @NotNull PsiFile file, Editor editor, @NotNull PsiElement startElement, @NotNull PsiElement endElement) {
    // Replace this position with the same value, we have to trigger a reparse somehow
    Document document = file.getViewProvider().getDocument();
    if (document != null && document.isWritable()) {
        PsiElement replacement = BashPsiElementFactory.createComposedVar(project, variableName);
        startElement.replace(replacement);
    }
}
 

@Override
public void invoke(@NotNull Project project, @NotNull PsiFile file, Editor editor, @NotNull PsiElement startElement, @NotNull PsiElement endElement) {
    BashConditionalCommand conditionalCommand = (BashConditionalCommand) startElement;
    String command = conditionalCommand.getCommandText();
    PsiElement replacement = useDoubleBrackets(project, command);
    startElement.replace(replacement);
}
 

@Override
public void invoke(@NotNull Project project, @NotNull PsiFile psiFile, @Nullable("is null when called from inspection") Editor editor, @NotNull PsiElement element, @NotNull PsiElement end) throws IncorrectOperationException {
    PsiElement parent = element.getParent();
    if (!(parent instanceof JSNewExpression)) return;
    final JSExpressionCodeFragment useStrict = JSElementFactory.createExpressionCodeFragment(project, getNewExp(), parent);
    PsiElement child = useStrict.getFirstChild();
    parent.replace(child);
}
 

@Override
public void replace(@Nullable PsiElement newElement)
{
	ASTNode lazyNode = myMethodElement.getNode().findChildByType(CSharpElements.METHOD_BODIES);
	if(lazyNode != null)
	{
		if(newElement == null)
		{
			lazyNode.getPsi().delete();
		}
		else
		{
			lazyNode.getPsi().replace(newElement);
		}
	}
	else
	{
		PsiElement element = getElement();

		if(newElement != null)
		{
			if(element == null)
			{
				myMethodElement.add(newElement);
			}
			else
			{
				element.replace(newElement);
			}
		}
		else if(element != null)
		{
			element.delete();
		}
	}
}
 

@RequiredReadAction
public static void replaceNameIdentifier(PsiNameIdentifierOwner owner, String newName)
{
	PsiElement nameIdentifier = owner.getNameIdentifier();
	if(!(nameIdentifier instanceof CSharpIdentifier))
	{
		return;
	}

	CSharpIdentifier newIdentifier = CSharpFileFactory.createIdentifier(owner.getProject(), newName);

	nameIdentifier.replace(newIdentifier);
}
 

@Override
public void expand(@Nonnull PsiElement context, @Nonnull Editor editor)
{
	DotNetExpression newExpression = CSharpFileFactory.createExpression(context.getProject(), "(" + context.getText() + ")");

	context.replace(newExpression);
}
 

@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
    PsiElement psiElement1 = descriptor.getPsiElement();
    YAMLKeyValue replacement = YamlPsiElementFactory.createFromText(
            project,
            YAMLKeyValue.class,
            "class: " + replacementFQN
    );

    if (replacement != null && replacement.getValue() != null) {
        psiElement1.replace(replacement.getValue());
    }
}
 

public PsiElement[] reorder(PsiElement source, PsiElement destination)
{
    PsiElement[] results = new PsiElement[2];

    results[0] = destination.replace(source);
    results[1] = source.replace(destination);

    return results;
}
 

@Override
public PsiElement moveDslElement(@NotNull GradleDslElement element) {
  // 1. Get the anchor where we need to move the element to.
  GradleDslElement anchorAfter = element.getAnchor();

  GroovyPsiElement psiElement = ensureGroovyPsi(element.getPsiElement());
  if (psiElement == null) {
    return null;
  }

  PsiElement parentPsiElement = getParentPsi(element);
  if (parentPsiElement == null) {
    return null;
  }

  PsiElement anchor = getPsiElementForAnchor(parentPsiElement, anchorAfter);

  // 2. Create a dummy element that we can move the element to.
  GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(parentPsiElement.getProject());
  PsiElement lineTerminator = factory.createLineTerminator(1);
  PsiElement toReplace = parentPsiElement.addAfter(lineTerminator, anchor);

  // 3. Find the element we need to actually replace. The psiElement we have may be a child of what we need.
  PsiElement e = element.getPsiElement();
  while (!(e.getParent() instanceof GroovyFile || e.getParent() instanceof GrClosableBlock)) {
    // Make sure e isn't going to be set to null.
    if (e.getParent() == null) {
      e = element.getPsiElement();
      break;
    }
    e = e.getParent();
  }

  // 4. Copy the old PsiElement tree.
  PsiElement treeCopy = e.copy();

  // 5. Replace what we need to replace.
  PsiElement newTree = toReplace.replace(treeCopy);

  // 6. Delete the original tree.
  e.delete();

  // 7. Set the new PsiElement. Note: The internal state of this element will have invalid elements. It is required to reparse the file
  // to obtain the correct elements.
  element.setPsiElement(newTree);

  return element.getPsiElement();
}
 

public static void replaceIdentifier(@Nonnull PsiElement identifier, @Nonnull String newName)
{
	PsiElement newIdentifier = ShaderFileFactory.createSimpleIdentifier(identifier.getProject(), newName);
	identifier.replace(newIdentifier);
}
 

@Nullable
protected PsiElement replaceExpression(PsiElement expression, PsiElement newExpression, CSharpIntroduceOperation operation)
{
	return expression.replace(newExpression);
}
 

public void cleanupWhiteSpace(PsiElement parent)
{
    String result = "{\n" + parent.getText().substring(1).trim();
    parent.replace(JSUtil.createStatement(parent, result));
}