Added handle.IsClosed checks on all NativeHandle properties. This protects against accessing various things after they have been disposed. (#289)

Author: martindevans

src/Config.cs

@@ -353,7 +353,7 @@ internal Handle NativeHandle
         {
             get
             {
-                if (handle.IsInvalid)
+                if (handle.IsInvalid || handle.IsClosed)
                 {
                     throw new ObjectDisposedException(typeof(Config).FullName);
                 }

src/Engine.cs

@@ -48,7 +48,7 @@ internal Handle NativeHandle
         {
             get
             {
-                if (handle.IsInvalid)
+                if (handle.IsInvalid || handle.IsClosed)
                 {
                     throw new ObjectDisposedException(typeof(Engine).FullName);
                 }

src/Module.cs

@@ -387,7 +387,7 @@ internal Handle NativeHandle
         {
             get
             {
-                if (handle.IsInvalid)
+                if (handle.IsInvalid || handle.IsClosed)
                 {
                     throw new ObjectDisposedException(typeof(Module).FullName);
                 }

src/Store.cs

@@ -279,7 +279,7 @@ internal Handle NativeHandle
         {
             get
             {
-                if (handle.IsInvalid)
+                if (handle.IsInvalid || handle.IsClosed)
                 {
                     throw new ObjectDisposedException(typeof(Store).FullName);
                 }

tests/ConfigTests.cs

@@ -166,5 +166,17 @@ public void ItSetsMultiValue()
 
             act.Should().Throw<WasmtimeException>();
         }
+
+        [Fact]
+        public void ItCannotBeAccessedOnceDisposed()
+        {
+            var config = new Config();
+            config.Dispose();
+
+            Assert.Throws<ObjectDisposedException>(() => config.NativeHandle);
+            Assert.Throws<ObjectDisposedException>(() => config.WithBulkMemory(true));
+            Assert.Throws<ObjectDisposedException>(() => config.WithCacheConfig(null));
+            Assert.Throws<ObjectDisposedException>(() => config.WithEpochInterruption(true));
+        }
     }
 }

tests/EngineTests.cs

@@ -0,0 +1,18 @@
+using System;
+using Xunit;
+
+namespace Wasmtime.Tests;
+
+public class EngineTests
+{
+    [Fact]
+    public void ItCannotBeAccessedOnceDisposed()
+    {
+        var engine = new Engine();
+
+        engine.Dispose();
+
+        Assert.Throws<ObjectDisposedException>(() => engine.NativeHandle);
+        Assert.Throws<ObjectDisposedException>(() => engine.IncrementEpoch());
+    }
+}

tests/ModuleLoadTests.cs

@@ -51,5 +51,20 @@ public void ItLoadsModuleTextFromEmbeddedResource()
             // `ObjectDisposedException`
             stream.Read(new byte[0], 0, 0);
         }
+
+        [Fact]
+        public void ItCannotBeAccessedOnceDisposed()
+        {
+            using var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("hello.wasm");
+            stream.Should().NotBeNull();
+
+            using var engine = new Engine();
+            var module = Module.FromStream(engine, "hello.wasm", stream);
+
+            module.Dispose();
+
+            Assert.Throws<ObjectDisposedException>(() => module.NativeHandle);
+            Assert.Throws<ObjectDisposedException>(() => module.Serialize());
+        }
     }
 }

tests/StoreTests.cs

@@ -1,4 +1,5 @@
-using FluentAssertions;
+using System;
+using FluentAssertions;
 using System.IO;
 using Xunit;
 
@@ -91,5 +92,19 @@ public void ItLimitsMemories()
             var act = () => { new Instance(Store, module); };
             act.Should().Throw<WasmtimeException>();
         }
+
+        [Fact]
+        public void ItCannotBeAccessedOnceDisposed()
+        {
+            var ctx = Store.Context;
+            Assert.Equal(Store, ctx.Store);
+
+            Store.Dispose();
+
+            Assert.Throws<ObjectDisposedException>(() => { var x = Store.Context; });
+            Assert.Throws<ObjectDisposedException>(() => Store.NativeHandle);
+            Assert.Throws<ObjectDisposedException>(() => Store.Fuel);
+            Assert.Throws<ObjectDisposedException>(() => Store.GC());
+        }
     }
 }