Introduce MapAccessor in SpEL and deprecate existing implementation

Prior to this commit, the MapAccessor for SpEL resided in the
org.springframework.context.expression package in the spring-context
module; however, it arguably should reside in the spring-expression
module so that it can be used whenever SpEL is used (without requiring
spring-context).

This commit therefore officially deprecates the MapAccessor in
spring-context for removal in favor of a new copy of the implementation
in the org.springframework.expression.spel.support package in the
spring-expression module.

Closes gh-35537

Author: sbrannen

spring-context/src/main/java/org/springframework/context/expression/MapAccessor.java

@@ -16,18 +16,7 @@
 
 package org.springframework.context.expression;
 
-import java.util.Map;
-
-import org.jspecify.annotations.Nullable;
-
-import org.springframework.asm.MethodVisitor;
-import org.springframework.expression.AccessException;
-import org.springframework.expression.EvaluationContext;
 import org.springframework.expression.PropertyAccessor;
-import org.springframework.expression.TypedValue;
-import org.springframework.expression.spel.CodeFlow;
-import org.springframework.expression.spel.CompilablePropertyAccessor;
-import org.springframework.util.Assert;
 
 /**
  * SpEL {@link PropertyAccessor} that knows how to access the keys of a standard
@@ -36,11 +25,10 @@
  * @author Juergen Hoeller
  * @author Andy Clement
  * @since 3.0
+ * @deprecated as of Spring Framework 7.0 in favor of {@link org.springframework.expression.spel.support.MapAccessor}.
  */
-public class MapAccessor implements CompilablePropertyAccessor {
-
-	private final boolean allowWrite;
-
+@Deprecated(since = "7.0", forRemoval = true)
+public class MapAccessor extends org.springframework.expression.spel.support.MapAccessor {
 
 	/**
 	 * Create a new {@code MapAccessor} for reading as well as writing.
@@ -57,88 +45,7 @@ public MapAccessor() {
 	 * @see #canWrite
 	 */
 	public MapAccessor(boolean allowWrite) {
-		this.allowWrite = allowWrite;
-	}
-
-
-	@Override
-	public Class<?>[] getSpecificTargetClasses() {
-		return new Class<?>[] {Map.class};
-	}
-
-	@Override
-	public boolean canRead(EvaluationContext context, @Nullable Object target, String name) throws AccessException {
-		return (target instanceof Map<?, ?> map && map.containsKey(name));
-	}
-
-	@Override
-	public TypedValue read(EvaluationContext context, @Nullable Object target, String name) throws AccessException {
-		Assert.state(target instanceof Map, "Target must be of type Map");
-		Map<?, ?> map = (Map<?, ?>) target;
-		Object value = map.get(name);
-		if (value == null && !map.containsKey(name)) {
-			throw new MapAccessException(name);
-		}
-		return new TypedValue(value);
-	}
-
-	@Override
-	public boolean canWrite(EvaluationContext context, @Nullable Object target, String name) throws AccessException {
-		return (this.allowWrite && target instanceof Map);
-	}
-
-	@Override
-	@SuppressWarnings("unchecked")
-	public void write(EvaluationContext context, @Nullable Object target, String name, @Nullable Object newValue)
-			throws AccessException {
-
-		Assert.state(target instanceof Map, "Target must be of type Map");
-		Map<Object, Object> map = (Map<Object, Object>) target;
-		map.put(name, newValue);
-	}
-
-	@Override
-	public boolean isCompilable() {
-		return true;
-	}
-
-	@Override
-	public Class<?> getPropertyType() {
-		return Object.class;
-	}
-
-	@Override
-	public void generateCode(String propertyName, MethodVisitor mv, CodeFlow cf) {
-		String descriptor = cf.lastDescriptor();
-		if (descriptor == null || !descriptor.equals("Ljava/util/Map")) {
-			if (descriptor == null) {
-				cf.loadTarget(mv);
-			}
-			CodeFlow.insertCheckCast(mv, "Ljava/util/Map");
-		}
-		mv.visitLdcInsn(propertyName);
-		mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Map", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", true);
-	}
-
-
-	/**
-	 * Exception thrown from {@code read} in order to reset a cached
-	 * PropertyAccessor, allowing other accessors to have a try.
-	 */
-	@SuppressWarnings("serial")
-	private static class MapAccessException extends AccessException {
-
-		private final String key;
-
-		public MapAccessException(String key) {
-			super("");
-			this.key = key;
-		}
-
-		@Override
-		public String getMessage() {
-			return "Map does not contain a value for key '" + this.key + "'";
-		}
+		super(allowWrite);
 	}
 
 }

spring-context/src/main/java/org/springframework/context/expression/StandardBeanExpressionResolver.java

@@ -168,7 +168,7 @@ public void setExpressionParser(ExpressionParser expressionParser) {
 					StandardEvaluationContext sec = new StandardEvaluationContext(bec);
 					sec.addPropertyAccessor(new BeanExpressionContextAccessor());
 					sec.addPropertyAccessor(new BeanFactoryAccessor());
-					sec.addPropertyAccessor(new MapAccessor());
+					sec.addPropertyAccessor(new org.springframework.expression.spel.support.MapAccessor());
 					sec.addPropertyAccessor(new EnvironmentAccessor());
 					sec.setBeanResolver(new BeanFactoryResolver(beanFactory));
 					sec.setTypeLocator(new StandardTypeLocator(beanFactory.getBeanClassLoader()));

spring-context/src/test/java/org/springframework/context/expression/MapAccessorTests.java

@@ -36,6 +36,7 @@
  * @author Andy Clement
  * @author Sam Brannen
  */
+@SuppressWarnings("removal")
 class MapAccessorTests {
 
 	private final StandardEvaluationContext context = new StandardEvaluationContext();

spring-expression/src/test/java/org/springframework/expression/spel/CompilableMapAccessor.java renamed to spring-expression/src/main/java/org/springframework/expression/spel/support/MapAccessor.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.expression.spel;
+package org.springframework.expression.spel.support;
 
 import java.util.Map;
 
@@ -23,37 +23,39 @@
 import org.springframework.asm.MethodVisitor;
 import org.springframework.expression.AccessException;
 import org.springframework.expression.EvaluationContext;
+import org.springframework.expression.PropertyAccessor;
 import org.springframework.expression.TypedValue;
+import org.springframework.expression.spel.CodeFlow;
+import org.springframework.expression.spel.CompilablePropertyAccessor;
 import org.springframework.util.Assert;
 
 /**
- * This is a local COPY of {@link org.springframework.context.expression.MapAccessor}.
+ * SpEL {@link PropertyAccessor} that knows how to access the keys of a standard
+ * {@link java.util.Map}.
  *
  * @author Juergen Hoeller
  * @author Andy Clement
- * @since 4.1
+ * @since 7.0
  */
-public class CompilableMapAccessor implements CompilablePropertyAccessor {
+public class MapAccessor implements CompilablePropertyAccessor {
 
 	private final boolean allowWrite;
 
 
 	/**
-	 * Create a new {@code CompilableMapAccessor} for reading as well as writing.
-	 * @since 6.2
-	 * @see #CompilableMapAccessor(boolean)
+	 * Create a new {@code MapAccessor} for reading as well as writing.
+	 * @see #MapAccessor(boolean)
 	 */
-	public CompilableMapAccessor() {
+	public MapAccessor() {
 		this(true);
 	}
 
 	/**
-	 * Create a new {@code CompilableMapAccessor} for reading and possibly also writing.
+	 * Create a new {@code MapAccessor} for reading and possibly also writing.
 	 * @param allowWrite whether to allow write operations on a target instance
-	 * @since 6.2
 	 * @see #canWrite
 	 */
-	public CompilableMapAccessor(boolean allowWrite) {
+	public MapAccessor(boolean allowWrite) {
 		this.allowWrite = allowWrite;
 	}
 

spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java

@@ -57,6 +57,7 @@
 import org.springframework.expression.spel.standard.SpelCompiler;
 import org.springframework.expression.spel.standard.SpelExpression;
 import org.springframework.expression.spel.standard.SpelExpressionParser;
+import org.springframework.expression.spel.support.MapAccessor;
 import org.springframework.expression.spel.support.ReflectiveIndexAccessor;
 import org.springframework.expression.spel.support.StandardEvaluationContext;
 import org.springframework.expression.spel.testdata.PersonInOtherPackage;
@@ -618,9 +619,9 @@ void indexIntoMapOfPrimitiveIntArray() {
 		}
 
 		@Test  // gh-32356
-		void indexIntoMapOfPrimitiveIntArrayWithCompilableMapAccessor() {
+		void indexIntoMapOfPrimitiveIntArrayWithMapAccessor() {
 			StandardEvaluationContext context = new StandardEvaluationContext();
-			context.addPropertyAccessor(new CompilableMapAccessor());
+			context.addPropertyAccessor(new MapAccessor());
 
 			Map<String, int[]> map = Map.of("foo", new int[] { 1, 2, 3 });
 
@@ -635,21 +636,21 @@ void indexIntoMapOfPrimitiveIntArrayWithCompilableMapAccessor() {
 			assertThat(stringify(expression.getValue(context, map))).isEqualTo("1 2 3");
 			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
 
-			// custom CompilableMapAccessor via implicit #root & array index
+			// custom MapAccessor via implicit #root & array index
 			expression = parser.parseExpression("foo[1]");
 
 			assertThat(expression.getValue(context, map)).isEqualTo(2);
 			assertCanCompile(expression);
 			assertThat(expression.getValue(context, map)).isEqualTo(2);
 
-			// custom CompilableMapAccessor via explicit #root & array index
+			// custom MapAccessor via explicit #root & array index
 			expression = parser.parseExpression("#root.foo[1]");
 
 			assertThat(expression.getValue(context, map)).isEqualTo(2);
 			assertCanCompile(expression);
 			assertThat(expression.getValue(context, map)).isEqualTo(2);
 
-			// custom CompilableMapAccessor via explicit #this & array index
+			// custom MapAccessor via explicit #this & array index
 			expression = parser.parseExpression("#this.foo[1]");
 
 			assertThat(expression.getValue(context, map)).isEqualTo(2);