Expressions.evaluate (binary,unary,function): Avoid explicit boxing of Booleans, Integers and Doubles

During the evaluate calls, the code previously used 'new Boolean' and 'new
Integer' constructors for the result values. By removing these allocations
and simply letting Java take care of boxing the resulting primitive
values, the integrated caching of Java can avoid creating objects in a
lot of cases (always for Boolean, and often for Integers in a certain
range).

(adapted by Joachim Klein from https://github.com/prismmodelchecker/prism/pull/91)

Tag: performance

prism/src/parser/ast/ExpressionBinaryOp.java

@@ -147,69 +147,69 @@ public class ExpressionBinaryOp extends Expression
 	{
 		switch (op) {
 		case IMPLIES:
-			return new Boolean(!operand1.evaluateBoolean(ec) || operand2.evaluateBoolean(ec));
+			return !operand1.evaluateBoolean(ec) || operand2.evaluateBoolean(ec);
 		case IFF:
-			return new Boolean(operand1.evaluateBoolean(ec) == operand2.evaluateBoolean(ec));
+			return operand1.evaluateBoolean(ec) == operand2.evaluateBoolean(ec);
 		case OR:
-			return new Boolean(operand1.evaluateBoolean(ec) || operand2.evaluateBoolean(ec));
+			return operand1.evaluateBoolean(ec) || operand2.evaluateBoolean(ec);
 		case AND:
-			return new Boolean(operand1.evaluateBoolean(ec) && operand2.evaluateBoolean(ec));
+			return operand1.evaluateBoolean(ec) && operand2.evaluateBoolean(ec);
 		case EQ:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Boolean(operand1.evaluateInt(ec) == operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) == operand2.evaluateInt(ec);
 			} else {
-				return new Boolean(operand1.evaluateDouble(ec) == operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) == operand2.evaluateDouble(ec);
 			}
 		case NE:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Boolean(operand1.evaluateInt(ec) != operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) != operand2.evaluateInt(ec);
 			} else {
-				return new Boolean(operand1.evaluateDouble(ec) != operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) != operand2.evaluateDouble(ec);
 			}
 		case GT:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Boolean(operand1.evaluateInt(ec) > operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) > operand2.evaluateInt(ec);
 			} else {
-				return new Boolean(operand1.evaluateDouble(ec) > operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) > operand2.evaluateDouble(ec);
 			}
 		case GE:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Boolean(operand1.evaluateInt(ec) >= operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) >= operand2.evaluateInt(ec);
 			} else {
-				return new Boolean(operand1.evaluateDouble(ec) >= operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) >= operand2.evaluateDouble(ec);
 			}
 		case LT:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Boolean(operand1.evaluateInt(ec) < operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) < operand2.evaluateInt(ec);
 			} else {
-				return new Boolean(operand1.evaluateDouble(ec) < operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) < operand2.evaluateDouble(ec);
 			}
 		case LE:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Boolean(operand1.evaluateInt(ec) <= operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) <= operand2.evaluateInt(ec);
 			} else {
-				return new Boolean(operand1.evaluateDouble(ec) <= operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) <= operand2.evaluateDouble(ec);
 			}
 		case PLUS:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Integer(operand1.evaluateInt(ec) + operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) + operand2.evaluateInt(ec);
 			} else {
-				return new Double(operand1.evaluateDouble(ec) + operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) + operand2.evaluateDouble(ec);
 			}
 		case MINUS:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Integer(operand1.evaluateInt(ec) - operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) - operand2.evaluateInt(ec);
 			} else {
-				return new Double(operand1.evaluateDouble(ec) - operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) - operand2.evaluateDouble(ec);
 			}
 		case TIMES:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Integer(operand1.evaluateInt(ec) * operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) * operand2.evaluateInt(ec);
 			} else {
-				return new Double(operand1.evaluateDouble(ec) * operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) * operand2.evaluateDouble(ec);
 			}
 		case DIVIDE:
-			return new Double(operand1.evaluateDouble(ec) / operand2.evaluateDouble(ec));
+			return operand1.evaluateDouble(ec) / operand2.evaluateDouble(ec);
 		}
 		throw new PrismLangException("Unknown binary operator", this);
 	}

prism/src/parser/ast/ExpressionFunc.java

@@ -231,7 +231,7 @@ public class ExpressionFunc extends Expression
 				j = getOperand(i).evaluateInt(ec);
 				iMin = (j < iMin) ? j : iMin;
 			}
-			return new Integer(iMin);
+			return iMin;
 		} else {
 			dMin = getOperand(0).evaluateDouble(ec);
 			n = getNumOperands();
@@ -239,7 +239,7 @@ public class ExpressionFunc extends Expression
 				d = getOperand(i).evaluateDouble(ec);
 				dMin = (d < dMin) ? d : dMin;
 			}
-			return new Double(dMin);
+			return dMin;
 		}
 	}
 
@@ -266,7 +266,7 @@ public class ExpressionFunc extends Expression
 				j = getOperand(i).evaluateInt(ec);
 				iMax = (j > iMax) ? j : iMax;
 			}
-			return new Integer(iMax);
+			return iMax;
 		} else {
 			dMax = getOperand(0).evaluateDouble(ec);
 			n = getNumOperands();
@@ -274,7 +274,7 @@ public class ExpressionFunc extends Expression
 				d = getOperand(i).evaluateDouble(ec);
 				dMax = (d > dMax) ? d : dMax;
 			}
-			return new Double(dMax);
+			return dMax;
 		}
 	}
 
@@ -362,9 +362,9 @@ public class ExpressionFunc extends Expression
 	{
 		try {
 			if (type instanceof TypeInt) {
-				return new Integer(evaluatePowInt(getOperand(0).evaluateInt(ec), getOperand(1).evaluateInt(ec)));
+				return evaluatePowInt(getOperand(0).evaluateInt(ec), getOperand(1).evaluateInt(ec));
 			} else {
-				return new Double(evaluatePowDouble(getOperand(0).evaluateDouble(ec), getOperand(1).evaluateDouble(ec)));
+				return evaluatePowDouble(getOperand(0).evaluateDouble(ec), getOperand(1).evaluateDouble(ec));
 			}
 		} catch (PrismLangException e) {
 			e.setASTElement(this);
@@ -408,7 +408,7 @@ public class ExpressionFunc extends Expression
 	public Object evaluateMod(EvaluateContext ec) throws PrismLangException
 	{
 		try {
-			return new Integer(evaluateMod(getOperand(0).evaluateInt(ec), getOperand(1).evaluateInt(ec)));
+			return evaluateMod(getOperand(0).evaluateInt(ec), getOperand(1).evaluateInt(ec));
 		} catch (PrismLangException e) {
 			e.setASTElement(this);
 			throw e;
@@ -439,7 +439,7 @@ public class ExpressionFunc extends Expression
 	public Object evaluateLog(EvaluateContext ec) throws PrismLangException
 	{
 		try {
-			return new Double(evaluateLog(getOperand(0).evaluateDouble(ec), getOperand(1).evaluateDouble(ec)));
+			return evaluateLog(getOperand(0).evaluateDouble(ec), getOperand(1).evaluateDouble(ec));
 		} catch (PrismLangException e) {
 			e.setASTElement(this);
 			throw e;

prism/src/parser/ast/ExpressionUnaryOp.java

@@ -120,12 +120,12 @@ public class ExpressionUnaryOp extends Expression
 	{
 		switch (op) {
 		case NOT:
-			return new Boolean(!operand.evaluateBoolean(ec));
+			return !operand.evaluateBoolean(ec);
 		case MINUS:
 			if (type instanceof TypeInt) {
-				return new Integer(-operand.evaluateInt(ec));
+				return -operand.evaluateInt(ec);
 			} else {
-				return new Double(-operand.evaluateDouble(ec));
+				return -operand.evaluateDouble(ec);
 			}
 		case PARENTH:
 			return operand.evaluate(ec);