Added TableKind for tables

src/Table.cs

@@ -4,6 +4,22 @@
 
 namespace Wasmtime
 {
+    /// <summary>
+    /// Represents the possible kinds of WebAssembly values stored in a table
+    /// </summary>
+    public enum TableKind
+    {
+        /// <summary>
+        /// The value is a function reference.
+        /// </summary>
+        FuncRef = ValueKind.FuncRef,
+
+        /// <summary>
+        /// The value is an external reference.
+        /// </summary>
+        ExternRef = ValueKind.ExternRef,
+    }
+
     /// <summary>
     /// Represents a WebAssembly table.
     /// </summary>
@@ -17,14 +33,28 @@ public class Table : IExternal
         /// <param name="initialValue">The initial value for elements in the table.</param>
         /// <param name="initial">The number of initial elements in the table.</param>
         /// <param name="maximum">The maximum number of elements in the table.</param>
+        [Obsolete("Replace ValueKind parameter with TableKind")]
         public Table(Store store, ValueKind kind, object? initialValue, uint initial, uint maximum = uint.MaxValue)
+            : this(store, (TableKind)kind, initialValue, initial, maximum)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new WebAssembly table.
+        /// </summary>
+        /// <param name="store">The store to create the table in.</param>
+        /// <param name="kind">The value kind for the elements in the table.</param>
+        /// <param name="initialValue">The initial value for elements in the table.</param>
+        /// <param name="initial">The number of initial elements in the table.</param>
+        /// <param name="maximum">The maximum number of elements in the table.</param>
+        public Table(Store store, TableKind kind, object? initialValue, uint initial, uint maximum = uint.MaxValue)
         {
             if (store is null)
             {
                 throw new ArgumentNullException(nameof(store));
             }
 
-            if (kind != ValueKind.ExternRef && kind != ValueKind.FuncRef)
+            if (kind != TableKind.ExternRef && kind != TableKind.FuncRef)
             {
                 throw new WasmtimeException($"Table elements must be externref or funcref.");
             }
@@ -63,7 +93,7 @@ public Table(Store store, ValueKind kind, object? initialValue, uint initial, ui
         /// Gets the value kind of the table.
         /// </summary>
         /// <value></value>
-        public ValueKind Kind { get; private set; }
+        public TableKind Kind { get; private set; }
 
         /// <summary>
         /// The minimum table element size.
@@ -154,7 +184,7 @@ internal Table(Store store, ExternTable table)
             using var type = new TypeHandle(Native.wasmtime_table_type(store.Context.handle, this.table));
             GC.KeepAlive(store);
 
-            this.Kind = ValueType.ToKind(Native.wasm_tabletype_element(type.DangerousGetHandle()));
+            this.Kind = (TableKind)ValueType.ToKind(Native.wasm_tabletype_element(type.DangerousGetHandle()));
 
             unsafe
             {

src/Value.cs

@@ -59,6 +59,11 @@ public static bool IsAssignableFrom(this ValueKind kind, Type type)
 
     internal static class ValueType
     {
+        public static IntPtr FromKind(TableKind kind)
+        {
+            return FromKind((ValueKind)kind);
+        }
+
         public static IntPtr FromKind(ValueKind kind)
         {
             switch (kind)
@@ -251,6 +256,11 @@ public ValueBox ToValueBox()
             }
         }
 
+        public static Value FromObject(object? o, TableKind kind)
+        {
+            return FromObject(o, (ValueKind)kind);
+        }
+
         public static Value FromObject(object? o, ValueKind kind)
         {
             var value = new Value();

tests/TableExportsTests.cs

@@ -50,19 +50,19 @@ public void ItCreatesExternsForTheTables()
 
             var table1 = instance.GetTable("table1");
             table1.Should().NotBeNull();
-            table1.Kind.Should().Be(ValueKind.FuncRef);
+            table1.Kind.Should().Be(TableKind.FuncRef);
             table1.Minimum.Should().Be(1);
             table1.Maximum.Should().Be(10);
 
             var table2 = instance.GetTable("table2");
             table2.Should().NotBeNull();
-            table2.Kind.Should().Be(ValueKind.FuncRef);
+            table2.Kind.Should().Be(TableKind.FuncRef);
             table2.Minimum.Should().Be(10);
             table2.Maximum.Should().Be(uint.MaxValue);
 
             var table3 = instance.GetTable("table3");
             table3.Should().NotBeNull();
-            table3.Kind.Should().Be(ValueKind.FuncRef);
+            table3.Kind.Should().Be(TableKind.FuncRef);
             table3.Minimum.Should().Be(100);
             table3.Maximum.Should().Be(1000);
         }