Revise terminology: parenthesis -> round bracket, optimize -> minimize

src/main/java/spoon/reflect/visitor/DefaultJavaPrettyPrinter.java

@@ -218,10 +218,10 @@ public class DefaultJavaPrettyPrinter implements CtVisitor, PrettyPrinter {
 	protected boolean ignoreImplicit = true;
 
 	/**
-	 * EXPERIMENTAL: If true, the printer will attempt to print a minimal set of parentheses that
-	 * preserve the syntactical structure of the AST.
+	 * EXPERIMENTAL: If true, the printer will attempt to print a minimal set of round brackets in
+	 * expressions while preserving the syntactical structure of the AST.
 	 */
-	private boolean optimizeParentheses = false;
+	private boolean minimizeRoundBrackets = false;
 
 	public boolean inlineElseIf = true;
 
@@ -397,10 +397,11 @@ private boolean shouldSetBracket(CtExpression<?> e) {
 			return true;
 		}
 		try {
-			if (isOptimizeParentheses()) {
-				ParenOptimizer.MustParenthesize mustSetParens = ParenOptimizer.mustParenthesize(e);
-				if (mustSetParens != ParenOptimizer.MustParenthesize.UNKNOWN) {
-					return mustSetParens == ParenOptimizer.MustParenthesize.YES;
+			if (isMinimizeRoundBrackets()) {
+				RoundBracketAnalyzer.EncloseInRoundBrackets requiresBrackets =
+						RoundBracketAnalyzer.requiresRoundBrackets(e);
+				if (requiresBrackets != RoundBracketAnalyzer.EncloseInRoundBrackets.UNKNOWN) {
+					return requiresBrackets == RoundBracketAnalyzer.EncloseInRoundBrackets.YES;
 				}
 			}
 			if ((e.getParent() instanceof CtBinaryOperator) || (e.getParent() instanceof CtUnaryOperator)) {
@@ -2144,27 +2145,27 @@ public void visitCtYieldStatement(CtYieldStatement statement) {
 	}
 
 	/**
-	 * @return true if the printer is optimizing parentheses around expressions
+	 * @return true if the printer is minimizing the amount of round brackets in expressions
 	 */
-	protected boolean isOptimizeParentheses() {
-		return optimizeParentheses;
+	protected boolean isMinimizeRoundBrackets() {
+		return minimizeRoundBrackets;
 	}
 
 	/**
-	 * When set to true, this activates parenthesis optimization for expressions. This means that
-	 * the printer will attempt to only write those strictly necessary for preserving syntactical
-	 * structure (and by extension, semantics).
+	 * When set to true, this activates round bracket minimization for expressions. This means that
+	 * the printer will attempt to only write round brackets strictly necessary for preserving
+	 * syntactical structure (and by extension, semantics).
      *
 	 * As an example, the expression <code>1 + 2 + 3 + 4</code> is written as
-	 * <code>((1 + 2) + 3) + 4</code> without parenthesis optimization, but entirely without
-	 * parentheses when optimization is enabled. However, an expression <code>1 + 2 + (3 + 4)</code>
+	 * <code>((1 + 2) + 3) + 4</code> without round bracket minimization, but entirely without
+	 * parentheses when minimization is enabled. However, an expression <code>1 + 2 + (3 + 4)</code>
 	 * is still written as <code>1 + 2 + (3 + 4)</code> to preserve syntactical structure, even though
-	 * the parentheses are semantically redundant.
+	 * the brackets are semantically redundant.
 	 *
-	 * @param optimizeParentheses set whether or not to optimize parentheses around expressions
+	 * @param minimizeRoundBrackets set whether or not to minimize round brackets in expressions
 	 */
-	protected void setOptimizeParentheses(boolean optimizeParentheses) {
-		this.optimizeParentheses = optimizeParentheses;
+	protected void setMinimizeRoundBrackets(boolean minimizeRoundBrackets) {
+		this.minimizeRoundBrackets = minimizeRoundBrackets;
 	}
 
 }

src/main/java/spoon/reflect/visitor/RoundBracketAnalyzer.java

@@ -0,0 +1,114 @@
+/**
+ * SPDX-License-Identifier: (MIT OR CECILL-C)
+ * <p>
+ * Copyright (C) 2006-2019 INRIA and contributors
+ * <p>
+ * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) of the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
+ */
+package spoon.reflect.visitor;
+
+import spoon.reflect.code.CtBinaryOperator;
+import spoon.reflect.code.CtExpression;
+import spoon.reflect.code.CtUnaryOperator;
+import spoon.reflect.declaration.CtElement;
+
+/**
+ * Class for determining whether or not an expression requires round brackets in order to preserve
+ * AST structure (and consequently semantics).
+ */
+class RoundBracketAnalyzer {
+
+    enum EncloseInRoundBrackets {
+        YES, NO, UNKNOWN;
+    }
+
+    private RoundBracketAnalyzer() {
+    }
+
+    /**
+     * @param expr A unary or binary expr.
+     * @return true if the expr should be enclosed in round brackets.
+     */
+    static EncloseInRoundBrackets requiresRoundBrackets(CtExpression<?> expr) {
+        return isNestedOperator(expr)
+                ? nestedOperatorRequiresRoundBrackets(expr)
+                : EncloseInRoundBrackets.UNKNOWN;
+    }
+
+    /**
+     * Assuming that operator is a nested operator (i.e. both operator and its parent are
+     * {@link CtUnaryOperator} or {@link CtBinaryOperator}), determine whether or not it must be
+     * enclosed in round brackets.
+     *
+     * Given an element <code>e</code> with a parent <code>p</code>, we must parenthesize
+     * <code>e</code> if any of the following are true.
+     *
+     * <ul>
+     *     <li>The parent p is a unary operator</li>
+     *     <li>The parent p is a binary operator, and <code>precedence(p) > precedence(e></code></li>
+     *     <li>The parent p is a binary operator, <code>precedence(p) == precedence(e)</code>,
+     *     e appears as the X-hand-side operand of p, and e's operator is Y-associative, where
+     *     <code>X != Y</code></li>
+     * </ul>
+     *
+     * Note that the final rule is necessary to preserve syntactical structure, but it is not
+     * required for preserving semantics.
+     *
+     * @param nestedOperator A nested operator.
+     * @return Whether or not to enclose the nested operator in round brackets.
+     */
+    private static EncloseInRoundBrackets nestedOperatorRequiresRoundBrackets(CtExpression<?> nestedOperator) {
+        if (nestedOperator.getParent() instanceof CtUnaryOperator) {
+            return EncloseInRoundBrackets.YES;
+        }
+
+        OperatorHelper.OperatorAssociativity associativity = getOperatorAssociativity(nestedOperator);
+        OperatorHelper.OperatorAssociativity positionInParent = getPositionInParent(nestedOperator);
+
+        int parentPrecedence = getOperatorPrecedence(nestedOperator.getParent());
+        int precedence = getOperatorPrecedence(nestedOperator);
+        return precedence < parentPrecedence
+                || (precedence == parentPrecedence && associativity != positionInParent)
+                ? EncloseInRoundBrackets.YES
+                : EncloseInRoundBrackets.NO;
+    }
+
+    private static boolean isNestedOperator(CtElement e) {
+        return e.isParentInitialized() && isOperator(e) && isOperator(e.getParent());
+    }
+
+    private static boolean isOperator(CtElement e) {
+        return e instanceof CtBinaryOperator || e instanceof CtUnaryOperator;
+    }
+
+    private static int getOperatorPrecedence(CtElement e) {
+        if (e instanceof CtBinaryOperator) {
+            return OperatorHelper.getOperatorPrecedence(((CtBinaryOperator<?>) e).getKind());
+        } else if (e instanceof CtUnaryOperator) {
+            return OperatorHelper.getOperatorPrecedence(((CtUnaryOperator<?>) e).getKind());
+        } else {
+            return 0;
+        }
+    }
+
+    private static OperatorHelper.OperatorAssociativity getOperatorAssociativity(CtElement e) {
+        if (e instanceof CtBinaryOperator) {
+            return OperatorHelper.getOperatorAssociativity(((CtBinaryOperator<?>) e).getKind());
+        } else if (e instanceof CtUnaryOperator) {
+            return OperatorHelper.getOperatorAssociativity(((CtUnaryOperator<?>) e).getKind());
+        } else {
+            return OperatorHelper.OperatorAssociativity.NONE;
+        }
+    }
+
+    private static OperatorHelper.OperatorAssociativity getPositionInParent(CtElement e) {
+        CtElement parent = e.getParent();
+        if (parent instanceof CtBinaryOperator) {
+            return ((CtBinaryOperator<?>) parent).getLeftHandOperand() == e
+                    ? OperatorHelper.OperatorAssociativity.LEFT
+                    : OperatorHelper.OperatorAssociativity.RIGHT;
+        } else {
+            return OperatorHelper.OperatorAssociativity.NONE;
+        }
+    }
+}

src/main/java/spoon/support/sniper/SniperJavaPrettyPrinter.java

@@ -84,7 +84,7 @@ public SniperJavaPrettyPrinter(Environment env) {
 		this.setIgnoreImplicit(false);
 
 		// don't print redundant parentheses
-		this.setOptimizeParentheses(true);
+		this.setMinimizeRoundBrackets(true);
 	}
 
 	/**

src/test/java/spoon/reflect/visitor/DefaultJavaPrettyPrinterTest.java

@@ -55,7 +55,7 @@ private static Launcher createLauncherWithOptimizeParenthesesPrinter() {
         Launcher launcher = new Launcher();
         launcher.getEnvironment().setPrettyPrinterCreator(() -> {
             DefaultJavaPrettyPrinter printer = new DefaultJavaPrettyPrinter(launcher.getEnvironment());
-            printer.setOptimizeParentheses(true);
+            printer.setMinimizeRoundBrackets(true);
             return printer;
         });
         return launcher;