fix some clippy lints

Dushistov · Dushistov · commit ce9bbe0f868c · 2024-07-17T15:56:36.000+03:00
diff --git a/couchbase-lite/src/doc_enumerator.rs b/couchbase-lite/src/doc_enumerator.rs
@@ -29,7 +29,7 @@ pub struct DocumentInfo<'a, 'b> {
     phantom: PhantomData<&'a DocEnumerator<'b>>,
 }
 
-impl<'a, 'b> DocumentInfo<'_, '_> {
+impl DocumentInfo<'_, '_> {
     pub(crate) fn new(inner: C4DocumentInfo) -> Self {
         Self {
             inner,
diff --git a/couchbase-lite/src/replicator.rs b/couchbase-lite/src/replicator.rs
@@ -260,12 +260,7 @@ impl Replicator {
                     !ctx.is_null(),
                     "Replicator::call_on_status_changed: Internal error - null function pointer"
                 );
-                match ReplicatorState::try_from(status) {
-                    Ok(state) => ((*ctx).state_cb)(state),
-                    Err(err) => {
-                        error!("replicator status change: invalid status {err}");
-                    }
-                }
+                ((*ctx).state_cb)(ReplicatorState::from(status));
             });
             if r.is_err() {
                 error!("Replicator::call_on_status_changed: catch panic aborting");
diff --git a/couchbase-lite/src/value.rs b/couchbase-lite/src/value.rs
@@ -65,12 +65,10 @@ impl ValueRef<'_> {
                     ValueRef::UnsignedInt(FLValue_AsUnsigned(value))
                 } else if FLValue_IsInteger(value) {
                     ValueRef::SignedInt(FLValue_AsInt(value))
+                } else if FLValue_IsDouble(value) {
+                    ValueRef::Double(FLValue_AsDouble(value))
                 } else {
-                    if FLValue_IsDouble(value) {
-                        ValueRef::Double(FLValue_AsDouble(value))
-                    } else {
-                        ValueRef::Float(FLValue_AsFloat(value))
-                    }
+                    ValueRef::Float(FLValue_AsFloat(value))
                 }
             }
             kFLString => {
diff --git a/examples/chat-demo/src/main.rs b/examples/chat-demo/src/main.rs
@@ -92,7 +92,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 } else if msg.starts_with("!list") {
                     db_exec_repl.spawn(move |db| {
                         if let Some(db) = db.as_mut() {
-                            print_all_messages(&mut db.db).expect("read from db failed");
+                            print_all_messages(&db.db).expect("read from db failed");
                         }
                     });
                 } else {
@@ -103,7 +103,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                         let edit_id = edit_id.take();
                         db_exec_repl.spawn(move |db| {
                             if let Some(db) = db.as_mut() {
-                                save_msg(&mut db.db, &msg, edit_id.as_ref().map(String::as_str))
+                                save_msg(&mut db.db, &msg, edit_id.as_deref())
                                     .expect("save to db failed");
                             } else {
                                 eprintln!("db is NOT open");
@@ -150,7 +150,7 @@ fn fix_conflicts(db: &mut Database) -> Result<(), Box<dyn std::error::Error>> {
     println!("There are {} conflicts in database", conflicts.len());
 
     for doc_id in &conflicts {
-        resolve_conflict(db, &doc_id)?;
+        resolve_conflict(db, doc_id)?;
     }
     if !conflicts.is_empty() {
         println!("All conflicts was resolved");
@@ -316,7 +316,7 @@ fn print_all_messages(db: &Database) -> Result<(), Box<dyn std::error::Error>> {
 fn print_external_changes(mdb: &mut Option<MyDb>) -> Result<(), Box<dyn std::error::Error>> {
     let mdb = mdb
         .as_mut()
-        .ok_or_else(|| format!("print_external_changes: db not OPEN"))?;
+        .ok_or_else(|| "print_external_changes: db not OPEN")?;
     let mut doc_ids = HashSet::<String>::new();
     let db = &mut mdb.db;
     for change in db.observed_changes() {
diff --git a/serde-fleece/src/ser.rs b/serde-fleece/src/ser.rs
@@ -191,9 +191,9 @@ impl<'a> ser::Serializer for &'a mut Serializer {
         encoder_write!(self, FLEncoder_WriteNull)
     }
     #[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: Serialize,
+        T: ?Sized + Serialize,
     {
         value.serialize(&mut *self)
     }
@@ -215,26 +215,26 @@ impl<'a> ser::Serializer for &'a mut Serializer {
         encoder_write!(self, FLEncoder_WriteString, variant.into())
     }
     #[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: ?Sized + Serialize,
     {
         value.serialize(&mut *self)
     }
     #[inline]
-    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: ?Sized + Serialize,
     {
         encoder_write!(self, FLEncoder_BeginDict, 1)?;
         encoder_write!(self, FLEncoder_WriteKey, variant.into())?;
@@ -301,9 +301,9 @@ impl<'a> ser::Serializer for &'a mut Serializer {
         Ok(self)
     }
     #[inline]
-    fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
+    fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
     where
-        T: Display,
+        T: ?Sized + Display,
     {
         self.serialize_str(&value.to_string())
     }
diff --git a/serde-fleece/src/ser/map.rs b/serde-fleece/src/ser/map.rs
@@ -93,9 +93,9 @@ where
         Err(Error::Unsupported("key must be a string (none)"))
     }
 
-    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: ?Sized + Serialize,
     {
         Err(Error::Unsupported("key must be a string (some)"))
     }
@@ -117,26 +117,26 @@ where
         encoder_write!(self.ser, FLEncoder_WriteKey, variant.into())
     }
 
-    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: ?Sized + Serialize,
     {
         value.serialize(&mut *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: Serialize,
+        T: ?Sized + Serialize,
     {
         Err(Error::Unsupported("key must be a string (newtype variant)"))
     }

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ pub struct DocumentInfo<'a, 'b> {`
`29`	`29`	`phantom: PhantomData<&'a DocEnumerator<'b>>,`
`30`	`30`	`}`
`31`	`31`
`32`		`-impl<'a, 'b> DocumentInfo<'_, '_> {`
	`32`	`+impl DocumentInfo<'_, '_> {`
`33`	`33`	`pub(crate) fn new(inner: C4DocumentInfo) -> Self {`
`34`	`34`	`Self {`
`35`	`35`	`inner,`
Original file line number	Diff line number	Diff line change
`@@ -191,9 +191,9 @@ impl<'a> ser::Serializer for &'a mut Serializer {`
`191`	`191`	`encoder_write!(self, FLEncoder_WriteNull)`
`192`	`192`	`}`
`193`	`193`	`#[inline]`
`194`		`- fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>`
	`194`	`+ fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>`
`195`	`195`	`where`
`196`		`- T: Serialize,`
	`196`	`+ T: ?Sized + Serialize,`
`197`	`197`	`{`
`198`	`198`	`value.serialize(&mut *self)`
`199`	`199`	`}`
`@@ -215,26 +215,26 @@ impl<'a> ser::Serializer for &'a mut Serializer {`
`215`	`215`	`encoder_write!(self, FLEncoder_WriteString, variant.into())`
`216`	`216`	`}`
`217`	`217`	`#[inline]`
`218`		`- fn serialize_newtype_struct<T: ?Sized>(`
	`218`	`+ fn serialize_newtype_struct<T>(`
`219`	`219`	`self,`
`220`	`220`	`_name: &'static str,`
`221`	`221`	`value: &T,`
`222`	`222`	`) -> Result<Self::Ok, Self::Error>`
`223`	`223`	`where`
`224`		`- T: Serialize,`
	`224`	`+ T: ?Sized + Serialize,`
`225`	`225`	`{`
`226`	`226`	`value.serialize(&mut *self)`
`227`	`227`	`}`
`228`	`228`	`#[inline]`
`229`		`- fn serialize_newtype_variant<T: ?Sized>(`
	`229`	`+ fn serialize_newtype_variant<T>(`
`230`	`230`	`self,`
`231`	`231`	`_name: &'static str,`
`232`	`232`	`_variant_index: u32,`
`233`	`233`	`variant: &'static str,`
`234`	`234`	`value: &T,`
`235`	`235`	`) -> Result<Self::Ok, Self::Error>`
`236`	`236`	`where`
`237`		`- T: Serialize,`
	`237`	`+ T: ?Sized + Serialize,`
`238`	`238`	`{`
`239`	`239`	`encoder_write!(self, FLEncoder_BeginDict, 1)?;`
`240`	`240`	`encoder_write!(self, FLEncoder_WriteKey, variant.into())?;`
`@@ -301,9 +301,9 @@ impl<'a> ser::Serializer for &'a mut Serializer {`
`301`	`301`	`Ok(self)`
`302`	`302`	`}`
`303`	`303`	`#[inline]`
`304`		`- fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>`
	`304`	`+ fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>`
`305`	`305`	`where`
`306`		`- T: Display,`
	`306`	`+ T: ?Sized + Display,`
`307`	`307`	`{`
`308`	`308`	`self.serialize_str(&value.to_string())`
`309`	`309`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,9 +93,9 @@ where`
`93`	`93`	`Err(Error::Unsupported("key must be a string (none)"))`
`94`	`94`	`}`
`95`	`95`
`96`		`- fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>`
	`96`	`+ fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>`
`97`	`97`	`where`
`98`		`- T: Serialize,`
	`98`	`+ T: ?Sized + Serialize,`
`99`	`99`	`{`
`100`	`100`	`Err(Error::Unsupported("key must be a string (some)"))`
`101`	`101`	`}`
`@@ -117,26 +117,26 @@ where`
`117`	`117`	`encoder_write!(self.ser, FLEncoder_WriteKey, variant.into())`
`118`	`118`	`}`
`119`	`119`
`120`		`- fn serialize_newtype_struct<T: ?Sized>(`
	`120`	`+ fn serialize_newtype_struct<T>(`
`121`	`121`	`self,`
`122`	`122`	`_name: &'static str,`
`123`	`123`	`value: &T,`
`124`	`124`	`) -> Result<Self::Ok, Self::Error>`
`125`	`125`	`where`
`126`		`- T: Serialize,`
	`126`	`+ T: ?Sized + Serialize,`
`127`	`127`	`{`
`128`	`128`	`value.serialize(&mut *self)`
`129`	`129`	`}`
`130`	`130`
`131`		`- fn serialize_newtype_variant<T: ?Sized>(`
	`131`	`+ fn serialize_newtype_variant<T>(`
`132`	`132`	`self,`
`133`	`133`	`_name: &'static str,`
`134`	`134`	`_variant_index: u32,`
`135`	`135`	`_variant: &'static str,`
`136`	`136`	`_value: &T,`
`137`	`137`	`) -> Result<Self::Ok, Self::Error>`
`138`	`138`	`where`
`139`		`- T: Serialize,`
	`139`	`+ T: ?Sized + Serialize,`
`140`	`140`	`{`
`141`	`141`	`Err(Error::Unsupported("key must be a string (newtype variant)"))`
`142`	`142`	`}`