Consistent support for setContextClass in CGLIB beans package

Closes gh-28530

spring-core/spring-core.gradle

@@ -76,8 +76,7 @@ jar {
 	dependsOn cglibRepackJar
 	from(zipTree(cglibRepackJar.archivePath)) {
 		include "org/springframework/cglib/**"
-		exclude "org/springframework/cglib/beans/BeanMap.class"
-		exclude "org/springframework/cglib/beans/BeanMap\$*.class"
+		exclude "org/springframework/cglib/beans/**"
 		exclude "org/springframework/cglib/core/AbstractClassGenerator*.class"
 		exclude "org/springframework/cglib/core/AsmApi*.class"
 		exclude "org/springframework/cglib/core/KeyFactory.class"

spring-core/src/main/java/org/springframework/cglib/beans/BeanCopier.java

@@ -0,0 +1,179 @@
+/*
+ * Copyright 2003,2004 The Apache Software Foundation
+ *
+ *  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
+ *
+ *      https://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 org.springframework.cglib.beans;
+
+import java.beans.PropertyDescriptor;
+import java.lang.reflect.*;
+import java.security.ProtectionDomain;
+import org.springframework.cglib.core.*;
+import org.springframework.asm.ClassVisitor;
+import org.springframework.asm.Type;
+import java.util.*;
+
+/**
+ * @author Chris Nokleberg
+ */
+@SuppressWarnings({"rawtypes", "unchecked"})
+abstract public class BeanCopier
+{
+    private static final BeanCopierKey KEY_FACTORY =
+      (BeanCopierKey)KeyFactory.create(BeanCopierKey.class);
+    private static final Type CONVERTER =
+      TypeUtils.parseType("org.springframework.cglib.core.Converter");
+    private static final Type BEAN_COPIER =
+      TypeUtils.parseType("org.springframework.cglib.beans.BeanCopier");
+    private static final Signature COPY =
+      new Signature("copy", Type.VOID_TYPE, new Type[]{ Constants.TYPE_OBJECT, Constants.TYPE_OBJECT, CONVERTER });
+    private static final Signature CONVERT =
+      TypeUtils.parseSignature("Object convert(Object, Class, Object)");
+
+    interface BeanCopierKey {
+        public Object newInstance(String source, String target, boolean useConverter);
+    }
+
+    public static BeanCopier create(Class source, Class target, boolean useConverter) {
+        Generator gen = new Generator();
+        gen.setSource(source);
+        gen.setTarget(target);
+        gen.setUseConverter(useConverter);
+        return gen.create();
+    }
+
+    abstract public void copy(Object from, Object to, Converter converter);
+
+    public static class Generator extends AbstractClassGenerator {
+        private static final Source SOURCE = new Source(BeanCopier.class.getName());
+        private Class source;
+        private Class target;
+        private boolean useConverter;
+
+        public Generator() {
+            super(SOURCE);
+        }
+
+        public void setSource(Class source) {
+            if(!Modifier.isPublic(source.getModifiers())){ 
+               setNamePrefix(source.getName());
+            }
+            this.source = source;
+        }
+
+        public void setTarget(Class target) {
+            if(!Modifier.isPublic(target.getModifiers())){ 
+               setNamePrefix(target.getName());
+            }
+            this.target = target;
+			// SPRING PATCH BEGIN
+			setContextClass(target);
+			// SPRING PATCH END
+        }
+
+        public void setUseConverter(boolean useConverter) {
+            this.useConverter = useConverter;
+        }
+
+        protected ClassLoader getDefaultClassLoader() {
+            return source.getClassLoader();
+        }
+
+        protected ProtectionDomain getProtectionDomain() {
+        	return ReflectUtils.getProtectionDomain(source);
+        }
+
+        public BeanCopier create() {
+            Object key = KEY_FACTORY.newInstance(source.getName(), target.getName(), useConverter);
+            return (BeanCopier)super.create(key);
+        }
+
+        public void generateClass(ClassVisitor v) {
+            Type sourceType = Type.getType(source);
+            Type targetType = Type.getType(target);
+            ClassEmitter ce = new ClassEmitter(v);
+            ce.begin_class(Constants.V1_8,
+                           Constants.ACC_PUBLIC,
+                           getClassName(),
+                           BEAN_COPIER,
+                           null,
+                           Constants.SOURCE_FILE);
+
+            EmitUtils.null_constructor(ce);
+            CodeEmitter e = ce.begin_method(Constants.ACC_PUBLIC, COPY, null);
+            PropertyDescriptor[] getters = ReflectUtils.getBeanGetters(source);
+            PropertyDescriptor[] setters = ReflectUtils.getBeanSetters(target);
+
+            Map names = new HashMap();
+            for (int i = 0; i < getters.length; i++) {
+                names.put(getters[i].getName(), getters[i]);
+            }
+            Local targetLocal = e.make_local();
+            Local sourceLocal = e.make_local();
+            if (useConverter) {
+                e.load_arg(1);
+                e.checkcast(targetType);
+                e.store_local(targetLocal);
+                e.load_arg(0);                
+                e.checkcast(sourceType);
+                e.store_local(sourceLocal);
+            } else {
+                e.load_arg(1);
+                e.checkcast(targetType);
+                e.load_arg(0);
+                e.checkcast(sourceType);
+            }
+            for (int i = 0; i < setters.length; i++) {
+                PropertyDescriptor setter = setters[i];
+                PropertyDescriptor getter = (PropertyDescriptor)names.get(setter.getName());
+                if (getter != null) {
+                    MethodInfo read = ReflectUtils.getMethodInfo(getter.getReadMethod());
+                    MethodInfo write = ReflectUtils.getMethodInfo(setter.getWriteMethod());
+                    if (useConverter) {
+                        Type setterType = write.getSignature().getArgumentTypes()[0];
+                        e.load_local(targetLocal);
+                        e.load_arg(2);
+                        e.load_local(sourceLocal);
+                        e.invoke(read);
+                        e.box(read.getSignature().getReturnType());
+                        EmitUtils.load_class(e, setterType);
+                        e.push(write.getSignature().getName());
+                        e.invoke_interface(CONVERTER, CONVERT);
+                        e.unbox_or_zero(setterType);
+                        e.invoke(write);
+                    } else if (compatible(getter, setter)) {
+                        e.dup2();
+                        e.invoke(read);
+                        e.invoke(write);
+                    }
+                }
+            }
+            e.return_value();
+            e.end_method();
+            ce.end_class();
+        }
+
+        private static boolean compatible(PropertyDescriptor getter, PropertyDescriptor setter) {
+            // TODO: allow automatic widening conversions?
+            return setter.getPropertyType().isAssignableFrom(getter.getPropertyType());
+        }
+
+        protected Object firstInstance(Class type) {
+            return ReflectUtils.newInstance(type);
+        }
+
+        protected Object nextInstance(Object instance) {
+            return instance;
+        }
+    }
+}

spring-core/src/main/java/org/springframework/cglib/beans/BeanGenerator.java

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2003 The Apache Software Foundation
+ *
+ *  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
+ *
+ *      https://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 org.springframework.cglib.beans;
+
+import java.beans.PropertyDescriptor;
+import java.security.ProtectionDomain;
+import java.util.*;
+import org.springframework.cglib.core.*;
+import org.springframework.asm.ClassVisitor;
+import org.springframework.asm.Type;
+
+/**
+ * @author Juozas Baliuka, Chris Nokleberg
+ */
+@SuppressWarnings({"rawtypes", "unchecked"})
+public class BeanGenerator extends AbstractClassGenerator
+{
+    private static final Source SOURCE = new Source(BeanGenerator.class.getName());
+    private static final BeanGeneratorKey KEY_FACTORY =
+      (BeanGeneratorKey)KeyFactory.create(BeanGeneratorKey.class);
+
+    interface BeanGeneratorKey {
+        public Object newInstance(String superclass, Map props);
+    }
+
+    private Class superclass;
+    private Map props = new HashMap();
+    private boolean classOnly;
+
+    public BeanGenerator() {
+        super(SOURCE);
+    }
+
+    /**
+     * Set the class which the generated class will extend. The class
+     * must not be declared as final, and must have a non-private
+     * no-argument constructor.
+     * @param superclass class to extend, or null to extend Object
+     */
+    public void setSuperclass(Class superclass) {
+        if (superclass != null && superclass.equals(Object.class)) {
+            superclass = null;
+        }
+        this.superclass = superclass;
+		// SPRING PATCH BEGIN
+		setContextClass(superclass);
+		// SPRING PATCH END
+    }
+
+    public void addProperty(String name, Class type) {
+        if (props.containsKey(name)) {
+            throw new IllegalArgumentException("Duplicate property name \"" + name + "\"");
+        }
+        props.put(name, Type.getType(type));
+    }
+
+    protected ClassLoader getDefaultClassLoader() {
+        if (superclass != null) {
+            return superclass.getClassLoader();
+        } else {
+            return null;
+        }
+    }
+
+    protected ProtectionDomain getProtectionDomain() {
+        return ReflectUtils.getProtectionDomain(superclass);
+    }
+
+    public Object create() {
+        classOnly = false;
+        return createHelper();
+    }
+
+    public Object createClass() {
+        classOnly = true;
+        return createHelper();
+    }
+
+    private Object createHelper() {
+        if (superclass != null) {
+            setNamePrefix(superclass.getName());
+        }
+        String superName = (superclass != null) ? superclass.getName() : "java.lang.Object";
+        Object key = KEY_FACTORY.newInstance(superName, props);
+        return super.create(key);
+    }
+
+    public void generateClass(ClassVisitor v) throws Exception {
+        int size = props.size();
+        String[] names = (String[])props.keySet().toArray(new String[size]);
+        Type[] types = new Type[size];
+        for (int i = 0; i < size; i++) {
+            types[i] = (Type)props.get(names[i]);
+        }
+        ClassEmitter ce = new ClassEmitter(v);
+        ce.begin_class(Constants.V1_8,
+                       Constants.ACC_PUBLIC,
+                       getClassName(),
+                       superclass != null ? Type.getType(superclass) : Constants.TYPE_OBJECT,
+                       null,
+                       null);
+        EmitUtils.null_constructor(ce);
+        EmitUtils.add_properties(ce, names, types);
+        ce.end_class();
+    }
+
+    protected Object firstInstance(Class type) {
+        if (classOnly) {
+            return type;
+        } else {
+            return ReflectUtils.newInstance(type);
+        }
+    }
+
+    protected Object nextInstance(Object instance) {
+        Class protoclass = (instance instanceof Class) ? (Class)instance : instance.getClass();
+        if (classOnly) {
+            return protoclass;
+        } else {
+            return ReflectUtils.newInstance(protoclass);
+        }
+    }
+
+    public static void addProperties(BeanGenerator gen, Map props) {
+        for (Iterator it = props.keySet().iterator(); it.hasNext();) {
+            String name = (String)it.next();
+            gen.addProperty(name, (Class)props.get(name));
+        }
+    }
+
+    public static void addProperties(BeanGenerator gen, Class type) {
+        addProperties(gen, ReflectUtils.getBeanProperties(type));
+    }
+
+    public static void addProperties(BeanGenerator gen, PropertyDescriptor[] descriptors) {
+        for (int i = 0; i < descriptors.length; i++) {
+            gen.addProperty(descriptors[i].getName(), descriptors[i].getPropertyType());
+        }
+    }
+}

spring-core/src/main/java/org/springframework/cglib/beans/BeanMap.java

@@ -97,7 +97,9 @@ public void setBean(Object bean) {
             this.bean = bean;
             if (bean != null) {
 				beanClass = bean.getClass();
+				// SPRING PATCH BEGIN
 				setContextClass(beanClass);
+				// SPRING PATCH END
 			}
         }