Creating API that can be invoked programatically: Use Retrolambda.reify ...

retrolambda/src/main/java/net/orfjackal/retrolambda/Retrolambda.java

@@ -16,6 +16,63 @@
 import java.util.*;
 
 public class Retrolambda {
+    /** Public method exposed to external users of the module to backport
+     * content of a classfile into pre-JDK8 format. Primarilly eliminate
+     * use of invokeDynamic instruction for all lambda invocations. Also
+     * do something with interface static and defender methods.
+     * 
+     * @param bytecodeVersion version of bytecode to generate
+     * @param classes class loader to use when loading other classes related to the 
+     *   one being backported
+     * @param arr the bytes of a classfile to backport
+     * @return newly generated classes as well as updated content overriding
+     *    already existing classes
+     */
+
+    public static Map<String, byte[]> reify(
+        int bytecodeVersion, ClassLoader classes, byte[] arr
+    ) {
+        Map<String, byte[]> classFiles = new HashMap<>();
+        ClassSaver saver = new ClassSaver(null) {
+            @Override
+            public void save(byte[] bytecode) throws IOException {
+                if (bytecode == null) {
+                    return;
+                }
+                ClassReader cr = new ClassReader(bytecode);
+                classFiles.put(cr.getClassName(), bytecode);
+            }
+        };
+        ClassHierarchyAnalyzer analyzer = new ClassHierarchyAnalyzer();
+        Transformers transformers = new Transformers(bytecodeVersion, analyzer);
+        LambdaClassSaver lambdaClassSaver = new LambdaClassSaver(saver, transformers);
+        ClassLoader prev = Thread.currentThread().getContextClassLoader();
+        try (LambdaClassDumper dumper = new LambdaClassDumper(lambdaClassSaver)) {
+            Thread.currentThread().setContextClassLoader(classes);
+            dumper.install();
+
+            analyzer.analyze(arr);
+
+            for (ClassReader reader : analyzer.getInterfaces()) {
+                byte[] companion = transformers.extractInterfaceCompanion(reader);
+                ClassReader cr = new ClassReader(companion);
+                classFiles.put(cr.getClassName(), companion);
+
+                byte[] replace = transformers.backportInterface(reader);
+                ClassReader rcr = new ClassReader(replace);
+                classFiles.put(rcr.getClassName(), replace);
+            }
+            for (ClassReader reader : analyzer.getClasses()) {
+                byte[] replace = transformers.backportClass(reader);
+                ClassReader rcr = new ClassReader(replace);
+                classFiles.put(rcr.getClassName(), replace);
+            }
+        } finally {
+            Thread.currentThread().setContextClassLoader(prev);
+        }
+        return classFiles;
+    }
+
 
     public static void run(Config config) throws Throwable {
         int bytecodeVersion = config.getBytecodeVersion();

retrolambda/src/test/java/net/orfjackal/retrolambda/InMemoryTest.java

@@ -0,0 +1,51 @@
+package net.orfjackal.retrolambda;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import net.orfjackal.retrolambda.files.ClassSaver;
+import net.orfjackal.retrolambda.interfaces.ClassHierarchyAnalyzer;
+import net.orfjackal.retrolambda.lambdas.LambdaClassDumper;
+import net.orfjackal.retrolambda.lambdas.LambdaClassSaver;
+import static org.junit.Assert.*;
+import org.junit.Test;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.Opcodes;
+
+/**
+ *
+ * @author Jaroslav Tulach
+ */
+public class InMemoryTest {
+    @Test public void convertSingleClass() throws Exception {
+        InputStream is = InMemoryTest.class.getResourceAsStream("UseLambda.class");
+        byte[] arr = new byte[is.available()];
+        int len = is.read(arr);
+        assertEquals("Read just enough", arr.length, len);
+        ClassLoader classes = InMemoryTest.class.getClassLoader();
+        int bytecodeVersion = Opcodes.V1_7;
+
+        Map<String,byte[]> classFiles = Retrolambda.reify(bytecodeVersion, classes, arr);
+
+        ClassLoader l = new ClassLoader(UseLambda.class.getClassLoader().getParent()) {
+            @Override
+            protected Class<?> findClass(String name) throws ClassNotFoundException {
+                byte[] arr = classFiles.get(name.replace('.', '/'));
+                if (arr == null) {
+                    return null;
+                }
+                return defineClass(name, arr, 0, arr.length);
+            }
+        };
+
+        Class<?> useLambda = l.loadClass(UseLambda.class.getName());
+        Object ret = useLambda.getMethod("fourtyTwo").invoke(null);
+        assertEquals("Computed ok", 42, ret);
+    }
+
+}

retrolambda/src/test/java/net/orfjackal/retrolambda/UseLambda.java

@@ -0,0 +1,21 @@
+package net.orfjackal.retrolambda;
+
+/**
+ *
+ * @author Jaroslav Tulach
+ */
+public final class UseLambda {
+
+    public static void invoke(int times, Runnable r) {
+        for (int i = 0; i < times; i++) {
+            r.run();
+        }
+    }
+
+    public static int fourtyTwo() {
+        int[] arr = {0};
+        invoke(21, () -> arr[0] += 2);
+        return arr[0];
+    }
+
+}