Remove support for module linking (#85)

This gets tests to pass now that bytecodealliance/wasmtime#3958 has
landed.

Author: alexcrichton

tests/test_instance.py

@@ -71,25 +71,6 @@ def test_multiple_exports(self):
         assert(isinstance(instance.exports(store)[1], Func))
         assert(isinstance(instance.exports(store)[2], Global))
 
-    def test_instance_type(self):
-        store = Store()
-        module = Module(store.engine, """
-            (module
-                (func (export "a"))
-                (func (export "b"))
-                (global (export "c") i32 (i32.const 0))
-            )
-        """)
-        ty = Instance(store, module, []).type(store)
-        exports = ty.exports
-        self.assertEqual(len(exports), 3)
-        assert(isinstance(exports[0].type, FuncType))
-        assert(exports[0].name == 'a')
-        assert(isinstance(exports[1].type, FuncType))
-        assert(exports[1].name == 'b')
-        assert(isinstance(exports[2].type, GlobalType))
-        assert(exports[2].name == 'c')
-
     def test_import_func(self):
         store = Store()
         module = Module(store.engine, """

tests/test_module.py

@@ -111,43 +111,6 @@ def test_exports(self):
         self.assertEqual(ty.limits, Limits(1, None))
         self.assertEqual(ty.element, ValType.funcref())
 
-    def test_type(self):
-        store = Store()
-        module = Module(store.engine, """
-            (module
-                (import "" "" (func))
-                (import "a" "bcd" (global i32))
-                (import "" "x" (table 1 funcref))
-
-                (func (export "a") (param i32 f32) (result f64)
-                    f64.const 0)
-                (global (export "") (mut i32) (i32.const 1))
-                (memory (export "mem") 1)
-                (table (export "table") 1 funcref)
-            )
-        """)
-        ty = module.type
-        imports = ty.imports
-        exports = ty.exports
-        assert(imports[0].module == '')
-        assert(imports[0].name == '')
-        assert(isinstance(imports[0].type, FuncType))
-        assert(imports[1].module == 'a')
-        assert(imports[1].name == 'bcd')
-        assert(isinstance(imports[1].type, GlobalType))
-        assert(imports[2].module == '')
-        assert(imports[2].name == 'x')
-        assert(isinstance(imports[2].type, TableType))
-
-        assert(exports[0].name == 'a')
-        assert(isinstance(exports[0].type, FuncType))
-        assert(exports[1].name == '')
-        assert(isinstance(exports[1].type, GlobalType))
-        assert(exports[2].name == 'mem')
-        assert(isinstance(exports[2].type, MemoryType))
-        assert(exports[3].name == 'table')
-        assert(isinstance(exports[3].type, TableType))
-
     def test_serialize(self):
         engine = Engine()
         module = Module(engine, '(module)')

tests/test_module_linking.py

@@ -18,7 +18,7 @@
 from ._engine import Engine
 from ._store import Store, Storelike
 from ._types import FuncType, GlobalType, MemoryType, TableType
-from ._types import ValType, Limits, ImportType, ExportType, ModuleType, InstanceType
+from ._types import ValType, Limits, ImportType, ExportType
 from ._wat2wasm import wat2wasm
 from ._module import Module
 from ._value import Val, IntoVal

wasmtime/__init__.py

@@ -2035,12 +2035,6 @@ def wasmtime_config_wasm_multi_value_set(arg0: Any, arg1: Any) -> None:
 def wasmtime_config_wasm_multi_memory_set(arg0: Any, arg1: Any) -> None:
     return _wasmtime_config_wasm_multi_memory_set(arg0, arg1)  # type: ignore
 
-_wasmtime_config_wasm_module_linking_set = dll.wasmtime_config_wasm_module_linking_set
-_wasmtime_config_wasm_module_linking_set.restype = None
-_wasmtime_config_wasm_module_linking_set.argtypes = [POINTER(wasm_config_t), c_bool]
-def wasmtime_config_wasm_module_linking_set(arg0: Any, arg1: Any) -> None:
-    return _wasmtime_config_wasm_module_linking_set(arg0, arg1)  # type: ignore
-
 _wasmtime_config_wasm_memory64_set = dll.wasmtime_config_wasm_memory64_set
 _wasmtime_config_wasm_memory64_set.restype = None
 _wasmtime_config_wasm_memory64_set.argtypes = [POINTER(wasm_config_t), c_bool]
@@ -2101,41 +2095,6 @@ def wasmtime_config_cache_config_load(arg0: Any, arg1: Any) -> pointer:
 def wasmtime_engine_increment_epoch(engine: Any) -> None:
     return _wasmtime_engine_increment_epoch(engine)  # type: ignore
 
-class wasmtime_moduletype(Structure):
-    pass
-
-wasmtime_moduletype_t = wasmtime_moduletype
-
-_wasmtime_moduletype_delete = dll.wasmtime_moduletype_delete
-_wasmtime_moduletype_delete.restype = None
-_wasmtime_moduletype_delete.argtypes = [POINTER(wasmtime_moduletype_t)]
-def wasmtime_moduletype_delete(ty: Any) -> None:
-    return _wasmtime_moduletype_delete(ty)  # type: ignore
-
-_wasmtime_moduletype_imports = dll.wasmtime_moduletype_imports
-_wasmtime_moduletype_imports.restype = None
-_wasmtime_moduletype_imports.argtypes = [POINTER(wasmtime_moduletype_t), POINTER(wasm_importtype_vec_t)]
-def wasmtime_moduletype_imports(arg0: Any, out: Any) -> None:
-    return _wasmtime_moduletype_imports(arg0, out)  # type: ignore
-
-_wasmtime_moduletype_exports = dll.wasmtime_moduletype_exports
-_wasmtime_moduletype_exports.restype = None
-_wasmtime_moduletype_exports.argtypes = [POINTER(wasmtime_moduletype_t), POINTER(wasm_exporttype_vec_t)]
-def wasmtime_moduletype_exports(arg0: Any, out: Any) -> None:
-    return _wasmtime_moduletype_exports(arg0, out)  # type: ignore
-
-_wasmtime_moduletype_as_externtype = dll.wasmtime_moduletype_as_externtype
-_wasmtime_moduletype_as_externtype.restype = POINTER(wasm_externtype_t)
-_wasmtime_moduletype_as_externtype.argtypes = [POINTER(wasmtime_moduletype_t)]
-def wasmtime_moduletype_as_externtype(arg0: Any) -> pointer:
-    return _wasmtime_moduletype_as_externtype(arg0)  # type: ignore
-
-_wasmtime_externtype_as_moduletype = dll.wasmtime_externtype_as_moduletype
-_wasmtime_externtype_as_moduletype.restype = POINTER(wasmtime_moduletype_t)
-_wasmtime_externtype_as_moduletype.argtypes = [POINTER(wasm_externtype_t)]
-def wasmtime_externtype_as_moduletype(arg0: Any) -> pointer:
-    return _wasmtime_externtype_as_moduletype(arg0)  # type: ignore
-
 class wasmtime_module(Structure):
     pass
 
@@ -2159,18 +2118,24 @@ def wasmtime_module_delete(m: Any) -> None:
 def wasmtime_module_clone(m: Any) -> pointer:
     return _wasmtime_module_clone(m)  # type: ignore
 
+_wasmtime_module_imports = dll.wasmtime_module_imports
+_wasmtime_module_imports.restype = None
+_wasmtime_module_imports.argtypes = [POINTER(wasmtime_module_t), POINTER(wasm_importtype_vec_t)]
+def wasmtime_module_imports(module: Any, out: Any) -> None:
+    return _wasmtime_module_imports(module, out)  # type: ignore
+
+_wasmtime_module_exports = dll.wasmtime_module_exports
+_wasmtime_module_exports.restype = None
+_wasmtime_module_exports.argtypes = [POINTER(wasmtime_module_t), POINTER(wasm_exporttype_vec_t)]
+def wasmtime_module_exports(module: Any, out: Any) -> None:
+    return _wasmtime_module_exports(module, out)  # type: ignore
+
 _wasmtime_module_validate = dll.wasmtime_module_validate
 _wasmtime_module_validate.restype = POINTER(wasmtime_error_t)
 _wasmtime_module_validate.argtypes = [POINTER(wasm_engine_t), POINTER(c_uint8), c_size_t]
 def wasmtime_module_validate(engine: Any, wasm: Any, wasm_len: Any) -> pointer:
     return _wasmtime_module_validate(engine, wasm, wasm_len)  # type: ignore
 
-_wasmtime_module_type = dll.wasmtime_module_type
-_wasmtime_module_type.restype = POINTER(wasmtime_moduletype_t)
-_wasmtime_module_type.argtypes = [POINTER(wasmtime_module_t)]
-def wasmtime_module_type(arg0: Any) -> pointer:
-    return _wasmtime_module_type(arg0)  # type: ignore
-
 _wasmtime_module_serialize = dll.wasmtime_module_serialize
 _wasmtime_module_serialize.restype = POINTER(wasmtime_error_t)
 _wasmtime_module_serialize.argtypes = [POINTER(wasmtime_module_t), POINTER(wasm_byte_vec_t)]
@@ -2295,16 +2260,6 @@ class wasmtime_memory(Structure):
 
 wasmtime_memory_t = wasmtime_memory
 
-class wasmtime_instance(Structure):
-    _fields_ = [
-        ("store_id", c_uint64),
-        ("index", c_size_t),
-    ]
-    store_id: int
-    index: int
-
-wasmtime_instance_t = wasmtime_instance
-
 class wasmtime_global(Structure):
     _fields_ = [
         ("store_id", c_uint64),
@@ -2323,15 +2278,11 @@ class wasmtime_extern_union(Union):
         ("global_", wasmtime_global_t),
         ("table", wasmtime_table_t),
         ("memory", wasmtime_memory_t),
-        ("instance", wasmtime_instance_t),
-        ("module", POINTER(wasmtime_module_t)),
     ]
     func: wasmtime_func_t
     global_: wasmtime_global_t
     table: wasmtime_table_t
     memory: wasmtime_memory_t
-    instance: wasmtime_instance_t
-    module: pointer
 
 wasmtime_extern_union_t = wasmtime_extern_union
 
@@ -2551,47 +2502,22 @@ def wasmtime_global_get(store: Any, arg1: Any, out: Any) -> None:
 def wasmtime_global_set(store: Any, arg1: Any, val: Any) -> pointer:
     return _wasmtime_global_set(store, arg1, val)  # type: ignore
 
-class wasmtime_instancetype(Structure):
-    pass
-
-wasmtime_instancetype_t = wasmtime_instancetype
-
-_wasmtime_instancetype_delete = dll.wasmtime_instancetype_delete
-_wasmtime_instancetype_delete.restype = None
-_wasmtime_instancetype_delete.argtypes = [POINTER(wasmtime_instancetype_t)]
-def wasmtime_instancetype_delete(ty: Any) -> None:
-    return _wasmtime_instancetype_delete(ty)  # type: ignore
-
-_wasmtime_instancetype_exports = dll.wasmtime_instancetype_exports
-_wasmtime_instancetype_exports.restype = None
-_wasmtime_instancetype_exports.argtypes = [POINTER(wasmtime_instancetype_t), POINTER(wasm_exporttype_vec_t)]
-def wasmtime_instancetype_exports(arg0: Any, out: Any) -> None:
-    return _wasmtime_instancetype_exports(arg0, out)  # type: ignore
-
-_wasmtime_instancetype_as_externtype = dll.wasmtime_instancetype_as_externtype
-_wasmtime_instancetype_as_externtype.restype = POINTER(wasm_externtype_t)
-_wasmtime_instancetype_as_externtype.argtypes = [POINTER(wasmtime_instancetype_t)]
-def wasmtime_instancetype_as_externtype(arg0: Any) -> pointer:
-    return _wasmtime_instancetype_as_externtype(arg0)  # type: ignore
+class wasmtime_instance(Structure):
+    _fields_ = [
+        ("store_id", c_uint64),
+        ("index", c_size_t),
+    ]
+    store_id: int
+    index: int
 
-_wasmtime_externtype_as_instancetype = dll.wasmtime_externtype_as_instancetype
-_wasmtime_externtype_as_instancetype.restype = POINTER(wasmtime_instancetype_t)
-_wasmtime_externtype_as_instancetype.argtypes = [POINTER(wasm_externtype_t)]
-def wasmtime_externtype_as_instancetype(arg0: Any) -> pointer:
-    return _wasmtime_externtype_as_instancetype(arg0)  # type: ignore
+wasmtime_instance_t = wasmtime_instance
 
 _wasmtime_instance_new = dll.wasmtime_instance_new
 _wasmtime_instance_new.restype = POINTER(wasmtime_error_t)
 _wasmtime_instance_new.argtypes = [POINTER(wasmtime_context_t), POINTER(wasmtime_module_t), POINTER(wasmtime_extern_t), c_size_t, POINTER(wasmtime_instance_t), POINTER(POINTER(wasm_trap_t))]
 def wasmtime_instance_new(store: Any, module: Any, imports: Any, nimports: Any, instance: Any, trap: Any) -> pointer:
     return _wasmtime_instance_new(store, module, imports, nimports, instance, trap)  # type: ignore
 
-_wasmtime_instance_type = dll.wasmtime_instance_type
-_wasmtime_instance_type.restype = POINTER(wasmtime_instancetype_t)
-_wasmtime_instance_type.argtypes = [POINTER(wasmtime_context_t), POINTER(wasmtime_instance_t)]
-def wasmtime_instance_type(store: Any, instance: Any) -> pointer:
-    return _wasmtime_instance_type(store, instance)  # type: ignore
-
 _wasmtime_instance_export_get = dll.wasmtime_instance_export_get
 _wasmtime_instance_export_get.restype = c_bool
 _wasmtime_instance_export_get.argtypes = [POINTER(wasmtime_context_t), POINTER(wasmtime_instance_t), POINTER(c_char), c_size_t, POINTER(wasmtime_extern_t)]

wasmtime/_bindings.py

@@ -94,18 +94,6 @@ def wasm_multi_value(self, enable: bool) -> None:
             raise TypeError('expected a bool')
         ffi.wasmtime_config_wasm_multi_value_set(self._ptr, enable)
 
-    @setter_property
-    def wasm_module_linking(self, enable: bool) -> None:
-        """
-        Configures whether the wasm [module linking proposal] is enabled.
-
-        [module linking proposal]: https://github.com/webassembly/module-linking
-        """
-
-        if not isinstance(enable, bool):
-            raise TypeError('expected a bool')
-        ffi.wasmtime_config_wasm_module_linking_set(self._ptr, enable)
-
     @setter_property
     def wasm_multi_memory(self, enable: bool) -> None:
         """

wasmtime/_config.py

@@ -1,6 +1,6 @@
 from . import _ffi as ffi
 from ctypes import POINTER, byref
-from wasmtime import Module, WasmtimeError, Store, InstanceType
+from wasmtime import Module, WasmtimeError
 from ._extern import wrap_extern, get_extern_ptr
 from ._exportable import AsExtern
 from typing import Sequence, Union, Optional, Mapping, Iterable
@@ -51,14 +51,6 @@ def _from_raw(cls, instance: ffi.wasmtime_instance_t) -> "Instance":
         ty._instance = instance
         return ty
 
-    def type(self, store: Store) -> InstanceType:
-        """
-        Gets the type of this instance as an `InstanceType`
-        """
-
-        ptr = ffi.wasmtime_instance_type(store._context, byref(self._instance))
-        return InstanceType._from_ptr(ptr, None)
-
     def exports(self, store: Storelike) -> "InstanceExports":
         """
         Returns the exports of this module