Formatting

1 files changed, 36 insertions, 42 deletions

diff --git a/dice-lang/src/bjc/dicelang/v1/ast/optimization/ConstantCollapser.java b/dice-lang/src/bjc/dicelang/v1/ast/optimization/ConstantCollapser.java
index 89f17db..a0daf31 100644
--- a/dice-lang/src/bjc/dicelang/v1/ast/optimization/ConstantCollapser.java
+++ b/dice-lang/src/bjc/dicelang/v1/ast/optimization/ConstantCollapser.java
@@ -16,21 +16,20 @@ import bjc.utils.data.Tree;
  *
  */
 public class ConstantCollapser implements IOptimizationPass {
-	private static final ArithmeticCollapser	additionCollapser	= new ArithmeticCollapser(
+	private static final ArithmeticCollapser additionCollapser = new ArithmeticCollapser(
 			(left, right) -> left + right, OperatorDiceNode.ADD);
 
-	private static final ArithmeticCollapser	divideCollapser		= new ArithmeticCollapser(
+	private static final ArithmeticCollapser divideCollapser = new ArithmeticCollapser(
 			(left, right) -> left / right, OperatorDiceNode.DIVIDE);
 
-	private static final ArithmeticCollapser	multiplyCollapser	= new ArithmeticCollapser(
+	private static final ArithmeticCollapser multiplyCollapser = new ArithmeticCollapser(
 			(left, right) -> left * right, OperatorDiceNode.MULTIPLY);
 
-	private static final ArithmeticCollapser	subtractCollapser	= new ArithmeticCollapser(
+	private static final ArithmeticCollapser subtractCollapser = new ArithmeticCollapser(
 			(left, right) -> left - right, OperatorDiceNode.SUBTRACT);
 
-	private static final ArithmeticCollapser	compoundCollapser	= new ArithmeticCollapser(
-			(left, right) -> Integer.parseInt(
-					Integer.toString(left) + Integer.toString(left)),
+	private static final ArithmeticCollapser compoundCollapser = new ArithmeticCollapser(
+			(left, right) -> Integer.parseInt(Integer.toString(left) + Integer.toString(left)),
 			OperatorDiceNode.COMPOUND);
 
 	@Override
@@ -40,51 +39,46 @@ public class ConstantCollapser implements IOptimizationPass {
 	}
 
 	@Override
-	public ITree<IDiceASTNode> optimizeOperator(IDiceASTNode operator,
-			IList<ITree<IDiceASTNode>> children) {
+	public ITree<IDiceASTNode> optimizeOperator(IDiceASTNode operator, IList<ITree<IDiceASTNode>> children) {
 		if (!operator.isOperator()) {
 			return new Tree<>(operator, children);
 		}
 
 		switch ((OperatorDiceNode) operator) {
-			case ADD:
-				return additionCollapser.collapse(children);
-			case DIVIDE:
-				return divideCollapser.collapse(children);
-			case MULTIPLY:
-				return multiplyCollapser.collapse(children);
-			case SUBTRACT:
-				return subtractCollapser.collapse(children);
-			case COMPOUND:
-				return compoundCollapser.collapse(children);
-			case GROUP:
-				if (children.getSize() != 2) {
-					return new Tree<>(operator, children);
-				}
+		case ADD:
+			return additionCollapser.collapse(children);
+		case DIVIDE:
+			return divideCollapser.collapse(children);
+		case MULTIPLY:
+			return multiplyCollapser.collapse(children);
+		case SUBTRACT:
+			return subtractCollapser.collapse(children);
+		case COMPOUND:
+			return compoundCollapser.collapse(children);
+		case GROUP:
+			if (children.getSize() != 2) {
+				return new Tree<>(operator, children);
+			}
 
-				ComplexDice dice = new ComplexDice(
-						DiceASTUtils.literalToExpression(
-								children.getByIndex(0)),
-						DiceASTUtils.literalToExpression(
-								children.getByIndex(1)));
+			ComplexDice dice = new ComplexDice(DiceASTUtils.literalToExpression(children.getByIndex(0)),
+					DiceASTUtils.literalToExpression(children.getByIndex(1)));
 
-				if (dice.canOptimize()) {
-					return new Tree<>(
-							new IntegerLiteralNode(dice.optimize()));
-				}
+			if (dice.canOptimize()) {
+				return new Tree<>(new IntegerLiteralNode(dice.optimize()));
+			}
 
+			return new Tree<>(operator, children);
+		case ARRAY:
+			if (children.getSize() != 1) {
 				return new Tree<>(operator, children);
-			case ARRAY:
-				if (children.getSize() != 1) {
-					return new Tree<>(operator, children);
-				}
+			}
 
-				return children.first();
-			case ASSIGN:
-			case LET:
-			default:
-				// We don't optimize these operators
-				return new Tree<>(operator, children);
+			return children.first();
+		case ASSIGN:
+		case LET:
+		default:
+			// We don't optimize these operators
+			return new Tree<>(operator, children);
 		}
 	}
 }