Add Extern autodoc test

src/extern.zig

@@ -72,12 +72,47 @@ pub const Extern = extern struct {
     extern "c" fn wasmtime_extern_type(*const Store.Context, *const Extern) *ExternType;
 };
 
-// pub const ExternVec = Vec(*Extern, wasm_extern_vec_new_empty, wasm_extern_vec_new_uninitialized, wasm_extern_vec_new, wasm_extern_vec_copy, wasm_extern_vec_delete);
-// extern "c" fn wasm_extern_vec_new_empty(*anyopaque, usize) void;
-// extern "c" fn wasm_extern_vec_new_uninitialized(*anyopaque, usize) void;
-// extern "c" fn wasm_extern_vec_new(*anyopaque, usize, [*]const ?*Extern) void;
-// extern "c" fn wasm_extern_vec_copy(*anyopaque, *const anyopaque) void;
-// extern "c" fn wasm_extern_vec_delete(*anyopaque) void;
+test Extern {
+    const std = @import("std");
+    const expect = std.testing.expect;
+
+    const wasm = @import("./main.zig");
+
+    const wat_bytes =
+        \\(module
+        \\  (func (export "some_function"))
+        \\  (global (export "some_global") (mut i32) (i32.const 0))
+        \\  (memory (export "some_memory") 1)
+        \\)
+    ;
+
+    // If an error *does* occur, settings up Diagnostics with debug_print will
+    // make sure that the error will actually be visible in the test log.
+    var diag = try wasm.Diagnostics.init(std.testing.allocator, true);
+    defer diag.deinit();
+
+    var engine = try wasm.Engine.initDefault();
+    defer engine.deinit();
+    var module = try wasm.Module.initFromWat(engine, wat_bytes, diag);
+    defer module.deinit();
+    var store = wasm.Store.init(engine);
+    defer store.deinit();
+    var context = store.getContext();
+
+    var instance = try wasm.Instance.init(context, module, &.{}, null);
+
+    const some_function = try instance.getByIndex(context, 0, wasm.Func);
+    const some_global = try instance.getByIndex(context, 1, wasm.Global);
+    const some_memory = try instance.getByIndex(context, 2, wasm.Memory);
+
+    try expect(std.mem.eql(u8, some_function.name, "some_function"));
+    try expect(std.mem.eql(u8, some_global.name, "some_global"));
+    try expect(std.mem.eql(u8, some_memory.name, "some_memory"));
+
+    try expect(instance.getByIndex(context, 3, wasm.Func) == error.ExportNotFound);
+    try expect(instance.get(context, "no_such_func", wasm.Func) == error.ExportNotFound);
+    try expect(instance.get(context, "some_function", wasm.Global) == error.IncorrectType);
+}
 
 pub const ExternType = opaque {
     pub fn copy(self: *const ExternType) *ExternType {
@@ -132,10 +167,3 @@ pub const ExternType = opaque {
     // extern "c" fn wasm_externtype_as_globaltype_const(*const ExternType) ?*const GlobalType;
     extern "c" fn wasm_externtype_as_memorytype_const(*const ExternType) ?*const MemoryType;
 };
-
-// pub const ExternTypeVec = Vec(*ExternType, wasm_externtype_vec_new_empty, wasm_externtype_vec_new_uninitialized, wasm_externtype_vec_new, wasm_externtype_vec_copy, wasm_externtype_vec_delete);
-// extern "c" fn wasm_externtype_vec_new_empty(*anyopaque, usize) void;
-// extern "c" fn wasm_externtype_vec_new_uninitialized(*anyopaque, usize) void;
-// extern "c" fn wasm_externtype_vec_new(*anyopaque, usize, [*]const ?*ExternType) void;
-// extern "c" fn wasm_externtype_vec_copy(*anyopaque, *const anyopaque) void;
-// extern "c" fn wasm_externtype_vec_delete(*anyopaque) void;

src/instance.zig

@@ -90,10 +90,10 @@ pub const Instance = extern struct {
         comptime T: type,
     ) !struct { result: T, name: []const u8 } {
         var result: Extern = undefined;
-        var name: [*]const u8 = null;
+        var name: [*]const u8 = undefined;
         var name_len: usize = undefined;
         return if (wasmtime_instance_export_nth(context, self, index, &name, &name_len, &result))
-            .{ .result = result.as(T), .name = name[0..name_len] }
+            .{ .result = try result.as(T), .name = name[0..name_len] }
         else
             error.ExportNotFound;
     }

src/main.zig

@@ -6,6 +6,7 @@ pub usingnamespace @import("./extern.zig");
 pub usingnamespace @import("./func.zig");
 pub usingnamespace @import("./instance.zig");
 pub usingnamespace @import("./linker.zig");
+pub usingnamespace @import("./memory.zig");
 pub usingnamespace @import("./module.zig");
 pub usingnamespace @import("./store.zig");
 pub usingnamespace @import("./trap.zig");

src/val.zig

@@ -2,7 +2,6 @@ const std = @import("std");
 const expect = std.testing.expect;
 
 const Func = @import("./func.zig").Func;
-const Extern = @import("./extern.zig").Extern;
 const Vec = @import("./vec.zig").Vec;
 
 /// A host-defined un-forgeable reference to pass into WebAssembly.
@@ -144,48 +143,41 @@ pub const Val = extern struct {
 
     extern "c" fn wasmtime_val_copy(*Val, *const Val) void;
     extern "c" fn wasmtime_val_delete(*Val) void;
-
-    test "convert value to Val and back" {
-        var small = Val.fromValue(i32, -12);
-        defer small.deinit();
-        try expect(small.kind == ValKind.i32);
-        try expect(small.of.i32 == -12);
-        try expect(try small.toValue(i32) == -12);
-
-        var large = Val.fromValue(u64, 10000000000000000000);
-        defer large.deinit();
-        try expect(large.kind == ValKind.i64);
-        // The provided integer can't be represented as an i64, but Wasm
-        // only knows about signed integers, so we have to store it as one.
-        try expect(large.of.i64 == @as(i64, @bitCast(@as(u64, 10000000000000000000))));
-        try expect(try large.toValue(u64) == 10000000000000000000);
-
-        var pi = Val.fromValue(f32, 3.14159);
-        defer pi.deinit();
-        try expect(pi.kind == ValKind.f32);
-        try expect(pi.of.f32 == 3.14159);
-        try expect(try pi.toValue(f32) == 3.14159);
-
-        var yes = Val.fromValue(bool, true);
-        defer yes.deinit();
-        try expect(yes.kind == ValKind.i32);
-        try expect(yes.of.i32 == 1);
-        try expect(try yes.toValue(bool) == true);
-
-        var no = Val.fromValue(bool, false);
-        defer no.deinit();
-        try expect(no.kind == ValKind.i32);
-        try expect(no.of.i32 == 0);
-        try expect(try no.toValue(bool) == false);
-    }
 };
 
-// pub const ValVec = Vec(Val, wasm_val_vec_new_empty, wasm_val_vec_new_uninitialized, wasm_val_vec_new, wasm_val_vec_copy, wasm_val_vec_delete);
-// extern "c" fn wasm_val_vec_new_empty(*anyopaque, usize) void;
-// extern "c" fn wasm_val_vec_new_uninitialized(*anyopaque, usize) void;
-// extern "c" fn wasm_val_vec_new(*anyopaque, usize, [*]const Val) void;
-// extern "c" fn wasm_val_vec_copy(*anyopaque, *const anyopaque) void;
-// extern "c" fn wasm_val_vec_delete(*anyopaque) void;
+test Val {
+    var small = Val.fromValue(i32, -12);
+    defer small.deinit();
+    try expect(small.kind == ValKind.i32);
+    try expect(small.of.i32 == -12);
+    try expect(try small.toValue(i32) == -12);
+
+    var large = Val.fromValue(u64, 10000000000000000000);
+    defer large.deinit();
+    try expect(large.kind == ValKind.i64);
+    // The provided integer can't be represented as an i64, but Wasm
+    // only knows about signed integers, so we have to store it as one.
+    try expect(large.of.i64 == @as(i64, @bitCast(@as(u64, 10000000000000000000))));
+    try expect(try large.toValue(u64) == 10000000000000000000);
+
+    var pi = Val.fromValue(f32, 3.14159);
+    defer pi.deinit();
+    try expect(pi.kind == ValKind.f32);
+    try expect(pi.of.f32 == 3.14159);
+    try expect(try pi.toValue(f32) == 3.14159);
+
+    var yes = Val.fromValue(bool, true);
+    defer yes.deinit();
+    try expect(yes.kind == ValKind.i32);
+    try expect(yes.of.i32 == 1);
+    try expect(try yes.toValue(bool) == true);
+
+    var no = Val.fromValue(bool, false);
+    defer no.deinit();
+    try expect(no.kind == ValKind.i32);
+    try expect(no.of.i32 == 0);
+    try expect(try no.toValue(bool) == false);
+}
 
 /// An object representing the type of a value.
 pub const ValType = opaque {