Remove usage of gen as an identifier (bytecodealliance#9958)

This commit is a start to some preparation for the Rust 2024 edition for
Wasmtime and this workspace. The `rust-2024-compatibility` lint group in
rustc, currently off-by-default, is intended to assist with migrating
code to prepare for the 2024 edition. Some of those lints though are, in
my opinion, far too noisy to be turned on so this PR doesn't turn on the
whole group. Instead though I plan on enabling individual lints over
time in our `Cargo.toml` before the 2024 edition is enabled. This should
hopefully provide a relatively smooth and less churn-y path to enabling
the 2024 edition in the future.

The first lint enabled here in this commit is the `keyword_idents_2024`
lint which warns against usage of identifiers that will become keywords
in the 2024 edition. The only one affecting Wasmtime is the `gen`
identifier (soon to be keyword) and we had quite a few instances of it.
Where possible I've renamed to `generator` or `generate` or `generated`
but when used as methods from upstream crate traits (e.g.
`RngCore::gen`) we're forced to use `r#gen`. The `rand` crate will be
updated in 0.9.0 to avoid this keyword so this shouldn't be permanent.

Author: alexcrichton

Cargo.toml

@@ -179,6 +179,11 @@ unused_import_braces = 'warn'
 unused-lifetimes = 'warn'
 unused-macro-rules = 'warn'
 
+# Lints that are part of the `rust-2024-compatibility` group. This group is a
+# bit too noisy to enable wholesale but some selective items are ones we want to
+# opt-in to.
+keyword_idents_2024 = 'warn'
+
 # Don't warn about unknown cfgs for pulley
 [workspace.lints.rust.unexpected_cfgs]
 level = "warn"

crates/environ/src/component/dfg.rs

@@ -697,7 +697,7 @@ impl LinearizeDfg<'_> {
         &mut self,
         key: K,
         map: impl Fn(&mut Self) -> &mut HashMap<K, V>,
-        gen: impl FnOnce(&mut Self, K) -> T,
+        generate: impl FnOnce(&mut Self, K) -> T,
         init: impl FnOnce(V, T) -> GlobalInitializer,
     ) -> V
     where
@@ -707,7 +707,7 @@ impl LinearizeDfg<'_> {
         if let Some(val) = map(self).get(&key) {
             return *val;
         }
-        let tmp = gen(self, key);
+        let tmp = generate(self, key);
         let index = V::new(map(self).len());
         self.initializers.push(init(index, tmp));
         let prev = map(self).insert(key, index);

crates/fuzzing/src/single_module_fuzzer.rs

@@ -311,10 +311,10 @@ mod tests {
             let mutate = mutate::<u32>;
             let run2 = run_config::<(u32, u32)>;
 
-            if let Ok((module, known_valid)) = execute(&buf[..seed_size], run1, gen) {
+            if let Ok((module, known_valid)) = execute(&buf[..seed_size], run1, generate) {
                 assert_eq!(known_valid, KnownValid::Yes);
-                let new_size = mutate(&mut buf, seed_size, max_size, gen, noop_mutate);
-                if let Ok((module2, known_valid)) = execute(&buf[..new_size], run2, gen) {
+                let new_size = mutate(&mut buf, seed_size, max_size, generate, noop_mutate);
+                if let Ok((module2, known_valid)) = execute(&buf[..new_size], run2, generate) {
                     assert_eq!(known_valid, KnownValid::No);
                     compares += 1;
                     if module != module2 {
@@ -340,7 +340,7 @@ mod tests {
             Ok((data.to_vec(), known_valid))
         }
 
-        fn gen<T>(_: &mut T, u: &mut Unstructured<'_>) -> Result<(Vec<u8>, KnownValid)>
+        fn generate<T>(_: &mut T, u: &mut Unstructured<'_>) -> Result<(Vec<u8>, KnownValid)>
         where
             T: for<'a> Arbitrary<'a>,
         {

crates/misc/component-fuzz-util/src/lib.rs

@@ -68,13 +68,13 @@ impl<T, const L: u32, const H: u32> VecInRange<T, L, H> {
     fn new<'a>(
         input: &mut Unstructured<'a>,
         fuel: &mut u32,
-        gen: impl Fn(&mut Unstructured<'a>, &mut u32) -> arbitrary::Result<T>,
+        generate: impl Fn(&mut Unstructured<'a>, &mut u32) -> arbitrary::Result<T>,
     ) -> arbitrary::Result<Self> {
         let mut ret = Vec::new();
         input.arbitrary_loop(Some(L), Some(H), |input| {
             if *fuel > 0 {
                 *fuel = *fuel - 1;
-                ret.push(gen(input, fuel)?);
+                ret.push(generate(input, fuel)?);
                 Ok(std::ops::ControlFlow::Continue(()))
             } else {
                 Ok(std::ops::ControlFlow::Break(()))

crates/wasi-common/src/sync/mod.rs

@@ -131,7 +131,7 @@ impl WasiCtxBuilder {
 
 pub fn random_ctx() -> Box<dyn RngCore + Send + Sync> {
     let mut rng = cap_rand::thread_rng(cap_rand::ambient_authority());
-    Box::new(cap_rand::rngs::StdRng::from_seed(rng.gen()))
+    Box::new(cap_rand::rngs::StdRng::from_seed(rng.r#gen()))
 }
 
 #[cfg(feature = "wasmtime")]

crates/wasi-nn/src/wit.rs

@@ -7,8 +7,8 @@
 //! This module exports its [`types`] for use throughout the crate and the
 //! [`ML`] object, which exposes [`ML::add_to_linker`]. To implement all of
 //! this, this module proceeds in steps:
-//! 1. generate all of the WIT glue code into a `gen::*` namespace
-//! 2. wire up the `gen::*` glue to the context state, delegating actual
+//! 1. generate all of the WIT glue code into a `generated::*` namespace
+//! 2. wire up the `generated::*` glue to the context state, delegating actual
 //!    computation to a [`Backend`]
 //! 3. convert some types
 //!
@@ -115,7 +115,7 @@ pub enum ErrorCode {
 }
 
 /// Generate the traits and types from the `wasi-nn` WIT specification.
-mod gen_ {
+mod generated_ {
     wasmtime::component::bindgen!({
         world: "ml",
         path: "wit/wasi-nn.wit",
@@ -133,35 +133,35 @@ mod gen_ {
         },
     });
 }
-use gen_::wasi::nn::{self as gen}; // Shortcut to the module containing the types we need.
+use generated_::wasi::nn::{self as generated}; // Shortcut to the module containing the types we need.
 
 // Export the `types` used in this crate as well as `ML::add_to_linker`.
 pub mod types {
-    use super::gen;
-    pub use gen::errors::Error;
-    pub use gen::graph::{ExecutionTarget, Graph, GraphBuilder, GraphEncoding};
-    pub use gen::inference::GraphExecutionContext;
-    pub use gen::tensor::{Tensor, TensorType};
+    use super::generated;
+    pub use generated::errors::Error;
+    pub use generated::graph::{ExecutionTarget, Graph, GraphBuilder, GraphEncoding};
+    pub use generated::inference::GraphExecutionContext;
+    pub use generated::tensor::{Tensor, TensorType};
 }
-pub use gen::graph::{ExecutionTarget, Graph, GraphBuilder, GraphEncoding};
-pub use gen::inference::GraphExecutionContext;
-pub use gen::tensor::{Tensor, TensorData, TensorDimensions, TensorType};
-pub use gen_::Ml as ML;
+pub use generated::graph::{ExecutionTarget, Graph, GraphBuilder, GraphEncoding};
+pub use generated::inference::GraphExecutionContext;
+pub use generated::tensor::{Tensor, TensorData, TensorDimensions, TensorType};
+pub use generated_::Ml as ML;
 
 /// Add the WIT-based version of the `wasi-nn` API to a
 /// [`wasmtime::component::Linker`].
 pub fn add_to_linker<T>(
     l: &mut wasmtime::component::Linker<T>,
     f: impl Fn(&mut T) -> WasiNnView<'_> + Send + Sync + Copy + 'static,
 ) -> anyhow::Result<()> {
-    gen::graph::add_to_linker_get_host(l, f)?;
-    gen::tensor::add_to_linker_get_host(l, f)?;
-    gen::inference::add_to_linker_get_host(l, f)?;
-    gen::errors::add_to_linker_get_host(l, f)?;
+    generated::graph::add_to_linker_get_host(l, f)?;
+    generated::tensor::add_to_linker_get_host(l, f)?;
+    generated::inference::add_to_linker_get_host(l, f)?;
+    generated::errors::add_to_linker_get_host(l, f)?;
     Ok(())
 }
 
-impl gen::graph::Host for WasiNnView<'_> {
+impl generated::graph::Host for WasiNnView<'_> {
     fn load(
         &mut self,
         builders: Vec<GraphBuilder>,
@@ -210,7 +210,7 @@ impl gen::graph::Host for WasiNnView<'_> {
     }
 }
 
-impl gen::graph::HostGraph for WasiNnView<'_> {
+impl generated::graph::HostGraph for WasiNnView<'_> {
     fn init_execution_context(
         &mut self,
         graph: Resource<Graph>,
@@ -235,7 +235,7 @@ impl gen::graph::HostGraph for WasiNnView<'_> {
     }
 }
 
-impl gen::inference::HostGraphExecutionContext for WasiNnView<'_> {
+impl generated::inference::HostGraphExecutionContext for WasiNnView<'_> {
     fn set_input(
         &mut self,
         exec_context: Resource<GraphExecutionContext>,
@@ -291,7 +291,7 @@ impl gen::inference::HostGraphExecutionContext for WasiNnView<'_> {
     }
 }
 
-impl gen::tensor::HostTensor for WasiNnView<'_> {
+impl generated::tensor::HostTensor for WasiNnView<'_> {
     fn new(
         &mut self,
         dimensions: TensorDimensions,
@@ -328,17 +328,19 @@ impl gen::tensor::HostTensor for WasiNnView<'_> {
     }
 }
 
-impl gen::errors::HostError for WasiNnView<'_> {
-    fn code(&mut self, error: Resource<Error>) -> wasmtime::Result<gen::errors::ErrorCode> {
+impl generated::errors::HostError for WasiNnView<'_> {
+    fn code(&mut self, error: Resource<Error>) -> wasmtime::Result<generated::errors::ErrorCode> {
         let error = self.table.get(&error)?;
         match error.code {
-            ErrorCode::InvalidArgument => Ok(gen::errors::ErrorCode::InvalidArgument),
-            ErrorCode::InvalidEncoding => Ok(gen::errors::ErrorCode::InvalidEncoding),
-            ErrorCode::Timeout => Ok(gen::errors::ErrorCode::Timeout),
-            ErrorCode::RuntimeError => Ok(gen::errors::ErrorCode::RuntimeError),
-            ErrorCode::UnsupportedOperation => Ok(gen::errors::ErrorCode::UnsupportedOperation),
-            ErrorCode::TooLarge => Ok(gen::errors::ErrorCode::TooLarge),
-            ErrorCode::NotFound => Ok(gen::errors::ErrorCode::NotFound),
+            ErrorCode::InvalidArgument => Ok(generated::errors::ErrorCode::InvalidArgument),
+            ErrorCode::InvalidEncoding => Ok(generated::errors::ErrorCode::InvalidEncoding),
+            ErrorCode::Timeout => Ok(generated::errors::ErrorCode::Timeout),
+            ErrorCode::RuntimeError => Ok(generated::errors::ErrorCode::RuntimeError),
+            ErrorCode::UnsupportedOperation => {
+                Ok(generated::errors::ErrorCode::UnsupportedOperation)
+            }
+            ErrorCode::TooLarge => Ok(generated::errors::ErrorCode::TooLarge),
+            ErrorCode::NotFound => Ok(generated::errors::ErrorCode::NotFound),
             ErrorCode::Trap => Err(anyhow!(error.data.to_string())),
         }
     }
@@ -354,7 +356,7 @@ impl gen::errors::HostError for WasiNnView<'_> {
     }
 }
 
-impl gen::errors::Host for WasiNnView<'_> {
+impl generated::errors::Host for WasiNnView<'_> {
     fn convert_error(&mut self, err: Error) -> wasmtime::Result<Error> {
         if matches!(err.code, ErrorCode::Trap) {
             Err(err.data)
@@ -364,18 +366,18 @@ impl gen::errors::Host for WasiNnView<'_> {
     }
 }
 
-impl gen::tensor::Host for WasiNnView<'_> {}
-impl gen::inference::Host for WasiNnView<'_> {}
+impl generated::tensor::Host for WasiNnView<'_> {}
+impl generated::inference::Host for WasiNnView<'_> {}
 
-impl Hash for gen::graph::GraphEncoding {
+impl Hash for generated::graph::GraphEncoding {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         self.to_string().hash(state)
     }
 }
 
-impl fmt::Display for gen::graph::GraphEncoding {
+impl fmt::Display for generated::graph::GraphEncoding {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use gen::graph::GraphEncoding::*;
+        use generated::graph::GraphEncoding::*;
         match self {
             Openvino => write!(f, "openvino"),
             Onnx => write!(f, "onnx"),
@@ -388,16 +390,16 @@ impl fmt::Display for gen::graph::GraphEncoding {
     }
 }
 
-impl FromStr for gen::graph::GraphEncoding {
+impl FromStr for generated::graph::GraphEncoding {
     type Err = GraphEncodingParseError;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s.to_lowercase().as_str() {
-            "openvino" => Ok(gen::graph::GraphEncoding::Openvino),
-            "onnx" => Ok(gen::graph::GraphEncoding::Onnx),
-            "pytorch" => Ok(gen::graph::GraphEncoding::Pytorch),
-            "tensorflow" => Ok(gen::graph::GraphEncoding::Tensorflow),
-            "tensorflowlite" => Ok(gen::graph::GraphEncoding::Tensorflowlite),
-            "autodetect" => Ok(gen::graph::GraphEncoding::Autodetect),
+            "openvino" => Ok(generated::graph::GraphEncoding::Openvino),
+            "onnx" => Ok(generated::graph::GraphEncoding::Onnx),
+            "pytorch" => Ok(generated::graph::GraphEncoding::Pytorch),
+            "tensorflow" => Ok(generated::graph::GraphEncoding::Tensorflow),
+            "tensorflowlite" => Ok(generated::graph::GraphEncoding::Tensorflowlite),
+            "autodetect" => Ok(generated::graph::GraphEncoding::Autodetect),
             _ => Err(GraphEncodingParseError(s.into())),
         }
     }