Formatting

4 files changed, 73 insertions, 90 deletions

diff --git a/dice-lang/src/bjc/dicelang/v1/ast/optimization/ArithmeticCollapser.java b/dice-lang/src/bjc/dicelang/v1/ast/optimization/ArithmeticCollapser.java
index 0d10a07..9fb0a5e 100644
--- a/dice-lang/src/bjc/dicelang/v1/ast/optimization/ArithmeticCollapser.java
+++ b/dice-lang/src/bjc/dicelang/v1/ast/optimization/ArithmeticCollapser.java
@@ -13,17 +13,15 @@ import bjc.utils.funcdata.IList;
 import bjc.utils.data.Tree;
 
 class ArithmeticCollapser {
-	private BinaryOperator<Integer>	reducer;
-	private OperatorDiceNode		type;
+	private BinaryOperator<Integer> reducer;
+	private OperatorDiceNode type;
 
-	public ArithmeticCollapser(BinaryOperator<Integer> reducr,
-			OperatorDiceNode typ) {
+	public ArithmeticCollapser(BinaryOperator<Integer> reducr, OperatorDiceNode typ) {
 		reducer = reducr;
 		this.type = typ;
 	}
 
-	public ITree<IDiceASTNode> collapse(
-			IList<ITree<IDiceASTNode>> children) {
+	public ITree<IDiceASTNode> collapse(IList<ITree<IDiceASTNode>> children) {
 		boolean allConstant = children.allMatch((subtree) -> {
 			return subtree.transformHead((node) -> {
 				if (node.getType() == DiceASTType.LITERAL) {
@@ -40,10 +38,8 @@ class ArithmeticCollapser {
 
 		int initState = DiceASTUtils.literalToInteger(children.first());
 
-		return children.tail().reduceAux(initState,
-				(currentNode, state) -> {
-					return reducer.apply(state,
-							DiceASTUtils.literalToInteger(currentNode));
-				}, (state) -> new Tree<>(new IntegerLiteralNode(state)));
+		return children.tail().reduceAux(initState, (currentNode, state) -> {
+			return reducer.apply(state, DiceASTUtils.literalToInteger(currentNode));
+		}, (state) -> new Tree<>(new IntegerLiteralNode(state)));
 	}
 }
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);
 		}
 	}
 }
diff --git a/dice-lang/src/bjc/dicelang/v1/ast/optimization/IOptimizationPass.java b/dice-lang/src/bjc/dicelang/v1/ast/optimization/IOptimizationPass.java
index 58943fa..b09d95d 100644
--- a/dice-lang/src/bjc/dicelang/v1/ast/optimization/IOptimizationPass.java
+++ b/dice-lang/src/bjc/dicelang/v1/ast/optimization/IOptimizationPass.java
@@ -15,7 +15,7 @@ public interface IOptimizationPass {
 	 * Optimize a leaf in the tree
 	 * 
 	 * @param leafNode
-	 *            The node to optimize
+	 *                The node to optimize
 	 * @return The optimized node
 	 */
 	public ITree<IDiceASTNode> optimizeLeaf(IDiceASTNode leafNode);
@@ -24,11 +24,10 @@ public interface IOptimizationPass {
 	 * Optimize an operator in an AST node
 	 * 
 	 * @param operator
-	 *            The operator being optimized
+	 *                The operator being optimized
 	 * @param children
-	 *            The children of the operator being optimized
+	 *                The children of the operator being optimized
 	 * @return The optimized node
 	 */
-	public ITree<IDiceASTNode> optimizeOperator(IDiceASTNode operator,
-			IList<ITree<IDiceASTNode>> children);
+	public ITree<IDiceASTNode> optimizeOperator(IDiceASTNode operator, IList<ITree<IDiceASTNode>> children);
 }
diff --git a/dice-lang/src/bjc/dicelang/v1/ast/optimization/OperationCondenser.java b/dice-lang/src/bjc/dicelang/v1/ast/optimization/OperationCondenser.java
index 4a34167..f00d390 100644
--- a/dice-lang/src/bjc/dicelang/v1/ast/optimization/OperationCondenser.java
+++ b/dice-lang/src/bjc/dicelang/v1/ast/optimization/OperationCondenser.java
@@ -20,18 +20,15 @@ public class OperationCondenser {
 	 * Condense chained similiar operations into a single level
 	 * 
 	 * @param ast
-	 *            The AST to condense
+	 *                The AST to condense
 	 * @return The condensed AST
 	 */
 	public static ITree<IDiceASTNode> condense(ITree<IDiceASTNode> ast) {
-		return ast.topDownTransform(OperationCondenser::pickNode,
-				OperationCondenser::doCondense);
+		return ast.topDownTransform(OperationCondenser::pickNode, OperationCondenser::doCondense);
 	}
 
-	private static ITree<IDiceASTNode> doCondense(
-			ITree<IDiceASTNode> ast) {
-		OperatorDiceNode operation = ast
-				.transformHead((node) -> (OperatorDiceNode) node);
+	private static ITree<IDiceASTNode> doCondense(ITree<IDiceASTNode> ast) {
+		OperatorDiceNode operation = ast.transformHead((node) -> (OperatorDiceNode) node);
 
 		IHolder<Boolean> canCondense = new Identity<>(true);
 
@@ -72,35 +69,32 @@ public class OperationCondenser {
 
 	private static TopDownTransformResult pickNode(IDiceASTNode node) {
 		switch (node.getType()) {
-			case LITERAL:
-				return TopDownTransformResult.SKIP;
-			case OPERATOR:
-				return pickOperator((OperatorDiceNode) node);
-			case VARIABLE:
-				return TopDownTransformResult.SKIP;
-			default:
-				throw new UnsupportedOperationException(
-						"Attempted to traverse unknown node type " + node);
+		case LITERAL:
+			return TopDownTransformResult.SKIP;
+		case OPERATOR:
+			return pickOperator((OperatorDiceNode) node);
+		case VARIABLE:
+			return TopDownTransformResult.SKIP;
+		default:
+			throw new UnsupportedOperationException("Attempted to traverse unknown node type " + node);
 		}
 	}
 
-	private static TopDownTransformResult pickOperator(
-			OperatorDiceNode node) {
+	private static TopDownTransformResult pickOperator(OperatorDiceNode node) {
 		switch (node) {
-			case ADD:
-			case MULTIPLY:
-			case SUBTRACT:
-			case DIVIDE:
-			case COMPOUND:
-				return TopDownTransformResult.PUSHDOWN;
-			case ARRAY:
-			case ASSIGN:
-			case GROUP:
-			case LET:
-				return TopDownTransformResult.PASSTHROUGH;
-			default:
-				throw new UnsupportedOperationException(
-						"Attempted to traverse unknown operator " + node);
+		case ADD:
+		case MULTIPLY:
+		case SUBTRACT:
+		case DIVIDE:
+		case COMPOUND:
+			return TopDownTransformResult.PUSHDOWN;
+		case ARRAY:
+		case ASSIGN:
+		case GROUP:
+		case LET:
+			return TopDownTransformResult.PASSTHROUGH;
+		default:
+			throw new UnsupportedOperationException("Attempted to traverse unknown operator " + node);
 		}
 	}
 }