org.eclipse.text.edits.TextEdit Maven / Gradle / Ivy
/*******************************************************************************
* Copyright (c) 2000, 2015 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.text.edits;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Region;
/**
* A text edit describes an elementary text manipulation operation. Edits are
* executed by applying them to a document (e.g. an instance of IDocument
* ).
*
* Text edits form a tree. Clients can navigate the tree upwards, from child to
* parent, as well as downwards. Newly created edits are un-parented. New edits
* are added to the tree by calling one of the add methods on a parent
* edit.
*
*
* An edit tree is well formed in the following sense:
*
*
* - a parent edit covers all its children
* - children don't overlap
* - an edit with length 0 can't have any children
*
*
* Any manipulation of the tree that violates one of the above requirements results
* in a MalformedTreeException.
*
*
* Insert edits are represented by an edit of length 0. If more than one insert
* edit exists at the same offset then the edits are executed in the order in which
* they have been added to a parent. The following code example:
*
*
* IDocument document= new Document("org");
* MultiTextEdit edit= new MultiTextEdit();
* edit.addChild(new InsertEdit(0, "www."));
* edit.addChild(new InsertEdit(0, "eclipse."));
* edit.apply(document);
*
*
* therefore results in string: "www.eclipse.org".
*
*
* Text edits can be executed in a mode where the edit's region is updated to
* reflect the edit's position in the changed document. Region updating is enabled
* by default or can be requested by passing UPDATE_REGIONS to the
* {@link #apply(IDocument, int) apply(IDocument, int)} method. In the above example
* the region of the InsertEdit(0, "eclipse.") edit after executing
* the root edit is [3, 8]. If the region of an edit got deleted during
* change execution the region is set to [-1, -1] and the method {@link
* #isDeleted() isDeleted} returns true.
*
* This class isn't intended to be subclassed outside of the edit framework. Clients
* are only allowed to subclass MultiTextEdit.
*
* @since 3.0
* @noextend This class is not intended to be subclassed by clients.
*/
public abstract class TextEdit {
/**
* Flags indicating that neither CREATE_UNDO nor
* UPDATE_REGIONS is set.
*/
public static final int NONE= 0;
/**
* Flags indicating that applying an edit tree to a document
* is supposed to create a corresponding undo edit. If not
* specified null is returned from method
* apply.
*/
public static final int CREATE_UNDO= 1 << 0;
/**
* Flag indicating that the edit's region will be updated to
* reflect its position in the changed document. If not specified
* when applying an edit tree to a document the edit's region will
* be arbitrary. It is even not guaranteed that the tree is still
* well formed.
*/
public static final int UPDATE_REGIONS= 1 << 1;
private static class InsertionComparator implements Comparator {
@Override
public int compare(TextEdit edit1, TextEdit edit2) throws MalformedTreeException {
int offset1= edit1.getOffset();
int length1= edit1.getLength();
int offset2= edit2.getOffset();
int length2= edit2.getLength();
if (offset1 == offset2 && length1 == 0 && length2 == 0) {
return 0;
}
if (offset1 + length1 <= offset2) {
return -1;
}
if (offset2 + length2 <= offset1) {
return 1;
}
throw new MalformedTreeException(
null, edit1,
TextEditMessages.getString("TextEdit.overlapping")); //$NON-NLS-1$
}
}
private static final TextEdit[] EMPTY_ARRAY= new TextEdit[0];
private static final InsertionComparator INSERTION_COMPARATOR= new InsertionComparator();
private static final int DELETED_VALUE= -1;
private int fOffset;
private int fLength;
private TextEdit fParent;
private List fChildren;
int fDelta;
/**
* Create a new text edit. Parent is initialized to
* null and the edit doesn't have any children.
*
* @param offset the edit's offset
* @param length the edit's length
*/
protected TextEdit(int offset, int length) {
Assert.isTrue(offset >= 0 && length >= 0);
fOffset= offset;
fLength= length;
fDelta= 0;
}
/**
* Copy constructor
*
* @param source the source to copy form
*/
protected TextEdit(TextEdit source) {
fOffset= source.fOffset;
fLength= source.fLength;
fDelta= 0;
}
//---- Region management -----------------------------------------------
/**
* Returns the range that this edit is manipulating. The returned
* IRegion contains the edit's offset and length at
* the point in time when this call is made. Any subsequent changes
* to the edit's offset and length aren't reflected in the returned
* region object.
*
* Creating a region for a deleted edit will result in an assertion
* failure.
*
* @return the manipulated region
*/
public final IRegion getRegion() {
return new Region(getOffset(), getLength());
}
/**
* Returns the offset of the edit. An offset is a 0-based
* character index. Returns -1 if the edit
* is marked as deleted.
*
* @return the offset of the edit
*/
public int getOffset() {
return fOffset;
}
/**
* Returns the length of the edit. Returns -1
* if the edit is marked as deleted.
*
* @return the length of the edit
*/
public int getLength() {
return fLength;
}
/**
* Returns the inclusive end position of this edit. The inclusive end
* position denotes the last character of the region manipulated by
* this edit. The returned value is the result of the following
* calculation:
*
* getOffset() + getLength() - 1;
*
*
* @return the inclusive end position
*/
public final int getInclusiveEnd() {
return getOffset() + getLength() - 1;
}
/**
* Returns the exclusive end position of this edit. The exclusive end
* position denotes the next character of the region manipulated by
* this edit. The returned value is the result of the following
* calculation:
*
* getOffset() + getLength();
*
*
* @return the exclusive end position
*/
public final int getExclusiveEnd() {
return getOffset() + getLength();
}
/**
* Returns whether this edit has been deleted or not.
*
* @return true if the edit has been
* deleted; otherwise false is returned.
*/
public final boolean isDeleted() {
return fOffset == DELETED_VALUE && fLength == DELETED_VALUE;
}
/**
* Move all offsets in the tree by the given delta. This node must be a
* root node. The resulting offsets must be greater or equal to zero.
*
* @param delta the delta
* @since 3.1
*/
public final void moveTree(int delta) {
Assert.isTrue(fParent == null);
Assert.isTrue(getOffset() + delta >= 0);
internalMoveTree(delta);
}
/**
* Returns true if the edit covers the given edit
* other. It is up to the concrete text edit to
* decide if a edit of length zero can cover another edit.
*
* @param other the other edit
* @return true if the edit covers the other edit;
* otherwise false is returned.
*/
public boolean covers(TextEdit other) {
if (getLength() == 0 && !canZeroLengthCover())
return false;
if (!other.isDefined())
return true;
int thisOffset= getOffset();
int otherOffset= other.getOffset();
return thisOffset <= otherOffset && otherOffset + other.getLength() <= thisOffset + getLength();
}
/**
* Returns true if an edit with length zero can cover
* another edit. Returns false otherwise.
*
* @return whether an edit of length zero can cover another edit
*/
protected boolean canZeroLengthCover() {
return false;
}
/**
* Returns whether the region of this edit is defined or not.
*
* @return whether the region of this edit is defined or not
*
* @since 3.1
*/
boolean isDefined() {
return true;
}
//---- parent and children management -----------------------------
/**
* Returns the edit's parent. The method returns null
* if this edit hasn't been add to another edit.
*
* @return the edit's parent
*/
public final TextEdit getParent() {
return fParent;
}
/**
* Returns the root edit of the edit tree.
*
* @return the root edit of the edit tree
* @since 3.1
*/
public final TextEdit getRoot() {
TextEdit result= this;
while (result.fParent != null) {
result= result.fParent;
}
return result;
}
/**
* Adds the given edit child to this edit.
*
* @param child the child edit to add
* @exception MalformedTreeException is thrown if the child
* edit can't be added to this edit. This is the case if the child
* overlaps with one of its siblings or if the child edit's region
* isn't fully covered by this edit.
*/
public final void addChild(TextEdit child) throws MalformedTreeException {
internalAdd(child);
}
/**
* Adds all edits in edits to this edit.
*
* @param edits the text edits to add
* @exception MalformedTreeException is thrown if one of
* the given edits can't be added to this edit.
*
* @see #addChild(TextEdit)
*/
public final void addChildren(TextEdit[] edits) throws MalformedTreeException {
for (TextEdit edit : edits) {
internalAdd(edit);
}
}
/**
* Removes the edit specified by the given index from the list
* of children. Returns the child edit that was removed from
* the list of children. The parent of the returned edit is
* set to null.
*
* @param index the index of the edit to remove
* @return the removed edit
* @exception IndexOutOfBoundsException if the index
* is out of range
*/
public final TextEdit removeChild(int index) {
if (fChildren == null)
throw new IndexOutOfBoundsException("Index: " + index + " Size: 0"); //$NON-NLS-1$//$NON-NLS-2$
TextEdit result= fChildren.remove(index);
result.internalSetParent(null);
if (fChildren.isEmpty())
fChildren= null;
return result;
}
/**
* Removes the first occurrence of the given child from the list
* of children.
*
* @param child the child to be removed
* @return true if the edit contained the given
* child; otherwise false is returned
*/
public final boolean removeChild(TextEdit child) {
Assert.isNotNull(child);
if (fChildren == null)
return false;
boolean result= fChildren.remove(child);
if (result) {
child.internalSetParent(null);
if (fChildren.isEmpty())
fChildren= null;
}
return result;
}
/**
* Removes all child edits from and returns them. The parent
* of the removed edits is set to null.
*
* @return an array of the removed edits
*/
public final TextEdit[] removeChildren() {
if (fChildren == null)
return EMPTY_ARRAY;
int size= fChildren.size();
TextEdit[] result= new TextEdit[size];
for (int i= 0; i < size; i++) {
result[i]= fChildren.get(i);
result[i].internalSetParent(null);
}
fChildren= null;
return result;
}
/**
* Returns true if this edit has children. Otherwise
* false is returned.
*
* @return true if this edit has children; otherwise
* false is returned
*/
public final boolean hasChildren() {
return fChildren != null && ! fChildren.isEmpty();
}
/**
* Returns the edit's children. If the edit doesn't have any
* children an empty array is returned.
*
* @return the edit's children
*/
public final TextEdit[] getChildren() {
if (fChildren == null)
return EMPTY_ARRAY;
return fChildren.toArray(new TextEdit[fChildren.size()]);
}
/**
* Returns the size of the managed children.
*
* @return the size of the children
*/
public final int getChildrenSize() {
if (fChildren == null)
return 0;
return fChildren.size();
}
/**
* Returns the text range spawned by the given array of text edits.
* The method requires that the given array contains at least one
* edit. If all edits passed are deleted the method returns
* null.
*
* @param edits an array of edits
* @return the text range spawned by the given array of edits or
* null if all edits are marked as deleted
*/
public static IRegion getCoverage(TextEdit[] edits) {
Assert.isTrue(edits != null && edits.length > 0);
int offset= Integer.MAX_VALUE;
int end= Integer.MIN_VALUE;
int deleted= 0;
for (TextEdit edit : edits) {
if (edit.isDeleted()) {
deleted++;
} else {
offset= Math.min(offset, edit.getOffset());
end= Math.max(end, edit.getExclusiveEnd());
}
}
if (edits.length == deleted)
return null;
return new Region(offset, end - offset);
}
/**
* Hook called before this edit gets added to the passed parent.
*
* @param parent the parent text edit
*/
void aboutToBeAdded(TextEdit parent) {
}
//---- Object methods ------------------------------------------------------
/**
* The Edit implementation of this Object
* method uses object identity (==).
*
* @param obj the other object
* @return true iff this == obj; otherwise
* false is returned
*
* @see Object#equals(java.lang.Object)
*/
@Override
public final boolean equals(Object obj) {
return this == obj; // equivalent to Object.equals
}
/**
* The Edit implementation of this Object
* method calls uses Object#hashCode() to compute its
* hash code.
*
* @return the object's hash code value
*
* @see Object#hashCode()
*/
@Override
public final int hashCode() {
return super.hashCode();
}
@Override
public String toString() {
StringBuilder buffer= new StringBuilder();
toStringWithChildren(buffer, 0);
return buffer.toString();
}
/**
* Adds the string representation of this text edit without
* children information to the given string builder.
*
* @param buffer the string builder
* @param indent the indent level in number of spaces
* @since 3.3
*/
void internalToString(StringBuilder buffer, int indent) {
for (int i= indent; i > 0; i--) {
buffer.append(" "); //$NON-NLS-1$
}
buffer.append("{"); //$NON-NLS-1$
String name= getClass().getName();
int index= name.lastIndexOf('.');
if (index != -1) {
buffer.append(name.substring(index + 1));
} else {
buffer.append(name);
}
buffer.append("} "); //$NON-NLS-1$
if (isDeleted()) {
buffer.append("[deleted]"); //$NON-NLS-1$
} else {
buffer.append("["); //$NON-NLS-1$
buffer.append(getOffset());
buffer.append(","); //$NON-NLS-1$
buffer.append(getLength());
buffer.append("]"); //$NON-NLS-1$
}
}
/**
* Adds the string representation for this text edit
* and its children to the given string builder.
*
* @param buffer the string builder
* @param indent the indent level in number of spaces
* @since 3.3
*/
private void toStringWithChildren(StringBuilder buffer, int indent) {
internalToString(buffer, indent);
if (fChildren != null) {
for (TextEdit child : fChildren) {
buffer.append('\n');
child.toStringWithChildren(buffer, indent + 1);
}
}
}
//---- Copying -------------------------------------------------------------
/**
* Creates a deep copy of the edit tree rooted at this
* edit.
*
* @return a deep copy of the edit tree
* @see #doCopy()
*/
public final TextEdit copy() {
TextEditCopier copier= new TextEditCopier(this);
return copier.perform();
}
/**
* Creates and returns a copy of this edit. The copy method should be
* implemented in a way so that the copy can executed without causing
* any harm to the original edit. Implementors of this method are
* responsible for creating deep or shallow copies of referenced
* object to fulfill this requirement.
*
* Implementers of this method should use the copy constructor
* Edit#Edit(Edit source) to initialize the edit part of the copy.
* Implementors aren't responsible to actually copy the children or
* to set the right parent.
*
* This method should not be called from outside the framework.
* Please use copy to create a copy of a edit tree.
*
* @return a copy of this edit.
* @see #copy()
* @see #postProcessCopy(TextEditCopier)
* @see TextEditCopier
*/
protected abstract TextEdit doCopy();
/**
* This method is called on every edit of the copied tree to do some
* post-processing like connected an edit to a different edit in the tree.
*
* This default implementation does nothing
*
* @param copier the copier that manages a map between original and
* copied edit.
* @see TextEditCopier
*/
protected void postProcessCopy(TextEditCopier copier) {
}
//---- Visitor support -------------------------------------------------
/**
* Accepts the given visitor on a visit of the current edit.
*
* @param visitor the visitor object
* @exception IllegalArgumentException if the visitor is null
*/
public final void accept(TextEditVisitor visitor) {
Assert.isNotNull(visitor);
// begin with the generic pre-visit
visitor.preVisit(this);
// dynamic dispatch to internal method for type-specific visit/endVisit
accept0(visitor);
// end with the generic post-visit
visitor.postVisit(this);
}
/**
* Accepts the given visitor on a type-specific visit of the current edit.
* This method must be implemented in all concrete text edits.
*
* General template for implementation on each concrete TextEdit class:
*
*
*
* boolean visitChildren= visitor.visit(this);
* if (visitChildren) {
* acceptChildren(visitor);
* }
*
*
* Note that the caller (accept) takes care of invoking
* visitor.preVisit(this) and visitor.postVisit(this).
*
* @param visitor the visitor object
*/
protected abstract void accept0(TextEditVisitor visitor);
/**
* Accepts the given visitor on the edits children.
*
* This method must be used by the concrete implementations of
* accept to traverse list-values properties; it
* encapsulates the proper handling of on-the-fly changes to the list.
*
*
* @param visitor the visitor object
*/
protected final void acceptChildren(TextEditVisitor visitor) {
if (fChildren == null)
return;
Iterator iterator= fChildren.iterator();
while (iterator.hasNext()) {
TextEdit curr= iterator.next();
curr.accept(visitor);
}
}
//---- Execution -------------------------------------------------------
/**
* Applies the edit tree rooted by this edit to the given document. To check
* if the edit tree can be applied to the document either catch
* MalformedTreeException or use TextEditProcessor to
* execute an edit tree.
*
* @param document the document to be manipulated
* @param style flags controlling the execution of the edit tree. Valid
* flags are: CREATE_UNDO and UPDATE_REGIONS.
* @return a undo edit, if CREATE_UNDO is specified. Otherwise
* null is returned.
*
* @exception MalformedTreeException is thrown if the tree isn't
* in a valid state. This exception is thrown before any edit
* is executed. So the document is still in its original state.
* @exception BadLocationException is thrown if one of the edits
* in the tree can't be executed. The state of the document is
* undefined if this exception is thrown.
*
* @see TextEditProcessor#performEdits()
*/
public final UndoEdit apply(IDocument document, int style) throws MalformedTreeException, BadLocationException {
try {
TextEditProcessor processor= new TextEditProcessor(document, this, style);
return processor.performEdits();
} finally {
// disconnect from text edit processor
fParent= null;
}
}
/**
* Applies the edit tree rooted by this edit to the given document. This
* method is a convenience method for apply(document, CREATE_UNDO | UPDATE_REGIONS)
*
*
* @param document the document to which to apply this edit
* @return a undo edit, if CREATE_UNDO is specified. Otherwise
* null is returned.
* @exception MalformedTreeException is thrown if the tree isn't
* in a valid state. This exception is thrown before any edit
* is executed. So the document is still in its original state.
* @exception BadLocationException is thrown if one of the edits
* in the tree can't be executed. The state of the document is
* undefined if this exception is thrown.
* @see #apply(IDocument, int)
*/
public final UndoEdit apply(IDocument document) throws MalformedTreeException, BadLocationException {
return apply(document, CREATE_UNDO | UPDATE_REGIONS);
}
UndoEdit dispatchPerformEdits(TextEditProcessor processor) throws BadLocationException {
return processor.executeDo();
}
void dispatchCheckIntegrity(TextEditProcessor processor) throws MalformedTreeException {
processor.checkIntegrityDo();
}
//---- internal state accessors ----------------------------------------------------------
void internalSetParent(TextEdit parent) {
if (parent != null)
Assert.isTrue(fParent == null);
fParent= parent;
}
void internalSetOffset(int offset) {
Assert.isTrue(offset >= 0);
fOffset= offset;
}
void internalSetLength(int length) {
Assert.isTrue(length >= 0);
fLength= length;
}
List internalGetChildren() {
return fChildren;
}
void internalSetChildren(List children) {
fChildren= children;
}
void internalAdd(TextEdit child) throws MalformedTreeException {
child.aboutToBeAdded(this);
if (child.isDeleted())
throw new MalformedTreeException(this, child, TextEditMessages.getString("TextEdit.deleted_edit")); //$NON-NLS-1$
if (!covers(child))
throw new MalformedTreeException(this, child, TextEditMessages.getString("TextEdit.range_outside")); //$NON-NLS-1$
if (fChildren == null) {
fChildren= new ArrayList<>(2);
}
int index= computeInsertionIndex(child);
fChildren.add(index, child);
child.internalSetParent(this);
}
private int computeInsertionIndex(TextEdit edit) throws MalformedTreeException {
int size= fChildren.size();
if (size == 0)
return 0;
int lastIndex= size - 1;
TextEdit last= fChildren.get(lastIndex);
if (last.getExclusiveEnd() <= edit.getOffset())
return size;
try {
int index= Collections.binarySearch(fChildren, edit, INSERTION_COMPARATOR);
if (index < 0)
// edit is not in fChildren
return -index - 1;
// edit is already in fChildren
// make sure that multiple insertion points at the same offset are inserted last.
while (index < lastIndex && INSERTION_COMPARATOR.compare(fChildren.get(index), fChildren.get(index + 1)) == 0)
index++;
return index + 1;
} catch(MalformedTreeException e) {
e.setParent(this);
throw e;
}
}
//---- Offset & Length updating -------------------------------------------------
/**
* Adjusts the edits offset according to the given
* delta. This method doesn't update any children.
*
* @param delta the delta of the text replace operation
*/
void adjustOffset(int delta) {
if (isDeleted())
return;
fOffset+= delta;
Assert.isTrue(fOffset >= 0);
}
/**
* Adjusts the edits length according to the given
* delta. This method doesn't update any children.
*
* @param delta the delta of the text replace operation
*/
void adjustLength(int delta) {
if (isDeleted())
return;
fLength+= delta;
Assert.isTrue(fLength >= 0);
}
/**
* Marks the edit as deleted. This method doesn't update
* any children.
*/
void markAsDeleted() {
fOffset= DELETED_VALUE;
fLength= DELETED_VALUE;
}
//---- Edit processing ----------------------------------------------
/**
* Traverses the edit tree to perform the consistency check.
*
* @param processor the text edit processor
* @param document the document to be manipulated
* @param sourceEdits the list of source edits to be performed before
* the actual tree is applied to the document
*
* @return the number of indirect move or copy target edit children
*/
int traverseConsistencyCheck(TextEditProcessor processor, IDocument document, List> sourceEdits) {
int result= 0;
if (fChildren != null) {
for (int i= fChildren.size() - 1; i >= 0; i--) {
TextEdit child= fChildren.get(i);
result= Math.max(result, child.traverseConsistencyCheck(processor, document, sourceEdits));
}
}
if (processor.considerEdit(this)) {
performConsistencyCheck(processor, document);
}
return result;
}
/**
* Performs the consistency check.
*
* @param processor the text edit processor
* @param document the document to be manipulated
*/
void performConsistencyCheck(TextEditProcessor processor, IDocument document) {
}
/**
* Traverses the source computation.
*
* @param processor the text edit processor
* @param document the document to be manipulated
*/
void traverseSourceComputation(TextEditProcessor processor, IDocument document) {
}
/**
* Performs the source computation.
*
* @param processor the text edit processor
* @param document the document to be manipulated
*/
void performSourceComputation(TextEditProcessor processor, IDocument document) {
}
int traverseDocumentUpdating(TextEditProcessor processor, IDocument document) throws BadLocationException {
int delta= 0;
if (fChildren != null) {
for (int i= fChildren.size() - 1; i >= 0; i--) {
TextEdit child= fChildren.get(i);
delta+= child.traverseDocumentUpdating(processor, document);
childDocumentUpdated();
}
}
if (processor.considerEdit(this)) {
if (delta != 0)
adjustLength(delta);
int r= performDocumentUpdating(document);
if (r != 0)
adjustLength(r);
delta+= r;
}
return delta;
}
/**
* Hook method called when the document updating of a child edit has been
* completed. When a client calls {@link #apply(IDocument)} or
* {@link #apply(IDocument, int)} this method is called
* {@link #getChildrenSize()} times.
*
* May be overridden by subclasses of {@link MultiTextEdit}.
*
* @since 3.1
*/
protected void childDocumentUpdated() {
}
abstract int performDocumentUpdating(IDocument document) throws BadLocationException;
int traverseRegionUpdating(TextEditProcessor processor, IDocument document, int accumulatedDelta, boolean delete) {
performRegionUpdating(accumulatedDelta, delete);
if (fChildren != null) {
boolean childDelete= delete || deleteChildren();
for (TextEdit child : fChildren) {
accumulatedDelta= child.traverseRegionUpdating(processor, document, accumulatedDelta, childDelete);
childRegionUpdated();
}
}
return accumulatedDelta + fDelta;
}
/**
* Hook method called when the region updating of a child edit has been
* completed. When a client calls {@link #apply(IDocument)} this method is
* called {@link #getChildrenSize()} times. When calling
* {@link #apply(IDocument, int)} this method is called
* {@link #getChildrenSize()} times, when the style parameter contains the
* {@link #UPDATE_REGIONS} flag.
*
* May be overridden by subclasses of {@link MultiTextEdit}.
*
* @since 3.1
*/
protected void childRegionUpdated() {
}
void performRegionUpdating(int accumulatedDelta, boolean delete) {
if (delete)
markAsDeleted();
else
adjustOffset(accumulatedDelta);
}
abstract boolean deleteChildren();
void internalMoveTree(int delta) {
adjustOffset(delta);
if (fChildren != null) {
for (TextEdit textEdit : fChildren) {
textEdit.internalMoveTree(delta);
}
}
}
void deleteTree() {
markAsDeleted();
if (fChildren != null) {
for (TextEdit child : fChildren) {
child.deleteTree();
}
}
}
}