Implement accessing Module Imports (#31)

* Allows accessing ImportTypes from compiled Module

* Implement Unit Test

* Do not bump Version in PR

* General Refactoring

* Redesign imports method

Currently only accessing imports is supported

* Restrict direct access to value object and make it typesafe

* Code Cleanup and fix Unit Tests

* Implement Global Import Inspection

* Implement Accessing Import Memory

* Implement Accessing Import Tables

Author: BjoernAkAManf

Diff for: build.gradle

@@ -12,12 +12,14 @@ group = 'io.github.kawamuray.wasmtime'
 version = '0.9.0'
 
 repositories {
-    jcenter()
+    mavenCentral()
 }
 
 dependencies {
     compileOnly 'org.projectlombok:lombok:1.18.12'
     annotationProcessor 'org.projectlombok:lombok:1.18.12'
+    testCompileOnly 'org.projectlombok:lombok:1.18.12'
+    testAnnotationProcessor 'org.projectlombok:lombok:1.18.12'
     implementation 'org.slf4j:slf4j-api:1.7.25'
     testImplementation 'junit:junit:4.13'
     testRuntimeOnly 'ch.qos.logback:logback-classic:1.2.3'

Diff for: src/main/java/io/github/kawamuray/wasmtime/GlobalType.java

@@ -0,0 +1,11 @@
+package io.github.kawamuray.wasmtime;
+
+import lombok.AllArgsConstructor;
+import lombok.Value;
+
+@Value
+@AllArgsConstructor
+public class GlobalType {
+    Val.Type content;
+    Mutability mutability;
+}

Diff for: src/main/java/io/github/kawamuray/wasmtime/ImportType.java

@@ -0,0 +1,59 @@
+package io.github.kawamuray.wasmtime;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+
+@Accessors(fluent = true)
+@AllArgsConstructor(access = AccessLevel.PACKAGE)
+public class ImportType {
+    public enum Type {
+        FUNC,
+        GLOBAL,
+        TABLE,
+        MEMORY,
+        // TODO: Currently Unsupported
+        INSTANCE,
+        MODULE
+    }
+
+    @Getter
+    private final Type type;
+
+    @Getter(AccessLevel.PACKAGE)
+    private final Object typeObj;
+
+    @Getter
+    private final String module;
+
+    @Getter
+    private final String name;
+
+    private void ensureType(ImportType.Type expected) {
+        if (type != expected) {
+            throw new RuntimeException(
+                String.format("ImportType expected to have type %s but is actually %s", expected, type));
+        }
+    }
+
+    public FuncType func() {
+        ensureType(ImportType.Type.FUNC);
+        return (FuncType) typeObj;
+    }
+
+    public GlobalType global() {
+        ensureType(ImportType.Type.GLOBAL);
+        return (GlobalType) typeObj;
+    }
+
+    public MemoryType memory() {
+        ensureType(ImportType.Type.MEMORY);
+        return (MemoryType) typeObj;
+    }
+
+    public TableType table() {
+        ensureType(ImportType.Type.TABLE);
+        return (TableType) typeObj;
+    }
+}

Diff for: src/main/java/io/github/kawamuray/wasmtime/Module.java

@@ -23,6 +23,8 @@ public static Module fromBinary(Engine engine, byte[] bytes) {
         return new Module(newFromBinary(engine.innerPtr(), bytes));
     }
 
+    public native ImportType[] imports();
+
     @Override
     public native void dispose();
 

Diff for: src/main/java/io/github/kawamuray/wasmtime/Mutability.java

@@ -0,0 +1,6 @@
+package io.github.kawamuray.wasmtime;
+
+public enum Mutability {
+    CONST,
+    VAR,
+}

Diff for: src/main/java/io/github/kawamuray/wasmtime/TableType.java

@@ -0,0 +1,11 @@
+package io.github.kawamuray.wasmtime;
+
+import lombok.Value;
+import lombok.experimental.Accessors;
+
+@Value
+@Accessors(fluent = true)
+public class TableType {
+    Val.Type element;
+    MemoryType.Limit limit;
+}

Diff for: src/test/java/io/github/kawamuray/wasmtime/ModuleTest.java

@@ -1,19 +1,184 @@
 package io.github.kawamuray.wasmtime;
 
+import lombok.Data;
+import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.function.Consumer;
+
 public class ModuleTest {
     private static final byte[] WAT_BINARY = ("(module"
-                                             + "  (func (export \"add\") (param $p1 i32) (param $p2 i32) (result i32)"
-                                             + "    local.get $p1\n"
-                                             + "    local.get $p2\n"
-                                             + "    i32.add)"
-                                             + ")").getBytes();
+                                              + "  (func (export \"add\") (param $p1 i32) (param $p2 i32) (result i32)"
+                                              + "    local.get $p1\n"
+                                              + "    local.get $p2\n"
+                                              + "    i32.add)"
+                                              + ")").getBytes();
+
+    // Required: Only one memory may be defined
+    private static final byte[] MEM2 = ("(module" +
+                                        "  (import \"mem\" \"two\" (memory $mem2 13 37))" +
+                                        ")").getBytes();
+
+    private static final byte[] IMPORT_WAT_BINARY = ("(module" +
+                                                     "  (global $m1 (import \"globals\" \"mutable\") (mut i32))\n" +
+                                                     "  (global $c2 (import \"globalz\" \"const\") i64)\n" +
+                                                     "  (func $hello (import \"first\" \"package\"))\n" +
+                                                     "  (import \"tbl\" \"small\" (table 0 4 anyfunc))\n" +
+                                                     "  (import \"tbl\" \"big\" (table 12 1995 anyfunc))\n" +
+                                                     "  (import \"lua\" \"integration\" (table 1 anyfunc))\n" +
+                                                     "  (import \"env\" \"memory\" (memory $mem 1))\n" +
+                                                     "  (import \"\" \"package\" (func $world (param $p1 i32)))\n" +
+                                                     "  (import \"xyz\" \"return\" (func (result i32)))\n" +
+                                                     "  (import \"xyz\" \"return\" (func (param i32 i32 i32 i32 i32)))\n" +
+                                                     "  (func (export \"run\") (call $hello))\n" +
+                                                     ")").getBytes();
+
     @Test
     public void testCreateDispose() {
         try (Engine engine = new Engine()) {
             Module module = new Module(engine, WAT_BINARY);
             module.close();
         }
     }
+
+    @Test
+    public void testMem2() {
+        try (
+            Engine engine = new Engine();
+            Module module = new Module(engine, MEM2)
+        ) {
+            runImportTest(module, new TestImportData[]{
+                TestImportData.memory("mem", "two", 13, 37)
+            });
+        }
+    }
+
+    @Test
+    public void testAccessImports() {
+        try (
+            Engine engine = new Engine();
+            Module module = new Module(engine, IMPORT_WAT_BINARY)
+        ) {
+            // TODO: Test other import typese
+            runImportTest(module, new TestImportData[]{
+                TestImportData.global("globals", "mutable", Val.Type.I32, Mutability.VAR),
+                TestImportData.global("globalz", "const", Val.Type.I64, Mutability.CONST),
+                TestImportData.func("first", "package", new Val.Type[]{}, new Val.Type[]{}),
+                TestImportData.table("tbl", "small", Val.Type.FUNC_REF, 0, 4),
+                TestImportData.table("tbl", "big", Val.Type.FUNC_REF, 12, 1995),
+                TestImportData.table("lua", "integration", Val.Type.FUNC_REF, 1, -1),
+                TestImportData.memory("env", "memory", 1, -1),
+                TestImportData.func("", "package", new Val.Type[]{Val.Type.I32}, new Val.Type[]{}),
+                TestImportData.func("xyz", "return", new Val.Type[]{}, new Val.Type[]{Val.Type.I32}),
+                TestImportData.func("xyz", "return", new Val.Type[]{Val.Type.I32, Val.Type.I32, Val.Type.I32, Val.Type.I32, Val.Type.I32}, new Val.Type[]{})
+            });
+        }
+    }
+
+    private void runImportTest(Module module, TestImportData<?>[] testData) {
+        int i = 0;
+        for (ImportType imp : module.imports()) {
+            Assert.assertTrue("Test Data not big enough", testData.length > i);
+            TestImportData<?> data = testData[i];
+            Assert.assertEquals(data.getModule(), imp.module());
+            Assert.assertEquals(data.getName(), imp.name());
+            Assert.assertEquals(data.getType(), imp.type());
+            checkImportType(data, imp);
+            i += 1;
+        }
+        Assert.assertEquals("Not Every Test Case was returned", testData.length, i);
+    }
+
+    private <T> void checkImportType(TestImportData<T> data, ImportType type) {
+        Class<T> clazz = data.getClazz();
+        Object typeObj = type.typeObj();
+        Assert.assertNotNull("Type Object is null", typeObj);
+        Class<?> typeObjClass = typeObj.getClass();
+        Assert.assertTrue(String.format("Expected Type is different. Expected %s but was %s", clazz, typeObjClass), clazz.isAssignableFrom(typeObjClass));
+        data.verify(type, typeObj);
+    }
+
+    @Data
+    private static class TestImportData<T> {
+        private final String module;
+        private final String name;
+        private final ImportType.Type type;
+        private final Class<T> clazz;
+        private final Consumer<ImportType> verifyImport;
+        private final Consumer<T> consumer;
+
+        static TestImportData<MemoryType> memory(String module, String name, int min, int max) {
+            return new TestImportData<>(
+                module, name, ImportType.Type.MEMORY, MemoryType.class,
+                mod -> {
+                    Assert.assertThrows(RuntimeException.class, mod::func);
+                    Assert.assertThrows(RuntimeException.class, mod::global);
+                    Assert.assertEquals(mod.typeObj(), mod.memory());
+                    Assert.assertThrows(RuntimeException.class, mod::table);
+                },
+                mem -> {
+                    MemoryType.Limit limit = mem.limit();
+                    Assert.assertEquals(min, limit.min());
+                    Assert.assertEquals(max, limit.max());
+                }
+            );
+        }
+
+        static TestImportData<GlobalType> global(String module, String name, Val.Type content, Mutability mutability) {
+            return new TestImportData<>(
+                module, name, ImportType.Type.GLOBAL, GlobalType.class,
+                mod -> {
+                    Assert.assertThrows(RuntimeException.class, mod::func);
+                    Assert.assertEquals(mod.typeObj(), mod.global());
+                    Assert.assertThrows(RuntimeException.class, mod::memory);
+                    Assert.assertThrows(RuntimeException.class, mod::table);
+                },
+                global -> {
+                    Assert.assertEquals(content, global.getContent());
+                    Assert.assertEquals(mutability, global.getMutability());
+                }
+            );
+        }
+
+        static TestImportData<FuncType> func(String module, String name, Val.Type[] params, Val.Type[] results) {
+            return new TestImportData<>(
+                module, name, ImportType.Type.FUNC, FuncType.class,
+                mod -> {
+                    Assert.assertEquals(mod.typeObj(), mod.func());
+                    Assert.assertThrows(RuntimeException.class, mod::global);
+                    Assert.assertThrows(RuntimeException.class, mod::memory);
+                    Assert.assertThrows(RuntimeException.class, mod::table);
+                },
+                func -> {
+                    Assert.assertArrayEquals(params, func.getParams());
+                    Assert.assertArrayEquals(results, func.getResults());
+                }
+            );
+        }
+
+        public static TestImportData<TableType> table(String module, String name, Val.Type content, int min, int max) {
+            return new TestImportData<>(
+                module, name, ImportType.Type.TABLE, TableType.class,
+                mod -> {
+                    Assert.assertThrows(RuntimeException.class, mod::func);
+                    Assert.assertThrows(RuntimeException.class, mod::global);
+                    Assert.assertThrows(RuntimeException.class, mod::memory);
+                    Assert.assertEquals(mod.typeObj(), mod.table());
+                },
+                table -> {
+                    Assert.assertEquals(content, table.element());
+
+                    MemoryType.Limit limit = table.limit();
+                    Assert.assertEquals(min, limit.min());
+                    Assert.assertEquals(max, limit.max());
+                }
+            );
+        }
+
+        @SuppressWarnings("unchecked")
+        public void verify(final ImportType imp, final Object typeObj) {
+            this.verifyImport.accept(imp);
+            this.consumer.accept((T) typeObj);
+        }
+    }
 }

Diff for: wasmtime-jni/src/io_github_kawamuray_wasmtime_Global/imp.rs

@@ -2,21 +2,17 @@ use super::JniGlobal;
 use crate::errors::{self, Result};
 use crate::store::StoreData;
 use crate::{interop, wval};
-use jni::objects::{JObject};
+use jni::objects::JObject;
 use jni::sys::{jlong, jobject};
-use jni::{JNIEnv};
+use jni::JNIEnv;
 use wasmtime::{Global, Store};
 
 pub(super) struct JniGlobalImpl;
 
 impl<'a> JniGlobal<'a> for JniGlobalImpl {
     type Error = errors::Error;
 
-    fn native_get(
-        env: &JNIEnv,
-        this: JObject,
-        store_ptr: jlong,
-    ) -> Result<jobject, Self::Error> {
+    fn native_get(env: &JNIEnv, this: JObject, store_ptr: jlong) -> Result<jobject, Self::Error> {
         let mut store = interop::ref_from_raw::<Store<StoreData>>(store_ptr)?;
         let global = interop::get_inner::<Global>(&env, this)?;
 
@@ -35,14 +31,9 @@ impl<'a> JniGlobal<'a> for JniGlobalImpl {
         let global = interop::get_inner::<Global>(&env, this)?;
         global.set(&mut *store, wval::from_java(env, val)?)?;
         Ok(())
-        
     }
 
-    fn native_mutable(
-        env: &JNIEnv,
-        this: JObject,
-        store_ptr: jlong,
-    ) -> Result<u8, Self::Error> {
+    fn native_mutable(env: &JNIEnv, this: JObject, store_ptr: jlong) -> Result<u8, Self::Error> {
         let mut store = interop::ref_from_raw::<Store<StoreData>>(store_ptr)?;
         let global = interop::get_inner::<Global>(&env, this)?;
         let ty = global.ty(&mut *store);
@@ -56,5 +47,4 @@ impl<'a> JniGlobal<'a> for JniGlobalImpl {
         interop::dispose_inner::<Global>(&env, this)?;
         Ok(())
     }
-
 }

Diff for: wasmtime-jni/src/io_github_kawamuray_wasmtime_Global/mod.rs

@@ -22,22 +22,14 @@ macro_rules! wrap_error {
 trait JniGlobal<'a> {
     type Error: Desc<'a, JThrowable<'a>>;
     fn dispose(env: &JNIEnv, this: JObject) -> Result<(), Self::Error>;
-    fn native_get(
-        env: &JNIEnv,
-        this: JObject,
-        store_ptr: jlong,
-    ) -> Result<jobject, Self::Error>;
+    fn native_get(env: &JNIEnv, this: JObject, store_ptr: jlong) -> Result<jobject, Self::Error>;
     fn native_set(
         env: &JNIEnv,
         this: JObject,
         store_ptr: jlong,
         val: JObject,
     ) -> Result<(), Self::Error>;
-    fn native_mutable(
-        env: &JNIEnv,
-        this: JObject,
-        store_ptr: jlong,
-    ) -> Result<u8, Self::Error>;
+    fn native_mutable(env: &JNIEnv, this: JObject, store_ptr: jlong) -> Result<u8, Self::Error>;
 }
 
 #[no_mangle]
@@ -78,9 +70,5 @@ extern "system" fn Java_io_github_kawamuray_wasmtime_Global_nativeMutable(
     this: JObject,
     store_ptr: jlong,
 ) -> jboolean {
-    wrap_error!(
-        env,
-        JniGlobalImpl::native_mutable(&env, this, store_ptr),
-        0
-    )
+    wrap_error!(env, JniGlobalImpl::native_mutable(&env, this, store_ptr), 0)
 }