diff --git a/javaparser-core-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/DifferenceElementCalculatorTest.java b/javaparser-core-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/DifferenceElementCalculatorTest.java index 06a099ad46..0dcf7bbb4e 100644 --- a/javaparser-core-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/DifferenceElementCalculatorTest.java +++ b/javaparser-core-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/DifferenceElementCalculatorTest.java @@ -18,6 +18,7 @@ import com.github.javaparser.printer.concretesyntaxmodel.CsmToken; import com.github.javaparser.printer.concretesyntaxmodel.CsmUnindent; import com.github.javaparser.printer.lexicalpreservation.LexicalDifferenceCalculator.CsmChild; +import com.github.javaparser.printer.lexicalpreservation.difference.DifferenceElement; import org.junit.Test; import java.io.IOException; @@ -28,7 +29,7 @@ import static com.github.javaparser.TokenTypes.eolTokenKind; import static com.github.javaparser.TokenTypes.spaceTokenKind; -import static com.github.javaparser.printer.lexicalpreservation.DifferenceElementCalculator.DifferenceElement.*; +import static com.github.javaparser.printer.lexicalpreservation.difference.DifferenceElement.*; import static org.junit.Assert.assertEquals; public class DifferenceElementCalculatorTest extends AbstractLexicalPreservingTest { @@ -37,7 +38,7 @@ public class DifferenceElementCalculatorTest extends AbstractLexicalPreservingTe public void calculateDifferenceEmpty() { LexicalDifferenceCalculator.CalculatedSyntaxModel a = new LexicalDifferenceCalculator.CalculatedSyntaxModel(Collections.emptyList()); LexicalDifferenceCalculator.CalculatedSyntaxModel b = new LexicalDifferenceCalculator.CalculatedSyntaxModel(Collections.emptyList()); - List differenceElements = DifferenceElementCalculator.calculate(a, b); + List differenceElements = DifferenceElementCalculator.calculate(a, b); assertEquals(0, differenceElements.size()); } @@ -52,7 +53,7 @@ public void calculateDifferenceAIsEmpty() { new CsmChild(n1), new CsmToken(GeneratedJavaParserConstants.RPAREN), new CsmChild(n2))); - List differenceElements = DifferenceElementCalculator.calculate(a, b); + List differenceElements = DifferenceElementCalculator.calculate(a, b); assertEquals(4, differenceElements.size()); assertEquals(added(new CsmToken(GeneratedJavaParserConstants.LPAREN)), differenceElements.get(0)); assertEquals(added(new CsmChild(n1)), differenceElements.get(1)); @@ -71,7 +72,7 @@ public void calculateDifferenceBIsEmpty() { new CsmToken(GeneratedJavaParserConstants.RPAREN), new CsmChild(n2))); LexicalDifferenceCalculator.CalculatedSyntaxModel b = new LexicalDifferenceCalculator.CalculatedSyntaxModel(Collections.emptyList()); - List differenceElements = DifferenceElementCalculator.calculate(a, b); + List differenceElements = DifferenceElementCalculator.calculate(a, b); assertEquals(4, differenceElements.size()); assertEquals(removed(new CsmToken(GeneratedJavaParserConstants.LPAREN)), differenceElements.get(0)); assertEquals(removed(new CsmChild(n1)), differenceElements.get(1)); @@ -86,7 +87,7 @@ public void compilationUnitExampleWithPackageSetDiff() { PackageDeclaration packageDeclaration = new PackageDeclaration(new Name(new Name("foo"), "bar")); LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, cu); LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, cu, ObservableProperty.PACKAGE_DECLARATION, null, packageDeclaration); - List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); + List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); assertEquals(3, differenceElements.size()); assertEquals(added(new CsmChild(packageDeclaration)), differenceElements.get(0)); assertEquals(kept(new CsmChild(cu.getType(0))), differenceElements.get(1)); @@ -100,7 +101,7 @@ public void annotationDeclarationExampleWithModifierAdded() throws IOException { CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.MODIFIERS, EnumSet.noneOf(Modifier.class), EnumSet.of(Modifier.PUBLIC)); - List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); + List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); DifferenceElementCalculator.removeIndentationElements(differenceElements); int i = 0; assertEquals(added(new CsmToken(GeneratedJavaParserConstants.PUBLIC)), differenceElements.get(i++)); @@ -137,7 +138,7 @@ public void annotationDeclarationExampleWithNameChanged() throws IOException { SimpleName newName = new SimpleName("NewName"); LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.NAME, annotationDeclaration.getName(), newName); - List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); + List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); DifferenceElementCalculator.removeIndentationElements(differenceElements); int i = 0; assertEquals(kept(new CsmToken(GeneratedJavaParserConstants.AT)), differenceElements.get(i++)); @@ -172,7 +173,7 @@ public void annotationDeclarationExampleWithJavadocAdded() throws IOException { JavadocComment comment = new JavadocComment("Cool this annotation!"); LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.COMMENT, null, comment); - List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); + List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); DifferenceElementCalculator.removeIndentationElements(differenceElements); int i = 0; assertEquals(kept(new CsmToken(GeneratedJavaParserConstants.PUBLIC)), differenceElements.get(i++)); @@ -207,7 +208,7 @@ public void annotationDeclarationExampleWithJavadocRemoved() throws IOException CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.COMMENT, annotationDeclaration.getComment().get(), null); - List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); + List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); DifferenceElementCalculator.removeIndentationElements(differenceElements); int i = 0; assertEquals(kept(new CsmToken(GeneratedJavaParserConstants.PUBLIC)), differenceElements.get(i++)); @@ -242,7 +243,7 @@ public void annotationDeclarationExampleWithModifierRemoved() throws IOException CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.MODIFIERS, EnumSet.of(Modifier.PUBLIC), EnumSet.noneOf(Modifier.class)); - List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); + List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); DifferenceElementCalculator.removeIndentationElements(differenceElements); int i = 0; assertEquals(removed(new CsmToken(GeneratedJavaParserConstants.PUBLIC)), differenceElements.get(i++)); @@ -275,7 +276,7 @@ public void removeDefaultValueInAnnotationMemberDeclaration() { AnnotationMemberDeclaration md = considerAmd("int foo() default 10;"); LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(md); LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(md, ObservableProperty.DEFAULT_VALUE, md.getDefaultValue(), null); - List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); + List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); int i = 0; assertEquals(kept(new CsmChild(md.getType())), differenceElements.get(i++)); assertEquals(kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); @@ -296,7 +297,7 @@ public void addedDefaultValueInAnnotationMemberDeclaration() { LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(md); Expression defaultValue = new IntegerLiteralExpr(("10")); LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(md, ObservableProperty.DEFAULT_VALUE, null, defaultValue); - List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); + List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); int i = 0; assertEquals(kept(new CsmChild(md.getType())), differenceElements.get(i++)); assertEquals(kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); @@ -317,7 +318,7 @@ public void addedModifierToConstructorDeclaration() { LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(cd); LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(cd, ObservableProperty.MODIFIERS, EnumSet.noneOf(Modifier.class), EnumSet.of(Modifier.PUBLIC)); - List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); + List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); int i = 0; assertEquals(added(new CsmToken(GeneratedJavaParserConstants.PUBLIC)), differenceElements.get(i++)); assertEquals(added(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); @@ -336,10 +337,10 @@ public void replacingNameForEnumConstantDeclaration() throws IOException { LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(ecd); LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(ecd, ObservableProperty.NAME, ecd.getName(), newName); - List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); + List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); int i = 0; - assertEquals(DifferenceElementCalculator.DifferenceElement.removed(new CsmChild(ecd.getName())), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.added(new CsmChild(newName)), differenceElements.get(i++)); + assertEquals(DifferenceElement.removed(new CsmChild(ecd.getName())), differenceElements.get(i++)); + assertEquals(DifferenceElement.added(new CsmChild(newName)), differenceElements.get(i++)); assertEquals(i, differenceElements.size()); } @@ -354,15 +355,15 @@ public void addingStatementToEmptyMethodBody() { MethodDeclaration m = cu.getClassByName("A").get().getMethodsByName("foo").get(0); LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(m.getBody().get()); LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterListAddition(m.getBody().get(), ObservableProperty.STATEMENTS, 0, s); - List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); + List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); int i = 0; - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.LBRACE)), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(eolTokenKind())), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.added(new CsmIndent()), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.added(new CsmChild(s)), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.added(new CsmToken(eolTokenKind())), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.added(new CsmUnindent()), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.RBRACE)), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.LBRACE)), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(eolTokenKind())), differenceElements.get(i++)); + assertEquals(DifferenceElement.added(new CsmIndent()), differenceElements.get(i++)); + assertEquals(DifferenceElement.added(new CsmChild(s)), differenceElements.get(i++)); + assertEquals(DifferenceElement.added(new CsmToken(eolTokenKind())), differenceElements.get(i++)); + assertEquals(DifferenceElement.added(new CsmUnindent()), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.RBRACE)), differenceElements.get(i++)); assertEquals(i, differenceElements.size()); } @@ -371,18 +372,18 @@ public void methodDeclarationRemovingParameter() { MethodDeclaration md = considerMd("public void foo(float f){}"); LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(md); LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterListRemoval(md, ObservableProperty.PARAMETERS, 0); - List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); + List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); int i = 0; - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.PUBLIC)), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmChild(md.getType())), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmChild(md.getName())), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.LPAREN)), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.removed(new CsmChild(md.getParameter(0))), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.RPAREN)), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmChild(md.getBody().get())), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.PUBLIC)), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmChild(md.getType())), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmChild(md.getName())), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.LPAREN)), differenceElements.get(i++)); + assertEquals(DifferenceElement.removed(new CsmChild(md.getParameter(0))), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.RPAREN)), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmChild(md.getBody().get())), differenceElements.get(i++)); assertEquals(i, differenceElements.size()); } @@ -392,18 +393,18 @@ public void methodDeclarationAddingParameter() { Parameter newParameter = new Parameter(new ArrayType(PrimitiveType.intType()), new SimpleName("foo")); LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(md); LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterListAddition(md, ObservableProperty.PARAMETERS, 0, newParameter); - List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); + List differenceElements = DifferenceElementCalculator.calculate(csmOriginal, csmChanged); int i = 0; - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.PUBLIC)), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmChild(md.getType())), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmChild(md.getName())), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.LPAREN)), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.added(new CsmChild(newParameter)), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.RPAREN)), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(new CsmChild(md.getBody().get())), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.PUBLIC)), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmChild(md.getType())), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmChild(md.getName())), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.LPAREN)), differenceElements.get(i++)); + assertEquals(DifferenceElement.added(new CsmChild(newParameter)), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(GeneratedJavaParserConstants.RPAREN)), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmToken(spaceTokenKind())), differenceElements.get(i++)); + assertEquals(DifferenceElement.kept(new CsmChild(md.getBody().get())), differenceElements.get(i++)); assertEquals(i, differenceElements.size()); } diff --git a/javaparser-core-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-core-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index 69b53b25e4..896c404520 100644 --- a/javaparser-core-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-core-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -17,6 +17,7 @@ import com.github.javaparser.printer.ConcreteSyntaxModel; import com.github.javaparser.printer.concretesyntaxmodel.CsmElement; import com.github.javaparser.printer.concretesyntaxmodel.CsmToken; +import com.github.javaparser.printer.lexicalpreservation.difference.DifferenceElement; import org.junit.Test; import java.io.IOException; @@ -270,23 +271,23 @@ public void differenceAfterddingStatementToEmptyBlock() throws IOException { new NameExpr("aField"), AssignExpr.Operator.ASSIGN )); - List differenceElements = ldc.calculateListAdditionDifference( + List differenceElements = ldc.calculateListAdditionDifference( ObservableProperty.STATEMENTS, setter.getBody().get().getStatements(), 0, assignStatement); int index = 0; - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(CsmElement.token(GeneratedJavaParserConstants.LBRACE)), differenceElements.get(index++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(CsmElement.newline()), differenceElements.get(index++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.added(CsmElement.indent()), differenceElements.get(index++)); + assertEquals(DifferenceElement.kept(CsmElement.token(GeneratedJavaParserConstants.LBRACE)), differenceElements.get(index++)); + assertEquals(DifferenceElement.kept(CsmElement.newline()), differenceElements.get(index++)); + assertEquals(DifferenceElement.added(CsmElement.indent()), differenceElements.get(index++)); assertTrue(isAddedChild(differenceElements.get(index++), ExpressionStmt.class)); - assertEquals(DifferenceElementCalculator.DifferenceElement.added(CsmElement.newline()), differenceElements.get(index++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.added(CsmElement.unindent()), differenceElements.get(index++)); - assertEquals(DifferenceElementCalculator.DifferenceElement.kept(CsmElement.token(GeneratedJavaParserConstants.RBRACE)), differenceElements.get(index++)); + assertEquals(DifferenceElement.added(CsmElement.newline()), differenceElements.get(index++)); + assertEquals(DifferenceElement.added(CsmElement.unindent()), differenceElements.get(index++)); + assertEquals(DifferenceElement.kept(CsmElement.token(GeneratedJavaParserConstants.RBRACE)), differenceElements.get(index++)); assertEquals(index, differenceElements.size()); } - private boolean isAddedChild(DifferenceElementCalculator.DifferenceElement element, Class childClass) { + private boolean isAddedChild(DifferenceElement element, Class childClass) { return element.isAdded() && isChild(element.getElement(), childClass); } diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/ChildTextElement.java b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/ChildTextElement.java index ad890c4894..15da7fd394 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/ChildTextElement.java +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/ChildTextElement.java @@ -27,10 +27,10 @@ /** * Represent the position of a child node in the NodeText of its parent. */ -class ChildTextElement extends TextElement { +public class ChildTextElement extends TextElement { private final Node child; - ChildTextElement(Node child) { + public ChildTextElement(Node child) { this.child = child; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Difference.java b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Difference.java index 09216a2097..3e2f3e57c5 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Difference.java +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Difference.java @@ -6,6 +6,7 @@ import com.github.javaparser.ast.comments.Comment; import com.github.javaparser.printer.concretesyntaxmodel.*; import com.github.javaparser.printer.lexicalpreservation.LexicalDifferenceCalculator.CsmChild; +import com.github.javaparser.printer.lexicalpreservation.difference.*; import java.util.*; @@ -21,7 +22,7 @@ public class Difference { private static final int STANDARD_INDENTATION_SIZE = 4; - private final List diffElements; + private final List diffElements; private final NodeText nodeText; private final Node node; @@ -30,7 +31,7 @@ public class Difference { private int originalIndex = 0; private int diffIndex = 0; - Difference(List diffElements, NodeText nodeText, Node node) { + Difference(List diffElements, NodeText nodeText, Node node) { if (nodeText == null) { throw new NullPointerException("nodeText can not be null"); } @@ -123,9 +124,9 @@ void apply() { do { if (diffIndex < diffElements.size() && originalIndex >= originalElements.size()) { - DifferenceElementCalculator.DifferenceElement diffElement = diffElements.get(diffIndex); - if (diffElement instanceof DifferenceElementCalculator.Kept) { - DifferenceElementCalculator.Kept kept = (DifferenceElementCalculator.Kept) diffElement; + DifferenceElement diffElement = diffElements.get(diffIndex); + if (diffElement instanceof Kept) { + Kept kept = (Kept) diffElement; if (kept.isWhiteSpaceOrComment()) { diffIndex++; @@ -133,8 +134,8 @@ void apply() { throw new IllegalStateException("Cannot keep element because we reached the end of nodetext: " + nodeText + ". Difference: " + this); } - } else if (diffElement instanceof DifferenceElementCalculator.Added) { - DifferenceElementCalculator.Added addedElement = (DifferenceElementCalculator.Added) diffElement; + } else if (diffElement instanceof Added) { + Added addedElement = (Added) diffElement; nodeText.addElement(originalIndex, addedElement.toTextElement()); originalIndex++; @@ -152,10 +153,10 @@ void apply() { + this + " " + originalElement); } } else { - DifferenceElementCalculator.DifferenceElement diffElement = diffElements.get(diffIndex); + DifferenceElement diffElement = diffElements.get(diffIndex); - if (diffElement instanceof DifferenceElementCalculator.Added) { - DifferenceElementCalculator.Added addedElement = (DifferenceElementCalculator.Added) diffElement; + if (diffElement instanceof Added) { + Added addedElement = (Added) diffElement; if (addedElement.isIndent()) { for (int i=0;i= diffElements.size() || !(diffElements.get(diffIndex + 1) instanceof DifferenceElementCalculator.Added)) { + if (diffIndex + 1 >= diffElements.size() || !(diffElements.get(diffIndex + 1) instanceof Added)) { originalIndex = considerEnforcingIndentation(nodeText, originalIndex); } // If in front we have one space and before also we had space let's drop one space @@ -292,7 +293,7 @@ void apply() { if (originalElements.get(originalIndex).isWhiteSpace() && originalElements.get(originalIndex - 1).isWhiteSpace()) { // However we do not want to do that when we are about to adding or removing elements - if ((diffIndex + 1) == diffElements.size() || (diffElements.get(diffIndex + 1) instanceof DifferenceElementCalculator.Kept)) { + if ((diffIndex + 1) == diffElements.size() || (diffElements.get(diffIndex + 1) instanceof Kept)) { originalElements.remove(originalIndex--); } } @@ -311,20 +312,20 @@ void apply() { nodeText.removeElement(originalIndex); diffIndex++; } else { - throw new UnsupportedOperationException("removed " + removed.element + " vs " + originalElement); + throw new UnsupportedOperationException("removed " + removed.getElement() + " vs " + originalElement); } } else if (removed.isWhiteSpace()) { diffIndex++; } else if (originalElement.isWhiteSpace()) { originalIndex++; } else { - throw new UnsupportedOperationException("removed " + removed.element + " vs " + originalElement); + throw new UnsupportedOperationException("removed " + removed.getElement() + " vs " + originalElement); } - } else if (diffElement instanceof DifferenceElementCalculator.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 - DifferenceElementCalculator.Reshuffled reshuffled = (DifferenceElementCalculator.Reshuffled)diffElement; - CsmMix elementsFromPreviousOrder = reshuffled.previousOrder; - CsmMix elementsFromNextOrder = reshuffled.element; + Reshuffled reshuffled = (Reshuffled)diffElement; + CsmMix elementsFromPreviousOrder = reshuffled.getPreviousOrder(); + CsmMix elementsFromNextOrder = reshuffled.getNextOrder(); // This contains indexes from elementsFromNextOrder to indexes from elementsFromPreviousOrder Map correspondanceBetweenNextOrderAndPreviousOrder = getCorrespondanceBetweenNextOrderAndPreviousOrder(elementsFromPreviousOrder, elementsFromNextOrder); @@ -386,16 +387,16 @@ void apply() { int indexOfOriginalCSMElement = nodeTextIndexToPreviousCSMIndex.get(ntIndex); if (elementsToAddBeforeGivenOriginalCSMElement.containsKey(indexOfOriginalCSMElement)) { for (CsmElement elementToAdd : elementsToAddBeforeGivenOriginalCSMElement.get(indexOfOriginalCSMElement)) { - diffElements.add(diffElIterator++, new DifferenceElementCalculator.Added(elementToAdd)); + diffElements.add(diffElIterator++, new Added(elementToAdd)); } } CsmElement originalCSMElement = elementsFromPreviousOrder.getElements().get(indexOfOriginalCSMElement); boolean toBeKept = correspondanceBetweenNextOrderAndPreviousOrder.containsValue(indexOfOriginalCSMElement); if (toBeKept) { - diffElements.add(diffElIterator++, new DifferenceElementCalculator.Kept(originalCSMElement)); + diffElements.add(diffElIterator++, new Kept(originalCSMElement)); } else { - diffElements.add(diffElIterator++, new DifferenceElementCalculator.Removed(originalCSMElement)); + diffElements.add(diffElIterator++, new Removed(originalCSMElement)); } } // else we have a simple node text element, without associated csm element, just keep ignore it @@ -405,7 +406,7 @@ void apply() { // Finally we look for the remaining new elements that were not yet added and // add all of them for (CsmElement elementToAdd : elementsToBeAddedAtTheEnd) { - diffElements.add(diffElIterator++, new DifferenceElementCalculator.Added(elementToAdd)); + diffElements.add(diffElIterator++, new Added(elementToAdd)); } } else { throw new UnsupportedOperationException("" + diffElement + " vs " + originalElement); @@ -437,7 +438,7 @@ private Map getCorrespondanceBetweenNextOrderAndPreviousOrder( return correspondanceBetweenNextOrderAndPreviousOrder; } - private boolean isFollowedByUnindent(List diffElements, int diffIndex) { + private boolean isFollowedByUnindent(List diffElements, int diffIndex) { return (diffIndex + 1) < diffElements.size() && diffElements.get(diffIndex + 1).isAdded() && diffElements.get(diffIndex + 1).getElement() instanceof CsmUnindent; @@ -551,7 +552,7 @@ private int adjustIndentation(List indentation, NodeText nodeT } private boolean isAReplacement(int diffIndex) { - return (diffIndex > 0) && diffElements.get(diffIndex) instanceof DifferenceElementCalculator.Added && diffElements.get(diffIndex - 1) instanceof DifferenceElementCalculator.Removed; + return (diffIndex > 0) && diffElements.get(diffIndex) instanceof Added && diffElements.get(diffIndex - 1) instanceof Removed; } private boolean isPrimitiveType(TextElement textElement) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/DifferenceElementCalculator.java b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/DifferenceElementCalculator.java index 3faaf8042e..9d3be44c50 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/DifferenceElementCalculator.java +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/DifferenceElementCalculator.java @@ -1,9 +1,8 @@ package com.github.javaparser.printer.lexicalpreservation; -import com.github.javaparser.TokenTypes; import com.github.javaparser.ast.Node; -import com.github.javaparser.ast.type.PrimitiveType; import com.github.javaparser.printer.concretesyntaxmodel.*; +import com.github.javaparser.printer.lexicalpreservation.difference.*; import java.util.*; @@ -192,288 +191,8 @@ private static List calculateImpl(LexicalDifferenceCalculator return elements; } - interface DifferenceElement { - static DifferenceElement added(CsmElement element) { - return new Added(element); - } - - static DifferenceElement removed(CsmElement element) { - return new Removed(element); - } - - static DifferenceElement kept(CsmElement element) { - return new Kept(element); - } - - /** - * Return the CsmElement considered in this DifferenceElement. - */ - CsmElement getElement(); - - boolean isAdded(); - } - - static class Added implements DifferenceElement { - final CsmElement element; - - Added(CsmElement element) { - this.element = element; - } - - @Override - public String toString() { - return "Added{" + element + '}'; - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - - Added added = (Added) o; - - return element.equals(added.element); - } - - @Override - public int hashCode() { - return element.hashCode(); - } - - @Override - public CsmElement getElement() { - return element; - } - - @Override - public boolean isAdded() { - return true; - } - - boolean isIndent() { return element instanceof CsmIndent; } - - boolean isUnindent() { return element instanceof CsmUnindent; } - - TextElement toTextElement() { - if (element instanceof LexicalDifferenceCalculator.CsmChild) { - return new ChildTextElement(((LexicalDifferenceCalculator.CsmChild) element).getChild()); - } else if (element instanceof CsmToken) { - return new TokenTextElement(((CsmToken) element).getTokenType(), ((CsmToken) element).getContent(null)); - } else { - throw new UnsupportedOperationException(element.getClass().getSimpleName()); - } - } - } - - /** - * Elements in a CsmMix have been reshuffled. It could also mean that - * some new elements have been added or removed to the mix. - */ - static class Reshuffled implements DifferenceElement { - final CsmMix previousOrder; - final CsmMix element; - - Reshuffled(CsmMix previousOrder, CsmMix element) { - this.previousOrder = previousOrder; - this.element = element; - } - - @Override - public String toString() { - return "Reshuffled{" + element + ", previous="+ previousOrder+ '}'; - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - - Reshuffled that = (Reshuffled) o; - - if (!previousOrder.equals(that.previousOrder)) return false; - return element.equals(that.element); - } - - @Override - public int hashCode() { - int result = previousOrder.hashCode(); - result = 31 * result + element.hashCode(); - return result; - } - - @Override - public CsmMix getElement() { - return element; - } - - @Override - public boolean isAdded() { - return false; - } - } - - static class Kept implements DifferenceElement { - final CsmElement element; - - Kept(CsmElement element) { - this.element = element; - } - - @Override - public String toString() { - return "Kept{" + element + '}'; - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - - Kept kept = (Kept) o; - - return element.equals(kept.element); - } - - @Override - public int hashCode() { - return element.hashCode(); - } - - @Override - public CsmElement getElement() { - return element; - } - - int getTokenType() { - if (isToken()) { - CsmToken csmToken = (CsmToken) element; - return csmToken.getTokenType(); - } - - throw new IllegalStateException("Kept is not a " + CsmToken.class.getSimpleName()); - } - - @Override - public boolean isAdded() { - return false; - } - - boolean isIndent() { return element instanceof CsmIndent; } - - boolean isUnindent() { return element instanceof CsmUnindent; } - - boolean isToken() { return element instanceof CsmToken; } - - boolean isChild() { return element instanceof LexicalDifferenceCalculator.CsmChild; } - - boolean isPrimitiveType() { - if (isChild()) { - LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) element; - return csmChild.getChild() instanceof PrimitiveType; - } - - return false; - } - - boolean isWhiteSpace() { - if(isToken()) { - CsmToken csmToken = (CsmToken) element; - return csmToken.isWhiteSpace(); - } - - return false; - } - - boolean isWhiteSpaceOrComment() { - if (isToken()) { - CsmToken csmToken = (CsmToken) element; - return TokenTypes.isWhitespaceOrComment(csmToken.getTokenType()); - } - - return false; - } - } - - static class Removed implements DifferenceElement { - final CsmElement element; - - Removed(CsmElement element) { - this.element = element; - } - - @Override - public String toString() { - return "Removed{" + element + '}'; - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - - Removed removed = (Removed) o; - - return element.equals(removed.element); - } - - @Override - public int hashCode() { - return element.hashCode(); - } - - @Override - public CsmElement getElement() { - return element; - } - - Node getChild() { - if (isChild()) { - LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) element; - return csmChild.getChild(); - } - - throw new IllegalStateException("Removed is not a " + LexicalDifferenceCalculator.CsmChild.class.getSimpleName()); - } - - int getTokenType() { - if (isToken()) { - CsmToken csmToken = (CsmToken) element; - return csmToken.getTokenType(); - } - - throw new IllegalStateException("Removed is not a " + CsmToken.class.getSimpleName()); - } - - @Override - public boolean isAdded() { - return false; - } - - boolean isToken() { return element instanceof CsmToken; } - - boolean isChild() { return element instanceof LexicalDifferenceCalculator.CsmChild; } - - boolean isPrimitiveType() { - if (isChild()) { - LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) element; - return csmChild.getChild() instanceof PrimitiveType; - } - - return false; - } - - boolean isWhiteSpace() { - if(isToken()) { - CsmToken csmToken = (CsmToken) element; - return csmToken.isWhiteSpace(); - } - - return false; - } - } - static long cost(List elements) { - return elements.stream().filter(e -> !(e instanceof DifferenceElementCalculator.Kept)).count(); + return elements.stream().filter(e -> !(e instanceof Kept)).count(); } diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculator.java b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculator.java index b6f827eb24..ae032f7445 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculator.java +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculator.java @@ -11,10 +11,11 @@ import com.github.javaparser.printer.SourcePrinter; import com.github.javaparser.printer.concretesyntaxmodel.*; import com.github.javaparser.printer.lexicalpreservation.changes.*; +import com.github.javaparser.printer.lexicalpreservation.difference.DifferenceElement; import java.util.*; -class LexicalDifferenceCalculator { +public class LexicalDifferenceCalculator { /** * The ConcreteSyntaxModel represents the general format. This model is a calculated version of the ConcreteSyntaxModel, @@ -49,7 +50,7 @@ void removeIndentationElements() { } } - static class CsmChild implements CsmElement { + public static class CsmChild implements CsmElement { private final Node child; public Node getChild() { @@ -86,7 +87,7 @@ public int hashCode() { } } - List calculateListRemovalDifference(ObservableProperty observableProperty, NodeList nodeList, int index) { + List calculateListRemovalDifference(ObservableProperty observableProperty, NodeList nodeList, int index) { Node container = nodeList.getParentNodeForChildren(); CsmElement element = ConcreteSyntaxModel.forClass(container.getClass()); CalculatedSyntaxModel original = calculatedSyntaxModelForNode(element, container); @@ -94,7 +95,7 @@ List calculateListRemovalDifferen return DifferenceElementCalculator.calculate(original, after); } - List calculateListAdditionDifference(ObservableProperty observableProperty, NodeList nodeList, int index, Node nodeAdded) { + List calculateListAdditionDifference(ObservableProperty observableProperty, NodeList nodeList, int index, Node nodeAdded) { Node container = nodeList.getParentNodeForChildren(); CsmElement element = ConcreteSyntaxModel.forClass(container.getClass()); CalculatedSyntaxModel original = calculatedSyntaxModelForNode(element, container); @@ -102,7 +103,7 @@ List calculateListAdditionDiffere return DifferenceElementCalculator.calculate(original, after); } - List calculateListReplacementDifference(ObservableProperty observableProperty, NodeList nodeList, int index, Node newValue) { + List calculateListReplacementDifference(ObservableProperty observableProperty, NodeList nodeList, int index, Node newValue) { Node container = nodeList.getParentNodeForChildren(); CsmElement element = ConcreteSyntaxModel.forClass(container.getClass()); CalculatedSyntaxModel original = calculatedSyntaxModelForNode(element, container); @@ -117,7 +118,7 @@ public void calculatePropertyChange(NodeText nodeText, Node observedNode, Observ CsmElement element = ConcreteSyntaxModel.forClass(observedNode.getClass()); CalculatedSyntaxModel original = calculatedSyntaxModelForNode(element, observedNode); CalculatedSyntaxModel after = calculatedSyntaxModelAfterPropertyChange(element, observedNode, property, oldValue, newValue); - List differenceElements = DifferenceElementCalculator.calculate(original, after); + List differenceElements = DifferenceElementCalculator.calculate(original, after); Difference difference = new Difference(differenceElements, nodeText, observedNode); difference.apply(); } diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/LexicalPreservingPrinter.java b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/LexicalPreservingPrinter.java index 121a652f16..067d6ba910 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/LexicalPreservingPrinter.java +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/LexicalPreservingPrinter.java @@ -38,6 +38,7 @@ import com.github.javaparser.printer.concretesyntaxmodel.CsmElement; import com.github.javaparser.printer.concretesyntaxmodel.CsmMix; import com.github.javaparser.printer.concretesyntaxmodel.CsmToken; +import com.github.javaparser.printer.lexicalpreservation.difference.DifferenceElement; import com.github.javaparser.utils.Pair; import com.github.javaparser.utils.Utils; @@ -197,7 +198,7 @@ public void concretePropertyChange(Node observedNode, ObservableProperty propert @Override public void concreteListChange(NodeList changedList, AstObserver.ListChangeType type, int index, Node nodeAddedOrRemoved) { NodeText nodeText = getOrCreateNodeText(changedList.getParentNodeForChildren()); - List differenceElements; + List differenceElements; if (type == AstObserver.ListChangeType.REMOVAL) { differenceElements = LEXICAL_DIFFERENCE_CALCULATOR.calculateListRemovalDifference(findNodeListName(changedList), changedList, index); } else if (type == AstObserver.ListChangeType.ADDITION) { @@ -213,7 +214,7 @@ public void concreteListChange(NodeList changedList, AstObserver.ListChangeType @Override public void concreteListReplacement(NodeList changedList, int index, Node oldValue, Node newValue) { NodeText nodeText = getOrCreateNodeText(changedList.getParentNodeForChildren()); - List differenceElements = LEXICAL_DIFFERENCE_CALCULATOR.calculateListReplacementDifference(findNodeListName(changedList), changedList, index, newValue); + List differenceElements = LEXICAL_DIFFERENCE_CALCULATOR.calculateListReplacementDifference(findNodeListName(changedList), changedList, index, newValue); Difference difference = new Difference(differenceElements, nodeText, changedList.getParentNodeForChildren()); difference.apply(); diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/TokenTextElement.java b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/TokenTextElement.java index e57b214abf..7f5b3a5cbd 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/TokenTextElement.java +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/TokenTextElement.java @@ -25,14 +25,14 @@ import com.github.javaparser.TokenTypes; import com.github.javaparser.ast.Node; -class TokenTextElement extends TextElement { +public class TokenTextElement extends TextElement { private final JavaToken token; TokenTextElement(JavaToken token) { this.token = token; } - TokenTextElement(int tokenKind, String text) { + public TokenTextElement(int tokenKind, String text) { this(new JavaToken(tokenKind, text)); } diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/Added.java b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/Added.java new file mode 100644 index 0000000000..44136db22a --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/Added.java @@ -0,0 +1,62 @@ +package com.github.javaparser.printer.lexicalpreservation.difference; + +import com.github.javaparser.printer.concretesyntaxmodel.CsmElement; +import com.github.javaparser.printer.concretesyntaxmodel.CsmIndent; +import com.github.javaparser.printer.concretesyntaxmodel.CsmToken; +import com.github.javaparser.printer.concretesyntaxmodel.CsmUnindent; +import com.github.javaparser.printer.lexicalpreservation.ChildTextElement; +import com.github.javaparser.printer.lexicalpreservation.LexicalDifferenceCalculator; +import com.github.javaparser.printer.lexicalpreservation.TextElement; +import com.github.javaparser.printer.lexicalpreservation.TokenTextElement; + +public class Added implements DifferenceElement { + final CsmElement element; + + public Added(CsmElement element) { + this.element = element; + } + + @Override + public String toString() { + return "Added{" + element + '}'; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Added added = (Added) o; + + return element.equals(added.element); + } + + @Override + public int hashCode() { + return element.hashCode(); + } + + @Override + public CsmElement getElement() { + return element; + } + + @Override + public boolean isAdded() { + return true; + } + + public boolean isIndent() { return element instanceof CsmIndent; } + + public boolean isUnindent() { return element instanceof CsmUnindent; } + + public TextElement toTextElement() { + if (element instanceof LexicalDifferenceCalculator.CsmChild) { + return new ChildTextElement(((LexicalDifferenceCalculator.CsmChild) element).getChild()); + } else if (element instanceof CsmToken) { + return new TokenTextElement(((CsmToken) element).getTokenType(), ((CsmToken) element).getContent(null)); + } else { + throw new UnsupportedOperationException(element.getClass().getSimpleName()); + } + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/DifferenceElement.java b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/DifferenceElement.java new file mode 100644 index 0000000000..bfce79a2a8 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/DifferenceElement.java @@ -0,0 +1,25 @@ +package com.github.javaparser.printer.lexicalpreservation.difference; + +import com.github.javaparser.printer.concretesyntaxmodel.CsmElement; +import com.github.javaparser.printer.lexicalpreservation.DifferenceElementCalculator; + +public interface DifferenceElement { + static DifferenceElement added(CsmElement element) { + return new Added(element); + } + + static DifferenceElement removed(CsmElement element) { + return new Removed(element); + } + + static DifferenceElement kept(CsmElement element) { + return new Kept(element); + } + + /** + * Return the CsmElement considered in this DifferenceElement. + */ + public CsmElement getElement(); + + public boolean isAdded(); +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/Kept.java b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/Kept.java new file mode 100644 index 0000000000..413f28e124 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/Kept.java @@ -0,0 +1,92 @@ +package com.github.javaparser.printer.lexicalpreservation.difference; + +import com.github.javaparser.TokenTypes; +import com.github.javaparser.ast.type.PrimitiveType; +import com.github.javaparser.printer.concretesyntaxmodel.CsmElement; +import com.github.javaparser.printer.concretesyntaxmodel.CsmIndent; +import com.github.javaparser.printer.concretesyntaxmodel.CsmToken; +import com.github.javaparser.printer.concretesyntaxmodel.CsmUnindent; +import com.github.javaparser.printer.lexicalpreservation.DifferenceElementCalculator; +import com.github.javaparser.printer.lexicalpreservation.LexicalDifferenceCalculator; + +public class Kept implements DifferenceElement { + private final CsmElement element; + + public Kept(CsmElement element) { + this.element = element; + } + + @Override + public String toString() { + return "Kept{" + element + '}'; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Kept kept = (Kept) o; + + return element.equals(kept.element); + } + + @Override + public int hashCode() { + return element.hashCode(); + } + + @Override + public CsmElement getElement() { + 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 + public boolean isAdded() { + return false; + } + + public boolean isIndent() { return element instanceof CsmIndent; } + + public boolean isUnindent() { return element instanceof CsmUnindent; } + + public boolean isToken() { return element instanceof CsmToken; } + + public boolean isChild() { return element instanceof LexicalDifferenceCalculator.CsmChild; } + + public boolean isPrimitiveType() { + if (isChild()) { + LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) element; + return csmChild.getChild() instanceof PrimitiveType; + } + + return false; + } + + public boolean isWhiteSpace() { + if(isToken()) { + CsmToken csmToken = (CsmToken) element; + return csmToken.isWhiteSpace(); + } + + return false; + } + + public boolean isWhiteSpaceOrComment() { + if (isToken()) { + CsmToken csmToken = (CsmToken) element; + return TokenTypes.isWhitespaceOrComment(csmToken.getTokenType()); + } + + return false; + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/Removed.java b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/Removed.java new file mode 100644 index 0000000000..737d07c0b6 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/Removed.java @@ -0,0 +1,85 @@ +package com.github.javaparser.printer.lexicalpreservation.difference; + +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.type.PrimitiveType; +import com.github.javaparser.printer.concretesyntaxmodel.CsmElement; +import com.github.javaparser.printer.concretesyntaxmodel.CsmToken; +import com.github.javaparser.printer.lexicalpreservation.LexicalDifferenceCalculator; + +public class Removed implements DifferenceElement { + final CsmElement element; + + public Removed(CsmElement element) { + this.element = element; + } + + @Override + public String toString() { + return "Removed{" + element + '}'; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Removed removed = (Removed) o; + + return element.equals(removed.element); + } + + @Override + public int hashCode() { + return element.hashCode(); + } + + @Override + public CsmElement getElement() { + return element; + } + + public Node getChild() { + if (isChild()) { + LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) element; + return csmChild.getChild(); + } + + throw new IllegalStateException("Removed is not a " + LexicalDifferenceCalculator.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 + public boolean isAdded() { + return false; + } + + public boolean isToken() { return element instanceof CsmToken; } + + public boolean isChild() { return element instanceof LexicalDifferenceCalculator.CsmChild; } + + public boolean isPrimitiveType() { + if (isChild()) { + LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) element; + return csmChild.getChild() instanceof PrimitiveType; + } + + return false; + } + + public boolean isWhiteSpace() { + if(isToken()) { + CsmToken csmToken = (CsmToken) element; + return csmToken.isWhiteSpace(); + } + + return false; + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/Reshuffled.java b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/Reshuffled.java new file mode 100644 index 0000000000..65de12f091 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/difference/Reshuffled.java @@ -0,0 +1,58 @@ +package com.github.javaparser.printer.lexicalpreservation.difference; + +import com.github.javaparser.printer.concretesyntaxmodel.CsmMix; + +/** + * Elements in a CsmMix have been reshuffled. It could also mean that + * some new elements have been added or removed to the mix. + */ +public class Reshuffled implements DifferenceElement { + private final CsmMix previousOrder; + private final CsmMix nextOrder; + + public Reshuffled(CsmMix previousOrder, CsmMix nextOrder) { + this.previousOrder = previousOrder; + this.nextOrder = nextOrder; + } + + @Override + public String toString() { + return "Reshuffled{" + nextOrder + ", previous="+ previousOrder+ '}'; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Reshuffled that = (Reshuffled) o; + + if (!previousOrder.equals(that.previousOrder)) return false; + return nextOrder.equals(that.nextOrder); + } + + @Override + public int hashCode() { + int result = previousOrder.hashCode(); + result = 31 * result + nextOrder.hashCode(); + return result; + } + + @Override + public CsmMix getElement() { + return nextOrder; + } + + public CsmMix getPreviousOrder() { + return previousOrder; + } + + public CsmMix getNextOrder() { + return nextOrder; + } + + @Override + public boolean isAdded() { + return false; + } +}