Cleanup

5 files changed, 27 insertions, 42 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 9fb0a5e..acc1afa 100644
--- a/dice-lang/src/bjc/dicelang/v1/ast/optimization/ArithmeticCollapser.java
+++ b/dice-lang/src/bjc/dicelang/v1/ast/optimization/ArithmeticCollapser.java
@@ -1,7 +1,5 @@
 package bjc.dicelang.v1.ast.optimization;
 
-import java.util.function.BinaryOperator;
-
 import bjc.dicelang.v1.ast.DiceASTUtils;
 import bjc.dicelang.v1.ast.nodes.DiceASTType;
 import bjc.dicelang.v1.ast.nodes.IDiceASTNode;
@@ -9,12 +7,14 @@ import bjc.dicelang.v1.ast.nodes.ILiteralDiceNode;
 import bjc.dicelang.v1.ast.nodes.IntegerLiteralNode;
 import bjc.dicelang.v1.ast.nodes.OperatorDiceNode;
 import bjc.utils.data.ITree;
-import bjc.utils.funcdata.IList;
 import bjc.utils.data.Tree;
+import bjc.utils.funcdata.IList;
+
+import java.util.function.BinaryOperator;
 
 class ArithmeticCollapser {
-	private BinaryOperator<Integer> reducer;
-	private OperatorDiceNode type;
+	private BinaryOperator<Integer>	reducer;
+	private OperatorDiceNode	type;
 
 	public ArithmeticCollapser(BinaryOperator<Integer> reducr, OperatorDiceNode typ) {
 		reducer = reducr;
@@ -24,17 +24,14 @@ class ArithmeticCollapser {
 	public ITree<IDiceASTNode> collapse(IList<ITree<IDiceASTNode>> children) {
 		boolean allConstant = children.allMatch((subtree) -> {
 			return subtree.transformHead((node) -> {
-				if (node.getType() == DiceASTType.LITERAL) {
+				if(node.getType() == DiceASTType.LITERAL)
 					return ((ILiteralDiceNode) node).canOptimize();
-				}
 
 				return false;
 			});
 		});
 
-		if (!allConstant) {
-			return new Tree<>(type, children);
-		}
+		if(!allConstant) return new Tree<>(type, children);
 
 		int initState = DiceASTUtils.literalToInteger(children.first());
 
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 a0daf31..bf44953 100644
--- a/dice-lang/src/bjc/dicelang/v1/ast/optimization/ConstantCollapser.java
+++ b/dice-lang/src/bjc/dicelang/v1/ast/optimization/ConstantCollapser.java
@@ -6,12 +6,12 @@ import bjc.dicelang.v1.ast.nodes.IDiceASTNode;
 import bjc.dicelang.v1.ast.nodes.IntegerLiteralNode;
 import bjc.dicelang.v1.ast.nodes.OperatorDiceNode;
 import bjc.utils.data.ITree;
-import bjc.utils.funcdata.IList;
 import bjc.utils.data.Tree;
+import bjc.utils.funcdata.IList;
 
 /**
  * Collapses operations with constants to constants
- * 
+ *
  * @author ben
  *
  */
@@ -40,11 +40,9 @@ public class ConstantCollapser implements IOptimizationPass {
 
 	@Override
 	public ITree<IDiceASTNode> optimizeOperator(IDiceASTNode operator, IList<ITree<IDiceASTNode>> children) {
-		if (!operator.isOperator()) {
-			return new Tree<>(operator, children);
-		}
+		if(!operator.isOperator()) return new Tree<>(operator, children);
 
-		switch ((OperatorDiceNode) operator) {
+		switch((OperatorDiceNode) operator) {
 		case ADD:
 			return additionCollapser.collapse(children);
 		case DIVIDE:
@@ -56,22 +54,16 @@ public class ConstantCollapser implements IOptimizationPass {
 		case COMPOUND:
 			return compoundCollapser.collapse(children);
 		case GROUP:
-			if (children.getSize() != 2) {
-				return new Tree<>(operator, children);
-			}
+			if(children.getSize() != 2) return new Tree<>(operator, children);
 
 			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);
-			}
+			if(children.getSize() != 1) return new Tree<>(operator, children);
 
 			return children.first();
 		case ASSIGN:
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 b09d95d..082f042 100644
--- a/dice-lang/src/bjc/dicelang/v1/ast/optimization/IOptimizationPass.java
+++ b/dice-lang/src/bjc/dicelang/v1/ast/optimization/IOptimizationPass.java
@@ -6,14 +6,14 @@ import bjc.utils.funcdata.IList;
 
 /**
  * Represents a pass of optimizations over a dice AST
- * 
+ *
  * @author ben
  *
  */
 public interface IOptimizationPass {
 	/**
 	 * Optimize a leaf in the tree
-	 * 
+	 *
 	 * @param leafNode
 	 *                The node to optimize
 	 * @return The optimized node
@@ -22,7 +22,7 @@ public interface IOptimizationPass {
 
 	/**
 	 * Optimize an operator in an AST node
-	 * 
+	 *
 	 * @param operator
 	 *                The operator being optimized
 	 * @param 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 f00d390..7ce6f5d 100644
--- a/dice-lang/src/bjc/dicelang/v1/ast/optimization/OperationCondenser.java
+++ b/dice-lang/src/bjc/dicelang/v1/ast/optimization/OperationCondenser.java
@@ -11,14 +11,14 @@ import bjc.utils.data.Tree;
 
 /**
  * Condenses chained operations into a single level
- * 
+ *
  * @author ben
  *
  */
 public class OperationCondenser {
 	/**
 	 * Condense chained similiar operations into a single level
-	 * 
+	 *
 	 * @param ast
 	 *                The AST to condense
 	 * @return The condensed AST
@@ -33,12 +33,10 @@ public class OperationCondenser {
 		IHolder<Boolean> canCondense = new Identity<>(true);
 
 		ast.doForChildren((child) -> {
-			if (canCondense.getValue()) {
+			if(canCondense.getValue()) {
 				canCondense.replace(child.transformHead((node) -> {
-					if (node.getType() == DiceASTType.OPERATOR) {
-						if (operation.equals(node)) {
-							return true;
-						}
+					if(node.getType() == DiceASTType.OPERATOR) {
+						if(operation.equals(node)) return true;
 
 						return false;
 					}
@@ -48,14 +46,12 @@ public class OperationCondenser {
 			}
 		});
 
-		if (!canCondense.getValue()) {
-			return ast;
-		}
+		if(!canCondense.getValue()) return ast;
 
 		ITree<IDiceASTNode> condensedAST = new Tree<>(operation);
 
 		ast.doForChildren((child) -> {
-			if (child.getHead().getType() == DiceASTType.OPERATOR) {
+			if(child.getHead().getType() == DiceASTType.OPERATOR) {
 				child.doForChildren((subChild) -> {
 					condensedAST.addChild(subChild);
 				});
@@ -68,7 +64,7 @@ public class OperationCondenser {
 	}
 
 	private static TopDownTransformResult pickNode(IDiceASTNode node) {
-		switch (node.getType()) {
+		switch(node.getType()) {
 		case LITERAL:
 			return TopDownTransformResult.SKIP;
 		case OPERATOR:
@@ -81,7 +77,7 @@ public class OperationCondenser {
 	}
 
 	private static TopDownTransformResult pickOperator(OperatorDiceNode node) {
-		switch (node) {
+		switch(node) {
 		case ADD:
 		case MULTIPLY:
 		case SUBTRACT:
diff --git a/dice-lang/src/bjc/dicelang/v1/ast/optimization/package-info.java b/dice-lang/src/bjc/dicelang/v1/ast/optimization/package-info.java
index 04727d7..3c74a21 100644
--- a/dice-lang/src/bjc/dicelang/v1/ast/optimization/package-info.java
+++ b/dice-lang/src/bjc/dicelang/v1/ast/optimization/package-info.java
@@ -1,6 +1,6 @@
 /**
  * Contains optimizations on dice ASTs
- * 
+ *
  * @author ben
  *
  */