WIP

Author: javier-godoy

src/main/java/com/flowingcode/vaadin/jsonmigration/ClassInstrumentationUtil.java

@@ -33,6 +33,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.WeakHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 import lombok.experimental.UtilityClass;
 import org.objectweb.asm.ClassWriter;
@@ -62,7 +63,7 @@
 final class ClassInstrumentationUtil {
 
   private static final Map<ClassLoader, InstrumentedClassLoader> classLoaderCache =
-      new ConcurrentHashMap<>();
+      new WeakHashMap<>();
 
   /**
    * Creates and returns an instance of a dynamically instrumented class that extends the specified
@@ -122,7 +123,13 @@ public <T extends Component> Class<? extends T> instrumentClass(Class<T> parent)
       Constructor<?> defaultConstructor = parent.getDeclaredConstructor();
       if (!Modifier.isPublic(defaultConstructor.getModifiers())
           && !Modifier.isProtected(defaultConstructor.getModifiers())) {
-        defaultConstructor.setAccessible(true);
+        try {
+          defaultConstructor.setAccessible(true);
+        } catch (Exception e) {
+          throw new IllegalArgumentException(
+              "Parent class must have an accessible no-argument constructor: " + parent.getName(),
+              e);
+        }
       }
     } catch (NoSuchMethodException e) {
       throw new IllegalArgumentException(
@@ -178,12 +185,17 @@ private static boolean hasJsonValueParameters(Method method) {
 
   private <T extends Component> Class<? extends T> createInstrumentedClass(Class<T> parent,
       String className) throws Exception {
-    ClassLoader parentClassLoader = parent.getClassLoader();
     InstrumentedClassLoader classLoader =
-        classLoaderCache.computeIfAbsent(parentClassLoader, InstrumentedClassLoader::new);
+        getOrCreateInstrumentedClassLoader(parent.getClassLoader());
     return classLoader.defineInstrumentedClass(className, parent).asSubclass(parent);
   }
 
+  private InstrumentedClassLoader getOrCreateInstrumentedClassLoader(ClassLoader parent) {
+    synchronized (classLoaderCache) {
+      return classLoaderCache.computeIfAbsent(parent, InstrumentedClassLoader::new);
+    }
+  }
+
   private static final class InstrumentedClassLoader extends ClassLoader {
 
     private final Map<Class<?>, Class<?>> instrumentedClassCache = new ConcurrentHashMap<>();
@@ -289,7 +301,11 @@ private void generateMethodOverride(ClassWriter cw, Method method, String intern
       }
 
       // Return converted result or void
-      mv.visitInsn(Opcodes.ARETURN);
+      if (method.getReturnType() == Void.TYPE) {
+        mv.visitInsn(Opcodes.RETURN);
+      } else {
+        mv.visitInsn(Opcodes.ARETURN);
+      }
 
       mv.visitMaxs(0, 0);
       mv.visitEnd();