Skip to content

Commit

Permalink
Extracted some methods and renamed some variables
Browse files Browse the repository at this point in the history
  • Loading branch information
@ThLeu
ThLeu committed May 18, 2018
1 parent 2ae6f77 commit 7f177dc
Showing 1 changed file with 97 additions and 41 deletions.
138 changes: 97 additions & 41 deletions ...rser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Difference.java
View file
Expand Up @@ -180,6 +180,15 @@ public CsmElement getElement() {
return element; return element;
} }


public int getTokenType() {
if (isToken()) {
CsmToken csmToken = (CsmToken) element;
return csmToken.getTokenType();
}

throw new IllegalStateException("Kept is not a " + CsmToken.class.getSimpleName());
}

@Override @Override
public boolean isAdded() { public boolean isAdded() {
return false; return false;
Expand All @@ -202,6 +211,15 @@ public boolean isPrimitiveType() {
return false; return false;
} }


public boolean isWhiteSpace() {
if(isToken()) {
CsmToken csmToken = (CsmToken) element;
return csmToken.isWhiteSpace();
}

return false;
}

public boolean isWhiteSpaceOrComment() { public boolean isWhiteSpaceOrComment() {
if (isToken()) { if (isToken()) {
CsmToken csmToken = (CsmToken) element; CsmToken csmToken = (CsmToken) element;
Expand Down Expand Up @@ -244,6 +262,24 @@ public CsmElement getElement() {
return element; return element;
} }


public Node getChild() {
if (isChild()) {
CsmChild csmChild = (CsmChild) element;
return csmChild.getChild();
}

throw new IllegalStateException("Removed is not a " + CsmChild.class.getSimpleName());
}

public int getTokenType() {
if (isToken()) {
CsmToken csmToken = (CsmToken) element;
return csmToken.getTokenType();
}

throw new IllegalStateException("Removed is not a " + CsmToken.class.getSimpleName());
}

@Override @Override
public boolean isAdded() { public boolean isAdded() {
return false; return false;
Expand Down Expand Up @@ -541,7 +577,7 @@ void apply(NodeText nodeText, Node node) {
List<TextElement> originalElements = nodeText.getElements(); List<TextElement> originalElements = nodeText.getElements();
int originalIndex = 0; int originalIndex = 0;


List<DifferenceElement> diffElements = this.elements; List<DifferenceElement> diffElements = getElements();
int diffIndex = 0; int diffIndex = 0;
do { do {
if (diffIndex < diffElements.size() && originalIndex >= originalElements.size()) { if (diffIndex < diffElements.size() && originalIndex >= originalElements.size()) {
Expand All @@ -566,6 +602,7 @@ void apply(NodeText nodeText, Node node) {
} }
} else if (diffIndex >= diffElements.size() && originalIndex < originalElements.size()) { } else if (diffIndex >= diffElements.size() && originalIndex < originalElements.size()) {
TextElement originalElement = originalElements.get(originalIndex); TextElement originalElement = originalElements.get(originalIndex);

if (originalElement.isWhiteSpaceOrComment()) { if (originalElement.isWhiteSpaceOrComment()) {
originalIndex++; originalIndex++;
} else { } else {
Expand Down Expand Up @@ -594,14 +631,15 @@ void apply(NodeText nodeText, Node node) {
diffIndex++; diffIndex++;
continue; continue;
} }
TextElement textElement = addedElement.toTextElement();
TextElement addedTextElement = addedElement.toTextElement();
boolean used = false; boolean used = false;
if (originalIndex > 0 && originalElements.get(originalIndex - 1).isNewline()) { if (originalIndex > 0 && originalElements.get(originalIndex - 1).isNewline()) {
for (TextElement e : processIndentation(indentation, originalElements.subList(0, originalIndex - 1))) { for (TextElement e : processIndentation(indentation, originalElements.subList(0, originalIndex - 1))) {
nodeText.addElement(originalIndex++, e); nodeText.addElement(originalIndex++, e);
} }
} else if (isAfterLBrace(nodeText, originalIndex) && !isAReplacement(diffIndex)) { } else if (isAfterLBrace(nodeText, originalIndex) && !isAReplacement(diffIndex)) {
if (textElement.isNewline()) { if (addedTextElement.isNewline()) {
used = true; used = true;
} }
nodeText.addElement(originalIndex++, new TokenTextElement(TokenTypes.eolTokenKind())); nodeText.addElement(originalIndex++, new TokenTextElement(TokenTypes.eolTokenKind()));
Expand All @@ -623,16 +661,17 @@ void apply(NodeText nodeText, Node node) {
} }
} }
} }

if (!used) { if (!used) {
nodeText.addElement(originalIndex, textElement); nodeText.addElement(originalIndex, addedTextElement);
originalIndex++; originalIndex++;
} }
if (textElement.isNewline()) {
boolean followedByUnindent = (diffIndex + 1) < diffElements.size() if (addedTextElement.isNewline()) {
&& diffElements.get(diffIndex + 1).isAdded() boolean followedByUnindent = isFollowedByUnindent(diffElements, diffIndex);
&& diffElements.get(diffIndex + 1).getElement() instanceof CsmUnindent;
originalIndex = adjustIndentation(indentation, nodeText, originalIndex, followedByUnindent/* && !addedIndentation*/); originalIndex = adjustIndentation(indentation, nodeText, originalIndex, followedByUnindent/* && !addedIndentation*/);
} }

diffIndex++; diffIndex++;
} else { } else {
TextElement originalElement = originalElements.get(originalIndex); TextElement originalElement = originalElements.get(originalIndex);
Expand All @@ -641,6 +680,7 @@ void apply(NodeText nodeText, Node node) {


if (diffElement instanceof Kept) { if (diffElement instanceof Kept) {
Kept kept = (Kept)diffElement; Kept kept = (Kept)diffElement;

if (originalElement.isComment()) { if (originalElement.isComment()) {
originalIndex++; originalIndex++;
} else if (kept.isChild() && originalElementIsChild) { } else if (kept.isChild() && originalElementIsChild) {
Expand All @@ -658,22 +698,21 @@ void apply(NodeText nodeText, Node node) {
} }
} }
} else if (kept.isToken() && originalElementIsToken) { } else if (kept.isToken() && originalElementIsToken) {
CsmToken csmToken = (CsmToken) kept.element; TokenTextElement originalTextToken = (TokenTextElement) originalElement;
TokenTextElement nodeTextToken = (TokenTextElement) originalElement;
if (csmToken.getTokenType() == nodeTextToken.getTokenKind()) { if (kept.getTokenType() == originalTextToken.getTokenKind()) {
originalIndex++; originalIndex++;
diffIndex++; diffIndex++;
} else if (kept.isWhiteSpaceOrComment()) { } else if (kept.isWhiteSpaceOrComment()) {
diffIndex++; diffIndex++;
} else if (nodeTextToken.isWhiteSpaceOrComment()) { } else if (originalTextToken.isWhiteSpaceOrComment()) {
originalIndex++; originalIndex++;
} else { } else {
throw new UnsupportedOperationException("Csm token " + csmToken + " NodeText TOKEN " + nodeTextToken); throw new UnsupportedOperationException("Csm token " + kept.element + " NodeText TOKEN " + originalTextToken);
} }
} else if (kept.isToken() && ((CsmToken) kept.element).isWhiteSpace()) { } else if (kept.isWhiteSpace()) {
diffIndex++; diffIndex++;
} else if (kept.isIndent()) { } else if (kept.isIndent()) {
// Nothing to do
diffIndex++; diffIndex++;
} else if (kept.isUnindent()) { } else if (kept.isUnindent()) {
// Nothing to do, beside considering indentation // Nothing to do, beside considering indentation
Expand All @@ -686,14 +725,14 @@ void apply(NodeText nodeText, Node node) {
} }
} else if (diffElement instanceof Removed) { } else if (diffElement instanceof Removed) {
Removed removed = (Removed)diffElement; Removed removed = (Removed)diffElement;

if (removed.isChild() && originalElementIsChild) { if (removed.isChild() && originalElementIsChild) {
ChildTextElement actualChild = (ChildTextElement)originalElement; ChildTextElement originalElementChild = (ChildTextElement)originalElement;
if (actualChild.isComment()) { if (originalElementChild.isComment()) {
CsmChild csmChild = (CsmChild)removed.element;
// We expected to remove a proper node but we found a comment in between. // We expected to remove a proper node but we found a comment in between.
// If the comment is associated to the node we want to remove we remove it as well, otherwise we keep it // If the comment is associated to the node we want to remove we remove it as well, otherwise we keep it
Comment comment = (Comment)actualChild.getChild(); Comment comment = (Comment)originalElementChild.getChild();
if (!comment.isOrphan() && comment.getCommentedNode().isPresent() && comment.getCommentedNode().get().equals(csmChild.getChild())) { if (!comment.isOrphan() && comment.getCommentedNode().isPresent() && comment.getCommentedNode().get().equals(removed.getChild())) {
nodeText.removeElement(originalIndex); nodeText.removeElement(originalIndex);
} else { } else {
originalIndex++; originalIndex++;
Expand All @@ -720,7 +759,7 @@ void apply(NodeText nodeText, Node node) {
diffIndex++; diffIndex++;
} }
} else if (removed.isToken() && originalElementIsToken } else if (removed.isToken() && originalElementIsToken
&& ((CsmToken)removed.element).getTokenType() == ((TokenTextElement)originalElement).getTokenKind()) { && (removed.getTokenType() == ((TokenTextElement)originalElement).getTokenKind())) {
nodeText.removeElement(originalIndex); nodeText.removeElement(originalIndex);
diffIndex++; diffIndex++;
} else if (originalElementIsToken && originalElement.isWhiteSpaceOrComment()) { } else if (originalElementIsToken && originalElement.isWhiteSpaceOrComment()) {
Expand All @@ -740,27 +779,13 @@ void apply(NodeText nodeText, Node node) {
throw new UnsupportedOperationException("removed " + removed.element + " vs " + originalElement); throw new UnsupportedOperationException("removed " + removed.element + " vs " + originalElement);
} }
} else if (diffElement instanceof Reshuffled) { } else if (diffElement instanceof Reshuffled) {

// First, let's see how many tokens we need to attribute to the previous version of the of the CsmMix // First, let's see how many tokens we need to attribute to the previous version of the of the CsmMix
Reshuffled reshuffled = (Reshuffled)diffElement; Reshuffled reshuffled = (Reshuffled)diffElement;
CsmMix elementsFromPreviousOrder = reshuffled.previousOrder; CsmMix elementsFromPreviousOrder = reshuffled.previousOrder;
CsmMix elementsFromNextOrder = reshuffled.element; CsmMix elementsFromNextOrder = reshuffled.element;


// This contains indexes from elementsFromNextOrder to indexes from elementsFromPreviousOrder // This contains indexes from elementsFromNextOrder to indexes from elementsFromPreviousOrder
Map<Integer, Integer> correspondanceBetweenNextOrderAndPreviousOrder = new HashMap<>(); Map<Integer, Integer> correspondanceBetweenNextOrderAndPreviousOrder = getCorrespondanceBetweenNextOrderAndPreviousOrder(elementsFromPreviousOrder, elementsFromNextOrder);

for (int ni=0;ni<elementsFromNextOrder.getElements().size();ni++) {
boolean found = false;
CsmElement ne = elementsFromNextOrder.getElements().get(ni);
for (int pi=0;pi<elementsFromPreviousOrder.getElements().size() && !found;pi++) {
CsmElement pe = elementsFromPreviousOrder.getElements().get(pi);
if (!correspondanceBetweenNextOrderAndPreviousOrder.values().contains(pi)
&& matching(ne, pe)) {
found = true;
correspondanceBetweenNextOrderAndPreviousOrder.put(ni, pi);
}
}
}


// We now find out which Node Text elements corresponds to the elements in the original CSM // We now find out which Node Text elements corresponds to the elements in the original CSM
List<Integer> nodeTextIndexOfPreviousElements = findIndexOfCorrespondingNodeTextElement(elementsFromPreviousOrder.getElements(), nodeText, originalIndex, node); List<Integer> nodeTextIndexOfPreviousElements = findIndexOfCorrespondingNodeTextElement(elementsFromPreviousOrder.getElements(), nodeText, originalIndex, node);
Expand All @@ -776,25 +801,27 @@ && matching(ne, pe)) {


// Elements to be added at the end // Elements to be added at the end
List<CsmElement> elementsToBeAddedAtTheEnd = new LinkedList<>(); List<CsmElement> elementsToBeAddedAtTheEnd = new LinkedList<>();
List<CsmElement> nextOrderElements = elementsFromNextOrder.getElements();

Map<Integer, List<CsmElement>> elementsToAddBeforeGivenOriginalCSMElement = new HashMap<>(); Map<Integer, List<CsmElement>> elementsToAddBeforeGivenOriginalCSMElement = new HashMap<>();
for (int ni=0;ni<elementsFromNextOrder.getElements().size();ni++) { for (int ni = 0; ni< nextOrderElements.size(); ni++) {
// If it has a mapping, then it is kept // If it has a mapping, then it is kept
if (!correspondanceBetweenNextOrderAndPreviousOrder.containsKey(ni)) { if (!correspondanceBetweenNextOrderAndPreviousOrder.containsKey(ni)) {
// Ok, it is something new. Where to put it? Let's see what is the first following // Ok, it is something new. Where to put it? Let's see what is the first following
// element that has a mapping // element that has a mapping
int originalCsmIndex = -1; int originalCsmIndex = -1;
for (int nj=ni + 1;nj<elementsFromNextOrder.getElements().size() && originalCsmIndex==-1;nj++) { for (int nj = ni + 1; nj< nextOrderElements.size() && originalCsmIndex==-1; nj++) {
if (correspondanceBetweenNextOrderAndPreviousOrder.containsKey(nj)) { if (correspondanceBetweenNextOrderAndPreviousOrder.containsKey(nj)) {
originalCsmIndex = correspondanceBetweenNextOrderAndPreviousOrder.get(nj); originalCsmIndex = correspondanceBetweenNextOrderAndPreviousOrder.get(nj);
if (!elementsToAddBeforeGivenOriginalCSMElement.containsKey(originalCsmIndex)){ if (!elementsToAddBeforeGivenOriginalCSMElement.containsKey(originalCsmIndex)){
elementsToAddBeforeGivenOriginalCSMElement.put(originalCsmIndex, new LinkedList<>()); elementsToAddBeforeGivenOriginalCSMElement.put(originalCsmIndex, new LinkedList<>());
} }
elementsToAddBeforeGivenOriginalCSMElement.get(originalCsmIndex).add(elementsFromNextOrder.getElements().get(ni)); elementsToAddBeforeGivenOriginalCSMElement.get(originalCsmIndex).add(nextOrderElements.get(ni));
} }
} }
// it does not preceed anything, so it goes at the end // it does not preceed anything, so it goes at the end
if (originalCsmIndex == -1) { if (originalCsmIndex == -1) {
elementsToBeAddedAtTheEnd.add(elementsFromNextOrder.getElements().get(ni)); elementsToBeAddedAtTheEnd.add(nextOrderElements.get(ni));
} }
} }
} }
Expand All @@ -807,7 +834,8 @@ && matching(ne, pe)) {
// * if OCE is marked to be present also in the "after" CSM we add a kept element, // * if OCE is marked to be present also in the "after" CSM we add a kept element,
// otherwise we add a removed element // otherwise we add a removed element


this.getElements().remove(diffIndex); diffElements.remove(diffIndex);

int diffElIterator = diffIndex; int diffElIterator = diffIndex;
if (lastNodeTextIndex != -1) { if (lastNodeTextIndex != -1) {
for (int ntIndex = originalIndex; ntIndex<=lastNodeTextIndex; ntIndex++) { for (int ntIndex = originalIndex; ntIndex<=lastNodeTextIndex; ntIndex++) {
Expand Down Expand Up @@ -845,6 +873,34 @@ && matching(ne, pe)) {
} while (diffIndex < diffElements.size() || originalIndex < originalElements.size()); } while (diffIndex < diffElements.size() || originalIndex < originalElements.size());
} }


private Map<Integer, Integer> getCorrespondanceBetweenNextOrderAndPreviousOrder(CsmMix elementsFromPreviousOrder, CsmMix elementsFromNextOrder) {
Map<Integer, Integer> correspondanceBetweenNextOrderAndPreviousOrder = new HashMap<>();

List<CsmElement> nextOrderElements = elementsFromNextOrder.getElements();
for (int ni = 0; ni< nextOrderElements.size(); ni++) {
boolean found = false;
CsmElement ne = nextOrderElements.get(ni);

List<CsmElement> previousOrderElements = elementsFromPreviousOrder.getElements();
for (int pi = 0; pi< previousOrderElements.size() && !found; pi++) {
CsmElement pe = previousOrderElements.get(pi);
if (!correspondanceBetweenNextOrderAndPreviousOrder.values().contains(pi)
&& matching(ne, pe)) {
found = true;
correspondanceBetweenNextOrderAndPreviousOrder.put(ni, pi);
}
}
}

return correspondanceBetweenNextOrderAndPreviousOrder;
}

private boolean isFollowedByUnindent(List<DifferenceElement> diffElements, int diffIndex) {
return (diffIndex + 1) < diffElements.size()
&& diffElements.get(diffIndex + 1).isAdded()
&& diffElements.get(diffIndex + 1).getElement() instanceof CsmUnindent;
}

private List<Integer> findIndexOfCorrespondingNodeTextElement(List<CsmElement> elements, NodeText nodeText, int startIndex, Node node) { private List<Integer> findIndexOfCorrespondingNodeTextElement(List<CsmElement> elements, NodeText nodeText, int startIndex, Node node) {
List<Integer> correspondingIndices = new ArrayList<>(); List<Integer> correspondingIndices = new ArrayList<>();
for (ListIterator<CsmElement> csmElementListIterator = elements.listIterator(); csmElementListIterator.hasNext(); ) { for (ListIterator<CsmElement> csmElementListIterator = elements.listIterator(); csmElementListIterator.hasNext(); ) {
Expand Down

0 comments on commit 7f177dc

Please sign in to comment.