Formatting changes

5 files changed, 35 insertions, 35 deletions

diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ArithmeticCollapser.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ArithmeticCollapser.java
index 5318119..2b2a9ad 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ArithmeticCollapser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ArithmeticCollapser.java
@@ -2,15 +2,16 @@ package bjc.dicelang.ast.optimization;
 
 import java.util.function.BinaryOperator;
 
+import bjc.utils.funcdata.IFunctionalList;
+import bjc.utils.funcdata.ITree;
+import bjc.utils.funcdata.Tree;
+
 import bjc.dicelang.ast.DiceASTUtils;
 import bjc.dicelang.ast.nodes.DiceASTType;
 import bjc.dicelang.ast.nodes.IDiceASTNode;
 import bjc.dicelang.ast.nodes.ILiteralDiceNode;
 import bjc.dicelang.ast.nodes.IntegerLiteralNode;
 import bjc.dicelang.ast.nodes.OperatorDiceNode;
-import bjc.utils.funcdata.IFunctionalList;
-import bjc.utils.funcdata.ITree;
-import bjc.utils.funcdata.Tree;
 
 class ArithmeticCollapser {
 	private BinaryOperator<Integer>	reducer;
@@ -22,8 +23,8 @@ class ArithmeticCollapser {
 		this.type = typ;
 	}
 
-	public ITree<IDiceASTNode>
-			collapse(IFunctionalList<ITree<IDiceASTNode>> children) {
+	public ITree<IDiceASTNode> collapse(
+			IFunctionalList<ITree<IDiceASTNode>> children) {
 		boolean allConstant = children.allMatch((subtree) -> {
 			return subtree.transformHead((node) -> {
 				if (node.getType() == DiceASTType.LITERAL) {
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java
index 7b746ac..63c9037 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java
@@ -1,13 +1,14 @@
 package bjc.dicelang.ast.optimization;
 
+import bjc.utils.funcdata.IFunctionalList;
+import bjc.utils.funcdata.ITree;
+import bjc.utils.funcdata.Tree;
+
 import bjc.dicelang.ComplexDice;
 import bjc.dicelang.ast.DiceASTUtils;
 import bjc.dicelang.ast.nodes.IDiceASTNode;
 import bjc.dicelang.ast.nodes.IntegerLiteralNode;
 import bjc.dicelang.ast.nodes.OperatorDiceNode;
-import bjc.utils.funcdata.IFunctionalList;
-import bjc.utils.funcdata.ITree;
-import bjc.utils.funcdata.Tree;
 
 /**
  * Collapses operations with constants to constants
@@ -16,27 +17,22 @@ import bjc.utils.funcdata.Tree;
  *
  */
 public class ConstantCollapser implements IOptimizationPass {
-	private static final ArithmeticCollapser	additionCollapser	=
-			new ArithmeticCollapser((left, right) -> left + right,
-					OperatorDiceNode.ADD);
+	private static final ArithmeticCollapser	additionCollapser	= new ArithmeticCollapser(
+			(left, right) -> left + right, OperatorDiceNode.ADD);
 
-	private static final ArithmeticCollapser	divideCollapser		=
-			new ArithmeticCollapser((left, right) -> left / right,
-					OperatorDiceNode.DIVIDE);
+	private static final ArithmeticCollapser	divideCollapser		= new ArithmeticCollapser(
+			(left, right) -> left / right, OperatorDiceNode.DIVIDE);
 
-	private static final ArithmeticCollapser	multiplyCollapser	=
-			new ArithmeticCollapser((left, right) -> left * right,
-					OperatorDiceNode.MULTIPLY);
+	private static final ArithmeticCollapser	multiplyCollapser	= new ArithmeticCollapser(
+			(left, right) -> left * right, OperatorDiceNode.MULTIPLY);
 
-	private static final ArithmeticCollapser	subtractCollapser	=
-			new ArithmeticCollapser((left, right) -> left - right,
-					OperatorDiceNode.SUBTRACT);
+	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)),
-					OperatorDiceNode.SUBTRACT);
+	private static final ArithmeticCollapser	compoundCollapser	= new ArithmeticCollapser(
+			(left, right) -> Integer.parseInt(
+					Integer.toString(left) + Integer.toString(left)),
+			OperatorDiceNode.SUBTRACT);
 
 	@Override
 	public ITree<IDiceASTNode> optimizeLeaf(IDiceASTNode leafNode) {
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/IOptimizationPass.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/IOptimizationPass.java
index b631fb5..7dbea18 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/IOptimizationPass.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/IOptimizationPass.java
@@ -1,9 +1,10 @@
 package bjc.dicelang.ast.optimization;
 
-import bjc.dicelang.ast.nodes.IDiceASTNode;
 import bjc.utils.funcdata.IFunctionalList;
 import bjc.utils.funcdata.ITree;
 
+import bjc.dicelang.ast.nodes.IDiceASTNode;
+
 /**
  * Represents a pass of optimizations over a dice AST
  * 
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/OperationCondenser.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/OperationCondenser.java
index 3988d2a..bdf7b04 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/OperationCondenser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/OperationCondenser.java
@@ -1,14 +1,15 @@
 package bjc.dicelang.ast.optimization;
 
-import bjc.dicelang.ast.nodes.DiceASTType;
-import bjc.dicelang.ast.nodes.IDiceASTNode;
-import bjc.dicelang.ast.nodes.OperatorDiceNode;
 import bjc.utils.data.IHolder;
 import bjc.utils.data.Identity;
 import bjc.utils.funcdata.ITree;
 import bjc.utils.funcdata.TopDownTransformResult;
 import bjc.utils.funcdata.Tree;
 
+import bjc.dicelang.ast.nodes.DiceASTType;
+import bjc.dicelang.ast.nodes.IDiceASTNode;
+import bjc.dicelang.ast.nodes.OperatorDiceNode;
+
 /**
  * Condenses chained operations into a single level
  * 
@@ -42,8 +43,8 @@ public class OperationCondenser {
 		}
 	}
 
-	private static TopDownTransformResult
-			pickOperator(OperatorDiceNode node) {
+	private static TopDownTransformResult pickOperator(
+			OperatorDiceNode node) {
 		switch (node) {
 			case ADD:
 			case MULTIPLY:
@@ -62,10 +63,10 @@ public class OperationCondenser {
 		}
 	}
 
-	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);
 
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/package-info.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/package-info.java
index a3ec93c..6f75bf9 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/package-info.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/package-info.java
@@ -1,5 +1,6 @@
 /**
  * Contains optimizations on dice ASTs
+ * 
  * @author ben
  *
  */