Support Optional with null-safe and Elvis operators in SpEL expressions

This commit introduces null-safe support for java.util.Optional in the
following SpEL operators:

- Elvis
- Indexer
- MethodReference
- PropertyOrFieldReference
- Projection
- Selection

TODO: Update the SpEL chapter of the reference manual.

Closes spring-projectsgh-20433

Author: sbrannen

spring-expression/src/main/java/org/springframework/expression/spel/ast/Elvis.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,8 @@
 
 package org.springframework.expression.spel.ast;
 
+import java.util.Optional;
+
 import org.springframework.asm.Label;
 import org.springframework.asm.MethodVisitor;
 import org.springframework.expression.EvaluationException;
@@ -26,9 +28,13 @@
 import org.springframework.util.ObjectUtils;
 
 /**
- * Represents the Elvis operator <code>?:</code>. For an expression <code>a?:b</code> if <code>a</code> is neither null
- * nor an empty String, the value of the expression is <code>a</code>.
- * If <code>a</code> is null or the empty String, then the value of the expression is <code>b</code>.
+ * Represents the Elvis operator {@code ?:}.
+ *
+ * <p>For the expression "{@code A ?: B}", if {@code A} is neither {@code null},
+ * an empty {@link Optional}, nor an empty {@link String}, the value of the
+ * expression is {@code A}, or {@code A.get()} for an {@code Optional}. If
+ * {@code A} is {@code null}, an empty {@code Optional}, or an
+ * empty {@code String}, the value of the expression is {@code B}.
  *
  * @author Andy Clement
  * @author Juergen Hoeller
@@ -43,18 +49,32 @@ public Elvis(int startPos, int endPos, SpelNodeImpl... args) {
 
 
 	/**
-	 * Evaluate the condition and if neither null nor an empty String, return it.
-	 * If it is null or an empty String, return the other value.
+	 * If the left-hand operand is neither neither {@code null}, an empty
+	 * {@link Optional}, nor an empty {@link String}, return its value, or the
+	 * value contained in the {@code Optional}. If the left-hand operand is
+	 * {@code null}, an empty {@code Optional}, or an empty {@code String},
+	 * return the other value.
 	 * @param state the expression state
-	 * @throws EvaluationException if the condition does not evaluate correctly
-	 * to a boolean or there is a problem executing the chosen alternative
+	 * @throws EvaluationException if the null/empty check does not evaluate correctly
+	 * or there is a problem evaluating the alternative
 	 */
 	@Override
 	public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
-		TypedValue value = this.children[0].getValueInternal(state);
+		TypedValue leftHandTypedValue = this.children[0].getValueInternal(state);
+		Object leftHandValue = leftHandTypedValue.getValue();
+
+		if (leftHandValue instanceof Optional<?> optional) {
+			// Compilation is currently not supported for Optional with the Elvis operator.
+			this.exitTypeDescriptor = null;
+			if (optional.isPresent()) {
+				return new TypedValue(optional.get());
+			}
+			return this.children[1].getValueInternal(state);
+		}
+
 		// If this check is changed, the generateCode method will need changing too
-		if (value.getValue() != null && !"".equals(value.getValue())) {
-			return value;
+		if (leftHandValue != null && !"".equals(leftHandValue)) {
+			return leftHandTypedValue;
 		}
 		else {
 			TypedValue result = this.children[1].getValueInternal(state);

spring-expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java

@@ -20,6 +20,7 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.function.Supplier;
 
 import org.jspecify.annotations.Nullable;
@@ -67,7 +68,12 @@
  * <p>As of Spring Framework 6.2, null-safe indexing is supported via the {@code '?.'}
  * operator. For example, {@code 'colors?.[0]'} will evaluate to {@code null} if
  * {@code colors} is {@code null} and will otherwise evaluate to the 0<sup>th</sup>
- * color.
+ * color. As of Spring Framework 7.0, null-safe indexing also applies when
+ * indexing into a structure contained in an {@link Optional}. For example, if
+ * {@code colors} is of type {@code Optional<Colors>}, the expression
+ * {@code 'colors?.[0]'} will evaluate to {@code null} if {@code colors} is
+ * {@code null} or {@link Optional#isEmpty() empty} and will otherwise evaluate
+ * to the 0<sup>th</sup> color, effectively {@code colors.get()[0]}.
  *
  * @author Andy Clement
  * @author Phillip Webb
@@ -165,11 +171,20 @@ private ValueRef getValueRef(ExpressionState state, AccessMode accessMode) throw
 		TypedValue context = state.getActiveContextObject();
 		Object target = context.getValue();
 
-		if (target == null) {
-			if (isNullSafe()) {
+		if (isNullSafe()) {
+			if (target == null) {
 				return ValueRef.NullValueRef.INSTANCE;
 			}
-			// Raise a proper exception in case of a null target
+			if (target instanceof Optional<?> optional) {
+				if (optional.isEmpty()) {
+					return ValueRef.NullValueRef.INSTANCE;
+				}
+				target = optional.get();
+			}
+		}
+
+		// Raise a proper exception in case of a null target
+		if (target == null) {
 			throw new SpelEvaluationException(getStartPosition(), SpelMessage.CANNOT_INDEX_INTO_NULL_VALUE);
 		}