Inline constant results.

src/main/java/com/ezylang/evalex/Expression.java

···
 import java.util.*;
 import java.util.function.UnaryOperator;
 import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 /**
···
    */
   public EvaluationValue evaluateSubtree(ASTNode startNode, EvaluationContext context)
       throws EvaluationException {
-    if (startNode instanceof InlinedASTNode) {
-      return tryRoundValue(((InlinedASTNode) startNode).getValue()); // All primitives go here.
-    }
+    if (startNode instanceof InlinedASTNode) return tryRoundValue(((InlinedASTNode) startNode).getValue()); // All primitives go here.
 
     Token token = startNode.getToken();
     EvaluationValue result;
···
   private EvaluationValue getVariableOrConstant(Token token, EvaluationContext context)
       throws EvaluationException {
     EvaluationValue result = context.parameters().get(token.getValue());
+    if (result == null) {
+      result = configuration.getConstants().get(token.getValue());
+    }
     if (result == null && getDataAccessor() != null) {
       result = getDataAccessor().getData(token.getValue(), context);
     }
     if (result == null) {
-      result = configuration.getConstants().get(token.getValue());
-    }
-    if (result == null) {
       throw new EvaluationException(
           token, String.format("Variable or constant value for '%s' not found", token.getValue()));
     }
···
     }
 
     return abstractSyntaxTree;
+  }
+
+  /**
+   * Optional operation which attempts to inline nodes with constant results.<br>
+   * This method attempts to inline constant variables, functions and operators.
+   *
+   * <p>If an operator cannot be inlined, it must implement {@link
+   * OperatorIfc#inlineOperator(Expression, Token, List)} and return null. Same with functions, but
+   * {@link FunctionIfc#inlineFunction(Expression, Token, List)}.
+   *
+   * @throws ParseException If there was an issue parsing the expression.
+   * @throws EvaluationException If there was an issue inlining the expression value.
+   */
+  public void inlineAbstractSyntaxTree() throws ParseException, EvaluationException {
+    this.abstractSyntaxTree = this.inlineASTNode(this.getAbstractSyntaxTree());
+  }
+
+  private @NotNull ASTNode inlineASTNode(ASTNode node) throws EvaluationException, ParseException {
+    if (node instanceof InlinedASTNode) return node;
+
+    if (node.getParameters().isEmpty()) {
+      if (node.getToken().getType() == Token.TokenType.VARIABLE_OR_CONSTANT) {
+        if (!configuration.isAllowOverwriteConstants()) {
+          EvaluationValue constant = configuration.getConstants().get(node.getToken().getValue());
+          if (constant != null) return new InlinedASTNode(node.getToken(), constant);
+        }
+      } else if (node.getToken().getType() == Token.TokenType.FUNCTION) {
+        EvaluationValue function =
+            node.getToken()
+                .getFunctionDefinition()
+                .inlineFunction(this, node.getToken(), Collections.emptyList());
+        if (function != null) return new InlinedASTNode(node.getToken(), function);
+      }
+      return node;
+    }
+
+    List<ASTNode> result = new ArrayList<>();
+    for (ASTNode astNode : node.getParameters()) {
+      ASTNode inlineASTNode = inlineASTNode(astNode);
+      result.add(inlineASTNode);
+    }
+    if (!result.stream().allMatch(node1 -> node1 instanceof InlinedASTNode)) return node;
+    List<InlinedASTNode> parameters = (List<InlinedASTNode>) (Object) result;
+
+    switch (node.getToken().getType()) {
+      case POSTFIX_OPERATOR:
+      case PREFIX_OPERATOR:
+      case INFIX_OPERATOR:
+        EvaluationValue operator =
+            node.getToken()
+                .getOperatorDefinition()
+                .inlineOperator(this, node.getToken(), parameters);
+        if (operator != null)
+          return new InlinedASTNode(node.getToken(), operator, parameters.toArray(ASTNode[]::new));
+      case FUNCTION:
+        EvaluationValue function =
+            node.getToken()
+                .getFunctionDefinition()
+                .inlineFunction(this, node.getToken(), parameters);
+        if (function != null)
+          return new InlinedASTNode(node.getToken(), function, parameters.toArray(ASTNode[]::new));
+    }
+    return node;
   }
 
   /**

src/main/java/com/ezylang/evalex/config/ExpressionConfiguration.java

···
 */
 package com.ezylang.evalex.config;
 
+import com.ezylang.evalex.Expression;
 import com.ezylang.evalex.data.DataAccessorIfc;
 import com.ezylang.evalex.data.EvaluationValue;
 import com.ezylang.evalex.data.conversion.DefaultEvaluationValueConverter;
···
 
   /** The standard set constants for EvalEx. */
   public static final Map<String, EvaluationValue> StandardConstants =
-      getStandardConstants(() -> new TreeMap<>(String.CASE_INSENSITIVE_ORDER));
+      Collections.unmodifiableMap(
+          getStandardConstants(() -> new TreeMap<>(String.CASE_INSENSITIVE_ORDER)));
 
   /** Setting the decimal places to unlimited, will disable intermediate rounding. */
   public static final int DECIMAL_PLACES_ROUNDING_UNLIMITED = -1;
···
 
   /**
    * Default constants will be added automatically to each expression and can be used in expression
-   * evaluation.
+   * evaluation. <br>
+   * It is assumed that constant will <b>never</b> change. {@link
+   * Expression#inlineAbstractSyntaxTree()} relies on this assumption!
    */
   @Builder.Default
   private final Map<String, EvaluationValue> constants =
-      getStandardConstants(() -> new TreeMap<>(String.CASE_INSENSITIVE_ORDER));
+      Collections.unmodifiableMap(
+          getStandardConstants(() -> new TreeMap<>(String.CASE_INSENSITIVE_ORDER)));
 
   /** Support for arrays in expressions are allowed or not. */
   @Builder.Default private final boolean arraysAllowed = true;
···
    * If set to true (default), then variables can be set that have the name of a constant. In that
    * case, the constant value will be removed and a variable value will be set.
    */
-  @Builder.Default private final boolean allowOverwriteConstants = true;
+  @Builder.Default private final boolean allowOverwriteConstants = false;
 
   /** The time zone id. By default, the system default zone ID is used. */
   @Builder.Default private final ZoneId zoneId = ZoneId.systemDefault();
···
         "DT_FORMAT_LOCAL_DATE_TIME", EvaluationValue.stringValue("yyyy-MM-dd'T'HH:mm:ss[.SSS]"));
     constants.put("DT_FORMAT_LOCAL_DATE", EvaluationValue.stringValue("yyyy-MM-dd"));
 
-    return Collections.unmodifiableMap(constants);
+    return constants;
   }
 }

src/main/java/com/ezylang/evalex/functions/FunctionIfc.java

···
 import com.ezylang.evalex.EvaluationException;
 import com.ezylang.evalex.Expression;
 import com.ezylang.evalex.data.EvaluationValue;
+import com.ezylang.evalex.parser.InlinedASTNode;
+import com.ezylang.evalex.parser.ParseException;
 import com.ezylang.evalex.parser.Token;
 import java.util.List;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Interface that is required for all functions in a function dictionary for evaluation of
···
   default int getCountOfNonVarArgParameters() {
     int numOfParameters = getFunctionParameterDefinitions().size();
     return hasVarArgs() ? numOfParameters - 1 : numOfParameters;
+  }
+
+  default @Nullable EvaluationValue inlineFunction(
+      Expression expression, Token token, List<InlinedASTNode> parameters)
+      throws EvaluationException, ParseException {
+    EvaluationValue[] parsed =
+        parameters.stream().map(InlinedASTNode::getValue).toArray(EvaluationValue[]::new);
+    this.validatePreEvaluation(token, parsed);
+    return this.evaluate(expression, token, EvaluationContext.builder().build(), parsed);
   }
 }

src/main/java/com/ezylang/evalex/functions/basic/RandomFunction.java

···
 package com.ezylang.evalex.functions.basic;
 
 import com.ezylang.evalex.EvaluationContext;
+import com.ezylang.evalex.EvaluationException;
 import com.ezylang.evalex.Expression;
 import com.ezylang.evalex.data.EvaluationValue;
 import com.ezylang.evalex.functions.AbstractFunction;
+import com.ezylang.evalex.parser.InlinedASTNode;
+import com.ezylang.evalex.parser.ParseException;
 import com.ezylang.evalex.parser.Token;
 import java.security.SecureRandom;
+import java.util.List;
+import org.jetbrains.annotations.Nullable;
 
 /** Random function produces a random value between 0 and 1. */
 public class RandomFunction extends AbstractFunction {
···
     SecureRandom secureRandom = new SecureRandom();
 
     return expression.convertDoubleValue(secureRandom.nextDouble());
+  }
+
+  @Override
+  public @Nullable EvaluationValue inlineFunction(
+      Expression expression, Token token, List<InlinedASTNode> parameters)
+      throws EvaluationException, ParseException {
+    return null;
   }
 }

src/main/java/com/ezylang/evalex/functions/datetime/DateTimeNowFunction.java

···
 package com.ezylang.evalex.functions.datetime;
 
 import com.ezylang.evalex.EvaluationContext;
+import com.ezylang.evalex.EvaluationException;
 import com.ezylang.evalex.Expression;
 import com.ezylang.evalex.data.EvaluationValue;
 import com.ezylang.evalex.functions.AbstractFunction;
+import com.ezylang.evalex.parser.InlinedASTNode;
+import com.ezylang.evalex.parser.ParseException;
 import com.ezylang.evalex.parser.Token;
 import java.time.Instant;
+import java.util.List;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Produces a new DATE_TIME that represents the current date and time.
···
       EvaluationContext context,
       EvaluationValue... parameterValues) {
     return expression.convertValue(Instant.now());
+  }
+
+  @Override
+  public @Nullable EvaluationValue inlineFunction(
+      Expression expression, Token token, List<InlinedASTNode> parameters)
+      throws EvaluationException, ParseException {
+    return null;
   }
 }

src/main/java/com/ezylang/evalex/functions/datetime/DateTimeTodayFunction.java

···
 import com.ezylang.evalex.data.EvaluationValue;
 import com.ezylang.evalex.functions.AbstractFunction;
 import com.ezylang.evalex.functions.FunctionParameter;
+import com.ezylang.evalex.parser.InlinedASTNode;
+import com.ezylang.evalex.parser.ParseException;
 import com.ezylang.evalex.parser.Token;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.ZoneId;
+import java.util.List;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Produces a new DATE_TIME that represents the current date, at midnight (00:00).
···
       return ZoneIdConverter.convert(functionToken, parameterValues[0].getStringValue());
     }
     return expression.getConfiguration().getZoneId();
+  }
+
+  @Override
+  public @Nullable EvaluationValue inlineFunction(
+      Expression expression, Token token, List<InlinedASTNode> parameters)
+      throws EvaluationException, ParseException {
+    return null;
   }
 }

src/main/java/com/ezylang/evalex/operators/OperatorIfc.java

···
 import com.ezylang.evalex.Expression;
 import com.ezylang.evalex.config.ExpressionConfiguration;
 import com.ezylang.evalex.data.EvaluationValue;
+import com.ezylang.evalex.parser.InlinedASTNode;
+import com.ezylang.evalex.parser.ParseException;
 import com.ezylang.evalex.parser.Token;
+import java.util.List;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Interface that is required for all operators in an operator dictionary for evaluation of
···
       EvaluationContext context,
       EvaluationValue... operands)
       throws EvaluationException;
+
+  default @Nullable EvaluationValue inlineOperator(
+      Expression expression, Token token, List<InlinedASTNode> parameters)
+      throws EvaluationException, ParseException {
+    if (isPostfix() || isPrefix()) {
+      EvaluationValue operand = parameters.get(0).getValue();
+      return this.evaluate(expression, token, EvaluationContext.builder().build(), operand);
+    } else {
+      EvaluationValue left = parameters.get(0).getValue();
+      EvaluationValue right = parameters.get(1).getValue();
+      return this.evaluate(expression, token, EvaluationContext.builder().build(), left, right);
+    }
+  }
 }

src/test/java/com/ezylang/evalex/ExpressionEvaluatorConstantsTest.java

···
 
   @Test
   void testOverwriteConstantsWith() throws EvaluationException, ParseException {
-    Expression expression = new Expression("e");
+    Expression expression =
+        new Expression(
+            "e", ExpressionConfiguration.builder().allowOverwriteConstants(true).build());
     assertThat(expression.evaluate(builder -> builder.parameter("e", 9)).getStringValue())
         .isEqualTo("9");
   }
···
   void testOverwriteConstantsWithValues() throws EvaluationException, ParseException {
     Map<String, Object> values = new HashMap<>();
     values.put("E", 6);
-    Expression expression = new Expression("e");
+    Expression expression =
+        new Expression(
+            "e", ExpressionConfiguration.builder().allowOverwriteConstants(true).build());
     assertThat(expression.evaluate(builder -> builder.parameters(values)).getStringValue())
         .isEqualTo("6");
   }
 
   @Test
   void testOverwriteConstantsNotAllowed() {
-    Expression expression =
-        new Expression(
-            "e", ExpressionConfiguration.builder().allowOverwriteConstants(false).build());
+    Expression expression = new Expression("e");
     assertThatThrownBy(() -> expression.evaluate(builder -> builder.parameter("e", 9)))
         .isInstanceOf(UnsupportedOperationException.class)
         .hasMessage("Can't set value for constant 'e'");

src/test/java/com/ezylang/evalex/ExpressionInlineTest.java

···
+/*
+  Copyright 2012-2024 Udo Klimaschewski
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+package com.ezylang.evalex;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.ezylang.evalex.parser.InlinedASTNode;
+import com.ezylang.evalex.parser.ParseException;
+import java.math.BigDecimal;
+import java.util.function.UnaryOperator;
+import org.junit.jupiter.api.Test;
+
+public class ExpressionInlineTest extends BaseExpressionEvaluatorTest {
+
+  @Test
+  public void testSimpleInlinedExpression() throws ParseException, EvaluationException {
+    Expression expression = createExpression("2 + 2");
+    expression.inlineAbstractSyntaxTree();
+
+    assertThat(expression.evaluate(UnaryOperator.identity()).getNumberValue())
+        .isEqualTo(BigDecimal.valueOf(4));
+    assertThat(expression.getAbstractSyntaxTree()).isInstanceOf(InlinedASTNode.class);
+  }
+
+  @Test
+  public void testConstantInlinedExpression() throws ParseException, EvaluationException {
+    Expression expression = createExpression("2 + PI");
+    expression.inlineAbstractSyntaxTree();
+
+    assertThat(expression.evaluate(UnaryOperator.identity()).getNumberValue())
+        .isEqualTo(
+            BigDecimal.valueOf(2)
+                .add(
+                    new BigDecimal(
+                        "3.1415926535897932384626433832795028841971693993751058209749445923078")));
+    assertThat(expression.getAbstractSyntaxTree()).isInstanceOf(InlinedASTNode.class);
+  }
+
+  @Test
+  public void testParameterNotInlinedExpression() throws ParseException, EvaluationException {
+    Expression expression = createExpression("cheese / 2");
+    expression.inlineAbstractSyntaxTree();
+
+    assertThat(expression.evaluate(builder -> builder.parameter("cheese", 22)).getNumberValue())
+        .isEqualTo(
+            BigDecimal.valueOf(22).divide(BigDecimal.valueOf(2), configuration.getMathContext()));
+    assertThat(expression.getAbstractSyntaxTree()).isNotInstanceOf(InlinedASTNode.class);
+  }
+}

src/test/java/com/ezylang/evalex/config/ExpressionConfigurationTest.java

···
     assertThat(configuration.getDecimalPlacesRounding())
         .isEqualTo(ExpressionConfiguration.DECIMAL_PLACES_ROUNDING_UNLIMITED);
     assertThat(configuration.isStripTrailingZeros()).isTrue();
-    assertThat(configuration.isAllowOverwriteConstants()).isTrue();
+    assertThat(configuration.isAllowOverwriteConstants()).isFalse();
     assertThat(configuration.getZoneId()).isEqualTo(ZoneId.systemDefault());
     assertThat(configuration.getLocale()).isEqualTo(Locale.getDefault());
     assertThat(configuration.isSingleQuoteStringLiteralsAllowed()).isFalse();