refactor(spv-out): subvert-replace "recycle" in trait Recyclable to "reclaim"

This avoids `rustc` errors new to Rust 1.93. These errors are because
`Recyclable::recycle` triggers the `unstable_name_collisions` lint on
use, detecting a collision with the unstable `vec_recycle` Nightly
feature.

Author: ErichDonGubler

naga/src/back/spv/f16_polyfill.rs

@@ -96,9 +96,9 @@ impl F16IoPolyfill {
     }
 }
 
-impl crate::back::spv::recyclable::Recyclable for F16IoPolyfill {
-    fn recycle(mut self) -> Self {
-        self.io_var_to_f32_type = self.io_var_to_f32_type.recycle();
+impl crate::back::spv::reclaimable::Reclaimable for F16IoPolyfill {
+    fn reclaim(mut self) -> Self {
+        self.io_var_to_f32_type = self.io_var_to_f32_type.reclaim();
         self
     }
 }

naga/src/back/spv/layout.rs

@@ -39,8 +39,8 @@ impl PhysicalLayout {
     }
 }
 
-impl super::recyclable::Recyclable for PhysicalLayout {
-    fn recycle(self) -> Self {
+impl super::reclaimable::Reclaimable for PhysicalLayout {
+    fn reclaim(self) -> Self {
         PhysicalLayout {
             magic_number: self.magic_number,
             version: self.version,
@@ -67,20 +67,20 @@ impl LogicalLayout {
     }
 }
 
-impl super::recyclable::Recyclable for LogicalLayout {
-    fn recycle(self) -> Self {
+impl super::reclaimable::Reclaimable for LogicalLayout {
+    fn reclaim(self) -> Self {
         Self {
-            capabilities: self.capabilities.recycle(),
-            extensions: self.extensions.recycle(),
-            ext_inst_imports: self.ext_inst_imports.recycle(),
-            memory_model: self.memory_model.recycle(),
-            entry_points: self.entry_points.recycle(),
-            execution_modes: self.execution_modes.recycle(),
-            debugs: self.debugs.recycle(),
-            annotations: self.annotations.recycle(),
-            declarations: self.declarations.recycle(),
-            function_declarations: self.function_declarations.recycle(),
-            function_definitions: self.function_definitions.recycle(),
+            capabilities: self.capabilities.reclaim(),
+            extensions: self.extensions.reclaim(),
+            ext_inst_imports: self.ext_inst_imports.reclaim(),
+            memory_model: self.memory_model.reclaim(),
+            entry_points: self.entry_points.reclaim(),
+            execution_modes: self.execution_modes.reclaim(),
+            debugs: self.debugs.reclaim(),
+            annotations: self.annotations.reclaim(),
+            declarations: self.declarations.reclaim(),
+            function_declarations: self.function_declarations.reclaim(),
+            function_definitions: self.function_definitions.reclaim(),
         }
     }
 }

naga/src/back/spv/mod.rs

@@ -105,7 +105,7 @@ mod instructions;
 mod layout;
 mod mesh_shader;
 mod ray;
-mod recyclable;
+mod reclaimable;
 mod selection;
 mod subgroup;
 mod writer;
@@ -655,10 +655,10 @@ impl ops::IndexMut<Handle<crate::Expression>> for CachedExpressions {
         id
     }
 }
-impl recyclable::Recyclable for CachedExpressions {
-    fn recycle(self) -> Self {
+impl reclaimable::Reclaimable for CachedExpressions {
+    fn reclaim(self) -> Self {
         CachedExpressions {
-            ids: self.ids.recycle(),
+            ids: self.ids.reclaim(),
         }
     }
 }

naga/src/back/spv/recyclable.rs naga/src/back/spv/reclaimable.rsnaga/src/back/spv/recyclable.rs renamed to naga/src/back/spv/reclaimable.rs

@@ -22,54 +22,54 @@ use alloc::vec::Vec;
 /// that a field is missing from the literal. This trait's `recycle` method
 /// takes `self` by value, and returns `Self` by value, encouraging the use of
 /// struct literal expressions in its implementation.
-pub trait Recyclable {
+pub trait Reclaimable {
     /// Clear `self`, retaining its current memory allocations.
     ///
     /// Shrink the buffer if it's currently much larger than was actually used.
     /// This prevents a module with exceptionally large allocations from causing
     /// the `Writer` to retain more memory than it needs indefinitely.
-    fn recycle(self) -> Self;
+    fn reclaim(self) -> Self;
 }
 
 // Stock values for various collections.
 
-impl<T> Recyclable for Vec<T> {
-    fn recycle(mut self) -> Self {
+impl<T> Reclaimable for Vec<T> {
+    fn reclaim(mut self) -> Self {
         self.clear();
         self
     }
 }
 
-impl<K, V, S: Clone> Recyclable for hashbrown::HashMap<K, V, S> {
-    fn recycle(mut self) -> Self {
+impl<K, V, S: Clone> Reclaimable for hashbrown::HashMap<K, V, S> {
+    fn reclaim(mut self) -> Self {
         self.clear();
         self
     }
 }
 
-impl<K, S: Clone> Recyclable for hashbrown::HashSet<K, S> {
-    fn recycle(mut self) -> Self {
+impl<K, S: Clone> Reclaimable for hashbrown::HashSet<K, S> {
+    fn reclaim(mut self) -> Self {
         self.clear();
         self
     }
 }
 
-impl<K, S: Clone> Recyclable for indexmap::IndexSet<K, S> {
-    fn recycle(mut self) -> Self {
+impl<K, S: Clone> Reclaimable for indexmap::IndexSet<K, S> {
+    fn reclaim(mut self) -> Self {
         self.clear();
         self
     }
 }
 
-impl<K: Ord, V> Recyclable for alloc::collections::BTreeMap<K, V> {
-    fn recycle(mut self) -> Self {
+impl<K: Ord, V> Reclaimable for alloc::collections::BTreeMap<K, V> {
+    fn reclaim(mut self) -> Self {
         self.clear();
         self
     }
 }
 
-impl<K, V> Recyclable for crate::arena::HandleVec<K, V> {
-    fn recycle(mut self) -> Self {
+impl<K, V> Reclaimable for crate::arena::HandleVec<K, V> {
+    fn reclaim(mut self) -> Self {
         self.clear();
         self
     }

naga/src/back/spv/writer.rs

@@ -142,15 +142,15 @@ impl Writer {
 
     /// Reset `Writer` to its initial state, retaining any allocations.
     ///
-    /// Why not just implement `Recyclable` for `Writer`? By design,
-    /// `Recyclable::recycle` requires ownership of the value, not just
+    /// Why not just implement `Reclaimable` for `Writer`? By design,
+    /// `Reclaimable::reclaim` requires ownership of the value, not just
     /// `&mut`; see the trait documentation. But we need to use this method
     /// from functions like `Writer::write`, which only have `&mut Writer`.
     /// Workarounds include unsafe code (`core::ptr::read`, then `write`, ugh)
     /// or something like a `Default` impl that returns an oddly-initialized
     /// `Writer`, which is worse.
     fn reset(&mut self) {
-        use super::recyclable::Recyclable;
+        use super::reclaimable::Reclaimable;
         use core::mem::take;
 
         let mut id_gen = IdGenerator::default();
@@ -176,26 +176,26 @@ impl Writer {
             void_type,
             gl450_ext_inst_id,
 
-            // Recycled:
-            capabilities_used: take(&mut self.capabilities_used).recycle(),
-            extensions_used: take(&mut self.extensions_used).recycle(),
-            physical_layout: self.physical_layout.clone().recycle(),
-            logical_layout: take(&mut self.logical_layout).recycle(),
-            debug_strings: take(&mut self.debug_strings).recycle(),
-            debugs: take(&mut self.debugs).recycle(),
-            annotations: take(&mut self.annotations).recycle(),
-            lookup_type: take(&mut self.lookup_type).recycle(),
-            lookup_function: take(&mut self.lookup_function).recycle(),
-            lookup_function_type: take(&mut self.lookup_function_type).recycle(),
-            wrapped_functions: take(&mut self.wrapped_functions).recycle(),
-            constant_ids: take(&mut self.constant_ids).recycle(),
-            cached_constants: take(&mut self.cached_constants).recycle(),
-            global_variables: take(&mut self.global_variables).recycle(),
-            std140_compat_uniform_types: take(&mut self.std140_compat_uniform_types).recycle(),
-            saved_cached: take(&mut self.saved_cached).recycle(),
-            temp_list: take(&mut self.temp_list).recycle(),
-            ray_query_functions: take(&mut self.ray_query_functions).recycle(),
-            io_f16_polyfills: take(&mut self.io_f16_polyfills).recycle(),
+            // Reclaimed:
+            capabilities_used: take(&mut self.capabilities_used).reclaim(),
+            extensions_used: take(&mut self.extensions_used).reclaim(),
+            physical_layout: self.physical_layout.clone().reclaim(),
+            logical_layout: take(&mut self.logical_layout).reclaim(),
+            debug_strings: take(&mut self.debug_strings).reclaim(),
+            debugs: take(&mut self.debugs).reclaim(),
+            annotations: take(&mut self.annotations).reclaim(),
+            lookup_type: take(&mut self.lookup_type).reclaim(),
+            lookup_function: take(&mut self.lookup_function).reclaim(),
+            lookup_function_type: take(&mut self.lookup_function_type).reclaim(),
+            wrapped_functions: take(&mut self.wrapped_functions).reclaim(),
+            constant_ids: take(&mut self.constant_ids).reclaim(),
+            cached_constants: take(&mut self.cached_constants).reclaim(),
+            global_variables: take(&mut self.global_variables).reclaim(),
+            std140_compat_uniform_types: take(&mut self.std140_compat_uniform_types).reclaim(),
+            saved_cached: take(&mut self.saved_cached).reclaim(),
+            temp_list: take(&mut self.temp_list).reclaim(),
+            ray_query_functions: take(&mut self.ray_query_functions).reclaim(),
+            io_f16_polyfills: take(&mut self.io_f16_polyfills).reclaim(),
             debug_printf: None,
         };