chore: Optimize code efficiency and update toolchain version (#1247)

- Optimized memory usage by employing efficient cloning through the `clone_from` method in `compute_coeffs` and `build_frames` functions.
- Included the `#[allow(dead_code)]` attribute to the `CaseClause` struct and `Op` trait, to suppress possible warnings about unused codes.
- Enhanced constancy in the `lurk-metrics/src/lib.rs` by making the `LOCAL_SINK` instantiation constant.
- Upgraded the Rust toolchain channel from `1.76` to `1.78` in `rust-toolchain.toml`.
- Improved clarity and standard compliance by renaming the .cargo/config file to .cargo/config.toml.

benches/common/fib.rs

@@ -93,7 +93,7 @@ fn compute_coeffs<F: LurkField>(store: &Store<F>) -> (usize, usize) {
         let frame = step_func
             .call_simple(&input, store, &lang, 0, &dummy_terminal())
             .unwrap();
-        input = frame.output.clone();
+        input.clone_from(&frame.output);
         iteration += 1;
     }
     (coef_lin, coef_ang)

lurk-metrics/src/lib.rs

@@ -32,7 +32,7 @@ thread_local! {
     /// allows us not to think about contention on a global metrics sink among threads.
     ///
     /// A global metrics sink must be installed before any thread-local sinks can be accessed.
-    static LOCAL_SINK: OnceCell<ThreadMetricsSinkHandle> = OnceCell::new();
+    static LOCAL_SINK: OnceCell<ThreadMetricsSinkHandle> = const { OnceCell::new() };
 }
 
 /// A global metrics sink that keeps a list of thread-local sinks to aggregate from

rust-toolchain.toml

@@ -1,6 +1,6 @@
 [toolchain]
 # The default profile includes rustc, rust-std, cargo, rust-docs, rustfmt and clippy.
 profile = "default"
-channel = "1.76"
+channel = "1.78"
 targets = [ "wasm32-unknown-unknown" ]
 

src/circuit/gadgets/case.rs

@@ -5,6 +5,7 @@ use std::fmt::Debug;
 
 /// Initialized map entry for a fixed `key` with
 /// an allocated `value` computed at runtime.
+#[allow(dead_code)]
 pub(crate) struct CaseClause<'a, F: LurkField> {
     pub(crate) key: F,
     pub(crate) value: &'a AllocatedNum<F>,

src/lem/eval.rs

@@ -109,7 +109,7 @@ fn build_frames<F: LurkField, C: Coprocessor<F>>(
             compute_frame(lurk_step, cprocs, &input, store, lang, ch_terminal, pc)?;
 
         iterations += 1;
-        input = frame.output.clone();
+        input.clone_from(&frame.output);
         tracing::info!("{}", &log_fmt(iterations, &input, store));
         let expr = frame.output[0];
         frames.push(frame);
@@ -139,7 +139,7 @@ fn traverse_frames<F: LurkField, C: Coprocessor<F>>(
             compute_frame(lurk_step, cprocs, &input, store, lang, ch_terminal, pc)?;
 
         iterations += 1;
-        input = frame.output.clone();
+        input.clone_from(&frame.output);
 
         if must_break {
             break;

src/tag.rs

@@ -249,6 +249,7 @@ impl From<Op1> for u64 {
     }
 }
 
+#[allow(dead_code)]
 pub(crate) trait Op
 where
     Self: 'static,

src/z_data/serde/ser.rs

@@ -171,26 +171,26 @@ impl<'a> ser::Serializer for &'a Serializer {
     }
 
     #[inline]
-    fn serialize_newtype_struct<T: ?Sized>(
+    fn serialize_newtype_struct<T>(
         self,
         _name: &'static str,
         value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
-        T: ser::Serialize,
+        T: ?Sized + ser::Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(
+    fn serialize_newtype_variant<T>(
         self,
         _name: &'static str,
         variant_index: u32,
         _variant: &'static str,
         value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
-        T: ser::Serialize,
+        T: ?Sized + ser::Serialize,
     {
         // Assuming # of variants < 256
         Ok(ZData::Cell(vec![
@@ -205,9 +205,9 @@ impl<'a> ser::Serializer for &'a Serializer {
     }
 
     #[inline]
-    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
+    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
     where
-        T: ser::Serialize,
+        T: ?Sized + ser::Serialize,
     {
         Ok(ZData::Cell(vec![value.serialize(self)?]))
     }
@@ -292,9 +292,9 @@ impl ser::SerializeSeq for SerializeCell {
     type Ok = ZData;
     type Error = SerdeError;
 
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: ser::Serialize,
+        T: ?Sized + ser::Serialize,
     {
         self.cell.push(value.serialize(&Serializer)?);
         Ok(())
@@ -309,9 +309,9 @@ impl ser::SerializeTuple for SerializeCell {
     type Ok = ZData;
     type Error = SerdeError;
 
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: ser::Serialize,
+        T: ?Sized + ser::Serialize,
     {
         ser::SerializeSeq::serialize_element(self, value)
     }
@@ -325,9 +325,9 @@ impl ser::SerializeTupleStruct for SerializeCell {
     type Ok = ZData;
     type Error = SerdeError;
 
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: ser::Serialize,
+        T: ?Sized + ser::Serialize,
     {
         ser::SerializeSeq::serialize_element(self, value)
     }
@@ -341,9 +341,9 @@ impl ser::SerializeTupleVariant for SerializeTupleVariant {
     type Ok = ZData;
     type Error = SerdeError;
 
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: ser::Serialize,
+        T: ?Sized + ser::Serialize,
     {
         self.cell.push(value.serialize(&Serializer)?);
         Ok(())
@@ -362,17 +362,17 @@ impl ser::SerializeMap for SerializeMap {
     type Ok = ZData;
     type Error = SerdeError;
 
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
+    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
     where
-        T: ser::Serialize,
+        T: ?Sized + ser::Serialize,
     {
         self.next_key = Some(key.serialize(&Serializer)?);
         Ok(())
     }
 
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: ser::Serialize,
+        T: ?Sized + ser::Serialize,
     {
         let key = self
             .next_key