Remove inlining and replace ASTNode with Solvable in expressions.

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

···
 import com.ezylang.evalex.config.ExpressionConfiguration;
 import com.ezylang.evalex.data.DataAccessorIfc;
 import com.ezylang.evalex.data.EvaluationValue;
-import com.ezylang.evalex.data.IndexedAccessor;
-import com.ezylang.evalex.data.types.ExpressionNodeValue;
 import com.ezylang.evalex.data.types.NumberValue;
-import com.ezylang.evalex.functions.FunctionIfc;
-import com.ezylang.evalex.operators.OperatorIfc;
 import com.ezylang.evalex.parser.*;
 import java.math.BigDecimal;
-import java.util.*;
 import java.util.function.UnaryOperator;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
···
   private final ExpressionConfiguration configuration;
   private final String expressionString;
   private final @Nullable DataAccessorIfc dataAccessor;
-  private final ASTNode abstractSyntaxTree;
+  private final Solvable solvable;
 
   /**
    * Creates a new expression with a custom configuration. The expression is not parsed until it is
···
    * @param expressionString A string holding an expression.
    */
   public Expression(
-      String expressionString, ASTNode abstractSyntaxTree, ExpressionConfiguration configuration) {
+      String expressionString, Solvable solvable, ExpressionConfiguration configuration) {
     this.expressionString = expressionString;
-    this.abstractSyntaxTree = abstractSyntaxTree;
+    this.solvable = solvable;
     this.configuration = configuration;
     this.dataAccessor = configuration.getDataAccessorSupplier().get();
   }
···
    * @throws EvaluationException If there were problems while evaluating the expression.
    */
   public EvaluationValue evaluate(EvaluationContext context) throws EvaluationException {
-    EvaluationValue result = evaluateSubtree(getAbstractSyntaxTree(), context);
+    EvaluationValue result = evaluateSubtree(this.getSolvable(), context);
     if (result.isNumberValue()) {
       BigDecimal bigDecimal = result.getNumberValue();
       if (configuration.getDecimalPlacesResult()
···
   }
 
   public EvaluationValue evaluateSubtree(
-      ASTNode startNode, UnaryOperator<EvaluationContext.EvaluationContextBuilder> builder)
+      Solvable solvable, UnaryOperator<EvaluationContext.EvaluationContextBuilder> builder)
       throws EvaluationException {
-    return this.evaluateSubtree(startNode, builder.apply(EvaluationContext.builder(this)).build());
+    return this.evaluateSubtree(solvable, builder.apply(EvaluationContext.builder(this)).build());
   }
 
   /**
    * Evaluates only a subtree of the abstract syntax tree.
    *
-   * @param startNode The {@link ASTNode} to start evaluation from.
+   * @param solvable The {@link Solvable} to start evaluation from.
    * @return The evaluation result value.
    * @throws EvaluationException If there were problems while evaluating the expression.
    */
-  public EvaluationValue evaluateSubtree(ASTNode startNode, EvaluationContext context)
+  public EvaluationValue evaluateSubtree(Solvable solvable, EvaluationContext context)
       throws EvaluationException {
-    if (startNode instanceof InlinedASTNode)
-      return tryRoundValue(((InlinedASTNode) startNode).value()); // All primitives go here.
-
-    Token token = startNode.getToken();
-    return tryRoundValue(
-        switch (token.getType()) {
-          case VARIABLE_OR_CONSTANT -> {
-            var result = getVariableOrConstant(token, context);
-            if (result.isExpressionNode()) {
-              yield evaluateSubtree(result.getExpressionNode(), context);
-            }
-            yield result;
-          }
-          case PREFIX_OPERATOR, POSTFIX_OPERATOR -> token
-              .getOperatorDefinition()
-              .evaluate(context, token, evaluateSubtree(startNode.getParameters()[0], context));
-          case INFIX_OPERATOR -> evaluateInfixOperator(startNode, token, context);
-          case ARRAY_INDEX -> evaluateArrayIndex(startNode, context);
-          case STRUCTURE_SEPARATOR -> evaluateStructureSeparator(startNode, context);
-          case FUNCTION -> evaluateFunction(startNode, token, context);
-          default -> throw new EvaluationException(token, "Unexpected evaluation token: " + token);
-        });
+    return solvable.solve(context);
   }
 
   public EvaluationValue tryRoundValue(EvaluationValue value) {
···
     return value;
   }
 
-  private EvaluationValue getVariableOrConstant(Token token, EvaluationContext context)
+  public EvaluationValue getVariableOrConstant(Token token, EvaluationContext context)
       throws EvaluationException {
     EvaluationValue result = context.parameters().get(token.getValue());
     if (result == null) {
···
     return result;
   }
 
-  private EvaluationValue evaluateFunction(
-      ASTNode startNode, Token token, EvaluationContext context) throws EvaluationException {
-    EvaluationValue[] parameters;
-
-    if (startNode.getParameters().length == 0) {
-      parameters = EvaluationValue.EMPTY;
-    } else {
-      parameters = new EvaluationValue[startNode.getParameters().length];
-      for (int i = 0; i < startNode.getParameters().length; i++) {
-        if (token.getFunctionDefinition().isParameterLazy(i)) {
-          parameters[i] = ExpressionNodeValue.of(startNode.getParameters()[i]);
-        } else {
-          parameters[i] = evaluateSubtree(startNode.getParameters()[i], context);
-        }
-      }
-    }
-
-    FunctionIfc function = token.getFunctionDefinition();
-    function.validatePreEvaluation(token, parameters);
-    return function.evaluate(context, token, parameters);
-  }
-
-  private EvaluationValue evaluateArrayIndex(ASTNode startNode, EvaluationContext context)
-      throws EvaluationException {
-    EvaluationValue array = evaluateSubtree(startNode.getParameters()[0], context);
-    EvaluationValue index = evaluateSubtree(startNode.getParameters()[1], context);
-
-    if (array instanceof IndexedAccessor accessor && index.isNumberValue()) {
-      var result = accessor.getIndexedData(index.getNumberValue(), startNode.getToken(), context);
-      if (result == null)
-        throw new EvaluationException(
-            startNode.getToken(),
-            String.format(
-                "Index %s out of bounds for %s %s",
-                index.getNumberValue(), array.getClass().getSimpleName(), array.getValue()));
-      return result;
-    }
-    throw EvaluationException.ofUnsupportedDataTypeInOperation(startNode.getToken());
-  }
-
-  private EvaluationValue evaluateStructureSeparator(ASTNode startNode, EvaluationContext context)
-      throws EvaluationException {
-    EvaluationValue structure = evaluateSubtree(startNode.getParameters()[0], context);
-    Token nameToken = startNode.getParameters()[1].getToken();
-    String name = nameToken.getValue();
-
-    if (structure instanceof DataAccessorIfc accessor) {
-      var result = accessor.getVariableData(name, nameToken, context);
-      if (result == null)
-        throw new EvaluationException(
-            nameToken,
-            String.format(
-                "Field '%s' not found in %s", name, structure.getClass().getSimpleName()));
-      return result;
-    }
-    throw EvaluationException.ofUnsupportedDataTypeInOperation(startNode.getToken());
-  }
-
-  private EvaluationValue evaluateInfixOperator(
-      ASTNode startNode, Token token, EvaluationContext context) throws EvaluationException {
-    EvaluationValue left;
-    EvaluationValue right;
-
-    OperatorIfc op = token.getOperatorDefinition();
-    if (op.isOperandLazy()) {
-      left = ExpressionNodeValue.of(startNode.getParameters()[0]);
-      right = ExpressionNodeValue.of(startNode.getParameters()[1]);
-    } else {
-      left = evaluateSubtree(startNode.getParameters()[0], context);
-      right = evaluateSubtree(startNode.getParameters()[1], context);
-    }
-    return op.evaluate(context, token, left, right);
-  }
-
   /**
    * Rounds the given value.
    *
···
    * @return The copied Expression instance.
    */
   public Expression copy() {
-    return new Expression(getExpressionString(), getAbstractSyntaxTree(), getConfiguration());
+    return new Expression(getExpressionString(), getSolvable(), getConfiguration());
   }
 
   /**
···
    */
   public EvaluationValue convertValue(Object value) {
     return EvaluationValue.of(value, configuration);
-  }
-
-  /**
-   * Returns the list of all nodes of the abstract syntax tree.
-   *
-   * @return The list of all nodes in the parsed expression.
-   */
-  public List<ASTNode> getAllASTNodes() {
-    return getAllASTNodesForNode(getAbstractSyntaxTree());
-  }
-
-  private List<ASTNode> getAllASTNodesForNode(ASTNode node) {
-    List<ASTNode> nodes = new ArrayList<>();
-    nodes.add(node);
-    for (ASTNode child : node.getParameters()) {
-      nodes.addAll(getAllASTNodesForNode(child));
-    }
-    return nodes;
-  }
-
-  /**
-   * Returns all variables that are used i the expression, excluding the constants like e.g. <code>
-   * PI</code> or <code>TRUE</code> and <code>FALSE</code>.
-   *
-   * @return All used variables excluding constants.
-   */
-  public Set<String> getUsedVariables() {
-    Set<String> variables = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
-
-    for (ASTNode node : getAllASTNodes()) {
-      if (node.getToken().getType() == Token.TokenType.VARIABLE_OR_CONSTANT
-          && !configuration.getConstants().containsKey(node.getToken().getValue())) {
-        variables.add(node.getToken().getValue());
-      }
-    }
-
-    return variables;
   }
 }

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;
···
 import com.ezylang.evalex.operators.OperatorIfc;
 import com.ezylang.evalex.operators.arithmetic.*;
 import com.ezylang.evalex.operators.booleans.*;
-import com.ezylang.evalex.parser.ASTNode;
 import com.ezylang.evalex.parser.ExpressionParser;
 import java.math.BigDecimal;
 import java.math.MathContext;
···
   /**
    * Default constants will be added automatically to each expression and can be used in expression
    * evaluation. <br>
-   * It is assumed that constant will <b>never</b> change. {@link
-   * ExpressionParser#inlineASTNode(Expression, ASTNode)} relies on this assumption!
+   * It is assumed that constant will <b>never</b> change.
    */
   @Builder.Default
   private final Map<String, EvaluationValue> constants =

src/main/java/com/ezylang/evalex/data/EvaluationValue.java

···
 package com.ezylang.evalex.data;
 
 import com.ezylang.evalex.config.ExpressionConfiguration;
-import com.ezylang.evalex.data.types.ExpressionNodeValue;
-import com.ezylang.evalex.parser.ASTNode;
+import com.ezylang.evalex.data.types.SolvableValue;
+import com.ezylang.evalex.parser.Solvable;
 import java.math.BigDecimal;
 import java.time.Duration;
 import java.time.Instant;
···
     return false;
   }
 
-  default boolean isExpressionNode() {
+  default boolean isSolvable() {
     return false;
   }
 
···
     return Collections.emptyMap();
   }
 
-  default DataAccessorIfc getDataAccessorValue() {
-    return null;
-  }
-
   /**
-   * Gets the expression node, if this value is of type {@link ExpressionNodeValue}.
+   * Gets the {@link Solvable}, if this value is of type {@link SolvableValue}.
    *
-   * @return The expression node, or null for any other data type.
+   * @return The solvable, or null for any other data type.
    */
-  default ASTNode getExpressionNode() {
+  default Solvable getSolvable() {
     return null;
   }
 

src/main/java/com/ezylang/evalex/data/conversion/DefaultEvaluationValueConverter.java

···
 import com.ezylang.evalex.config.ExpressionConfiguration;
 import com.ezylang.evalex.data.EvaluationValue;
 import com.ezylang.evalex.data.types.NullValue;
-import com.ezylang.evalex.parser.ASTNode;
-import com.ezylang.evalex.parser.InlinedASTNode;
+import com.ezylang.evalex.parser.Solvable;
 import java.math.BigDecimal;
 import java.time.Duration;
 import java.time.Instant;
···
   public static final BooleanConverter BOOLEAN_CONVERTER = new BooleanConverter();
   public static final DateTimeConverter DATE_TIME_CONVERTER = new DateTimeConverter();
   public static final DurationConverter DURATION_CONVERTER = new DurationConverter();
-  public static final ExpressionNodeConverter EXPRESSION_NODE_CONVERTER =
-      new ExpressionNodeConverter();
+  public static final SolvableConverter SOLVABLE_CONVERTER = new SolvableConverter();
   public static final ArrayConverter ARRAY_CONVERTER = new ArrayConverter();
   public static final StructureConverter STRUCTURE_CONVERTER = new StructureConverter();
 
···
           BOOLEAN_CONVERTER,
           DATE_TIME_CONVERTER,
           DURATION_CONVERTER,
-          EXPRESSION_NODE_CONVERTER,
+          SOLVABLE_CONVERTER,
           ARRAY_CONVERTER,
           STRUCTURE_CONVERTER);
 
···
 
     fastPath.put(Duration.class, DURATION_CONVERTER);
 
-    fastPath.put(ASTNode.class, EXPRESSION_NODE_CONVERTER);
-    fastPath.put(InlinedASTNode.class, EXPRESSION_NODE_CONVERTER);
+    fastPath.put(Solvable.class, SOLVABLE_CONVERTER);
 
     fastPath.put(List.class, ARRAY_CONVERTER);
     fastPath.put(Object[].class, ARRAY_CONVERTER);

src/main/java/com/ezylang/evalex/data/conversion/ExpressionNodeConverter.java src/main/java/com/ezylang/evalex/data/conversion/SolvableConverter.java

···
 
 import com.ezylang.evalex.config.ExpressionConfiguration;
 import com.ezylang.evalex.data.EvaluationValue;
-import com.ezylang.evalex.data.types.ExpressionNodeValue;
-import com.ezylang.evalex.parser.ASTNode;
+import com.ezylang.evalex.data.types.SolvableValue;
+import com.ezylang.evalex.parser.Solvable;
 
-/** Converter to convert to the EXPRESSION_NODE data type. */
-public class ExpressionNodeConverter implements ConverterIfc {
+/** Converter to convert to the {@link SolvableValue} data type. */
+public class SolvableConverter implements ConverterIfc {
   @Override
   public EvaluationValue convert(Object object, ExpressionConfiguration configuration) {
-    return ExpressionNodeValue.of((ASTNode) object);
+    return SolvableValue.of((Solvable) object);
   }
 
   @Override
   public boolean canConvert(Object object) {
-    return object instanceof ASTNode;
+    return object instanceof Solvable;
   }
 }

src/main/java/com/ezylang/evalex/data/types/ExpressionNodeValue.java src/main/java/com/ezylang/evalex/data/types/SolvableValue.java

···
 package com.ezylang.evalex.data.types;
 
 import com.ezylang.evalex.data.EvaluationValue;
-import com.ezylang.evalex.parser.ASTNode;
+import com.ezylang.evalex.parser.Solvable;
 import lombok.*;
 
 @ToString()
 @EqualsAndHashCode(callSuper = false)
 @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
-public final class ExpressionNodeValue implements EvaluationValue {
+public class SolvableValue implements EvaluationValue {
 
-  private final ASTNode value;
+  private final Solvable value;
 
-  public static ExpressionNodeValue of(@NonNull ASTNode node) {
-    return new ExpressionNodeValue(node);
+  public static SolvableValue of(@NonNull Solvable node) {
+    return new SolvableValue(node);
   }
 
   @Override
···
   }
 
   @Override
-  public boolean isExpressionNode() {
+  public boolean isSolvable() {
     return true;
   }
 
   @Override
-  public ASTNode getExpressionNode() {
+  public Solvable getSolvable() {
     return value;
   }
 }

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

···
 
 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.data.types.ExpressionNodeValue;
-import com.ezylang.evalex.parser.ASTNode;
-import com.ezylang.evalex.parser.InlinedASTNode;
 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 boolean forceInline() {
-    return false;
-  }
-
-  default @Nullable EvaluationValue inlineFunction(
-      Expression expression, Token token, ASTNode... parameters) throws EvaluationException {
-
-    EvaluationValue[] parsed;
-    if (parameters.length == 0) {
-      parsed = EvaluationValue.EMPTY;
-    } else {
-      parsed = new EvaluationValue[parameters.length];
-      for (int i = 0; i < parameters.length; i++) {
-        if (token.getFunctionDefinition().isParameterLazy(i)) {
-          parsed[i] = ExpressionNodeValue.of(parameters[i]);
-        } else {
-          parsed[i] = ((InlinedASTNode) parameters[i]).value();
-        }
-      }
-    }
-
-    this.validatePreEvaluation(token, parsed);
-    return this.evaluate(EvaluationContext.builder(expression).build(), token, parsed);
   }
 }

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

···
       EvaluationContext context, Token functionToken, EvaluationValue... parameterValues)
       throws EvaluationException {
     if (Boolean.TRUE.equals(parameterValues[0].getBooleanValue())) {
-      return context.expression().evaluateSubtree(parameterValues[1].getExpressionNode(), context);
+      return context.expression().evaluateSubtree(parameterValues[1].getSolvable(), context);
     } else {
-      return context.expression().evaluateSubtree(parameterValues[2].getExpressionNode(), context);
+      return context.expression().evaluateSubtree(parameterValues[2].getSolvable(), context);
     }
   }
 }

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.Expression;
 import com.ezylang.evalex.data.EvaluationValue;
 import com.ezylang.evalex.functions.AbstractFunction;
-import com.ezylang.evalex.parser.ASTNode;
 import com.ezylang.evalex.parser.Token;
 import java.security.SecureRandom;
-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 context.expression().convertDoubleValue(secureRandom.nextDouble());
-  }
-
-  @Override
-  public @Nullable EvaluationValue inlineFunction(
-      Expression expression, Token token, ASTNode... parameters) {
-    return null;
   }
 }

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

···
   private EvaluationValue evaluateParameter(
       Expression expression, EvaluationValue parameter, EvaluationContext context)
       throws EvaluationException {
-    return parameter.isExpressionNode()
-        ? expression.evaluateSubtree(parameter.getExpressionNode(), context)
+    return parameter.isSolvable()
+        ? expression.evaluateSubtree(parameter.getSolvable(), context)
         : parameter;
   }
 }

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.Expression;
 import com.ezylang.evalex.data.EvaluationValue;
 import com.ezylang.evalex.data.types.DateTimeValue;
 import com.ezylang.evalex.functions.AbstractFunction;
-import com.ezylang.evalex.parser.ASTNode;
 import com.ezylang.evalex.parser.Token;
 import java.time.Instant;
-import org.jetbrains.annotations.Nullable;
 
 /**
  * Produces a new DATE_TIME that represents the current date and time.
···
   public EvaluationValue evaluate(
       EvaluationContext context, Token functionToken, EvaluationValue... parameterValues) {
     return DateTimeValue.of(Instant.now());
-  }
-
-  @Override
-  public @Nullable EvaluationValue inlineFunction(
-      Expression expression, Token token, ASTNode... parameters) {
-    return null;
   }
 }

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

···
 import com.ezylang.evalex.data.types.DateTimeValue;
 import com.ezylang.evalex.functions.AbstractFunction;
 import com.ezylang.evalex.functions.FunctionParameter;
-import com.ezylang.evalex.parser.ASTNode;
 import com.ezylang.evalex.parser.Token;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.ZoneId;
-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, ASTNode... parameters) {
-    return null;
   }
 }

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

···
 
 import com.ezylang.evalex.EvaluationContext;
 import com.ezylang.evalex.EvaluationException;
-import com.ezylang.evalex.Expression;
 import com.ezylang.evalex.config.ExpressionConfiguration;
 import com.ezylang.evalex.data.EvaluationValue;
-import com.ezylang.evalex.data.types.ExpressionNodeValue;
-import com.ezylang.evalex.parser.ASTNode;
-import com.ezylang.evalex.parser.InlinedASTNode;
 import com.ezylang.evalex.parser.Token;
-import org.jetbrains.annotations.Nullable;
 
 /**
  * Interface that is required for all operators in an operator dictionary for evaluation of
···
   EvaluationValue evaluate(
       EvaluationContext context, Token operatorToken, EvaluationValue... operands)
       throws EvaluationException;
-
-  default boolean forceInline() {
-    return false;
-  }
-
-  default @Nullable EvaluationValue inlineOperator(
-      Expression expression, Token token, ASTNode... parameters) throws EvaluationException {
-    EvaluationValue left =
-        this.isOperandLazy()
-            ? ExpressionNodeValue.of(parameters[0])
-            : ((InlinedASTNode) parameters[0]).value();
-    if (isPostfix() || isPrefix()) {
-      return this.evaluate(EvaluationContext.builder(expression).build(), token, left);
-    } else {
-      EvaluationValue right =
-          this.isOperandLazy()
-              ? ExpressionNodeValue.of(parameters[1])
-              : ((InlinedASTNode) parameters[1]).value();
-      return this.evaluate(EvaluationContext.builder(expression).build(), token, left, right);
-    }
-  }
 }

src/main/java/com/ezylang/evalex/operators/booleans/InfixAndOperator.java

···
       EvaluationContext context, Token operatorToken, EvaluationValue... operands)
       throws EvaluationException {
     return BooleanValue.of(
-        context
-                .expression()
-                .evaluateSubtree(operands[0].getExpressionNode(), context)
-                .getBooleanValue()
+        context.expression().evaluateSubtree(operands[0].getSolvable(), context).getBooleanValue()
             && context
                 .expression()
-                .evaluateSubtree(operands[1].getExpressionNode(), context)
+                .evaluateSubtree(operands[1].getSolvable(), context)
                 .getBooleanValue());
   }
 }

src/main/java/com/ezylang/evalex/operators/booleans/InfixOrOperator.java

···
       EvaluationContext context, Token operatorToken, EvaluationValue... operands)
       throws EvaluationException {
     return BooleanValue.of(
-        context
-                .expression()
-                .evaluateSubtree(operands[0].getExpressionNode(), context)
-                .getBooleanValue()
+        context.expression().evaluateSubtree(operands[0].getSolvable(), context).getBooleanValue()
             || context
                 .expression()
-                .evaluateSubtree(operands[1].getExpressionNode(), context)
+                .evaluateSubtree(operands[1].getSolvable(), context)
                 .getBooleanValue());
   }
 }

src/main/java/com/ezylang/evalex/parser/ExpressionParser.java

···
 import com.ezylang.evalex.EvaluationException;
 import com.ezylang.evalex.Expression;
 import com.ezylang.evalex.config.ExpressionConfiguration;
+import com.ezylang.evalex.data.DataAccessorIfc;
 import com.ezylang.evalex.data.EvaluationValue;
+import com.ezylang.evalex.data.IndexedAccessor;
+import com.ezylang.evalex.data.types.SolvableValue;
 import com.ezylang.evalex.functions.FunctionIfc;
 import com.ezylang.evalex.operators.OperatorIfc;
-import java.util.Arrays;
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
 
 @Getter
 public final class ExpressionParser {
···
   public Expression parse(String expression) throws ParseException {
     return new Expression(
         expression,
-        converter.toAbstractSyntaxTree(tokenizer.parse(expression), expression),
+        this.toSolvable(converter.toAbstractSyntaxTree(tokenizer.parse(expression), expression)),
         configuration);
   }
 
-  public Expression parseAndInline(String expression) throws ParseException, EvaluationException {
-    Expression result = this.parse(expression);
-    return new Expression(
-        expression, this.inlineASTNode(result, result.getAbstractSyntaxTree()), configuration);
+  public Solvable toSolvable(ASTNode node) {
+    if (node instanceof InlinedASTNode inlined)
+      return context -> context.expression().tryRoundValue(inlined.value());
+
+    Token token = node.getToken();
+    Solvable value =
+        switch (token.getType()) {
+          case VARIABLE_OR_CONSTANT -> context -> {
+            var result = context.expression().getVariableOrConstant(token, context);
+            if (result.isSolvable()) return result.getSolvable().solve(context);
+            return result;
+          };
+          case PREFIX_OPERATOR, POSTFIX_OPERATOR -> {
+            OperatorIfc operator = token.getOperatorDefinition();
+            Solvable solvable = toSolvable(node.getParameters()[0]);
+            yield context -> operator.evaluate(context, token, solvable.solve(context));
+          }
+          case INFIX_OPERATOR -> infixOperatorToSolvable(node);
+          case ARRAY_INDEX -> arrayIndexToSolvable(node);
+          case STRUCTURE_SEPARATOR -> structureSeparatorToSolvable(node);
+          case FUNCTION -> functionToSolvable(node);
+          default -> throw new IllegalStateException("Unexpected evaluation token: " + token);
+        };
+    return context -> context.expression().tryRoundValue(value.solve(context));
   }
 
-  public Expression inlineExpression(Expression expression) throws EvaluationException {
-    return new Expression(
-        expression.getExpressionString(),
-        this.inlineASTNode(expression, expression.getAbstractSyntaxTree()),
-        expression.getConfiguration());
+  private Solvable infixOperatorToSolvable(ASTNode node) {
+    Token token = node.getToken();
+    OperatorIfc operator = token.getOperatorDefinition();
+
+    Solvable left;
+    Solvable right;
+    if (operator.isOperandLazy()) {
+      var first = SolvableValue.of(toSolvable(node.getParameters()[0]));
+      var second = SolvableValue.of(toSolvable(node.getParameters()[1]));
+      left = context -> first;
+      right = context -> second;
+    } else {
+      left = toSolvable(node.getParameters()[0]);
+      right = toSolvable(node.getParameters()[1]);
+    }
+    return context -> operator.evaluate(context, token, left.solve(context), right.solve(context));
   }
 
-  /**
-   * 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, ASTNode...)} and return null. Same with
-   * functions, but {@link FunctionIfc#inlineFunction(Expression, Token, ASTNode...)}.
-   *
-   * @return New {@link InlinedASTNode} or {@link ASTNode} if inlining was unsuccessful.
-   */
-  public @NotNull ASTNode inlineASTNode(Expression owner, ASTNode node) {
-    if (node instanceof InlinedASTNode) return node;
-    var token = node.getToken();
+  private Solvable arrayIndexToSolvable(ASTNode node) {
+    Token token = node.getToken();
 
-    if (node.getParameters().length == 0) {
-      if (token.getType() == Token.TokenType.VARIABLE_OR_CONSTANT) {
-        if (!owner.getConfiguration().isAllowOverwriteConstants()) {
-          EvaluationValue constant = owner.getConfiguration().getConstants().get(token.getValue());
-          if (constant != null) return InlinedASTNode.of(token, owner.tryRoundValue(constant));
-        }
-      } else if (token.getType() == Token.TokenType.FUNCTION
-          && token.getFunctionDefinition().forceInline()) {
-        try {
-          EvaluationValue function = token.getFunctionDefinition().inlineFunction(owner, token);
-          if (function != null) return InlinedASTNode.of(token, owner.tryRoundValue(function));
-        } catch (Exception e) {
-          return node;
-        }
+    Solvable solvableArray = toSolvable(node.getParameters()[0]);
+    Solvable solvableIndex = toSolvable(node.getParameters()[1]);
+
+    return context -> {
+      var array = solvableArray.solve(context);
+      var index = solvableIndex.solve(context);
+
+      if (array instanceof IndexedAccessor accessor && index.isNumberValue()) {
+        var result = accessor.getIndexedData(index.getNumberValue(), token, context);
+        if (result == null)
+          throw new EvaluationException(
+              token,
+              String.format(
+                  "Index %s out of bounds for %s %s",
+                  index.getNumberValue(), array.getClass().getSimpleName(), array.getValue()));
+        return result;
       }
-      return node;
-    }
+      throw EvaluationException.ofUnsupportedDataTypeInOperation(token);
+    };
+  }
 
-    ASTNode[] parameters = node.getParameters();
-    for (int i = 0; i < node.getParameters().length; i++) {
-      parameters[i] = inlineASTNode(owner, parameters[i]);
-    }
-    boolean allMatch = Arrays.stream(parameters).allMatch(node1 -> node1 instanceof InlinedASTNode);
+  private Solvable structureSeparatorToSolvable(ASTNode startNode) {
+    Solvable solvableStructure = toSolvable(startNode.getParameters()[0]);
+    Token nameToken = startNode.getParameters()[1].getToken();
+    String name = nameToken.getValue();
 
-    switch (token.getType()) {
-      case POSTFIX_OPERATOR, PREFIX_OPERATOR, INFIX_OPERATOR -> {
-        var operator = token.getOperatorDefinition();
-        if (!allMatch && !operator.forceInline()) return node;
-        try {
-          var result = operator.inlineOperator(owner, token, parameters.clone());
-          if (result != null)
-            return InlinedASTNode.of(token, owner.tryRoundValue(result), parameters);
-        } catch (Exception e) {
-          return node;
-        }
+    return context -> {
+      EvaluationValue structure = solvableStructure.solve(context);
+      if (structure instanceof DataAccessorIfc accessor) {
+        var result = accessor.getVariableData(name, nameToken, context);
+        if (result == null)
+          throw new EvaluationException(
+              nameToken,
+              String.format(
+                  "Field '%s' not found in %s", name, structure.getClass().getSimpleName()));
+        return result;
       }
-      case FUNCTION -> {
-        var function = token.getFunctionDefinition();
-        if (!allMatch && !function.forceInline()) return node;
-        try {
-          var result = function.inlineFunction(owner, token, parameters.clone());
-          if (result != null)
-            return InlinedASTNode.of(token, owner.tryRoundValue(result), parameters);
-        } catch (Exception e) {
-          return node;
+      throw EvaluationException.ofUnsupportedDataTypeInOperation(startNode.getToken());
+    };
+  }
+
+  private Solvable functionToSolvable(ASTNode node) {
+    Token token = node.getToken();
+    FunctionIfc function = token.getFunctionDefinition();
+    Solvable[] solvables;
+
+    if (node.getParameters().length == 0) {
+      solvables = new Solvable[0];
+    } else {
+      solvables = new Solvable[node.getParameters().length];
+      for (int i = 0; i < node.getParameters().length; i++) {
+        if (function.isParameterLazy(i)) {
+          var unwrapped = SolvableValue.of(toSolvable(node.getParameters()[i]));
+          solvables[i] = context -> unwrapped;
+        } else {
+          solvables[i] = toSolvable(node.getParameters()[i]);
         }
       }
     }
-    return node;
+
+    return context -> {
+      EvaluationValue[] parameters = new EvaluationValue[solvables.length];
+      for (int i = 0; i < solvables.length; i++) {
+        parameters[i] = solvables[i].solve(context);
+      }
+      function.validatePreEvaluation(token, parameters);
+      return function.evaluate(context, token, parameters);
+    };
   }
 }

src/main/java/com/ezylang/evalex/parser/Solvable.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.parser;
+
+import com.ezylang.evalex.EvaluationContext;
+import com.ezylang.evalex.EvaluationException;
+import com.ezylang.evalex.data.EvaluationValue;
+
+public interface Solvable {
+  EvaluationValue solve(EvaluationContext context) throws EvaluationException;
+}

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

···
   protected EvaluationValue evaluate(String expressionString)
       throws EvaluationException, ParseException {
     Expression expression =
-        TestConfigurationProvider.StandardParserWithAdditionalTestOperators.parseAndInline(
-            expressionString);
+        TestConfigurationProvider.StandardParserWithAdditionalTestOperators.parse(expressionString);
     return expression.evaluate(EvaluationContext.builder(expression).build());
   }
 
   private EvaluationValue evaluate(String expressionString, ExpressionConfiguration configuration)
       throws EvaluationException, ParseException {
     ExpressionParser parser = new ExpressionParser(configuration);
-    Expression expression = parser.parseAndInline(expressionString);
+    Expression expression = parser.parse(expressionString);
 
     return expression.evaluate(EvaluationContext.builder(expression).build());
   }

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

···
 import com.ezylang.evalex.parser.ParseException;
 import com.ezylang.evalex.parser.Token;
 import com.ezylang.evalex.parser.Token.TokenType;
-import java.util.function.UnaryOperator;
 import org.junit.jupiter.api.Test;
 
 class ExpressionEvaluationExceptionsTest {
···
     assertThatThrownBy(
             () -> {
               ASTNode node = ASTNode.of(new Token(1, "(", TokenType.BRACE_OPEN));
-              expression.evaluateSubtree(node, UnaryOperator.identity());
+              ExpressionConfiguration.defaultExpressionParser().toSolvable(node);
             })
-        .isInstanceOf(EvaluationException.class)
+        .isInstanceOf(IllegalStateException.class)
         .hasMessage(
             "Unexpected evaluation token: Token(startPosition=1, value=(, type=BRACE_OPEN)");
   }

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 testInlinedExpression() throws ParseException, EvaluationException {
-    Expression expression = parser.inlineExpression(createExpression("2 + 2"));
-
-    assertThat(expression.evaluate(UnaryOperator.identity()).getStringValue())
-        .isEqualTo(BigDecimal.valueOf(4).toPlainString());
-    assertThat(expression.getAbstractSyntaxTree()).isInstanceOf(InlinedASTNode.class);
-  }
-
-  @Test
-  public void testInlinedConstant() throws ParseException, EvaluationException {
-    Expression expression = parser.inlineExpression(createExpression("2 + PI"));
-
-    assertThat(expression.evaluate(UnaryOperator.identity()).getStringValue())
-        .isEqualTo(
-            BigDecimal.valueOf(2)
-                .add(
-                    new BigDecimal(
-                        "3.1415926535897932384626433832795028841971693993751058209749445923078"))
-                .toPlainString());
-    assertThat(expression.getAbstractSyntaxTree()).isInstanceOf(InlinedASTNode.class);
-  }
-
-  @Test
-  public void testNotInlinedParameter() throws ParseException, EvaluationException {
-    Expression expression = parser.inlineExpression(createExpression("cheese / 2"));
-
-    assertThat(expression.evaluate(builder -> builder.parameter("cheese", 22)).getStringValue())
-        .isEqualTo(
-            BigDecimal.valueOf(22)
-                .divide(BigDecimal.valueOf(2), configuration.getMathContext())
-                .toPlainString());
-    assertThat(expression.getAbstractSyntaxTree()).isNotInstanceOf(InlinedASTNode.class);
-  }
-
-  @Test
-  public void testFunctionInlined() throws ParseException, EvaluationException {
-    Expression expression = parser.inlineExpression(createExpression("SUM(2, 4, 6, 7)"));
-
-    assertThat(expression.evaluate(UnaryOperator.identity()).getStringValue())
-        .isEqualTo(BigDecimal.valueOf(2 + 4 + 6 + 7).toPlainString());
-    assertThat(expression.getAbstractSyntaxTree()).isInstanceOf(InlinedASTNode.class);
-  }
-
-  @Test
-  public void testFunctionNotInlined() throws ParseException, EvaluationException {
-    Expression expression = parser.inlineExpression(createExpression("SUM(2, a, 6, 7)"));
-
-    assertThat(expression.evaluate(builder -> builder.parameter("a", 5)).getStringValue())
-        .isEqualTo(BigDecimal.valueOf(2 + 5 + 6 + 7).toPlainString());
-    assertThat(expression.getAbstractSyntaxTree()).isNotInstanceOf(InlinedASTNode.class);
-  }
-
-  @Test
-  public void testRandomNotInlined() throws ParseException, EvaluationException {
-    Expression expression = parser.inlineExpression(createExpression("RANDOM()"));
-
-    assertThat(expression.getAbstractSyntaxTree()).isNotInstanceOf(InlinedASTNode.class);
-  }
-}

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

···
 import com.ezylang.evalex.data.DataAccessorIfc;
 import com.ezylang.evalex.data.EvaluationValue;
 import com.ezylang.evalex.data.types.StringValue;
-import com.ezylang.evalex.parser.ASTNode;
-import com.ezylang.evalex.parser.ExpressionParser;
-import com.ezylang.evalex.parser.ParseException;
-import com.ezylang.evalex.parser.Token;
+import com.ezylang.evalex.parser.*;
 import java.math.MathContext;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.function.Supplier;
 import org.junit.jupiter.api.Test;
···
   @Test
   void testExpressionNode() throws ParseException, EvaluationException {
     Expression expression = ExpressionConfiguration.defaultExpressionParser().parse("a*b");
-    ASTNode subExpression =
-        ExpressionConfiguration.defaultExpressionParser()
-            .parseAndInline("4+3")
-            .getAbstractSyntaxTree();
+    Solvable subExpression =
+        ExpressionConfiguration.defaultExpressionParser().parse("4+3").getSolvable();
 
     EvaluationValue result =
         expression.evaluate(builder -> builder.parameter("a", 2).parameter("b", subExpression));
···
             .parse("1");
     assertThat(limitedMathContextExpression.convertDoubleValue(1.6789).getNumberValue())
         .isEqualByComparingTo("1.68");
-  }
-
-  @Test
-  void testGetAllASTNodes() throws ParseException {
-    Expression expression = ExpressionConfiguration.defaultExpressionParser().parse("1+2/3");
-    List<ASTNode> nodes = expression.getAllASTNodes();
-    assertThat(nodes.get(0).getToken().getValue()).isEqualTo("+");
-    assertThat(nodes.get(1).getToken().getValue()).isEqualTo("1");
-    assertThat(nodes.get(2).getToken().getValue()).isEqualTo("/");
-    assertThat(nodes.get(3).getToken().getValue()).isEqualTo("2");
-    assertThat(nodes.get(4).getToken().getValue()).isEqualTo("3");
-  }
-
-  @Test
-  void testGetUsedVariables() throws ParseException {
-    Expression expression =
-        ExpressionConfiguration.defaultExpressionParser().parse("a/2*PI+MIN(e,b)");
-    assertThat(expression.getUsedVariables()).containsExactlyInAnyOrder("a", "b");
-  }
-
-  @Test
-  void testGetUsedVariablesLongNames() throws ParseException {
-    Expression expression =
-        ExpressionConfiguration.defaultExpressionParser().parse("var1/2*PI+MIN(var2,var3)");
-    assertThat(expression.getUsedVariables()).containsExactlyInAnyOrder("var1", "var2", "var3");
-  }
-
-  @Test
-  void testGetUsedVariablesNoVariables() throws ParseException {
-    Expression expression = ExpressionConfiguration.defaultExpressionParser().parse("1/2");
-    assertThat(expression.getUsedVariables()).isEmpty();
-  }
-
-  @Test
-  void testGetUsedVariablesCaseSensitivity() throws ParseException {
-    Expression expression =
-        ExpressionConfiguration.defaultExpressionParser().parse("a+B*b-A/PI*(1/2)*pi+e-E+a");
-    assertThat(expression.getUsedVariables()).containsExactlyInAnyOrder("a", "b");
   }
 
   @Test

src/test/java/com/ezylang/evalex/data/EvaluationValueTest.java

···
 package com.ezylang.evalex.data;
 
 import static com.ezylang.evalex.config.ExpressionConfiguration.defaultConfiguration;
+import static com.ezylang.evalex.config.ExpressionConfiguration.defaultExpressionParser;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import com.ezylang.evalex.EvaluationException;
···
 import com.ezylang.evalex.data.types.NumberValue;
 import com.ezylang.evalex.parser.ASTNode;
 import com.ezylang.evalex.parser.ParseException;
+import com.ezylang.evalex.parser.Solvable;
 import com.ezylang.evalex.parser.Token;
 import com.ezylang.evalex.parser.Token.TokenType;
 import java.math.BigDecimal;
···
     assertThat(value.isBooleanValue()).isFalse();
     assertThat(value.isStructureValue()).isFalse();
     assertThat(value.isArrayValue()).isFalse();
-    assertThat(value.isExpressionNode()).isFalse();
+    assertThat(value.isSolvable()).isFalse();
     assertThat(value.isNullValue()).isFalse();
     assertDataIsCorrect(
         value, "Hello World", BigDecimal.ZERO, false, Instant.EPOCH, Duration.ZERO, String.class);
···
     assertThat(value.isStringValue()).isFalse();
     assertThat(value.isStructureValue()).isFalse();
     assertThat(value.isArrayValue()).isFalse();
-    assertThat(value.isExpressionNode()).isFalse();
+    assertThat(value.isSolvable()).isFalse();
     assertThat(value.isNullValue()).isFalse();
     assertDataIsCorrect(
         value, "true", BigDecimal.ONE, true, Instant.EPOCH, Duration.ZERO, Boolean.class);
···
     assertThat(value.isBooleanValue()).isFalse();
     assertThat(value.isStructureValue()).isFalse();
     assertThat(value.isStringValue()).isFalse();
-    assertThat(value.isExpressionNode()).isFalse();
+    assertThat(value.isSolvable()).isFalse();
     assertThat(value.isNullValue()).isFalse();
 
     assertThat(value.getArrayValue()).hasSize(2);
···
     assertThat(value.isBooleanValue()).isFalse();
     assertThat(value.isStringValue()).isFalse();
     assertThat(value.isArrayValue()).isFalse();
-    assertThat(value.isExpressionNode()).isFalse();
+    assertThat(value.isSolvable()).isFalse();
     assertThat(value.isNullValue()).isFalse();
 
     assertThat(value.getStructureValue()).hasSize(2);
···
   @Test
   void testExpressionNode() {
     ASTNode node = ASTNode.of(new Token(1, "a", TokenType.VARIABLE_OR_CONSTANT));
-    EvaluationValue value = EvaluationValue.of(node, defaultConfiguration());
+    EvaluationValue value =
+        EvaluationValue.of(defaultExpressionParser().toSolvable(node), defaultConfiguration());
 
-    assertThat(value.isExpressionNode()).isTrue();
+    assertThat(value.isSolvable()).isTrue();
     assertThat(value.isNumberValue()).isFalse();
     assertThat(value.isBooleanValue()).isFalse();
     assertThat(value.isStructureValue()).isFalse();
···
     assertThat(value.isNullValue()).isFalse();
 
     assertDataIsCorrect(
-        value,
-        "ASTNode(parameters=[], token=Token(startPosition=1, value=a, type=VARIABLE_OR_CONSTANT))",
-        BigDecimal.ZERO,
-        false,
-        Instant.EPOCH,
-        Duration.ZERO,
-        ASTNode.class);
+        value, null, BigDecimal.ZERO, false, Instant.EPOCH, Duration.ZERO, Solvable.class);
   }
 
   @Test
   void testExpressionNodeReturnsNull() {
     EvaluationValue value = EvaluationValue.of(false, defaultConfiguration());
-    assertThat(value.getExpressionNode()).isNull();
+    assertThat(value.getSolvable()).isNull();
   }
 
   @Test
···
     assertThat(value.isBooleanValue()).isFalse();
     assertThat(value.isStructureValue()).isFalse();
     assertThat(value.isArrayValue()).isFalse();
-    assertThat(value.isExpressionNode()).isFalse();
+    assertThat(value.isSolvable()).isFalse();
     assertThat(value.isNullValue()).isTrue();
     assertDataIsCorrect(value, null, null, null);
   }
···
 
   private void assertDataIsCorrect(
       EvaluationValue value, String stringValue, BigDecimal numberValue, Boolean booleanValue) {
-    assertThat(value.getStringValue()).isEqualTo(stringValue);
+    if (stringValue != null) assertThat(value.getStringValue()).isEqualTo(stringValue);
     assertThat(value.getNumberValue()).isEqualTo(numberValue);
     assertThat(value.getBooleanValue()).isEqualTo(booleanValue);
   }
···
       Duration durationValue,
       Class<?> valueInstance) {
     assertDataIsCorrect(value, stringValue, numberValue, booleanValue);
-    assertThat(value.getStringValue()).isEqualTo(stringValue);
-    assertThat(value.getNumberValue()).isEqualTo(numberValue);
-    assertThat(value.getBooleanValue()).isEqualTo(booleanValue);
     assertThat(value.getDateTimeValue()).isEqualTo(dateTimeValue);
     assertThat(value.getDurationValue()).isEqualTo(durationValue);
     assertThat(value.getValue()).isInstanceOf(valueInstance);

src/test/java/com/ezylang/evalex/data/conversion/ExpressionNodeConverterTest.java src/test/java/com/ezylang/evalex/data/conversion/SolvableConverterTest.java

···
 
 import com.ezylang.evalex.config.ExpressionConfiguration;
 import com.ezylang.evalex.data.EvaluationValue;
-import com.ezylang.evalex.data.types.ExpressionNodeValue;
-import com.ezylang.evalex.parser.ASTNode;
-import com.ezylang.evalex.parser.Token;
+import com.ezylang.evalex.data.types.SolvableValue;
+import com.ezylang.evalex.data.types.StringValue;
+import com.ezylang.evalex.parser.Solvable;
 import java.math.BigDecimal;
 import org.junit.jupiter.api.Test;
 
-class ExpressionNodeConverterTest {
+class SolvableConverterTest {
 
   private final ExpressionConfiguration defaultConfiguration =
       ExpressionConfiguration.defaultConfiguration();
 
-  private final ExpressionNodeConverter converter = new ExpressionNodeConverter();
+  private final SolvableConverter converter = new SolvableConverter();
 
-  private final ASTNode testNode =
-      ASTNode.of(new Token(1, "a", Token.TokenType.VARIABLE_OR_CONSTANT));
+  private final Solvable testNode = context -> StringValue.of("Hello!");
 
   @Test
   void testDuration() {
-
     EvaluationValue converted = converter.convert(testNode, defaultConfiguration);
 
-    assertThat(converted).isInstanceOf(ExpressionNodeValue.class);
-    assertThat(converted.getExpressionNode().toJSON()).isEqualTo(testNode.toJSON());
+    assertThat(converted).isInstanceOf(SolvableValue.class);
+    assertThat(converted.getSolvable()).isEqualTo(testNode);
   }
 
   @Test