From 7e233d02a01629b2667e6f12472aa87daf62db3d Mon Sep 17 00:00:00 2001 From: ChUrl Date: Sun, 31 Jan 2021 20:10:04 +0100 Subject: [PATCH] ParseTreeCleaner + SyntaxTreeRebalancer --- ...STCompacter.java => ParseTreeCleaner.java} | 116 +++++++++------- src/main/java/parser/ast/SyntaxTree.java | 4 +- ...alancer.java => SyntaxTreeRebalancer.java} | 126 ++++++++++++------ ...terTest.java => ParseTreeCleanerTest.java} | 16 +-- ...est.java => SyntaxTreeRebalancerTest.java} | 38 +++--- 5 files changed, 181 insertions(+), 119 deletions(-) rename src/main/java/parser/ast/{ASTCompacter.java => ParseTreeCleaner.java} (60%) rename src/main/java/parser/ast/{ASTBalancer.java => SyntaxTreeRebalancer.java} (54%) rename src/test/java/parser/ast/{SyntaxTreeCompacterTest.java => ParseTreeCleanerTest.java} (77%) rename src/test/java/parser/ast/{SyntaxTreeBalancerTest.java => SyntaxTreeRebalancerTest.java} (83%) diff --git a/src/main/java/parser/ast/ASTCompacter.java b/src/main/java/parser/ast/ParseTreeCleaner.java similarity index 60% rename from src/main/java/parser/ast/ASTCompacter.java rename to src/main/java/parser/ast/ParseTreeCleaner.java index 417f27a..81417c8 100644 --- a/src/main/java/parser/ast/ASTCompacter.java +++ b/src/main/java/parser/ast/ParseTreeCleaner.java @@ -7,28 +7,42 @@ import java.util.HashSet; import static util.Logger.log; -public final class ASTCompacter { +/** + * Wendet in der Grammatik definierte Regeln auf einen Parsebaum an. + * Dies ist der erste Schritt zum Abstrakten Syntaxbaum. + * + * + */ +public final class ParseTreeCleaner { - private ASTCompacter() {} + private ParseTreeCleaner() {} - public static void clean(SyntaxTree tree, Grammar grammar) { - deleteChildren(tree, grammar); - deleteIfEmpty(tree, grammar); - promote(tree, grammar); + public static void clean(SyntaxTree parseTree, Grammar grammar) { + deleteChildren(parseTree, grammar); + deleteIfEmpty(parseTree, grammar); + promote(parseTree, grammar); - renameTo(tree, grammar); - nameToValue(tree, grammar); - valueToValue(tree, grammar); + renameTo(parseTree, grammar); + nameToValue(parseTree, grammar); + valueToValue(parseTree, grammar); - log("\nCleaned Tree:\n" + tree); + log("\nCleaned Tree:\n" + parseTree); log("-".repeat(100)); System.out.println(" - Compressing syntax-tree..."); } - // Entfernt [promote]-able Nodes (Reicht Werte nach oben) - public static void promote(SyntaxTree tree, Grammar grammar) { + /** + * Es werden Werte nach oben gereicht von [promote]-able Nodes. + */ + public static void promote(SyntaxTree parseTree, Grammar grammar) { log("\nPromoting nodes:"); - promote(tree.getRoot(), grammar); + promote(parseTree.getRoot(), grammar); } private static void promote(SyntaxTreeNode root, Grammar grammar) { @@ -49,17 +63,19 @@ public final class ASTCompacter { root.setValue(child.getValue()); root.setChildren(child.getChildren()); - child.setValue("REMOVE"); // If both childs have the same identity both are removed + child.setValue("REMOVE"); // If both childs have the same identity both are removed, so change one toRemove.add(child); } root.getChildren().removeAll(toRemove); } - // Entfernt [delIfEmpty] Nodes (löscht Nodes ohne Inhalt) - public static void deleteIfEmpty(SyntaxTree tree, Grammar grammar) { + /** + * Löscht leere Knoten mit [delIfEmpty]. + */ + public static void deleteIfEmpty(SyntaxTree parseTree, Grammar grammar) { log("\nDeleting empty nodes:"); - deleteIfEmpty(tree.getRoot(), grammar); + deleteIfEmpty(parseTree.getRoot(), grammar); } private static void deleteIfEmpty(SyntaxTreeNode root, Grammar grammar) { @@ -74,17 +90,19 @@ public final class ASTCompacter { log("Removing " + child.getName()); - child.setValue("REMOVE"); // If both childs have the same identity both are removed + child.setValue("REMOVE"); // If both childs have the same identity both are removed, so change one toRemove.add(child); } root.getChildren().removeAll(toRemove); } - // Löscht redundante Informationen in [delChildren]-Nodes (z.b. IF-child von COND) und Epsilon-Nodes - public static void deleteChildren(SyntaxTree tree, Grammar grammar) { + /** + * Löscht redundante Informationen in [delChildren]-Nodes (z.b. IF-child von COND) und Epsilon-Nodes. + */ + public static void deleteChildren(SyntaxTree parseTree, Grammar grammar) { log("Removing redundant children:"); - deleteChildren(tree.getRoot(), grammar); + deleteChildren(parseTree.getRoot(), grammar); } private static void deleteChildren(SyntaxTreeNode root, Grammar grammar) { @@ -99,17 +117,19 @@ public final class ASTCompacter { log("Removing " + root.getName() + " -> " + child.getName()); - child.setValue("REMOVE"); // If both childs have the same identity both are removed + child.setValue("REMOVE"); // If both childs have the same identity both are removed, so change one toRemove.add(child); } root.getChildren().removeAll(toRemove); } - // Umbenennungen - private static void renameTo(SyntaxTree tree, Grammar grammar) { + /** + * Führt Umbenennungen durch. + */ + private static void renameTo(SyntaxTree parseTree, Grammar grammar) { log("\nRenaming nodes:"); - renameTo(tree.getRoot(), grammar); + renameTo(parseTree.getRoot(), grammar); } private static void renameTo(SyntaxTreeNode root, Grammar grammar) { @@ -126,9 +146,12 @@ public final class ASTCompacter { } } - public static void nameToValue(SyntaxTree tree, Grammar grammar) { + /** + * Verschiebt Knotennamen von [nametoval]-Nodes in Parent-Values und löscht das Child. + */ + public static void nameToValue(SyntaxTree parseTree, Grammar grammar) { log("\nMoving names to values:"); - nameToValue(tree.getRoot(), grammar); + nameToValue(parseTree.getRoot(), grammar); } private static void nameToValue(SyntaxTreeNode root, Grammar grammar) { @@ -146,17 +169,21 @@ public final class ASTCompacter { root.setValue(child.getName()); - child.setValue("REMOVE"); // If both childs have the same identity both are removed + child.setValue("REMOVE"); // If both childs have the same identity both are removed, so change one toRemove.add(child); } root.getChildren().removeAll(toRemove); } - // Assignment bekommt den Identifier als Value anstatt als Child - public static void valueToValue(SyntaxTree tree, Grammar grammar) { + /** + * [valtoval]-Nodes bekommen den Child-Namen als Value anstatt als Child. + * Wird z.B. durchgeführt bei Assignments: Der Assignment-Node bekommt den + * Variablennamen als Wert anstatt als Child-Node. + */ + public static void valueToValue(SyntaxTree parseTree, Grammar grammar) { log("\nMoving values to values:"); - valueToValue(tree.getRoot(), grammar); + valueToValue(parseTree.getRoot(), grammar); } private static void valueToValue(SyntaxTreeNode root, Grammar grammar) { @@ -165,36 +192,31 @@ public final class ASTCompacter { for (SyntaxTreeNode child : root.getChildren()) { valueToValue(child, grammar); - if (!grammar.hasValToVal(root, child)) { - continue; - } - - if (!root.getValue().isBlank()) { - // Do not overwrite + if (!grammar.hasValToVal(root, child) || !root.getValue().isBlank()) { continue; } if (root.getChildren().size() == 2 && root.getChildren().get(0).getName().equals(root.getChildren().get(1).getName())) { - // Special case where variable is assigned another variable + // Case where variable is assigned another variable with the same name - log("Special case: Var to var assignment"); log("Moving " + root.getChildren().get(1).getValue() + " to value of " + root.getName()); log(root.toString()); root.setValue(root.getChildren().get(1).getValue()); - root.getChildren().get(1).setValue("REMOVE"); // If both childs have the same identity both are removed + root.getChildren().get(1).setValue("REMOVE"); // If both childs have the same identity both are removed, so change one toRemove.add(root.getChildren().get(1)); - continue; + } else { + // Usual case where an expression is assigned + + log("Moving " + child.getValue() + " to value of " + root.getName()); + log(root.toString()); + + root.setValue(child.getValue()); + toRemove.add(child); } - - log("Moving " + child.getValue() + " to value of " + root.getName()); - log(root.toString()); - - root.setValue(child.getValue()); - toRemove.add(child); } root.getChildren().removeAll(toRemove); diff --git a/src/main/java/parser/ast/SyntaxTree.java b/src/main/java/parser/ast/SyntaxTree.java index 465c884..cd41079 100644 --- a/src/main/java/parser/ast/SyntaxTree.java +++ b/src/main/java/parser/ast/SyntaxTree.java @@ -23,8 +23,8 @@ public class SyntaxTree { public static SyntaxTree toAbstractSyntaxTree(SyntaxTree concreteSyntaxTree, Grammar grammar) { final SyntaxTree abstractSyntaxTree = concreteSyntaxTree.deepCopy(); - ASTCompacter.clean(abstractSyntaxTree, grammar); - ASTBalancer.balance(abstractSyntaxTree); + ParseTreeCleaner.clean(abstractSyntaxTree, grammar); + SyntaxTreeRebalancer.rebalance(abstractSyntaxTree); System.out.println("Tree processing successful."); return abstractSyntaxTree; diff --git a/src/main/java/parser/ast/ASTBalancer.java b/src/main/java/parser/ast/SyntaxTreeRebalancer.java similarity index 54% rename from src/main/java/parser/ast/ASTBalancer.java rename to src/main/java/parser/ast/SyntaxTreeRebalancer.java index 4593a0b..02854b9 100644 --- a/src/main/java/parser/ast/ASTBalancer.java +++ b/src/main/java/parser/ast/SyntaxTreeRebalancer.java @@ -6,11 +6,19 @@ import java.util.Set; import static util.Logger.log; -public final class ASTBalancer { +/** + * Ein SyntaxTree wird an bestimmten Stellen rotiert, sodass bestimmte Eigenschaften + * korrekt repräsentiert werden (Operatorpräzedenz, Linkassoziativität etc.). + */ +public final class SyntaxTreeRebalancer { - private static final Map priority; - private static final Set unary; - private static final Set commutative; + /** + * Jedem Operator wird eine Priorität zugewiesen, 0 ist die höchste. + */ + private static final Map operatorPriority; + + private static final Set unaryOperators; + private static final Set commutativeOperators; //!: Operatorpräzedenz // 0 - Unary: -, +, ! @@ -21,44 +29,56 @@ public final class ASTBalancer { // 5 - Logical AND: && // 6 - Logical OR: || static { - priority = Map.ofEntries(Map.entry("NOT", 0), - Map.entry("MUL", 1), - Map.entry("DIV", 1), - Map.entry("MOD", 1), - Map.entry("ADD", 2), - Map.entry("SUB", 2), - Map.entry("LESS", 3), - Map.entry("LESS_EQUAL", 3), - Map.entry("GREATER", 3), - Map.entry("GREATER_EQUAL", 3), - Map.entry("EQUAL", 4), - Map.entry("NOT_EQUAL", 4), - Map.entry("AND", 5), - Map.entry("OR", 6)); + operatorPriority = Map.ofEntries(Map.entry("NOT", 0), + Map.entry("MUL", 1), + Map.entry("DIV", 1), + Map.entry("MOD", 1), + Map.entry("ADD", 2), + Map.entry("SUB", 2), + Map.entry("LESS", 3), + Map.entry("LESS_EQUAL", 3), + Map.entry("GREATER", 3), + Map.entry("GREATER_EQUAL", 3), + Map.entry("EQUAL", 4), + Map.entry("NOT_EQUAL", 4), + Map.entry("AND", 5), + Map.entry("OR", 6)); - unary = Set.of("NOT", "ADD", "SUB"); + unaryOperators = Set.of("NOT", "ADD", "SUB"); - commutative = Set.of("ADD", "MUL", "EQUAL", "NOT_EQUAL", "AND", "OR"); + commutativeOperators = Set.of("ADD", "MUL", "EQUAL", "NOT_EQUAL", "AND", "OR"); } - private ASTBalancer() {} + private SyntaxTreeRebalancer() {} - public static void balance(SyntaxTree tree) { - flip(tree); - leftPrecedence(tree); - operatorPrecedence(tree); - flipCommutativeExpr(tree); + /** + * Ein Abstrakter Syntaxbaum wird umbalanciert. + * + *
    + *
  • Baum wird gespiegelt, damit die Ausdrücke vorwárts laufen (Tiefste Ebenen müssen nach links)
    • + *
  • Linkspräzedenz wird durch Links-Rotationen durchgesetzt
    • + *
  • Operatorpräzedenz wird durch Rechtsrotationen durchgesetzt
    • + *
  • Kommutative Ausdrücke werden gespiegelt, damit die tiefen Teilausdrücke zuerst berechnet werden
    • + *
+ */ + public static void rebalance(SyntaxTree abstractSyntaxTree) { + flip(abstractSyntaxTree); + leftPrecedence(abstractSyntaxTree); + operatorPrecedence(abstractSyntaxTree); + flipCommutativeExpr(abstractSyntaxTree); - log(tree.toString()); + log(abstractSyntaxTree.toString()); log("-".repeat(100)); System.out.println(" - Balancing syntax-tree..."); } - // Baum spiegeln, damit höhere Ebenen links sind und EXPR vorwärts laufen - public static void flip(SyntaxTree tree) { + /** + * Baum spiegeln, damit höhere Ebenen links sind und EXPR vorwärts laufen. + */ + public static void flip(SyntaxTree abstractSyntaxTree) { log("Flipping tree for ltr evaluation"); - flip(tree.getRoot()); + flip(abstractSyntaxTree.getRoot()); } private static void flip(SyntaxTreeNode root) { @@ -69,9 +89,12 @@ public final class ASTBalancer { Collections.reverse(root.getChildren()); } - public static void flipCommutativeExpr(SyntaxTree tree) { + /** + * Kommutative Ausdrücke werden gespiegelt, damit die tiefen Teilexpressions zuerst berechnet werden. + */ + public static void flipCommutativeExpr(SyntaxTree abstractSyntaxTree) { log("Flipping commutative expressions for stack efficiency"); - flipCommutativeExpr(tree.getRoot()); + flipCommutativeExpr(abstractSyntaxTree.getRoot()); } private static void flipCommutativeExpr(SyntaxTreeNode root) { @@ -79,9 +102,12 @@ public final class ASTBalancer { flipCommutativeExpr(child); } - if ("expr".equals(root.getName()) && commutative.contains(root.getValue())) { + if ("expr".equals(root.getName()) && commutativeOperators.contains(root.getValue())) { + // Ausdruck ist kommutativ + if (root.getChildren().size() == 2 && root.getChildren().get(0).size() < root.getChildren().get(1).size()) { // Make the bigger subtree the left one + log("Flipping " + root.getName() + ": " + root.getValue() + " for stack efficiency."); log(root.toString()); @@ -90,14 +116,15 @@ public final class ASTBalancer { } } - // Führt Linksrotationen durch - // Es werden EXPR-Nodes (2 Childs, 1 davon EXPR, Kein Wert) solange wie möglich linksrotiert - public static void leftPrecedence(SyntaxTree tree) { + /** + * Führt Linksrotationen durch für Linkspräzedenz. + * Es werden EXPR-Nodes (2 Childs, 1 davon EXPR, Kein Wert) solange wie möglich linksrotiert. + */ + public static void leftPrecedence(SyntaxTree abstractSyntaxTree) { log("Left-rotating expressions for left-precedence"); - leftPrecedence(tree.getRoot()); + leftPrecedence(abstractSyntaxTree.getRoot()); } - // Es wird solange rotiert bis die letzte "Rotation" durchgeführt wurde private static void leftPrecedence(SyntaxTreeNode root) { for (SyntaxTreeNode child : root.getChildren()) { leftPrecedence(child); @@ -116,7 +143,12 @@ public final class ASTBalancer { } while (change); } - // Die Letzte Rotation ist keine richtige Rotation, dort wird false zurückgegeben + /** + * Führt eine Linksrotation durch. + * Diese ist nicht regulär, da der Operator linksvererbt wird. + * + * @return Es wird false zurückgegeben, sobald keine weitere Rotation mehr möglich ist. + */ private static boolean specialLeftRotate(SyntaxTreeNode root) { log("Special-Left-Rotation around " + root.getName()); log(root.toString()); @@ -157,13 +189,18 @@ public final class ASTBalancer { return root.getChildren().size() == 1; } - public static void operatorPrecedence(SyntaxTree tree) { + /** + * Führt Rechtsrotationen durch für Operatorpräzedenz. + * Es wird solange rechtsrotiert, bis alle Operatoren mit hoher Priorität tiefer stehen + * als die Operatoren mit niedriger Priorität. + */ + public static void operatorPrecedence(SyntaxTree abstractSyntaxTree) { log("Right-rotating expressions for operator-precedence"); boolean changed; do { - changed = operatorPrecedence(tree.getRoot()); + changed = operatorPrecedence(abstractSyntaxTree.getRoot()); } while (changed); } @@ -182,6 +219,9 @@ public final class ASTBalancer { return changed; } + /** + * Ermittelt, ob der ParentNode höhere Priorität als der ChildNode hat. + */ private static boolean preceding(SyntaxTreeNode parent, SyntaxTreeNode child) { if (!"expr".equals(parent.getName()) || parent.getValue().isEmpty() || !"expr".equals(child.getName()) || child.getValue().isEmpty()) { @@ -189,13 +229,13 @@ public final class ASTBalancer { } // Unary operators have the highest precedence - if (child.getChildren().size() == 1 && unary.contains(child.getValue())) { + if (child.getChildren().size() == 1 && unaryOperators.contains(child.getValue())) { return false; } // Less equals higher { - return priority.get(parent.getValue()) < priority.get(child.getValue()); + return operatorPriority.get(parent.getValue()) < operatorPriority.get(child.getValue()); } } diff --git a/src/test/java/parser/ast/SyntaxTreeCompacterTest.java b/src/test/java/parser/ast/ParseTreeCleanerTest.java similarity index 77% rename from src/test/java/parser/ast/SyntaxTreeCompacterTest.java rename to src/test/java/parser/ast/ParseTreeCleanerTest.java index 09b1e54..fcc21d2 100644 --- a/src/test/java/parser/ast/SyntaxTreeCompacterTest.java +++ b/src/test/java/parser/ast/ParseTreeCleanerTest.java @@ -17,21 +17,21 @@ import java.nio.file.Paths; import static org.assertj.core.api.Assertions.assertThat; -class SyntaxTreeCompacterTest { +class ParseTreeCleanerTest { private static Grammar grammar; private static StupsParser parser; @BeforeAll static void init() throws IOException, URISyntaxException { - final Path path = Paths.get(SyntaxTreeCompacterTest.class.getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI()); + final Path path = Paths.get(ParseTreeCleanerTest.class.getClassLoader().getResource("exampleGrammars/Grammar.grammar").toURI()); grammar = Grammar.fromFile(path); parser = StupsParser.fromGrammar(grammar); } private static SyntaxTree getTree(String program) { try { - final Path path = Paths.get(SyntaxTreeCompacterTest.class.getClassLoader().getResource("examplePrograms/" + program).toURI()); + final Path path = Paths.get(ParseTreeCleanerTest.class.getClassLoader().getResource("examplePrograms/" + program).toURI()); final String programCode = Files.readString(path, StandardCharsets.US_ASCII); final Lexer lex = new StupsLexer(CharStreams.fromString(programCode)); return parser.parse(lex.getAllTokens(), lex.getVocabulary()); @@ -47,7 +47,7 @@ class SyntaxTreeCompacterTest { final SyntaxTree tree = getTree("GeneralOperator.stups"); final long before = tree.size(); - ASTCompacter.deleteChildren(tree, grammar); + ParseTreeCleaner.deleteChildren(tree, grammar); assertThat(before - tree.size()).isEqualTo(3); } @@ -57,7 +57,7 @@ class SyntaxTreeCompacterTest { final SyntaxTree tree = getTree("GeneralOperator.stups"); final long before = tree.size(); - ASTCompacter.promote(tree, grammar); + ParseTreeCleaner.promote(tree, grammar); assertThat(before - tree.size()).isEqualTo(14); } @@ -65,10 +65,10 @@ class SyntaxTreeCompacterTest { @Test void testDeleteEmpty() { final SyntaxTree tree = getTree("GeneralOperator.stups"); - ASTCompacter.deleteChildren(tree, grammar); + ParseTreeCleaner.deleteChildren(tree, grammar); final long before = tree.size(); - ASTCompacter.deleteIfEmpty(tree, grammar); + ParseTreeCleaner.deleteIfEmpty(tree, grammar); assertThat(before - tree.size()).isEqualTo(2); } @@ -77,7 +77,7 @@ class SyntaxTreeCompacterTest { void testClean() { final SyntaxTree tree = getTree("GeneralOperator.stups"); - ASTCompacter.clean(tree, grammar); + ParseTreeCleaner.clean(tree, grammar); assertThat(tree.size()).isEqualTo(28); } diff --git a/src/test/java/parser/ast/SyntaxTreeBalancerTest.java b/src/test/java/parser/ast/SyntaxTreeRebalancerTest.java similarity index 83% rename from src/test/java/parser/ast/SyntaxTreeBalancerTest.java rename to src/test/java/parser/ast/SyntaxTreeRebalancerTest.java index 7fe41bf..af6d319 100644 --- a/src/test/java/parser/ast/SyntaxTreeBalancerTest.java +++ b/src/test/java/parser/ast/SyntaxTreeRebalancerTest.java @@ -4,7 +4,7 @@ import org.junit.jupiter.api.Test; import static org.assertj.core.api.Assertions.assertThat; -class SyntaxTreeBalancerTest { +class SyntaxTreeRebalancerTest { //expr //├── expr: SUB @@ -84,7 +84,7 @@ class SyntaxTreeBalancerTest { void testTree1Flip() { final SyntaxTree tree = tree1(); - ASTBalancer.flip(tree); + SyntaxTreeRebalancer.flip(tree); assertThat(tree.getRoot().getChildren().get(0).getName()).isEqualTo("INTEGER_LIT"); assertThat(tree.getRoot().getChildren().get(1).getName()).isEqualTo("expr"); @@ -94,8 +94,8 @@ class SyntaxTreeBalancerTest { void testTree1Flip2x() { final SyntaxTree tree = tree1(); - ASTBalancer.flip(tree); - ASTBalancer.flip(tree); + SyntaxTreeRebalancer.flip(tree); + SyntaxTreeRebalancer.flip(tree); assertThat(tree).isEqualTo(tree1()); } @@ -104,7 +104,7 @@ class SyntaxTreeBalancerTest { void testTree2Flip() { final SyntaxTree tree = tree2(); - ASTBalancer.flip(tree); + SyntaxTreeRebalancer.flip(tree); assertThat(tree.getRoot().getChildren().get(0).getName()).isEqualTo("INTEGER_LIT"); assertThat(tree.getRoot().getChildren().get(1).getName()).isEqualTo("expr"); @@ -116,8 +116,8 @@ class SyntaxTreeBalancerTest { void testTree2Flip2x() { final SyntaxTree tree = tree2(); - ASTBalancer.flip(tree); - ASTBalancer.flip(tree); + SyntaxTreeRebalancer.flip(tree); + SyntaxTreeRebalancer.flip(tree); assertThat(tree).isEqualTo(tree2()); } @@ -125,9 +125,9 @@ class SyntaxTreeBalancerTest { @Test void testTree1LeftPrecedence() { final SyntaxTree tree = tree1(); - ASTBalancer.flip(tree); + SyntaxTreeRebalancer.flip(tree); - ASTBalancer.leftPrecedence(tree); + SyntaxTreeRebalancer.leftPrecedence(tree); assertThat(tree.size()).isEqualTo(3); assertThat(tree.getRoot().getValue()).isEqualTo("SUB"); @@ -136,9 +136,9 @@ class SyntaxTreeBalancerTest { @Test void testTree2LeftPrecedence() { final SyntaxTree tree = tree2(); - ASTBalancer.flip(tree); + SyntaxTreeRebalancer.flip(tree); - ASTBalancer.leftPrecedence(tree); + SyntaxTreeRebalancer.leftPrecedence(tree); assertThat(tree.size()).isEqualTo(5); assertThat(tree.getRoot().getValue()).isEqualTo("SUB"); @@ -147,14 +147,14 @@ class SyntaxTreeBalancerTest { @Test void testTree2OperatorPrecedence() { final SyntaxTree tree = tree2(); - ASTBalancer.flip(tree); - ASTBalancer.leftPrecedence(tree); + SyntaxTreeRebalancer.flip(tree); + SyntaxTreeRebalancer.leftPrecedence(tree); final SyntaxTree tree1 = tree2(); - ASTBalancer.flip(tree1); - ASTBalancer.leftPrecedence(tree1); + SyntaxTreeRebalancer.flip(tree1); + SyntaxTreeRebalancer.leftPrecedence(tree1); - ASTBalancer.operatorPrecedence(tree); + SyntaxTreeRebalancer.operatorPrecedence(tree); assertThat(tree).isEqualTo(tree1); } @@ -162,12 +162,12 @@ class SyntaxTreeBalancerTest { @Test void testTree3OperatorPrecedence() { final SyntaxTree tree = tree3(); - ASTBalancer.flip(tree); - ASTBalancer.leftPrecedence(tree); + SyntaxTreeRebalancer.flip(tree); + SyntaxTreeRebalancer.leftPrecedence(tree); assertThat(tree.getRoot().getValue()).isEqualTo("MUL"); - ASTBalancer.operatorPrecedence(tree); + SyntaxTreeRebalancer.operatorPrecedence(tree); assertThat(tree.size()).isEqualTo(5); assertThat(tree.getRoot().getValue()).isEqualTo("SUB");