treewide: Update rust-toolchain to 2023-03-07

Bump the rust-toolchain to nightly-2023-03-07.

Basically all the changes here come from automatically fixing clippy
lints with `cargo clippy --fix`, with a couple of exceptions:

* A few places were wrapping `async fn`s with `#[track_caller]`, which
  has apparently always been a no-op - these have been removed
* A few places were doing `let _ = ...` on a future without `await`ing
  that future, which unintentionally would have never actually run that
  future. This has been fixed to actually `await` the future.

Change-Id: Id690fde21fa1157966bf7c92e98523d962852887
Reviewed-on: https://gerrit.readyset.name/c/readyset/+/4661
Tested-by: Buildkite CI
Reviewed-by: Dan Wilbanks <[email protected]>

Author: glittershark

benchmarks/src/spec.rs

@@ -197,18 +197,15 @@ impl WorkloadSpec {
             info!("Generating distribution {name}");
 
             let data: Vec<Vec<DfValue>> = match from {
-                WorkloadDistributionSource::Range { range } => range
-                    .clone()
-                    .into_iter()
-                    .map(|n| vec![DfValue::from(n)])
-                    .collect(),
+                WorkloadDistributionSource::Range { range } => {
+                    range.clone().map(|n| vec![DfValue::from(n)]).collect()
+                }
                 WorkloadDistributionSource::Pair {
                     pair: Pair { range, distance },
                 } => {
                     let mut rng = rand::thread_rng();
                     range
                         .clone()
-                        .into_iter()
                         .map(|n| {
                             vec![
                                 DfValue::from(n),

benchmarks/src/utils/query.rs

@@ -55,7 +55,7 @@ impl<'de> Deserialize<'de> for QueryFile {
 impl TryFrom<PathBuf> for QueryFile {
     type Error = anyhow::Error;
     fn try_from(path: PathBuf) -> Result<Self, Self::Error> {
-        let query = fs::read_to_string(&benchmark_path(&path)?)
+        let query = fs::read_to_string(benchmark_path(&path)?)
             .map_err(|e| anyhow!("Could not load query from file: {}", e))?;
         Ok(Self { path, query })
     }

benchmarks/src/utils/spec.rs

@@ -180,7 +180,7 @@ impl DatabaseSchema {
 impl TryFrom<PathBuf> for DatabaseSchema {
     type Error = anyhow::Error;
     fn try_from(path: PathBuf) -> anyhow::Result<Self> {
-        let ddl = read_to_string(&path).with_context(|| "Failed to read schema file")?;
+        let ddl = read_to_string(path).with_context(|| "Failed to read schema file")?;
         DatabaseSchema::new(&ddl, HashMap::new())
     }
 }

dataflow-expression/src/eval/builtins.rs

@@ -150,7 +150,7 @@ where
             .unwrap()
             .with_month(1)
             .unwrap()
-            .num_days_from_ce() as i32;
+            .num_days_from_ce();
         let mut weekday = if monday_first {
             time.weekday().num_days_from_monday()
         } else {
@@ -164,8 +164,8 @@ where
             }
             week_year = true;
             year -= 1;
-            days = days_in_year(year) as i32;
-            first_daynr -= days as i32;
+            days = days_in_year(year);
+            first_daynr -= days;
             weekday = (weekday + 53 * 7 - days) % 7;
         }
 

dataflow-expression/src/like.rs

@@ -11,22 +11,17 @@ use lazy_static::lazy_static;
 use regex::Regex;
 
 /// Case-sensitivity mode for a [`LikePattern`]
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Debug, Eq, PartialEq, Default)]
 pub enum CaseSensitivityMode {
     /// Match case-sentitively
+    #[default]
     CaseSensitive,
 
     /// Match case-insentitively
     CaseInsensitive,
 }
 pub use CaseSensitivityMode::*;
 
-impl Default for CaseSensitivityMode {
-    fn default() -> Self {
-        CaseSensitive
-    }
-}
-
 struct LikeTokenReplacer;
 impl regex::Replacer for LikeTokenReplacer {
     fn replace_append(&mut self, caps: &regex::Captures<'_>, dst: &mut String) {

dataflow-expression/tests/mysql_oracle.rs

@@ -73,7 +73,6 @@ async fn mysql_eval(expr: &str, conn: &mut Conn) -> DfValue {
     res.coerce_to(&target_type, &DfType::Unknown).unwrap()
 }
 
-#[track_caller]
 async fn compare_eval(expr: &str, conn: &mut Conn) {
     let mysql_result = mysql_eval(expr, conn).await;
     let our_result = parse_lower_eval(

dataflow-expression/tests/postgres_oracle.rs

@@ -29,7 +29,6 @@ async fn postgres_eval(expr: &str, client: &Client) -> DfValue {
         .get(0)
 }
 
-#[track_caller]
 async fn compare_eval(expr: &str, client: &Client) {
     let our_result = parse_lower_eval(
         expr,

dataflow-state/src/keyed_state.rs

@@ -87,22 +87,22 @@ impl KeyedState {
     /// Panics if the length of `key` is different than the length of this `KeyedState`
     pub(super) fn lookup<'a>(&'a self, key: &PointKey) -> Option<&'a Rows> {
         match (self, key) {
-            (&KeyedState::SingleBTree(ref m), &PointKey::Single(ref k)) => m.get(k),
-            (&KeyedState::DoubleBTree(ref m), &PointKey::Double(ref k)) => m.get(k),
-            (&KeyedState::TriBTree(ref m), &PointKey::Tri(ref k)) => m.get(k),
-            (&KeyedState::QuadBTree(ref m), &PointKey::Quad(ref k)) => m.get(k),
-            (&KeyedState::QuinBTree(ref m), &PointKey::Quin(ref k)) => m.get(k),
-            (&KeyedState::SexBTree(ref m), &PointKey::Sex(ref k)) => m.get(k),
-            (&KeyedState::MultiBTree(ref m, len), &PointKey::Multi(ref k)) if k.len() == len => {
+            (KeyedState::SingleBTree(m), PointKey::Single(k)) => m.get(k),
+            (KeyedState::DoubleBTree(m), PointKey::Double(k)) => m.get(k),
+            (KeyedState::TriBTree(m), PointKey::Tri(k)) => m.get(k),
+            (KeyedState::QuadBTree(m), PointKey::Quad(k)) => m.get(k),
+            (KeyedState::QuinBTree(m), PointKey::Quin(k)) => m.get(k),
+            (KeyedState::SexBTree(m), PointKey::Sex(k)) => m.get(k),
+            (&KeyedState::MultiBTree(ref m, len), PointKey::Multi(k)) if k.len() == len => {
                 m.get(k.as_ref())
             }
-            (&KeyedState::SingleHash(ref m), &PointKey::Single(ref k)) => m.get(k),
-            (&KeyedState::DoubleHash(ref m), &PointKey::Double(ref k)) => m.get(k),
-            (&KeyedState::TriHash(ref m), &PointKey::Tri(ref k)) => m.get(k),
-            (&KeyedState::QuadHash(ref m), &PointKey::Quad(ref k)) => m.get(k),
-            (&KeyedState::QuinHash(ref m), &PointKey::Quin(ref k)) => m.get(k),
-            (&KeyedState::SexHash(ref m), &PointKey::Sex(ref k)) => m.get(k),
-            (&KeyedState::MultiHash(ref m, len), &PointKey::Multi(ref k)) if k.len() == len => {
+            (KeyedState::SingleHash(m), PointKey::Single(k)) => m.get(k),
+            (KeyedState::DoubleHash(m), PointKey::Double(k)) => m.get(k),
+            (KeyedState::TriHash(m), PointKey::Tri(k)) => m.get(k),
+            (KeyedState::QuadHash(m), PointKey::Quad(k)) => m.get(k),
+            (KeyedState::QuinHash(m), PointKey::Quin(k)) => m.get(k),
+            (KeyedState::SexHash(m), PointKey::Sex(k)) => m.get(k),
+            (&KeyedState::MultiHash(ref m, len), PointKey::Multi(k)) if k.len() == len => {
                 m.get(k.as_ref())
             }
             _ => {
@@ -384,7 +384,7 @@ impl KeyedState {
         }
 
         match (self, key) {
-            (&KeyedState::SingleBTree(ref m), &RangeKey::Unbounded) => m
+            (KeyedState::SingleBTree(m), &RangeKey::Unbounded) => m
                 .range(&(..))
                 .map_err(|misses| {
                     misses
@@ -393,23 +393,23 @@ impl KeyedState {
                         .collect()
                 })
                 .map(flatten_rows),
-            (&KeyedState::DoubleBTree(ref m), &RangeKey::Unbounded) => full_range!(m),
-            (&KeyedState::TriBTree(ref m), &RangeKey::Unbounded) => full_range!(m),
-            (&KeyedState::QuadBTree(ref m), &RangeKey::Unbounded) => full_range!(m),
-            (&KeyedState::SexBTree(ref m), &RangeKey::Unbounded) => full_range!(m),
-            (&KeyedState::SingleBTree(ref m), RangeKey::Single(range)) => {
+            (KeyedState::DoubleBTree(m), &RangeKey::Unbounded) => full_range!(m),
+            (KeyedState::TriBTree(m), &RangeKey::Unbounded) => full_range!(m),
+            (KeyedState::QuadBTree(m), &RangeKey::Unbounded) => full_range!(m),
+            (KeyedState::SexBTree(m), &RangeKey::Unbounded) => full_range!(m),
+            (KeyedState::SingleBTree(m), RangeKey::Single(range)) => {
                 m.range(range).map(flatten_rows).map_err(|misses| {
                     misses
                         .into_iter()
                         .map(|(lower, upper)| (lower.map(|k| vec![k]), upper.map(|k| vec![k])))
                         .collect()
                 })
             }
-            (&KeyedState::DoubleBTree(ref m), RangeKey::Double(range)) => range!(m, range),
-            (&KeyedState::TriBTree(ref m), RangeKey::Tri(range)) => range!(m, range),
-            (&KeyedState::QuadBTree(ref m), RangeKey::Quad(range)) => range!(m, range),
-            (&KeyedState::SexBTree(ref m), RangeKey::Sex(range)) => range!(m, range),
-            (&KeyedState::MultiBTree(ref m, _), RangeKey::Multi(range)) => m
+            (KeyedState::DoubleBTree(m), RangeKey::Double(range)) => range!(m, range),
+            (KeyedState::TriBTree(m), RangeKey::Tri(range)) => range!(m, range),
+            (KeyedState::QuadBTree(m), RangeKey::Quad(range)) => range!(m, range),
+            (KeyedState::SexBTree(m), RangeKey::Sex(range)) => range!(m, range),
+            (KeyedState::MultiBTree(m, _), RangeKey::Multi(range)) => m
                 .range::<_, [DfValue]>(&(
                     range.0.as_ref().map(|b| b.as_ref()),
                     range.1.as_ref().map(|b| b.as_ref()),

mysql-srv/src/params.rs

@@ -78,8 +78,8 @@ impl<'a> Iterator for Params<'a> {
                 };
                 self.bound_types.clear();
                 for i in 0..self.params as usize {
-                    let bound_type_col = typmap.get(2 * i as usize);
-                    let bound_type_flag = typmap.get(2 * i as usize + 1);
+                    let bound_type_col = typmap.get(2 * i);
+                    let bound_type_flag = typmap.get(2 * i + 1);
                     match (bound_type_col, bound_type_flag) {
                         (None, _) | (_, None) => return Some(Err(MsqlSrvError::IndexingError)),
                         (Some(col), Some(flag)) => {

nom-sql/src/common.rs

@@ -270,7 +270,9 @@ impl TableKey {
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Serialize, Deserialize)]
 #[allow(clippy::large_enum_variant)] // NOTE(grfn): do we actually care about this?
+#[derive(Default)]
 pub enum FieldDefinitionExpr {
+    #[default]
     All,
     AllInTable(Relation),
     Expr {
@@ -303,12 +305,6 @@ impl From<Literal> for FieldDefinitionExpr {
     }
 }
 
-impl Default for FieldDefinitionExpr {
-    fn default() -> FieldDefinitionExpr {
-        FieldDefinitionExpr::All
-    }
-}
-
 impl FieldDefinitionExpr {
     pub fn display(&self, dialect: Dialect) -> impl fmt::Display + Copy + '_ {
         fmt_with(move |f| match self {