Bump to Rust 1.72.0

Author: coolreader18

Cargo.toml

@@ -22,6 +22,7 @@ members = [
   "modules/quickstart-chat",
 ]
 default-members = ["crates/cli"]
+resolver = "2"
 
 [profile.release]
 opt-level = 3

crates/cli/src/subcommands/call.rs

@@ -261,7 +261,9 @@ fn find_of_type_in_schema<'v, 't: 'v>(
     let iter = entities
         .into_iter()
         .filter(move |(_, value)| {
-            let Some(obj) = value.as_object() else { return false; };
+            let Some(obj) = value.as_object() else {
+                return false;
+            };
             obj.get("type").filter(|x| x.as_str() == Some(ty)).is_some()
         })
         .map(|(key, value)| (key.as_str(), value));

crates/core/src/db/relational_db.rs

@@ -620,7 +620,7 @@ mod tests {
         schema.table_name = "MyTable".to_string();
         stdb.create_table(&mut tx, schema.clone())?;
         let result = stdb.create_table(&mut tx, schema);
-        assert!(matches!(result, Err(_)));
+        result.expect_err("create_table should error when called twice");
         Ok(())
     }
 
@@ -737,7 +737,7 @@ mod tests {
 
         let mut tx = stdb.begin_tx();
         let result = stdb.drop_table(&mut tx, table_id);
-        assert!(matches!(result, Err(_)));
+        result.expect_err("drop_table should fail");
         Ok(())
     }
 

crates/core/src/db/relational_operators.rs

@@ -126,7 +126,7 @@ impl<S: Relation, U: Relation> IntoIterator for UnionAll<S, U> {
     type IntoIter = std::iter::Chain<S::IntoIter, U::IntoIter>;
 
     fn into_iter(self) -> Self::IntoIter {
-        self.s.into_iter().chain(self.u.into_iter())
+        itertools::chain(self.s, self.u)
     }
 }
 

crates/lib/src/filter.rs

@@ -100,7 +100,8 @@ macro_rules! impl_product {
                 $(
                     let $field =
                         prod
-                        .next_element_seed(impl_product!(@seed $($seed(self.ctx),)? self.with_type::<$field_ty>()))?
+                        // TODO: remove the braces around {$seed} when clippy false positive is fixed
+                        .next_element_seed(impl_product!(@seed $({$seed}(self.ctx),)? self.with_type::<$field_ty>()))?
                         .ok_or_else(|| {
                             A::Error::missing_field(
                                 {

crates/lib/src/name/tests.rs

@@ -14,13 +14,12 @@ fn gen_valid_domain_name() -> impl Strategy<Value = String> {
 proptest! {
     #[test]
     fn prop_domain_name_parses(s in gen_valid_domain_name()) {
-        let domain = parse_domain_name(s);
-        prop_assert!(matches!(domain, Ok(_)), "expected ok, got err: {domain:?}")
+        parse_domain_name(s)?;
     }
 
     #[test]
     fn prop_domain_name_displays_input(s in gen_valid_domain_name()) {
-        let domain = DomainName::from_str(&s).unwrap();
+        let domain = DomainName::from_str(&s)?;
         prop_assert_eq!(s, domain.to_string())
     }
 
@@ -29,7 +28,7 @@ proptest! {
         tld in "[\\S&&[^/]]{1,64}",
         sub in prop::option::of(gen_valid_domain_name())
     ) {
-        let domain = parse_domain_name(iter::once(tld.as_str()).chain(sub.as_deref()).join("/")).unwrap();
+        let domain = parse_domain_name(iter::once(tld.as_str()).chain(sub.as_deref()).join("/"))?;
         prop_assert_eq!(&tld, domain.tld().as_str());
         prop_assert_eq!(sub.as_deref(), domain.sub_domain());
         let domain_tld = Tld::from(domain);
@@ -38,26 +37,26 @@ proptest! {
 
     #[test]
     fn prop_domain_name_serde(s in gen_valid_domain_name()) {
-        let a = parse_domain_name(s).unwrap();
-        let js = serde_json::to_string(&a).unwrap();
+        let a = parse_domain_name(s)?;
+        let js = serde_json::to_string(&a)?;
         eprintln!("json: `{js}`");
-        let b: DomainName = serde_json::from_str(&js).unwrap();
+        let b: DomainName = serde_json::from_str(&js)?;
         prop_assert_eq!(a, b)
     }
 
     #[test]
     fn prop_domain_name_sats(s in gen_valid_domain_name()) {
-        let a = parse_domain_name(s).unwrap();
-        let bsatn = bsatn::to_vec(&a).unwrap();
-        let b: DomainName = bsatn::from_slice(&bsatn).unwrap();
+        let a = parse_domain_name(s)?;
+        let bsatn = bsatn::to_vec(&a)?;
+        let b: DomainName = bsatn::from_slice(&bsatn)?;
         prop_assert_eq!(a, b)
     }
 
     #[test]
     fn prop_domain_name_inequality(a in gen_valid_domain_name(), b in gen_valid_domain_name()) {
         prop_assume!(a != b);
-        let a = parse_domain_name(a).unwrap();
-        let b = parse_domain_name(b).unwrap();
+        let a = parse_domain_name(a)?;
+        let b = parse_domain_name(b)?;
         prop_assert_ne!(a, b);
     }
 
@@ -121,7 +120,7 @@ proptest! {
     #[test]
     fn prop_but_tld_can_be_some_other_hex_value(bytes in any::<[u8; 32]>()) {
         let addr = hex::encode(bytes);
-        prop_assert!(matches!(parse_domain_name(addr), Ok(_)))
+        parse_domain_name(addr)?;
     }
 }
 

crates/lib/src/relation.rs

@@ -497,7 +497,7 @@ impl RelValue {
     pub fn extend(self, head: &Header, with: RelValue) -> RelValue {
         let mut x = self;
         x.head = head.clone();
-        x.data.elements.extend(with.data.elements.into_iter());
+        x.data.elements.extend(with.data.elements);
         x
     }
 }

crates/sats/src/de.rs

@@ -722,7 +722,9 @@ fn one_of_names(names: impl Fn(&mut dyn ValidNames)) -> Option<impl fmt::Display
             //       = 2 -> "`foo` or `bar`"
             //       > 2 -> "one of `foo`, `bar`, or `baz`"
 
-            let Ok(f) = &mut self.f else { return; };
+            let Ok(f) = &mut self.f else {
+                return;
+            };
 
             self.index += 1;
 

crates/sats/tests/encoding_roundtrip.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::arc_with_non_send_sync)]
+
 use proptest::prelude::*;
 use proptest::proptest;
 use spacetimedb_sats::buffer::DecodeError;

crates/sdk/examples/cursive-chat/module_bindings/mod.rs

@@ -77,8 +77,9 @@ fn handle_event(
     state: Arc<ClientCache>,
 ) -> Option<Arc<AnyReducerEvent>> {
     let Some(function_call) = &event.function_call else {
-				spacetimedb_sdk::log::warn!("Received Event with None function_call"); return None;
-};
+        spacetimedb_sdk::log::warn!("Received Event with None function_call");
+        return None;
+    };
     match &function_call.reducer[..] {
         "send_message" => reducer_callbacks
             .handle_event_of_type::<send_message_reducer::SendMessageArgs, ReducerEvent>(