Fix *asm4 + asm3 to match *.asmx (due to recent SPI refactoring)

Author: vsilaev

net.tascalate.javaflow.providers.asm3/src/main/java/org/apache/commons/javaflow/providers/asm3/Asm3ResourceTransformationFactory.java

@@ -15,38 +15,61 @@
  */
 package org.apache.commons.javaflow.providers.asm3;
 
-import java.util.Map;
-import java.util.WeakHashMap;
+import java.io.IOException;
 
+import org.apache.commons.javaflow.spi.Cache;
+import org.apache.commons.javaflow.spi.ClassMatcher;
+import org.apache.commons.javaflow.spi.ClassMatchers;
 import org.apache.commons.javaflow.spi.ContinuableClassInfoResolver;
 import org.apache.commons.javaflow.spi.ResourceLoader;
 import org.apache.commons.javaflow.spi.ResourceTransformationFactory;
 import org.apache.commons.javaflow.spi.ResourceTransformer;
+import org.apache.commons.javaflow.spi.VetoableResourceLoader;
+
+import org.objectweb.asm.ClassReader;
 
 public class Asm3ResourceTransformationFactory implements ResourceTransformationFactory {
 
-    public ResourceTransformer createTransformer(ContinuableClassInfoResolver cciResolver) {
-        return new Asm3ClassTransformer(getOrCreateClassHierarchy(cciResolver), cciResolver);
+    public ResourceTransformer createTransformer(ResourceLoader resourceLoader) {
+        SharedContinuableClassInfos cciShared = CACHED_SHARED_CCI.get(resourceLoader);
+        return new ContinuableClassTransformer(
+            // Actualize ClassHierarchy per resource loader
+            cciShared.hierarchy().shareWith(resourceLoader), 
+            new IContinuableClassInfoResolver(resourceLoader, cciShared)
+        );
     }
 
     public ContinuableClassInfoResolver createResolver(ResourceLoader resourceLoader) {
-        return new Asm3ContinuableClassInfoResolver(resourceLoader);
+        return new IContinuableClassInfoResolver(
+            resourceLoader,
+            CACHED_SHARED_CCI.get(resourceLoader)
+        );
     }
 
-    private static ClassHierarchy getOrCreateClassHierarchy(ContinuableClassInfoResolver cciResolver) {
-        ClassHierarchy result;
-        ResourceLoader loader = cciResolver.resourceLoader();
-        synchronized (CACHED_CLASS_HIERARCHY) {
-            result = CACHED_CLASS_HIERARCHY.get(loader);
-            if (null == result) {
-                result = new ClassHierarchy(loader);
-                CACHED_CLASS_HIERARCHY.put(loader, result);
+    public String readClassName(byte[] classBytes) {
+        return new ClassReader(classBytes).getClassName();
+    }
+
+    static ClassMatcher createVeto(ResourceLoader resourceLoader) {
+        if (resourceLoader instanceof VetoableResourceLoader) {
+            try {
+                return ((VetoableResourceLoader)resourceLoader).createVeto();
+            } catch (IOException ex) {
+                throw new RuntimeException(ex);
             }
+        } else {
+            return ClassMatchers.MATCH_NONE;
         }
-        return result;
     }
 
-    private static final Map<ResourceLoader, ClassHierarchy> CACHED_CLASS_HIERARCHY = 
-        new WeakHashMap<ResourceLoader, ClassHierarchy>();
+    private static final Cache<ResourceLoader, SharedContinuableClassInfos> CACHED_SHARED_CCI = 
+        new Cache<ResourceLoader, SharedContinuableClassInfos>() {
+            @Override
+            protected SharedContinuableClassInfos createValue(ResourceLoader loader) {
+                return new SharedContinuableClassInfos(
+                    new ClassHierarchy(loader), createVeto(loader)
+                );
+            }
+        };
 
 }

net.tascalate.javaflow.providers.asm3/src/main/java/org/apache/commons/javaflow/providers/asm3/ClassHierarchy.java

@@ -47,18 +47,34 @@
 public class ClassHierarchy {
 
     private final ResourceLoader loader;
-    private final Map<Key, String> lookupCache = new HashMap<Key, String>();
-    private final Map<TypeInfo, Reference<TypeInfo>> typesCache 
-        = new WeakHashMap<TypeInfo, Reference<TypeInfo>>();
+    private final Map<Key, String> lookupCache;
+    private final Map<TypeInfo, Reference<TypeInfo>> typesCache; 
 
     public ClassHierarchy(ResourceLoader loader) {
         this.loader = loader;
+        this.lookupCache  = new HashMap<Key, String>();
+        this.typesCache = new WeakHashMap<TypeInfo, Reference<TypeInfo>>();
         // Next will never be removed from the cache
         // while there is a hard-reference
         for (TypeInfo ti : SPECIAL_CLASSES) {
             typesCache.put(ti, new SoftReference<TypeInfo>(ti));
         }
     }
+    
+    private ClassHierarchy(ResourceLoader loader,
+                           Map<Key, String> lookupCache, 
+                           Map<TypeInfo, Reference<TypeInfo>> typesCache) {
+        this.loader = loader;
+        this.lookupCache = lookupCache;        
+        this.typesCache = typesCache;
+    }
+    
+    public ClassHierarchy shareWith(ResourceLoader resourceLoader) {
+        if (resourceLoader == this.loader) {
+            return this;
+        }
+        return new ClassHierarchy(resourceLoader, lookupCache, typesCache);
+    }
 
     public boolean isSubClass(String type1, String type2) {
         String commonSuperClass = getCommonSuperClass(type1, type2);

net.tascalate.javaflow.providers.asm3/src/main/java/org/apache/commons/javaflow/providers/asm3/Asm3ClassTransformer.java renamed to net.tascalate.javaflow.providers.asm3/src/main/java/org/apache/commons/javaflow/providers/asm3/ContinuableClassTransformer.java

@@ -23,35 +23,36 @@
  */
 package org.apache.commons.javaflow.providers.asm3;
 
-import org.objectweb.asm.ClassReader;
-import org.objectweb.asm.ClassWriter;
+import java.util.Collection;
 
-import org.apache.commons.javaflow.spi.ContinuableClassInfoResolver;
-import org.apache.commons.javaflow.spi.ResourceTransformer;
+import org.apache.commons.javaflow.spi.AbstractResourceTransformer;
 import org.apache.commons.javaflow.spi.StopException;
 
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
 /**
  * AsmClassTransformer
  * 
  * @author Eugene Kuleshov
  */
-class Asm3ClassTransformer implements ResourceTransformer {
+class ContinuableClassTransformer extends AbstractResourceTransformer {
 
     private final ClassHierarchy classHierarchy;
-    private final ContinuableClassInfoResolver cciResolver;
+    private final IContinuableClassInfoResolver cciResolver;
 
-    Asm3ClassTransformer(ClassHierarchy classHierarchy, ContinuableClassInfoResolver cciResolver) {
+    ContinuableClassTransformer(ClassHierarchy classHierarchy, IContinuableClassInfoResolver cciResolver) {
         this.classHierarchy = classHierarchy;
         this.cciResolver = cciResolver;
     }
 
-    public byte[] transform(byte[] original) {
+    public byte[] transform(byte[] original, Collection<String> retransformClasses) {
         ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES) {
             @Override
             protected String getCommonSuperClass(final String type1, final String type2) {
                 return classHierarchy.getCommonSuperClass(type1, type2);
             }
         };
+        cciResolver.reset(retransformClasses);
         ContinuableClassVisitor visitor = new ContinuableClassVisitor(
             cw /* BytecodeDebugUtils.decorateClassVisitor(cw, true, * System.err) -- DUMP*/, 
             classHierarchy,
@@ -73,4 +74,8 @@ protected String getCommonSuperClass(final String type1, final String type2) {
         // BytecodeDebugUtils.dumpClass(bytecode);
         return bytecode;
     }
+    
+    public void release() {
+        cciResolver.release();
+    }
 }

net.tascalate.javaflow.providers.asm3/src/main/java/org/apache/commons/javaflow/providers/asm3/ContinuableClassVisitor.java

@@ -29,8 +29,6 @@
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 
-import org.apache.commons.javaflow.spi.ContinuableClassInfo;
-import org.apache.commons.javaflow.spi.ContinuableClassInfoResolver;
 import org.apache.commons.javaflow.spi.StopException;
 
 /**
@@ -41,16 +39,16 @@
 class ContinuableClassVisitor extends ClassAdapter {
 
     private final ClassHierarchy classHierarchy;
-    private final ContinuableClassInfoResolver cciResolver;
+    private final IContinuableClassInfoResolver cciResolver;
     private final byte[] originalBytes;
 
     private String className;
-    private ContinuableClassInfo classInfo;
+    private IContinuableClassInfo classInfo;
     private boolean skipEnchancing = false;
 
     ContinuableClassVisitor(ClassVisitor cv, 
                             ClassHierarchy classHierarchy, 
-                            ContinuableClassInfoResolver cciResolver, 
+                            IContinuableClassInfoResolver cciResolver, 
                             byte[] originalBytes) {
         super(cv);
         this.classHierarchy = classHierarchy;
@@ -67,7 +65,7 @@ public void visit(int version, int access, String name, String signature, String
         className = name;
         classInfo = cciResolver.resolve(name, originalBytes);
 
-        if (null == classInfo || 
+        if (null == classInfo ||
             classInfo.isClassProcessed() || 
             cciResolver.veto().matches(name, signature, superName, interfaces)) {
             skipEnchancing = true;

net.tascalate.javaflow.providers.asm3/src/main/java/org/apache/commons/javaflow/providers/asm3/ContinuableMethodNode.java

@@ -71,6 +71,7 @@ class ContinuableMethodNode extends MethodNode implements Opcodes {
                           ClassHierarchy classHierarchy, 
                           ContinuableClassInfoResolver cciResolver, 
                           MethodVisitor mv) {
+        
         super(access, name, desc, signature, exceptions);
         this.className = className;
         this.classHierarchy = classHierarchy;

net.tascalate.javaflow.providers.asm3/src/main/java/org/apache/commons/javaflow/providers/asm3/ContinuableClassInfoInternal.java renamed to net.tascalate.javaflow.providers.asm3/src/main/java/org/apache/commons/javaflow/providers/asm3/IContinuableClassInfo.java

@@ -19,27 +19,27 @@
 
 import org.apache.commons.javaflow.spi.ContinuableClassInfo;
 
-class ContinuableClassInfoInternal implements ContinuableClassInfo {
+class IContinuableClassInfo implements ContinuableClassInfo {
     private boolean processed;
     private final Set<String> methods;
 
-    ContinuableClassInfoInternal(boolean defaultProcessed, Set<String> methods) {
+    IContinuableClassInfo(boolean defaultProcessed, Set<String> methods) {
         this.processed = defaultProcessed;
         this.methods = methods;
     }
+    
+    public boolean isContinuableMethod(int access, String name, String desc, String signature) {
+        return methods.contains(name + desc);
+    }
 
-    public boolean isClassProcessed() {
+    boolean isClassProcessed() {
         return processed;
     }
 
-    public void markClassProcessed() {
+    void markClassProcessed() {
         processed = true;
     }
 
-    public boolean isContinuableMethod(int access, String name, String desc, String signature) {
-        return methods.contains(name + desc);
-    }
-
     Set<String> continuableMethods() {
         return methods;
     }