Use a new StubInstance to avoid requiring the "test" feature (#2509)

* Move `wit_generation` module into a sub-directory

Prepare to add a new sub-module with a `StubInstance`, so that there's
no need to use the `MockInstance`.

* Create a new `StubInstance` type

A replacement for the `MockInstance` type to use when generating WIT
files. This allows generating the files without having to activate the
"test" feature.

* Use the `StubInstance` in the `wit_generator`

Replace usages of the `MockInstance` type and don't enable
`linera-witty`'s "test" feature.

Author: jvff

linera-sdk/Cargo.toml

@@ -66,7 +66,7 @@ linera-chain = { workspace = true, features = ["metrics"] }
 linera-core = { workspace = true, features = ["metrics", "wasmer"] }
 linera-execution = { workspace = true, features = ["fs", "metrics", "wasmer"] }
 linera-storage = { workspace = true, features = ["metrics", "wasmer"] }
-linera-witty = { workspace = true, features = ["test"] }
+linera-witty.workspace = true
 serde_json.workspace = true
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 wasmtime.workspace = true

linera-sdk/src/bin/wit_generator.rs

@@ -18,10 +18,7 @@ use linera_execution::{
     ContractEntrypoints, ContractSyncRuntimeHandle, ContractSystemApi, ServiceEntrypoints,
     ServiceSyncRuntimeHandle, ServiceSystemApi, SystemApiData, ViewSystemApi,
 };
-use linera_witty::{
-    wit_generation::{WitInterfaceWriter, WitWorldWriter},
-    MockInstance,
-};
+use linera_witty::wit_generation::{StubInstance, WitInterfaceWriter, WitWorldWriter};
 
 /// Command line parameters for the WIT generator.
 #[derive(Debug, clap::Parser)]
@@ -50,27 +47,27 @@ fn main() -> Result<()> {
 
 /// Runs the main `operation` on all the WIT files.
 fn run_operation(options: WitGeneratorOptions, mut operation: impl Operation) -> Result<()> {
-    let contract_entrypoints = WitInterfaceWriter::new::<ContractEntrypoints<MockInstance<()>>>();
-    let service_entrypoints = WitInterfaceWriter::new::<ServiceEntrypoints<MockInstance<()>>>();
+    let contract_entrypoints = WitInterfaceWriter::new::<ContractEntrypoints<StubInstance>>();
+    let service_entrypoints = WitInterfaceWriter::new::<ServiceEntrypoints<StubInstance>>();
 
     let contract_system_api = WitInterfaceWriter::new::<
-        ContractSystemApi<MockInstance<SystemApiData<ContractSyncRuntimeHandle>>>,
+        ContractSystemApi<StubInstance<SystemApiData<ContractSyncRuntimeHandle>>>,
     >();
     let service_system_api = WitInterfaceWriter::new::<
-        ServiceSystemApi<MockInstance<SystemApiData<ServiceSyncRuntimeHandle>>>,
+        ServiceSystemApi<StubInstance<SystemApiData<ServiceSyncRuntimeHandle>>>,
     >();
     let view_system_api = WitInterfaceWriter::new::<
-        ViewSystemApi<MockInstance<SystemApiData<ContractSyncRuntimeHandle>>>,
+        ViewSystemApi<StubInstance<SystemApiData<ContractSyncRuntimeHandle>>>,
     >();
 
     let contract_world = WitWorldWriter::new("linera:app", "contract")
-        .export::<ContractEntrypoints<MockInstance<()>>>()
-        .import::<ContractSystemApi<MockInstance<SystemApiData<ContractSyncRuntimeHandle>>>>()
-        .import::<ViewSystemApi<MockInstance<SystemApiData<ContractSyncRuntimeHandle>>>>();
+        .export::<ContractEntrypoints<StubInstance>>()
+        .import::<ContractSystemApi<StubInstance<SystemApiData<ContractSyncRuntimeHandle>>>>()
+        .import::<ViewSystemApi<StubInstance<SystemApiData<ContractSyncRuntimeHandle>>>>();
     let service_world = WitWorldWriter::new("linera:app", "service")
-        .export::<ServiceEntrypoints<MockInstance<()>>>()
-        .import::<ServiceSystemApi<MockInstance<SystemApiData<ServiceSyncRuntimeHandle>>>>()
-        .import::<ViewSystemApi<MockInstance<SystemApiData<ContractSyncRuntimeHandle>>>>();
+        .export::<ServiceEntrypoints<StubInstance>>()
+        .import::<ServiceSystemApi<StubInstance<SystemApiData<ServiceSyncRuntimeHandle>>>>()
+        .import::<ViewSystemApi<StubInstance<SystemApiData<ContractSyncRuntimeHandle>>>>();
 
     operation.run_for_file(
         &options.base_directory.join("contract-entrypoints.wit"),

linera-witty/src/wit_generation.rs renamed to linera-witty/src/wit_generation/mod.rs

@@ -3,10 +3,13 @@
 
 //! Generation of WIT files.
 
+mod stub_instance;
+
 use std::collections::BTreeMap;
 
 use genawaiter::{rc::gen, yield_};
 
+pub use self::stub_instance::StubInstance;
 pub use crate::type_traits::RegisterWitTypes;
 
 /// Generates WIT snippets for an interface.

linera-witty/src/wit_generation/stub_instance.rs

@@ -0,0 +1,114 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+//! Contains a [`StubInstance`] type and the code it requires to implement the necessary
+//! trait to be used as a Wasm instance type during compile time.
+
+use std::{borrow::Cow, marker::PhantomData};
+
+use crate::{
+    memory_layout::FlatLayout, GuestPointer, Instance, InstanceWithFunction, InstanceWithMemory,
+    Runtime, RuntimeError, RuntimeMemory,
+};
+
+/// A stub Wasm instance.
+///
+/// This is when a Wasm instance type is needed for type-checking but is not needed during
+/// runtime.
+pub struct StubInstance<UserData = ()> {
+    _user_data: PhantomData<UserData>,
+}
+
+impl<UserData> Default for StubInstance<UserData> {
+    fn default() -> Self {
+        StubInstance {
+            _user_data: PhantomData,
+        }
+    }
+}
+
+impl<UserData> Instance for StubInstance<UserData> {
+    type Runtime = StubRuntime;
+    type UserData = UserData;
+    type UserDataReference<'a> = &'a UserData
+    where
+        Self::UserData: 'a,
+        Self: 'a;
+    type UserDataMutReference<'a> = &'a mut UserData
+    where
+        Self::UserData: 'a,
+        Self: 'a;
+
+    fn load_export(&mut self, _name: &str) -> Option<()> {
+        unimplemented!("`StubInstance` can not be used as a real `Instance`");
+    }
+
+    fn user_data(&self) -> Self::UserDataReference<'_> {
+        unimplemented!("`StubInstance` can not be used as a real `Instance`");
+    }
+
+    fn user_data_mut(&mut self) -> Self::UserDataMutReference<'_> {
+        unimplemented!("`StubInstance` can not be used as a real `Instance`");
+    }
+}
+
+impl<Parameters, Results, UserData> InstanceWithFunction<Parameters, Results>
+    for StubInstance<UserData>
+where
+    Parameters: FlatLayout + 'static,
+    Results: FlatLayout + 'static,
+{
+    type Function = ();
+
+    fn function_from_export(
+        &mut self,
+        _name: <Self::Runtime as Runtime>::Export,
+    ) -> Result<Option<Self::Function>, RuntimeError> {
+        unimplemented!("`StubInstance` can not be used as a real `InstanceWithFunction`");
+    }
+
+    fn call(
+        &mut self,
+        _function: &Self::Function,
+        _parameters: Parameters,
+    ) -> Result<Results, RuntimeError> {
+        unimplemented!("`StubInstance` can not be used as a real `InstanceWithFunction`");
+    }
+}
+
+impl<UserData> InstanceWithMemory for StubInstance<UserData> {
+    fn memory_from_export(&self, _export: ()) -> Result<Option<StubMemory>, RuntimeError> {
+        unimplemented!("`StubInstance` can not be used as a real `InstanceWithMemory`");
+    }
+}
+
+/// A stub Wasm runtime.
+pub struct StubRuntime;
+
+impl Runtime for StubRuntime {
+    type Export = ();
+    type Memory = StubMemory;
+}
+
+/// A stub Wasm runtime memory.
+pub struct StubMemory;
+
+impl<UserData> RuntimeMemory<StubInstance<UserData>> for StubMemory {
+    fn read<'instance>(
+        &self,
+        _instance: &'instance StubInstance<UserData>,
+        _location: GuestPointer,
+        _length: u32,
+    ) -> Result<Cow<'instance, [u8]>, RuntimeError> {
+        unimplemented!("`StubMemory` can not be used as a real `RuntimeMemory`");
+    }
+
+    fn write(
+        &mut self,
+        _instance: &mut StubInstance<UserData>,
+        _location: GuestPointer,
+        _bytes: &[u8],
+    ) -> Result<(), RuntimeError> {
+        unimplemented!("`StubMemory` can not be used as a real `RuntimeMemory`");
+    }
+}