Bump to 0.39.1 (#90)

* Bump to 0.39.1

* Update bindings for 0.39.0

* Ignore type errors I don't know how to fix

Author: alexcrichton

VERSION

@@ -1 +1 @@
-0.38.0
+0.39.1

wasmtime/_bindings.py

@@ -2042,9 +2042,9 @@ def wasmtime_config_wasm_memory64_set(arg0: Any, arg1: Any) -> None:
     return _wasmtime_config_wasm_memory64_set(arg0, arg1)  # type: ignore
 
 _wasmtime_config_strategy_set = dll.wasmtime_config_strategy_set
-_wasmtime_config_strategy_set.restype = POINTER(wasmtime_error_t)
+_wasmtime_config_strategy_set.restype = None
 _wasmtime_config_strategy_set.argtypes = [POINTER(wasm_config_t), wasmtime_strategy_t]
-def wasmtime_config_strategy_set(arg0: Any, arg1: Any) -> pointer:
+def wasmtime_config_strategy_set(arg0: Any, arg1: Any) -> None:
     return _wasmtime_config_strategy_set(arg0, arg1)  # type: ignore
 
 _wasmtime_config_cranelift_debug_verifier_set = dll.wasmtime_config_cranelift_debug_verifier_set
@@ -2066,9 +2066,9 @@ def wasmtime_config_cranelift_opt_level_set(arg0: Any, arg1: Any) -> None:
     return _wasmtime_config_cranelift_opt_level_set(arg0, arg1)  # type: ignore
 
 _wasmtime_config_profiler_set = dll.wasmtime_config_profiler_set
-_wasmtime_config_profiler_set.restype = POINTER(wasmtime_error_t)
+_wasmtime_config_profiler_set.restype = None
 _wasmtime_config_profiler_set.argtypes = [POINTER(wasm_config_t), wasmtime_profiling_strategy_t]
-def wasmtime_config_profiler_set(arg0: Any, arg1: Any) -> pointer:
+def wasmtime_config_profiler_set(arg0: Any, arg1: Any) -> None:
     return _wasmtime_config_profiler_set(arg0, arg1)  # type: ignore
 
 _wasmtime_config_static_memory_maximum_size_set = dll.wasmtime_config_static_memory_maximum_size_set

wasmtime/_config.py

@@ -130,13 +130,11 @@ def strategy(self, strategy: str) -> None:
         """
 
         if strategy == "auto":
-            error = ffi.wasmtime_config_strategy_set(self._ptr, 0)
+            ffi.wasmtime_config_strategy_set(self._ptr, 0)
         elif strategy == "cranelift":
-            error = ffi.wasmtime_config_strategy_set(self._ptr, 1)
+            ffi.wasmtime_config_strategy_set(self._ptr, 1)
         else:
             raise WasmtimeError("unknown strategy: " + str(strategy))
-        if error:
-            raise WasmtimeError._from_ptr(error)
 
     @setter_property
     def cranelift_debug_verifier(self, enable: bool) -> None:
@@ -158,13 +156,11 @@ def cranelift_opt_level(self, opt_level: str) -> None:
     @setter_property
     def profiler(self, profiler: str) -> None:
         if profiler == "none":
-            error = ffi.wasmtime_config_profiler_set(self._ptr, 0)
+            ffi.wasmtime_config_profiler_set(self._ptr, 0)
         elif profiler == "jitdump":
-            error = ffi.wasmtime_config_profiler_set(self._ptr, 1)
+            ffi.wasmtime_config_profiler_set(self._ptr, 1)
         else:
             raise WasmtimeError("unknown profiler: " + str(profiler))
-        if error:
-            raise WasmtimeError._from_ptr(error)
 
     @setter_property
     def cache(self, enabled: typing.Union[bool, str]) -> None:

wasmtime/_func.py

@@ -255,7 +255,7 @@ def deallocate(self, idx: int) -> None:
 @contextmanager
 def enter_wasm(store: Storelike):  # type: ignore
     try:
-        trap = POINTER(ffi.wasm_trap_t)()
+        trap = POINTER(ffi.wasm_trap_t)()  # type: ignore
         yield byref(trap)
         if trap:
             trap_obj = Trap._from_ptr(trap)

wasmtime/_instance.py

@@ -30,7 +30,7 @@ def __init__(self, store: Storelike, module: Module, imports: Sequence[AsExtern]
             imports_ptr[i] = get_extern_ptr(val)
 
         instance = ffi.wasmtime_instance_t()
-        trap = POINTER(ffi.wasm_trap_t)()
+        trap = POINTER(ffi.wasm_trap_t)()  # type: ignore
         with enter_wasm(store) as trap:
             error = ffi.wasmtime_instance_new(
                 store._context,
@@ -77,7 +77,7 @@ def __init__(self, store: Storelike, instance: Instance):
 
         i = 0
         item = ffi.wasmtime_extern_t()
-        name_ptr = POINTER(ffi.c_char)()
+        name_ptr = POINTER(ffi.c_char)()  # type: ignore
         name_len = ffi.c_size_t(0)
         while ffi.wasmtime_instance_export_nth(
                 store._context,

wasmtime/_linker.py

@@ -156,7 +156,7 @@ def instantiate(self, store: Storelike, module: Module) -> Instance:
         Raises an error if an import of `module` hasn't been defined in this
         linker or if a trap happens while instantiating the instance.
         """
-        trap = POINTER(ffi.wasm_trap_t)()
+        trap = POINTER(ffi.wasm_trap_t)()  # type: ignore
         instance = ffi.wasmtime_instance_t()
         with enter_wasm(store) as trap:
             error = ffi.wasmtime_linker_instantiate(

wasmtime/_module.py

@@ -35,7 +35,7 @@ def __init__(self, engine: Engine, wasm: typing.Union[str, bytes]):
         # TODO: can the copy be avoided here? I can't for the life of me
         # figure this out.
         binary = (c_uint8 * len(wasm)).from_buffer_copy(wasm)
-        ptr = POINTER(ffi.wasmtime_module_t)()
+        ptr = POINTER(ffi.wasmtime_module_t)()  # type: ignore
         error = ffi.wasmtime_module_new(engine._ptr, binary, len(wasm), byref(ptr))
         if error:
             raise WasmtimeError._from_ptr(error)
@@ -63,7 +63,7 @@ def deserialize(cls, engine: Engine, encoded: typing.Union[bytes, bytearray]) ->
         if not isinstance(encoded, (bytes, bytearray)):
             raise TypeError("expected bytes")
 
-        ptr = POINTER(ffi.wasmtime_module_t)()
+        ptr = POINTER(ffi.wasmtime_module_t)()  # type: ignore
 
         # TODO: can the copy be avoided here? I can't for the life of me
         # figure this out.
@@ -87,7 +87,7 @@ def deserialize_file(cls, engine: Engine, path: str) -> 'Module':
         Otherwise this function is the same as `Module.deserialize`.
         """
 
-        ptr = POINTER(ffi.wasmtime_module_t)()
+        ptr = POINTER(ffi.wasmtime_module_t)()  # type: ignore
         path_bytes = path.encode('utf-8')
         error = ffi.wasmtime_module_deserialize_file(
             engine._ptr,

wasmtime/_value.py

@@ -79,7 +79,7 @@ def f64(cls, val: float) -> "Val":
     @classmethod
     def externref(cls, extern: typing.Optional[typing.Any]) -> "Val":
         ffi = wasmtime_val_t(WASMTIME_EXTERNREF)
-        ffi.of.externref = POINTER(wasmtime_externref_t)()
+        ffi.of.externref = POINTER(wasmtime_externref_t)()  # type: ignore
         if extern is not None:
             extern_id = _intern(extern)
             ptr = wasmtime_externref_new(extern_id, _externref_finalizer)