Merge pull request #550 from cobalt-org/renovate/rust-1.x

chore(deps): update dependency rust to v1.80.0

.clippy.toml

@@ -1,4 +1,4 @@
-msrv = "1.74"  # MSRV
+msrv = "1.80.0"  # MSRV
 warn-on-all-wildcard-imports = true
 allow-expect-in-tests = true
 allow-unwrap-in-tests = true

.github/workflows/ci.yml

@@ -49,15 +49,15 @@ jobs:
     - name: No-default features
       run: cargo test --workspace --no-default-features
   msrv:
-    name: "Check MSRV: 1.74"
+    name: "Check MSRV: 1.80.0"
     runs-on: ubuntu-latest
     steps:
     - name: Checkout repository
       uses: actions/checkout@v4
     - name: Install Rust
       uses: dtolnay/rust-toolchain@stable
       with:
-        toolchain: "1.74"  # MSRV
+        toolchain: "1.80.0"  # MSRV
     - uses: Swatinem/rust-cache@v2
     - name: Default features
       run: cargo check --workspace --all-targets
@@ -119,7 +119,7 @@ jobs:
     - name: Install Rust
       uses: dtolnay/rust-toolchain@stable
       with:
-        toolchain: "1.74"  # MSRV
+        toolchain: "1.80.0"  # MSRV
         components: clippy
     - uses: Swatinem/rust-cache@v2
     - name: Install SARIF tools

Cargo.toml

@@ -7,7 +7,7 @@ members = [
 [workspace.package]
 license = "MIT OR Apache-2.0"
 edition = "2021"
-rust-version = "1.74"  # MSRV
+rust-version = "1.80.0"  # MSRV
 include = [
   "build.rs",
   "src/**/*",

crates/core/src/model/object/map.rs

@@ -49,10 +49,10 @@ impl Object {
     /// The key may be any borrowed form of the map's key type, but the ordering
     /// on the borrowed form *must* match the ordering on the key type.
     #[inline]
-    pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&Value>
+    pub fn get<Q>(&self, key: &Q) -> Option<&Value>
     where
         Key: Borrow<Q>,
-        Q: Ord + Eq + Hash,
+        Q: Ord + Eq + Hash + ?Sized,
     {
         self.map.get(key)
     }
@@ -62,10 +62,10 @@ impl Object {
     /// The key may be any borrowed form of the map's key type, but the ordering
     /// on the borrowed form *must* match the ordering on the key type.
     #[inline]
-    pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool
+    pub fn contains_key<Q>(&self, key: &Q) -> bool
     where
         Key: Borrow<Q>,
-        Q: Ord + Eq + Hash,
+        Q: Ord + Eq + Hash + ?Sized,
     {
         self.map.contains_key(key)
     }
@@ -75,10 +75,10 @@ impl Object {
     /// The key may be any borrowed form of the map's key type, but the ordering
     /// on the borrowed form *must* match the ordering on the key type.
     #[inline]
-    pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut Value>
+    pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut Value>
     where
         Key: Borrow<Q>,
-        Q: Ord + Eq + Hash,
+        Q: Ord + Eq + Hash + ?Sized,
     {
         self.map.get_mut(key)
     }
@@ -100,10 +100,10 @@ impl Object {
     /// The key may be any borrowed form of the map's key type, but the ordering
     /// on the borrowed form *must* match the ordering on the key type.
     #[inline]
-    pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<Value>
+    pub fn remove<Q>(&mut self, key: &Q) -> Option<Value>
     where
         Key: Borrow<Q>,
-        Q: Ord + Eq + Hash,
+        Q: Ord + Eq + Hash + ?Sized,
     {
         self.map.remove(key)
     }

crates/core/src/model/object/ser.rs

@@ -125,26 +125,22 @@ impl serde::Serializer for ObjectSerializer {
     }
 
     #[inline]
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _name: &'static str,
-        value: &T,
-    ) -> Result<Object, SerError>
+    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Object, SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         value.serialize(ObjectSerializer)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(
+    fn serialize_newtype_variant<T>(
         self,
         _name: &'static str,
         _variant_index: u32,
         variant: &'static str,
         value: &T,
     ) -> Result<Object, SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         let mut values = Object::new();
         values.insert(
@@ -160,9 +156,9 @@ impl serde::Serializer for ObjectSerializer {
     }
 
     #[inline]
-    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Object, SerError>
+    fn serialize_some<T>(self, value: &T) -> Result<Object, SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         value.serialize(ObjectSerializer)
     }

crates/core/src/model/scalar/datetime/strftime.rs

@@ -52,10 +52,10 @@ impl fmt::Display for DateFormatError {
 /// Know exceptions are listed below:
 ///
 /// - `%Z` is used to print the (possibly) abbreviated time zone name. `chrono`
-/// did not actually implement this and instead just put the UTC offset with a
-/// colon, ie +/-HH:MM, and Ruby itself recommends _not_ using `%Z` as it is
-/// OS-dependent on what the string will be, in addition to the abbreviated time
-/// zone names being ambiguous. `Z` is also not supported at all by liquidjs.
+///   did not actually implement this and instead just put the UTC offset with a
+///   colon, ie +/-HH:MM, and Ruby itself recommends _not_ using `%Z` as it is
+///   OS-dependent on what the string will be, in addition to the abbreviated time
+///   zone names being ambiguous. `Z` is also not supported at all by liquidjs.
 pub fn strftime(ts: time::OffsetDateTime, fmt: &str) -> Result<String, DateFormatError> {
     let mut output = String::new();
     let mut fmt_iter = fmt.char_indices().peekable();

crates/core/src/model/scalar/ser.rs

@@ -126,26 +126,22 @@ impl serde::Serializer for ScalarSerializer {
         self.serialize_str(variant)
     }
 
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _name: &'static str,
-        value: &T,
-    ) -> Result<Scalar, SerError>
+    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Scalar, SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         value.serialize(ScalarSerializer)
     }
 
-    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: Serialize,
+        T: Serialize + ?Sized,
     {
         Err(scalar_must_be_a_string())
     }
@@ -154,9 +150,9 @@ impl serde::Serializer for ScalarSerializer {
         Err(scalar_must_be_a_string())
     }
 
-    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: Serialize,
+        T: Serialize + ?Sized,
     {
         Err(scalar_must_be_a_string())
     }

crates/core/src/model/ser.rs

@@ -81,9 +81,9 @@ impl<O: From<Object>> serde::ser::SerializeStructVariant for SerializeStructVari
     type Ok = O;
     type Error = SerError;
 
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), SerError>
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         self.map
             .insert(KString::from_static(key), value.serialize(ValueSerializer)?);
@@ -109,9 +109,9 @@ impl<O: From<Object>> serde::ser::SerializeTupleVariant for SerializeTupleVarian
     type Ok = O;
     type Error = SerError;
 
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), SerError>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         self.vec.push(value.serialize(ValueSerializer)?);
         Ok(())
@@ -138,9 +138,9 @@ impl<O: From<Object>> serde::ser::SerializeStruct for SerializeMap<O> {
     type Ok = O;
     type Error = SerError;
 
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), SerError>
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         match *self {
             SerializeMap::Map {
@@ -163,9 +163,9 @@ impl<O: From<Object>> serde::ser::SerializeMap for SerializeMap<O> {
     type Ok = O;
     type Error = SerError;
 
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), SerError>
+    fn serialize_key<T>(&mut self, key: &T) -> Result<(), SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         match *self {
             SerializeMap::Map {
@@ -177,9 +177,9 @@ impl<O: From<Object>> serde::ser::SerializeMap for SerializeMap<O> {
         }
     }
 
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), SerError>
+    fn serialize_value<T>(&mut self, value: &T) -> Result<(), SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         match *self {
             SerializeMap::Map {
@@ -233,13 +233,13 @@ impl serde::Serializer for MapKeySerializer {
     }
 
     #[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: Serialize,
+        T: Serialize + ?Sized,
     {
         value.serialize(self)
     }
@@ -314,15 +314,15 @@ impl serde::Serializer for MapKeySerializer {
         Err(key_must_be_a_string())
     }
 
-    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: Serialize,
+        T: Serialize + ?Sized,
     {
         Err(key_must_be_a_string())
     }
@@ -331,9 +331,9 @@ impl serde::Serializer for MapKeySerializer {
         Err(key_must_be_a_string())
     }
 
-    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: Serialize,
+        T: Serialize + ?Sized,
     {
         Err(key_must_be_a_string())
     }

crates/core/src/model/value/ser.rs

@@ -138,26 +138,22 @@ impl serde::Serializer for ValueSerializer {
     }
 
     #[inline]
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _name: &'static str,
-        value: &T,
-    ) -> Result<Value, SerError>
+    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value, SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         value.serialize(ValueSerializer)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(
+    fn serialize_newtype_variant<T>(
         self,
         _name: &'static str,
         _variant_index: u32,
         variant: &'static str,
         value: &T,
     ) -> Result<Value, SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         let mut values = Object::new();
         values.insert(
@@ -173,9 +169,9 @@ impl serde::Serializer for ValueSerializer {
     }
 
     #[inline]
-    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Value, SerError>
+    fn serialize_some<T>(self, value: &T) -> Result<Value, SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         value.serialize(ValueSerializer)
     }
@@ -253,9 +249,9 @@ impl serde::ser::SerializeSeq for SerializeVec {
     type Ok = Value;
     type Error = SerError;
 
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), SerError>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         self.vec.push(value.serialize(ValueSerializer)?);
         Ok(())
@@ -270,9 +266,9 @@ impl serde::ser::SerializeTuple for SerializeVec {
     type Ok = Value;
     type Error = SerError;
 
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), SerError>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         serde::ser::SerializeSeq::serialize_element(self, value)
     }
@@ -286,9 +282,9 @@ impl serde::ser::SerializeTupleStruct for SerializeVec {
     type Ok = Value;
     type Error = SerError;
 
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), SerError>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), SerError>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         serde::ser::SerializeSeq::serialize_element(self, value)
     }