Attachment #20064 for bug #91938

View | Details | Raw Unified | Return to bug 91938
Collapse All | Expand All

Lines 178-187 Link Here

(-)dom/org/eclipse/jdt/core/dom/rewrite/ASTRewrite.java (-2 / +6 lines)
178	if (rootNode != null) {	178	if (rootNode != null) {
179	//validateASTNotModified(rootNode);	179	//validateASTNotModified(rootNode);
180		180
181	getRewriteEventStore().markMovedNodesRemoved();	181	TargetSourceRangeComputer sourceRangeComputer= getExtendedSourceRangeComputer();
		182
		183	this.eventStore.prepareMovedNodes(sourceRangeComputer);
182		184
183	ASTRewriteAnalyzer visitor= new ASTRewriteAnalyzer(document, result, this.eventStore, this.nodeStore, options, getExtendedSourceRangeComputer());	185	ASTRewriteAnalyzer visitor= new ASTRewriteAnalyzer(document, result, this.eventStore, this.nodeStore, options, sourceRangeComputer);
184	rootNode.accept(visitor); // throws IllegalArgumentException	186	rootNode.accept(visitor); // throws IllegalArgumentException
		187
		188	this.eventStore.revertMovedNodes();
185	}	189	}
186	return result;	190	return result;
187	}	191	}




import java.util.Collections;
import java.util.List;

import org.eclipse.text.edits.TextEditGroup;

import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.ChildListPropertyDescriptor;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;

import org.eclipse.jdt.internal.core.dom.rewrite.ListRewriteEvent;
import org.eclipse.jdt.internal.core.dom.rewrite.NodeInfoStore;
import org.eclipse.jdt.internal.core.dom.rewrite.RewriteEvent;
import org.eclipse.jdt.internal.core.dom.rewrite.RewriteEventStore;
import org.eclipse.jdt.internal.core.dom.rewrite.RewriteEventStore.CopySourceInfo;
import org.eclipse.text.edits.TextEditGroup;

/**
 * For describing manipulations to a child list property of an AST node.

	}
	
	
	private ASTNode createTargetNode(ASTNode first, ASTNode last, boolean isMove, ASTNode replacingNode, TextEditGroup editGroup) {
		if (first == null || last == null) {
			throw new IllegalArgumentException();
		}

		CopySourceInfo info= getRewriteStore().markAsRangeCopySource(this.parent, this.childProperty, first, last, isMove);
	
		NodeInfoStore nodeStore= this.rewriter.getNodeStore();
		ASTNode placeholder= nodeStore.newPlaceholderNode(first.getNodeType()); // revisit: could use list type
		if (placeholder == null) {
			throw new IllegalArgumentException("Creating a target node is not supported for nodes of type" + first.getClass().getName()); //$NON-NLS-1$
		}
		
		Block internalPlaceHolder= nodeStore.createCollapsePlaceholder();
		CopySourceInfo info= getRewriteStore().createRangeCopy(this.parent, this.childProperty, first, last, isMove, internalPlaceHolder, replacingNode, editGroup);
		nodeStore.markAsCopyTarget(placeholder, info);
		
		return placeholder;		

	 * @param first the node that starts the range
	 * @param last the node that ends the range
	 * @return the new placeholder node
	 * @throws IllegalArgumentException An exception is thrown if the first or last node
	 * are <code>null</code>, if a node is not a child of the current list or if the first node
	 * is not before the last node. An <code>IllegalArgumentException</code> is
	 * also thrown if the copied range is overlapping with an other moved or copied range. 
	 */
	public final ASTNode createCopyTarget(ASTNode first, ASTNode last) {
		if (first == last) {
			return this.rewriter.createCopyTarget(first);
		} else {
			return createTargetNode(first, last, false, null, null);
		}
	}
	

	 * @param first the node that starts the range
	 * @param last the node that ends the range
	 * @return the new placeholder node
	 * @throws IllegalArgumentException An exception is thrown if the first or last node
	 * are <code>null</code>, if a node is not a child of the current list or if the first node
	 * is not before the last node. An <code>IllegalArgumentException</code> is
	 * also thrown if the moved range is overlapping with an other moved or copied range. 
	 * 
	 * @since 3.1
	 */
	public final ASTNode createMoveTarget(ASTNode first, ASTNode last) {
		return createMoveTarget(first, last, null, null);
	}
	
	/**
	 * Creates and returns a placeholder node for a move of a range of nodes of the
	 * current list. The moved nodes can optionally be replaced by a specified node.
	 * 
	 * The placeholder node can either be inserted as new or used to replace an
	 * existing node. When the document is rewritten, a copy of the source code 
	 * for the given node range is inserted into the output document at the position
	 * corresponding to the placeholder (indentation is adjusted).
	 * 
	 * @param first the node that starts the range
	 * @param last the node that ends the range
	 * @param replacingNode a node that is set at the location of the moved nodes
	 * or <code>null</code> to remove all nodes
	 * @param editGroup the edit group in which to collect the corresponding
	 * text edits fro a replace, or <code>null</code> if ungrouped
	 * @return the new placeholder node
	 * @throws IllegalArgumentException An exception is thrown if the first or
	 * last node are <code>null</code>, if a node is not a child of the current list or
	 * if the first node is not before the last node. An <code>IllegalArgumentException
	 * </code> is also thrown if the moved range is overlapping with an other moved
	 * or copied range. 
	 * 
	 * @since 3.1
	 */
	public final ASTNode createMoveTarget(ASTNode first, ASTNode last, ASTNode replacingNode, TextEditGroup editGroup) {
		if (first == last) {
			replace(first, replacingNode, editGroup);
			return this.rewriter.createMoveTarget(first);
		} else {
			return createTargetNode(first, last, true, replacingNode, editGroup);
		}
	}
	

Lines 125-133 Link Here

(-)dom/org/eclipse/jdt/core/dom/rewrite/TargetSourceRangeComputer.java (-4 / +6 lines)
125	* that should be replaced (or deleted)	125	* that should be replaced (or deleted)
126	*/	126	*/
127	public SourceRange computeSourceRange(ASTNode node) {	127	public SourceRange computeSourceRange(ASTNode node) {
128	CompilationUnit cu = (CompilationUnit) node.getRoot();	128	ASTNode root= node.getRoot();
129	return new SourceRange(	129	if (root instanceof CompilationUnit) {
130	cu.getExtendedStartPosition(node),	130	CompilationUnit cu= (CompilationUnit) root;
131	cu.getExtendedLength(node));	131	return new SourceRange(cu.getExtendedStartPosition(node), cu.getExtendedLength(node));
		132	}
		133	return new SourceRange(node.getStartPosition(), node.getLength());
132	}	134	}
133	}	135	}




	}
	
	/**
	 * Returns the extended source range for a node.
	 * 
	 * @return an extended source range (never null)
	 * @since 3.1
	 */
	private TargetSourceRangeComputer getExtendedSourceRangeComputer() {
		return this.extendedSourceRangeComputer;
	}
	
	final SourceRange getExtendedRange(ASTNode node) {
		if (node.getParent() == null) {
			return new SourceRange(node.getStartPosition(), node.getLength());
		}
		return this.extendedSourceRangeComputer.computeSourceRange(node);
	}
	
	final int getExtendedOffset(ASTNode node) {
		return getExtendedRange(node).getStartPosition();
	}
	
	final int getExtendedEnd(ASTNode node) {
		TargetSourceRangeComputer.SourceRange range= getExtendedRange(node);
			getExtendedSourceRangeComputer().computeSourceRange(node);
		return range.getStartPosition() + range.getLength();
	}
	
	final TextEdit getCopySourceEdit(CopySourceInfo info) {
		TextEdit edit= (TextEdit) this.sourceCopyInfoToEdit.get(info);
		if (edit == null) {
			SourceRange range= getExtendedRange(info.getNode());
			int start= range.getStartPosition();
			int end= start + range.getLength();
				start= range.getStartPosition();
				end= start + range.getLength();
			} else {
				start= getExtendedOffset(info.getStartNode());
				end= getExtendedEnd(info.getEndNode());
			}
			if (info.isMove) {
				MoveSourceEdit moveSourceEdit= new MoveSourceEdit(start, end - start);
				moveSourceEdit.setTargetEdit(new MoveTargetEdit(0));

		if (property.isChildProperty() && node != null) {
			return doVisit((ASTNode) node);
		} else if (property.isChildListProperty()) {
			return doVisitList((List) node, offset);
			return doVisitList((List) node, offset, hasRangeCopySources);
		}
		return offset;
	}
	
	private int doVisitList(List list, int offset) {
		int endPos= offset;
		for (Iterator iter= list.iterator(); iter.hasNext();) {
			ASTNode curr= ((ASTNode) iter.next());
			endPos= doVisit(curr);
			for (Iterator iter= list.iterator(); iter.hasNext();) {
				ASTNode curr= ((ASTNode) iter.next());
				doCopySourcePreVisit(this.eventStore.getRangeCopySources(curr), nodeRangeEndStack);
				endPos= doVisit(curr);
				doCopySourcePostVisit(curr, nodeRangeEndStack);
			}
			return endPos;
		} else {
			int endPos= offset;
			for (Iterator iter= list.iterator(); iter.hasNext();) {
				ASTNode curr= ((ASTNode) iter.next());
				endPos= doVisit(curr);
			}
			return endPos;
		}
		return endPos;
	}
	
	final void voidVisit(ASTNode node) {

		if (property.isChildProperty() && node != null) {
			voidVisit((ASTNode) node);
		} else if (property.isChildListProperty()) {
			voidVisitList((List) node);
			voidVisitList((List) node, hasRangeCopySources);
		}
	}
	
	private void voidVisitList(List list) {
		for (Iterator iter= list.iterator(); iter.hasNext();) {
			doVisit(((ASTNode) iter.next()));
			Stack nodeRangeEndStack= new Stack();
			for (Iterator iter= list.iterator(); iter.hasNext();) {
				ASTNode curr= ((ASTNode) iter.next());
				doCopySourcePreVisit(this.eventStore.getRangeCopySources(curr), nodeRangeEndStack);
				doVisit(curr);
				doCopySourcePostVisit(curr, nodeRangeEndStack);
			}
		} else {
			for (Iterator iter= list.iterator(); iter.hasNext();) {
				doVisit(((ASTNode) iter.next()));
			}
		}
	}
	
	private final boolean doVisitUnchangedChildren(ASTNode parent) {
		List properties= parent.structuralPropertiesForType();
		for (int i= 0; i < properties.size(); i++) {
			voidVisit(parent, (StructuralPropertyDescriptor) properties.get(i));
			if (property.isChildProperty()) {
				ASTNode child= (ASTNode) parent.getStructuralProperty(property);
				if (child != null) {
					voidVisit(child);
				}
			} else if (property.isChildListProperty()) {
				List list= (List) parent.getStructuralProperty(property);
				boolean hasRangeCopySources= this.eventStore.hasRangeCopySources(parent, property);
				voidVisitList(list, hasRangeCopySources);
			}
		}
		return false;
	}

		
		protected RewriteEvent[] list;
		
		private Stack copyRangeEndStack;
		
		protected final ASTNode getOriginalNode(int index) {
			return (ASTNode) this.list[index].getOriginalValue();
		}

			this.startPos= offset;
			this.list= getEvent(parent, property).getChildren();
			
			initCopyRangeChecks(parent, property);
			
			int total= this.list.length;
			if (total == 0) {
				return this.startPos;

					if (i > lastNonDelete && separatorState == EXISTING) {
						// is last, remove previous separator: split delete to allow range copies
						doTextRemove(prevEnd, currPos - prevEnd, editGroup); // remove separator
						checkForRangeStart(node);
						doTextRemoveAndVisit(currPos, currEnd - currPos, node, editGroup); // remove node
						checkForRangeEnd(node);
						currPos= currEnd;
						prevEnd= currEnd;
					} else {
						// remove element and next separator
						int end= getStartOfNextNode(nextIndex, currEnd); // start of next
						checkForRangeStart(node);
						doTextRemoveAndVisit(currPos, currEnd - currPos, node, getEditGroup(currEvent)); // remove node
						checkForRangeEnd(node);
						doTextRemove(currEnd, end - currEnd, editGroup); // remove separator
						currPos= end;
						prevEnd= currEnd;

						
						TextEditGroup editGroup= getEditGroup(currEvent);
						ASTNode changed= (ASTNode) currEvent.getNewValue();
						checkForRangeStart(node);
						doTextRemoveAndVisit(currPos, currEnd - currPos, node, editGroup);
						doTextInsert(currPos, changed, getNodeIndent(i), true, editGroup);
						checkForRangeEnd(node);
						
						prevEnd= currEnd;
					} else { // is unchanged
						ASTNode node= (ASTNode) currEvent.getOriginalValue();
						checkForRangeStart(node);
						voidVisit(node);
						checkForRangeEnd(node);
					}
					if (i == lastNonInsert) { // last node or next nodes are all inserts
						separatorState= NONE;

			return currPos;
		}
		
		private void initCopyRangeChecks(ASTNode parent, StructuralPropertyDescriptor property) {
			if (ASTRewriteAnalyzer.this.eventStore.hasRangeCopySources(parent, property)) {
				this.copyRangeEndStack= new Stack();
			}
		}

		private void checkForRangeStart(ASTNode node) {
			if (this.copyRangeEndStack != null) {
				doCopySourcePreVisit(ASTRewriteAnalyzer.this.eventStore.getRangeCopySources(node), this.copyRangeEndStack);
			}
		}
		
		private void checkForRangeEnd(ASTNode node) {
			if (this.copyRangeEndStack != null) {
				doCopySourcePostVisit(node, this.copyRangeEndStack);
			}
		}
	}
				
	private int rewriteRequiredNode(ASTNode parent, StructuralPropertyDescriptor property) {

				String destIndentString=  this.formatter.getIndentString(getCurrentLine(formatted, offset));
				if (data instanceof CopyPlaceholderData) { // replace with a copy/move target
					CopySourceInfo copySource= ((CopyPlaceholderData) data).copySource;
					int srcIndentLevel= getIndent(copySource.getNode().getStartPosition());
					TextEdit sourceEdit= getCopySourceEdit(copySource);
					doTextCopy(sourceEdit, insertOffset, srcIndentLevel, destIndentString, editGroup);
					currPos= offset + curr.length; // continue to insert after the replaced string

				TextEdit edit= getCopySourceEdit(curr);
				addEdit(edit);
				this.currentEdit= edit;
				nodeEndStack.push(curr.getNode());
			}
		}
	}




 *******************************************************************************/
package org.eclipse.jdt.internal.core.dom.rewrite;

import java.util.*;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.text.edits.TextEditGroup;

import org.eclipse.jdt.core.Signature;
import org.eclipse.jdt.core.dom.*;
import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;
import org.eclipse.text.edits.TextEditGroup;


/**

	

	public final class PropertyLocation {
		private final ASTNode parent;
		private final StructuralPropertyDescriptor property;
		
		public PropertyLocation(ASTNode parent, StructuralPropertyDescriptor property) {
			this.parent= parent;

		public StructuralPropertyDescriptor getProperty() {
			return this.property;
		}
		
		public boolean equals(Object obj) {
			if (obj != null && obj.getClass().equals(this.getClass())) {
				PropertyLocation other= (PropertyLocation) obj;
				return other.getParent().equals(getParent()) && other.getProperty().equals(getProperty());
			}
			return false;
		}
		
		public int hashCode() {
			return getParent().hashCode() + getProperty().hashCode();
		}
		
	}
	
	/**

		}
	}
	
	public static class CopySourceInfo implements Comparable {
		public final PropertyLocation location; // can be null, only used to mark as removed on move
		private final ASTNode node;
		public final boolean isMove;
		
		public CopySourceInfo(PropertyLocation location, ASTNode node, boolean isMove) {
			this.location= location;
			this.node= node;
			this.isMove= isMove;
		}
		
		public ASTNode getNode() {
			return this.node;
		}
		
		public int compareTo(Object o2) {
			CopySourceInfo r2= (CopySourceInfo) o2;
		
			int startDiff= this.getNode().getStartPosition() - r2.getNode().getStartPosition();
			if (startDiff != 0) {
				return startDiff; // insert before if start node is first
			}

			if (r2.isMove != this.isMove) {
				return this.isMove ? -1 : 1; // first move then copy
			}
			return 0;
		}
		
		public String toString() {
			StringBuffer buf= new StringBuffer();
			if (this.isMove) {
				buf.append("move source: "); //$NON-NLS-1$
			} else {
				buf.append("copy source: "); //$NON-NLS-1$
			}
			buf.append(this.node);
			return buf.toString();
		}
	}
	
	private static class NodeRangeInfo implements Comparable {
		private final ASTNode first;
		private final ASTNode last;
		public final CopySourceInfo copyInfo; // containing the internal placeholder and the 'isMove' flag
		public final ASTNode replacingNode;
		public final TextEditGroup editGroup;
		
		public NodeRangeInfo(ASTNode parent, StructuralPropertyDescriptor childProperty, ASTNode first, ASTNode last, CopySourceInfo copyInfo, ASTNode replacingNode, TextEditGroup editGroup) {
			this.parent= parent;
			this.childProperty= childProperty;
			this.first= first;
			this.last= last;
			this.copyInfo= copyInfo;
			this.replacingNode= replacingNode;
			this.editGroup= editGroup;
		}
		
		public ASTNode getStartNode() {

		public ASTNode getEndNode() {
			return this.last;
		}
		
		public boolean isMove() {
			return this.copyInfo.isMove;
		}
		
		public Block getInternalPlaceholder() {
			return (Block) this.copyInfo.getNode();
		}
				
		public int compareTo(Object o2) {
			NodeRangeInfo r2= (NodeRangeInfo) o2;
		
			int startDiff= this.getStartNode().getStartPosition() - r2.getStartNode().getStartPosition();
			if (startDiff != 0) {
				return startDiff; // insert before if start node is first
			}
			int endDiff= this.getEndNode().getStartPosition() - r2.getEndNode().getStartPosition();
			if (endDiff != 0) {
				return -endDiff; // insert before if length is longer
			}
			if (r2.isMove() != this.isMove()) {
				return this.isMove() ? -1 : 1; // first move then copy
			}
			return 0;
		}
		
		public void updatePlaceholderSourceRanges(TargetSourceRangeComputer sourceRangeComputer) {
			TargetSourceRangeComputer.SourceRange startRange= sourceRangeComputer.computeSourceRange(getStartNode());
			TargetSourceRangeComputer.SourceRange endRange= sourceRangeComputer.computeSourceRange(getEndNode());
			int startPos= startRange.getStartPosition();
			int endPos= endRange.getStartPosition() + endRange.getLength();
			
			Block internalPlaceholder= getInternalPlaceholder();
			internalPlaceholder.setSourceRange(startPos, endPos - startPos);
		}
		
		public String toString() {
			StringBuffer buf= new StringBuffer();
			if (this.first != this.last) {
				buf.append("range ");  //$NON-NLS-1$
			}
			if (isMove()) {
				buf.append("move source: "); //$NON-NLS-1$
			} else {
				buf.append("copy source: "); //$NON-NLS-1$
			}
			buf.append(this.first);
			buf.append(" - "); //$NON-NLS-1$
			buf.append(this.last);
				buf.append(this.last);
			}
			return buf.toString();
		}
	}

	public static class CopySourceInfoSorter implements Comparator {

		public int compare(Object o1, Object o2) {
			CopySourceInfo e1= (CopySourceInfo) o1;
			CopySourceInfo e2= (CopySourceInfo) o2;
			if (e1.isMove) {
				return -1;
			} else if (e2.isMove) {
				return 1;
			}
			return e2.getEndNode().getStartPosition() - e1.getEndNode().getStartPosition();
		}
	
	}
	
	/**

			} else {
				this.sourceNodeIter= Collections.EMPTY_LIST.iterator();
			}
			if (RewriteEventStore.this.nodeRangeInfos != null) {
				this.rangeNodeIter= RewriteEventStore.this.nodeRangeInfos.keySet().iterator();
			} else {
				this.rangeNodeIter= Collections.EMPTY_LIST.iterator();
			}

				return ((EventHolder) this.eventIter.next()).parent;
			}
			if (this.sourceNodeIter.hasNext()) {
				return ((CopySourceInfo) this.sourceNodeIter.next()).getNode();
			}
			if (this.rangeNodeIter.hasNext()) {
				return ((PropertyLocation) this.rangeNodeIter.next()).getParent();
			}
			return this.trackedNodeIter.next();
		}

	/** Maps events to group descriptions */
	private Map editGroups;
		
	/** Stores which nodes are source of a copy or move (list of CopySourceInfo)*/
	List nodeCopySources;
	
	/** Stores node ranges that are used to copy or move (map of <PropertyLocation, CopyRangeInfo>)*/
	Map nodeRangeInfos;
	
	/** Stores which nodes are tracked and the corresponding edit group*/
	Map trackedNodes;

		
		this.nodePropertyMapper= null;
		this.nodeCopySources= null;
		this.nodeRangeInfos= null;
	}
	
	/**

		setTrackedNodeData(node, editGroup);
	}	
	
	private final CopySourceInfo createCopySourceInfo(PropertyLocation location, ASTNode node, boolean isMove) {
		CopySourceInfo copySource= new CopySourceInfo(location, node, isMove);
		
		if (this.nodeCopySources == null) {
			this.nodeCopySources= new ArrayList();

		return copySource;
	}
	
	public final CopySourceInfo markAsCopySource(ASTNode parent, StructuralPropertyDescriptor property, ASTNode node, boolean isMove) {
		return createCopySourceInfo(new PropertyLocation(parent, property), node, isMove);
	}
	
	public final CopySourceInfo createRangeCopy(ASTNode parent, StructuralPropertyDescriptor childProperty, ASTNode first, ASTNode last, boolean isMove, ASTNode internalPlaceholder, ASTNode replacingNode, TextEditGroup editGroup) {
		CopySourceInfo copyInfo= createCopySourceInfo(null, internalPlaceholder, isMove);
		
		NodeRangeInfo copyRangeInfo= new NodeRangeInfo(parent, childProperty, first, last, copyInfo, replacingNode, editGroup);
		
		ListRewriteEvent listEvent= getListEvent(parent, childProperty, true);
		
		int indexFirst= listEvent.getIndex(first, ListRewriteEvent.OLD);
		if (indexFirst == -1) {
			throw new IllegalArgumentException("Start node is not a original child of the given list"); //$NON-NLS-1$
		}
		int indexLast= listEvent.getIndex(last, ListRewriteEvent.OLD);
		if (indexLast == -1) {
			throw new IllegalArgumentException("End node is not a original child of the given list"); //$NON-NLS-1$
		}

		if (indexFirst > indexLast) {
			throw new IllegalArgumentException("Start node must be before end node"); //$NON-NLS-1$
		}
		
		if (this.nodeRangeInfos == null) {
			this.nodeRangeInfos= new HashMap();
		}
		PropertyLocation loc= new PropertyLocation(parent, childProperty);
		List innerList= (List) this.nodeRangeInfos.get(loc);
		if (innerList == null) {
			innerList= new ArrayList(2);
			this.nodeRangeInfos.put(loc, innerList);
		} else {
			assertNoOverlap(listEvent, indexFirst, indexLast, innerList);
		}
		innerList.add(copyRangeInfo);
		
		
		return copyInfo;
	}
	
	
	public CopySourceInfo[] getNodeCopySources(ASTNode node) {
		if (this.nodeCopySources == null) {
			return null;

		return internalGetCopySources(this.nodeCopySources, node);
	}
	
	public CopySourceInfo[] getRangeCopySources(ASTNode node) {
		if (this.rangeCopySources == null) {
			return null;
		}
		return internalGetCopySources(this.rangeCopySources, node);
	}
	
	public boolean hasRangeCopySources(ASTNode parent, StructuralPropertyDescriptor property) {
		if (this.rangeCopySources == null) {
			return false;
		}
		for (int i= 0; i < this.rangeCopySources.size(); i++) {
			CopySourceInfo curr= (CopySourceInfo) this.rangeCopySources.get(i);
			if (curr.parent == parent && curr.childProperty == property) {
				return true;
			}
		}
		return false;
	}
	
	public CopySourceInfo[] internalGetCopySources(List copySources, ASTNode node) {
		ArrayList res= new ArrayList(3);
		for (int i= 0; i < copySources.size(); i++) {
			CopySourceInfo curr= (CopySourceInfo) copySources.get(i);
			if (curr.getNode() == node) {
				res.add(curr);
			}
		}
		if (res.isEmpty()) {
			return null;
		}
		
		CopySourceInfo[] arr= (CopySourceInfo[]) res.toArray(new CopySourceInfo[res.size()]);
		Arrays.sort(arr);
			Arrays.sort(arr, new CopySourceInfoSorter());
		}
		return arr;
	}
	
	
	private void assertNoOverlap(ListRewriteEvent listEvent, int indexFirst, int indexLast, List innerList) {
		for (Iterator iter= innerList.iterator(); iter.hasNext();) {
			NodeRangeInfo curr= (NodeRangeInfo) iter.next();
			int currStart= listEvent.getIndex(curr.getStartNode(), ListRewriteEvent.BOTH);
			int currEnd= listEvent.getIndex(curr.getEndNode(), ListRewriteEvent.BOTH);
			if (currStart < indexFirst && currEnd < indexLast && currEnd >= indexFirst
					|| currStart > indexFirst && currStart <= currEnd && currEnd > indexLast) {
				throw new IllegalArgumentException("Range overlapps with an existing copy or move range"); //$NON-NLS-1$ 
			}
		}
	}
	
	public void prepareMovedNodes(TargetSourceRangeComputer sourceRangeComputer) {
		if (this.nodeCopySources != null) {
			prepareSingleNodeCopies();
		}
		
		if (this.nodeRangeInfos != null) {
			prepareNodeRangeCopies(sourceRangeComputer);
			throw new IllegalArgumentException("Start node is not a original child of the given list"); //$NON-NLS-1$
		}
	}
	
	public void revertMovedNodes() {
		if (this.nodeRangeInfos != null) {
			removeMoveRangePlaceholders();
		}
	}
	
	private void removeMoveRangePlaceholders() {
		for (Iterator iter= this.nodeRangeInfos.entrySet().iterator(); iter.hasNext();) {
			Map.Entry entry= (Map.Entry) iter.next();
			Set placeholders= new HashSet(); // collect all placeholders
			List rangeInfos= (List) entry.getValue(); // list of CopySourceRange
			for (int i= 0; i < rangeInfos.size(); i++) {
				placeholders.add(((NodeRangeInfo) rangeInfos.get(i)).getInternalPlaceholder());
			}
			
			PropertyLocation loc= (PropertyLocation) entry.getKey();
			
			RewriteEvent[] children= getListEvent(loc.getParent(), loc.getProperty(), true).getChildren();
			List revertedChildren= new ArrayList();
			revertListWithRanges(children, placeholders, revertedChildren);
			RewriteEvent[] revertedChildrenArr= (RewriteEvent[]) revertedChildren.toArray(new RewriteEvent[revertedChildren.size()]);
			addEvent(loc.getParent(), loc.getProperty(), new ListRewriteEvent(revertedChildrenArr)); // replace the current edits
		}	
	}
	
	private void revertListWithRanges(RewriteEvent[] childEvents, Set placeholders, List revertedChildren) {
		for (int i= 0; i < childEvents.length; i++) {
			RewriteEvent event= childEvents[i];
			ASTNode node= (ASTNode) event.getOriginalValue();
			if (placeholders.contains(node)) {
				RewriteEvent[] placeholderChildren= getListEvent(node, Block.STATEMENTS_PROPERTY, false).getChildren();
				revertListWithRanges(placeholderChildren, placeholders, revertedChildren);
			} else {
				revertedChildren.add(event);
			}
		}
	}

	private void prepareNodeRangeCopies(TargetSourceRangeComputer sourceRangeComputer) {
		for (Iterator iter= this.nodeRangeInfos.entrySet().iterator(); iter.hasNext();) {
			Map.Entry entry= (Map.Entry) iter.next();
			List rangeInfos= (List) entry.getValue(); // list of CopySourceRange
			Collections.sort(rangeInfos); // sort by start index, length, move or copy
			
			PropertyLocation loc= (PropertyLocation) entry.getKey();
			RewriteEvent[] children= getListEvent(loc.getParent(), loc.getProperty(), true).getChildren();
			
			RewriteEvent[] newChildren= processListWithRanges(rangeInfos, children, sourceRangeComputer);
			addEvent(loc.getParent(), loc.getProperty(), new ListRewriteEvent(newChildren)); // replace the current edits
		}		
	}

	private RewriteEvent[] processListWithRanges(List rangeInfos, RewriteEvent[] childEvents, TargetSourceRangeComputer sourceRangeComputer) {
		List newChildEvents= new ArrayList(childEvents.length);
		NodeRangeInfo topInfo= null;
		Stack newChildrenStack= new Stack();
		Stack topInfoStack= new Stack();

		Iterator rangeInfoIterator= rangeInfos.iterator();
		NodeRangeInfo nextInfo= (NodeRangeInfo) rangeInfoIterator.next();
		
		for (int k= 0; k < childEvents.length; k++) {
			RewriteEvent event= childEvents[k];
			ASTNode node= (ASTNode) event.getOriginalValue();
			// check for ranges and add a placeholder for them
			while (nextInfo != null && node == nextInfo.getStartNode()) { // is this child the beginning of a range?
				nextInfo.updatePlaceholderSourceRanges(sourceRangeComputer);
				
				Block internalPlaceholder= nextInfo.getInternalPlaceholder();
				RewriteEvent newEvent;
				if (nextInfo.isMove()) {
					newEvent= new NodeRewriteEvent(internalPlaceholder, nextInfo.replacingNode); // remove or replace
				} else {
					newEvent= new NodeRewriteEvent(internalPlaceholder, internalPlaceholder); // unchanged
				}
				newChildEvents.add(newEvent);
				if (nextInfo.editGroup != null) {
					setEventEditGroup(newEvent, nextInfo.editGroup);
				}
				
				newChildrenStack.push(newChildEvents);
				topInfoStack.push(topInfo);
				
				newChildEvents= new ArrayList(childEvents.length);
				topInfo= nextInfo;
				
				nextInfo= rangeInfoIterator.hasNext() ? (NodeRangeInfo) rangeInfoIterator.next() : null;
			}
			
			newChildEvents.add(event);

			while (topInfo != null && node == topInfo.getEndNode()) {
				RewriteEvent[] placeholderChildEvents= (RewriteEvent[]) newChildEvents.toArray(new RewriteEvent[newChildEvents.size()]);
				Block internalPlaceholder= topInfo.getInternalPlaceholder();
				addEvent(internalPlaceholder, Block.STATEMENTS_PROPERTY, new ListRewriteEvent(placeholderChildEvents));
				
				newChildEvents= (List) newChildrenStack.pop();
				topInfo= (NodeRangeInfo) topInfoStack.pop();
			}
		}
		return (RewriteEvent[]) newChildEvents.toArray(new RewriteEvent[newChildEvents.size()]);
	}

	/**
	 * Make sure all moved nodes are marked as removed or replaced.
	 */
	private void prepareSingleNodeCopies() {
		if (this.nodeCopySources == null) {
			return;
		}
		for (int i= 0; i < this.nodeCopySources.size(); i++) {
			CopySourceInfo curr= (CopySourceInfo) this.nodeCopySources.get(i);
			if (curr.isMove && curr.location != null) {
				doMarkMovedAsRemoved(curr, curr.location.getParent(), curr.location.getProperty());
			}
		}
		
	}
	
	private void doMarkMovedAsRemoved(CopySourceInfo curr, ASTNode parent, StructuralPropertyDescriptor childProperty) {
		if (childProperty.isChildListProperty()) {
			ListRewriteEvent event= getListEvent(parent, childProperty, true);
			int index= event.getIndex(curr.getNode(), ListRewriteEvent.OLD);
			if (index != -1 && event.getChangeKind(index) == RewriteEvent.UNCHANGED) {
				event.setNewValue(null, index);
			}
		} else {
			NodeRewriteEvent event= getNodeEvent(parent, childProperty, true);
			if (event.getChangeKind() == RewriteEvent.UNCHANGED) {
				event.setNewValue(null);
			}

Return to bug 91938

Lines 13-31 Link Here

(-)dom/org/eclipse/jdt/core/dom/rewrite/ListRewrite.java (-13 / +46 lines)
13	import java.util.Collections;	13	import java.util.Collections;
14	import java.util.List;	14	import java.util.List;
15		15
16	import org.eclipse.text.edits.TextEditGroup;
17
18	import org.eclipse.jdt.core.dom.ASTNode;	16	import org.eclipse.jdt.core.dom.ASTNode;
		17	import org.eclipse.jdt.core.dom.Block;
19	import org.eclipse.jdt.core.dom.ChildListPropertyDescriptor;	18	import org.eclipse.jdt.core.dom.ChildListPropertyDescriptor;
20	import org.eclipse.jdt.core.dom.FieldDeclaration;	19	import org.eclipse.jdt.core.dom.FieldDeclaration;
21	import org.eclipse.jdt.core.dom.Statement;	20	import org.eclipse.jdt.core.dom.Statement;
22	import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;	21	import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
23
24	import org.eclipse.jdt.internal.core.dom.rewrite.ListRewriteEvent;	22	import org.eclipse.jdt.internal.core.dom.rewrite.ListRewriteEvent;
25	import org.eclipse.jdt.internal.core.dom.rewrite.NodeInfoStore;	23	import org.eclipse.jdt.internal.core.dom.rewrite.NodeInfoStore;
26	import org.eclipse.jdt.internal.core.dom.rewrite.RewriteEvent;	24	import org.eclipse.jdt.internal.core.dom.rewrite.RewriteEvent;
27	import org.eclipse.jdt.internal.core.dom.rewrite.RewriteEventStore;	25	import org.eclipse.jdt.internal.core.dom.rewrite.RewriteEventStore;
28	import org.eclipse.jdt.internal.core.dom.rewrite.RewriteEventStore.CopySourceInfo;	26	import org.eclipse.jdt.internal.core.dom.rewrite.RewriteEventStore.CopySourceInfo;
		27	import org.eclipse.text.edits.TextEditGroup;
29		28
30	/**	29	/**
31	* For describing manipulations to a child list property of an AST node.	30	* For describing manipulations to a child list property of an AST node.
Lines 290-307 Link Here
290	}	289	}
291		290
292		291
293	private ASTNode createTargetNode(ASTNode first, ASTNode last, boolean isMove) {	292	private ASTNode createTargetNode(ASTNode first, ASTNode last, boolean isMove, ASTNode replacingNode, TextEditGroup editGroup) {
294	if (first == null \|\| last == null) {	293	if (first == null \|\| last == null) {
295	throw new IllegalArgumentException();	294	throw new IllegalArgumentException();
296	}	295	}
297	//validateIsInsideAST(node);	296
298	CopySourceInfo info= getRewriteStore().markAsRangeCopySource(this.parent, this.childProperty, first, last, isMove);
299
300	NodeInfoStore nodeStore= this.rewriter.getNodeStore();	297	NodeInfoStore nodeStore= this.rewriter.getNodeStore();
301	ASTNode placeholder= nodeStore.newPlaceholderNode(first.getNodeType()); // revisit: could use list type	298	ASTNode placeholder= nodeStore.newPlaceholderNode(first.getNodeType()); // revisit: could use list type
302	if (placeholder == null) {	299	if (placeholder == null) {
303	throw new IllegalArgumentException("Creating a target node is not supported for nodes of type" + first.getClass().getName()); //$NON-NLS-1$	300	throw new IllegalArgumentException("Creating a target node is not supported for nodes of type" + first.getClass().getName()); //$NON-NLS-1$
304	}	301	}
		302
		303	Block internalPlaceHolder= nodeStore.createCollapsePlaceholder();
		304	CopySourceInfo info= getRewriteStore().createRangeCopy(this.parent, this.childProperty, first, last, isMove, internalPlaceHolder, replacingNode, editGroup);
305	nodeStore.markAsCopyTarget(placeholder, info);	305	nodeStore.markAsCopyTarget(placeholder, info);
306		306
307	return placeholder;	307	return placeholder;
Lines 318-331 Link Here
318	* @param first the node that starts the range	318	* @param first the node that starts the range
319	* @param last the node that ends the range	319	* @param last the node that ends the range
320	* @return the new placeholder node	320	* @return the new placeholder node
321	* @throws IllegalArgumentException if the node is null, or if the node	321	* @throws IllegalArgumentException An exception is thrown if the first or last node
322	* is not part of this rewriter's AST	322	* are <code>null</code>, if a node is not a child of the current list or if the first node
		323	* is not before the last node. An <code>IllegalArgumentException</code> is
		324	* also thrown if the copied range is overlapping with an other moved or copied range.
323	*/	325	*/
324	public final ASTNode createCopyTarget(ASTNode first, ASTNode last) {	326	public final ASTNode createCopyTarget(ASTNode first, ASTNode last) {
325	if (first == last) {	327	if (first == last) {
326	return this.rewriter.createCopyTarget(first);	328	return this.rewriter.createCopyTarget(first);
327	} else {	329	} else {
328	return createTargetNode(first, last, false);	330	return createTargetNode(first, last, false, null, null);
329	}	331	}
330	}	332	}
331		333
Lines 340-355 Link Here
340	* @param first the node that starts the range	342	* @param first the node that starts the range
341	* @param last the node that ends the range	343	* @param last the node that ends the range
342	* @return the new placeholder node	344	* @return the new placeholder node
343	* @throws IllegalArgumentException if the node is null, or if the node	345	* @throws IllegalArgumentException An exception is thrown if the first or last node
344	* is not part of this rewriter's AST	346	* are <code>null</code>, if a node is not a child of the current list or if the first node
		347	* is not before the last node. An <code>IllegalArgumentException</code> is
		348	* also thrown if the moved range is overlapping with an other moved or copied range.
345	*	349	*
346	* @since 3.1	350	* @since 3.1
347	*/	351	*/
348	public final ASTNode createMoveTarget(ASTNode first, ASTNode last) {	352	public final ASTNode createMoveTarget(ASTNode first, ASTNode last) {
		353	return createMoveTarget(first, last, null, null);
		354	}
		355
		356	/**
		357	* Creates and returns a placeholder node for a move of a range of nodes of the
		358	* current list. The moved nodes can optionally be replaced by a specified node.
		359	*
		360	* The placeholder node can either be inserted as new or used to replace an
		361	* existing node. When the document is rewritten, a copy of the source code
		362	* for the given node range is inserted into the output document at the position
		363	* corresponding to the placeholder (indentation is adjusted).
		364	*
		365	* @param first the node that starts the range
		366	* @param last the node that ends the range
		367	* @param replacingNode a node that is set at the location of the moved nodes
		368	* or <code>null</code> to remove all nodes
		369	* @param editGroup the edit group in which to collect the corresponding
		370	* text edits fro a replace, or <code>null</code> if ungrouped
		371	* @return the new placeholder node
		372	* @throws IllegalArgumentException An exception is thrown if the first or
		373	* last node are <code>null</code>, if a node is not a child of the current list or
		374	* if the first node is not before the last node. An <code>IllegalArgumentException
		375	* </code> is also thrown if the moved range is overlapping with an other moved
		376	* or copied range.
		377	*
		378	* @since 3.1
		379	*/
		380	public final ASTNode createMoveTarget(ASTNode first, ASTNode last, ASTNode replacingNode, TextEditGroup editGroup) {
349	if (first == last) {	381	if (first == last) {
		382	replace(first, replacingNode, editGroup);
350	return this.rewriter.createMoveTarget(first);	383	return this.rewriter.createMoveTarget(first);
351	} else {	384	} else {
352	return createTargetNode(first, last, true);	385	return createTargetNode(first, last, true, replacingNode, editGroup);
353	}	386	}
354	}	387	}
355		388

Lines 114-154 Link Here

(-)dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java (-98 / +25 lines)
114	}	114	}
115		115
116	/**	116	/**
117	* Returns the extended source range computer for this AST rewriter.	117	* Returns the extended source range for a node.
118	*	118	*
119	* @return an extended source range computer (never null)	119	* @return an extended source range (never null)
120	* @since 3.1	120	* @since 3.1
121	*/	121	*/
122	private TargetSourceRangeComputer getExtendedSourceRangeComputer() {
123	return this.extendedSourceRangeComputer;
124	}
125
126	final SourceRange getExtendedRange(ASTNode node) {	122	final SourceRange getExtendedRange(ASTNode node) {
127	return getExtendedSourceRangeComputer().computeSourceRange(node);	123	if (node.getParent() == null) {
		124	return new SourceRange(node.getStartPosition(), node.getLength());
		125	}
		126	return this.extendedSourceRangeComputer.computeSourceRange(node);
128	}	127	}
129		128
130	final int getExtendedOffset(ASTNode node) {	129	final int getExtendedOffset(ASTNode node) {
131	return getExtendedSourceRangeComputer().computeSourceRange(node).getStartPosition();	130	return getExtendedRange(node).getStartPosition();
132	}	131	}
133		132
134	final int getExtendedEnd(ASTNode node) {	133	final int getExtendedEnd(ASTNode node) {
135	TargetSourceRangeComputer.SourceRange range =	134	TargetSourceRangeComputer.SourceRange range= getExtendedRange(node);
136	getExtendedSourceRangeComputer().computeSourceRange(node);
137	return range.getStartPosition() + range.getLength();	135	return range.getStartPosition() + range.getLength();
138	}	136	}
139		137
140	final TextEdit getCopySourceEdit(CopySourceInfo info) {	138	final TextEdit getCopySourceEdit(CopySourceInfo info) {
141	TextEdit edit= (TextEdit) this.sourceCopyInfoToEdit.get(info);	139	TextEdit edit= (TextEdit) this.sourceCopyInfoToEdit.get(info);
142	if (edit == null) {	140	if (edit == null) {
143	int start, end;	141	SourceRange range= getExtendedRange(info.getNode());
144	if (info.getStartNode() == info.getEndNode()) {	142	int start= range.getStartPosition();
145	SourceRange range= getExtendedRange(info.getStartNode());	143	int end= start + range.getLength();
146	start= range.getStartPosition();
147	end= start + range.getLength();
148	} else {
149	start= getExtendedOffset(info.getStartNode());
150	end= getExtendedEnd(info.getEndNode());
151	}
152	if (info.isMove) {	144	if (info.isMove) {
153	MoveSourceEdit moveSourceEdit= new MoveSourceEdit(start, end - start);	145	MoveSourceEdit moveSourceEdit= new MoveSourceEdit(start, end - start);
154	moveSourceEdit.setTargetEdit(new MoveTargetEdit(0));	146	moveSourceEdit.setTargetEdit(new MoveTargetEdit(0));
Lines 284-315 Link Here
284	if (property.isChildProperty() && node != null) {	276	if (property.isChildProperty() && node != null) {
285	return doVisit((ASTNode) node);	277	return doVisit((ASTNode) node);
286	} else if (property.isChildListProperty()) {	278	} else if (property.isChildListProperty()) {
287	boolean hasRangeCopySources= this.eventStore.hasRangeCopySources(parent, property);	279	return doVisitList((List) node, offset);
288	return doVisitList((List) node, offset, hasRangeCopySources);
289	}	280	}
290	return offset;	281	return offset;
291	}	282	}
292		283
293	private int doVisitList(List list, int offset, boolean hasRangeCopySources) {	284	private int doVisitList(List list, int offset) {
294	if (hasRangeCopySources) {	285	int endPos= offset;
295	// list with copy source ranges	286	for (Iterator iter= list.iterator(); iter.hasNext();) {
296	Stack nodeRangeEndStack= new Stack();	287	ASTNode curr= ((ASTNode) iter.next());
297	int endPos= offset;	288	endPos= doVisit(curr);
298	for (Iterator iter= list.iterator(); iter.hasNext();) {
299	ASTNode curr= ((ASTNode) iter.next());
300	doCopySourcePreVisit(this.eventStore.getRangeCopySources(curr), nodeRangeEndStack);
301	endPos= doVisit(curr);
302	doCopySourcePostVisit(curr, nodeRangeEndStack);
303	}
304	return endPos;
305	} else {
306	int endPos= offset;
307	for (Iterator iter= list.iterator(); iter.hasNext();) {
308	ASTNode curr= ((ASTNode) iter.next());
309	endPos= doVisit(curr);
310	}
311	return endPos;
312	}	289	}
		290	return endPos;
313	}	291	}
314		292
315	final void voidVisit(ASTNode node) {	293	final void voidVisit(ASTNode node) {
Lines 321-362 Link Here
321	if (property.isChildProperty() && node != null) {	299	if (property.isChildProperty() && node != null) {
322	voidVisit((ASTNode) node);	300	voidVisit((ASTNode) node);
323	} else if (property.isChildListProperty()) {	301	} else if (property.isChildListProperty()) {
324	boolean hasRangeCopySources= this.eventStore.hasRangeCopySources(parent, property);	302	voidVisitList((List) node);
325	voidVisitList((List) node, hasRangeCopySources);
326	}	303	}
327	}	304	}
328		305
329	private void voidVisitList(List list, boolean hasRangeCopySources) {	306	private void voidVisitList(List list) {
330	if (hasRangeCopySources) {	307	for (Iterator iter= list.iterator(); iter.hasNext();) {
331	// list with copy source ranges	308	doVisit(((ASTNode) iter.next()));
332	Stack nodeRangeEndStack= new Stack();
333	for (Iterator iter= list.iterator(); iter.hasNext();) {
334	ASTNode curr= ((ASTNode) iter.next());
335	doCopySourcePreVisit(this.eventStore.getRangeCopySources(curr), nodeRangeEndStack);
336	doVisit(curr);
337	doCopySourcePostVisit(curr, nodeRangeEndStack);
338	}
339	} else {
340	for (Iterator iter= list.iterator(); iter.hasNext();) {
341	doVisit(((ASTNode) iter.next()));
342	}
343	}	309	}
344	}	310	}
345		311
346	private final boolean doVisitUnchangedChildren(ASTNode parent) {	312	private final boolean doVisitUnchangedChildren(ASTNode parent) {
347	List properties= parent.structuralPropertiesForType();	313	List properties= parent.structuralPropertiesForType();
348	for (int i= 0; i < properties.size(); i++) {	314	for (int i= 0; i < properties.size(); i++) {
349	StructuralPropertyDescriptor property= (StructuralPropertyDescriptor) properties.get(i);	315	voidVisit(parent, (StructuralPropertyDescriptor) properties.get(i));
350	if (property.isChildProperty()) {
351	ASTNode child= (ASTNode) parent.getStructuralProperty(property);
352	if (child != null) {
353	voidVisit(child);
354	}
355	} else if (property.isChildListProperty()) {
356	List list= (List) parent.getStructuralProperty(property);
357	boolean hasRangeCopySources= this.eventStore.hasRangeCopySources(parent, property);
358	voidVisitList(list, hasRangeCopySources);
359	}
360	}	316	}
361	return false;	317	return false;
362	}	318	}
Lines 409-416 Link Here
409		365
410	protected RewriteEvent[] list;	366	protected RewriteEvent[] list;
411		367
412	private Stack copyRangeEndStack;
413
414	protected final ASTNode getOriginalNode(int index) {	368	protected final ASTNode getOriginalNode(int index) {
415	return (ASTNode) this.list[index].getOriginalValue();	369	return (ASTNode) this.list[index].getOriginalValue();
416	}	370	}
Lines 465-472 Link Here
465	this.startPos= offset;	419	this.startPos= offset;
466	this.list= getEvent(parent, property).getChildren();	420	this.list= getEvent(parent, property).getChildren();
467		421
468	initCopyRangeChecks(parent, property);
469
470	int total= this.list.length;	422	int total= this.list.length;
471	if (total == 0) {	423	if (total == 0) {
472	return this.startPos;	424	return this.startPos;
Lines 543-559 Link Here
543	if (i > lastNonDelete && separatorState == EXISTING) {	495	if (i > lastNonDelete && separatorState == EXISTING) {
544	// is last, remove previous separator: split delete to allow range copies	496	// is last, remove previous separator: split delete to allow range copies
545	doTextRemove(prevEnd, currPos - prevEnd, editGroup); // remove separator	497	doTextRemove(prevEnd, currPos - prevEnd, editGroup); // remove separator
546	checkForRangeStart(node);
547	doTextRemoveAndVisit(currPos, currEnd - currPos, node, editGroup); // remove node	498	doTextRemoveAndVisit(currPos, currEnd - currPos, node, editGroup); // remove node
548	checkForRangeEnd(node);
549	currPos= currEnd;	499	currPos= currEnd;
550	prevEnd= currEnd;	500	prevEnd= currEnd;
551	} else {	501	} else {
552	// remove element and next separator	502	// remove element and next separator
553	int end= getStartOfNextNode(nextIndex, currEnd); // start of next	503	int end= getStartOfNextNode(nextIndex, currEnd); // start of next
554	checkForRangeStart(node);
555	doTextRemoveAndVisit(currPos, currEnd - currPos, node, getEditGroup(currEvent)); // remove node	504	doTextRemoveAndVisit(currPos, currEnd - currPos, node, getEditGroup(currEvent)); // remove node
556	checkForRangeEnd(node);
557	doTextRemove(currEnd, end - currEnd, editGroup); // remove separator	505	doTextRemove(currEnd, end - currEnd, editGroup); // remove separator
558	currPos= end;	506	currPos= end;
559	prevEnd= currEnd;	507	prevEnd= currEnd;
Lines 566-582 Link Here
566		514
567	TextEditGroup editGroup= getEditGroup(currEvent);	515	TextEditGroup editGroup= getEditGroup(currEvent);
568	ASTNode changed= (ASTNode) currEvent.getNewValue();	516	ASTNode changed= (ASTNode) currEvent.getNewValue();
569	checkForRangeStart(node);
570	doTextRemoveAndVisit(currPos, currEnd - currPos, node, editGroup);	517	doTextRemoveAndVisit(currPos, currEnd - currPos, node, editGroup);
571	doTextInsert(currPos, changed, getNodeIndent(i), true, editGroup);	518	doTextInsert(currPos, changed, getNodeIndent(i), true, editGroup);
572	checkForRangeEnd(node);
573		519
574	prevEnd= currEnd;	520	prevEnd= currEnd;
575	} else { // is unchanged	521	} else { // is unchanged
576	ASTNode node= (ASTNode) currEvent.getOriginalValue();	522	ASTNode node= (ASTNode) currEvent.getOriginalValue();
577	checkForRangeStart(node);
578	voidVisit(node);	523	voidVisit(node);
579	checkForRangeEnd(node);
580	}	524	}
581	if (i == lastNonInsert) { // last node or next nodes are all inserts	525	if (i == lastNonInsert) { // last node or next nodes are all inserts
582	separatorState= NONE;	526	separatorState= NONE;
Lines 600-622 Link Here
600	return currPos;	544	return currPos;
601	}	545	}
602		546
603	private void initCopyRangeChecks(ASTNode parent, StructuralPropertyDescriptor property) {
604	if (ASTRewriteAnalyzer.this.eventStore.hasRangeCopySources(parent, property)) {
605	this.copyRangeEndStack= new Stack();
606	}
607	}
608
609	private void checkForRangeStart(ASTNode node) {
610	if (this.copyRangeEndStack != null) {
611	doCopySourcePreVisit(ASTRewriteAnalyzer.this.eventStore.getRangeCopySources(node), this.copyRangeEndStack);
612	}
613	}
614
615	private void checkForRangeEnd(ASTNode node) {
616	if (this.copyRangeEndStack != null) {
617	doCopySourcePostVisit(node, this.copyRangeEndStack);
618	}
619	}
620	}	547	}
621		548
622	private int rewriteRequiredNode(ASTNode parent, StructuralPropertyDescriptor property) {	549	private int rewriteRequiredNode(ASTNode parent, StructuralPropertyDescriptor property) {
Lines 1109-1115 Link Here
1109	String destIndentString= this.formatter.getIndentString(getCurrentLine(formatted, offset));	1036	String destIndentString= this.formatter.getIndentString(getCurrentLine(formatted, offset));
1110	if (data instanceof CopyPlaceholderData) { // replace with a copy/move target	1037	if (data instanceof CopyPlaceholderData) { // replace with a copy/move target
1111	CopySourceInfo copySource= ((CopyPlaceholderData) data).copySource;	1038	CopySourceInfo copySource= ((CopyPlaceholderData) data).copySource;
1112	int srcIndentLevel= getIndent(copySource.getStartNode().getStartPosition());	1039	int srcIndentLevel= getIndent(copySource.getNode().getStartPosition());
1113	TextEdit sourceEdit= getCopySourceEdit(copySource);	1040	TextEdit sourceEdit= getCopySourceEdit(copySource);
1114	doTextCopy(sourceEdit, insertOffset, srcIndentLevel, destIndentString, editGroup);	1041	doTextCopy(sourceEdit, insertOffset, srcIndentLevel, destIndentString, editGroup);
1115	currPos= offset + curr.length; // continue to insert after the replaced string	1042	currPos= offset + curr.length; // continue to insert after the replaced string
Lines 1297-1303 Link Here
1297	TextEdit edit= getCopySourceEdit(curr);	1224	TextEdit edit= getCopySourceEdit(curr);
1298	addEdit(edit);	1225	addEdit(edit);
1299	this.currentEdit= edit;	1226	this.currentEdit= edit;
1300	nodeEndStack.push(curr.getEndNode());	1227	nodeEndStack.push(curr.getNode());
1301	}	1228	}
1302	}	1229	}
1303	}	1230	}