Dev: fix memory leak in @swiftblock

Author: andriydruk

compiler/src/main/java/com/readdle/codegen/SwiftBlockDescriptor.java

@@ -151,7 +151,8 @@ File generateCode() throws IOException {
                 sig));
 
         swiftWriter.emitEmptyLine();
-        swiftWriter.emitStatement(String.format("public lazy var block: %s = {", simpleTypeName));
+        swiftWriter.emitStatement(String.format("public var block: %s {", simpleTypeName));
+        swiftWriter.emitStatement("return {");
 
         for (SwiftParamDescriptor param : params) {
             swiftWriter.emitStatement(String.format("let java_%s: JNIArgumentProtocol", param.name));
@@ -243,6 +244,7 @@ File generateCode() throws IOException {
             swiftWriter.emitStatement("}");
         }
 
+        swiftWriter.emitStatement("}");
         swiftWriter.emitStatement("}");
 
         swiftWriter.emitEmptyLine();

sample/src/androidTest/java/com/readdle/swiftjava/sample/MemoryLeakVerifier.java

@@ -0,0 +1,48 @@
+package com.readdle.swiftjava.sample;
+
+import org.junit.Assert;
+
+import java.lang.ref.WeakReference;
+
+public class MemoryLeakVerifier {
+
+    private static final int MAX_GC_ITERATIONS = 50;
+    private static final int GC_SLEEP_TIME = 100;
+
+    private final WeakReference reference;
+
+    public MemoryLeakVerifier(Object object) {
+        this.reference = new WeakReference(object);
+    }
+
+    public Object getObject() {
+        return reference.get();
+    }
+
+    /**
+     * Attempts to perform a full garbage collection so that all weak references will be removed. Usually only
+     * a single GC is required, but there have been situations where some unused memory is not cleared up on the
+     * first pass. This method performs a full garbage collection and then validates that the weak reference
+     * now has been cleared. If it hasn't then the thread will sleep for 50 milliseconds and then retry up to
+     * 10 more times. If after this the object still has not been collected then the assertion will fail.
+     * <p>
+     * Based upon the method described in: http://www.javaworld.com/javaworld/javatips/jw-javatip130.html
+     */
+    public void assertGarbageCollected(String name) {
+        Runtime runtime = Runtime.getRuntime();
+        for (int i = 0; i < MAX_GC_ITERATIONS; i++) {
+            runtime.runFinalization();
+            runtime.gc();
+            if (getObject() == null)
+                break;
+
+            // Pause for a while and then go back around the loop to try again...
+            try {
+                Thread.sleep(GC_SLEEP_TIME);
+            } catch (InterruptedException e) {
+                // Ignore any interrupts and just try again...
+            }
+        }
+        Assert.assertNull(name + ": object should not exist after " + MAX_GC_ITERATIONS + " collections", getObject());
+    }
+}

sample/src/androidTest/java/com/readdle/swiftjava/sample/SampleReferenceTest.java

@@ -1,5 +1,10 @@
 package com.readdle.swiftjava.sample;
 
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.LargeTest;
+
 import com.readdle.codegen.anotation.JavaSwift;
 import com.readdle.codegen.anotation.SwiftError;
 import com.readdle.swiftjava.sample.asbtracthierarhy.AbstractType;
@@ -10,11 +15,6 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.test.runner.AndroidJUnit4;
-import android.test.suitebuilder.annotation.LargeTest;
-
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
@@ -163,6 +163,30 @@ public String call(@Nullable Exception error, @Nullable String string) {
         Assert.assertTrue(result.equals("123"));
     }
 
+    @Test
+    public void testBlockMemoryLeak() {
+        SampleReference.CompletionBlock block = new SampleReference.CompletionBlock() {
+            @Nullable
+            @Override
+            public String call(@Nullable Exception error, @Nullable String string) {
+                if (error == null) {
+                    return string;
+                }
+                else {
+                    return null;
+                }
+            }
+        };
+
+        MemoryLeakVerifier memoryLeakVerifier = new MemoryLeakVerifier(block);
+
+        String result = sampleReference.funcWithBlock(block);
+        Assert.assertNotNull(result);
+
+        block = null;
+        memoryLeakVerifier.assertGarbageCollected("SampleReference.CompletionBlock");
+    }
+
     @Test
     public void testAbstractTypes() {
         AbstractType child = sampleReference.getAbstractType();