Upgrade Rust to 2024-12-16 (#32566)

GitOrigin-RevId: 003a15e6970b7caba6ac6fdf5ad4121fddc8ba74

Author: goffrie

crates/application/src/application_function_runner/mod.rs

@@ -526,7 +526,7 @@ struct RequestGuard<'a> {
     permit: Option<SemaphorePermit<'a>>,
 }
 
-impl<'a> RequestGuard<'a> {
+impl RequestGuard<'_> {
     async fn acquire_permit(&mut self) -> anyhow::Result<()> {
         let timer = function_waiter_timer(self.limiter.udf_type);
         assert!(
@@ -541,7 +541,7 @@ impl<'a> RequestGuard<'a> {
     }
 }
 
-impl<'a> Drop for RequestGuard<'a> {
+impl Drop for RequestGuard<'_> {
     fn drop(&mut self) {
         // Drop the semaphore permit before updating gauges.
         drop(self.permit.take());

crates/application/src/cache/mod.rs

@@ -584,7 +584,7 @@ impl<'a> WaitingEntryGuard<'a> {
     }
 }
 
-impl<'a> Drop for WaitingEntryGuard<'a> {
+impl Drop for WaitingEntryGuard<'_> {
     fn drop(&mut self) {
         // Remove the cache entry from the cache if still present.
         if let Some(entry_id) = self.entry_id {

crates/application/src/deploy_config.rs

@@ -615,7 +615,7 @@ impl<'a, RT: Runtime> ApplicationInitializerEvaluator<'a, RT> {
 }
 
 #[async_trait]
-impl<'a, RT: Runtime> InitializerEvaluator for ApplicationInitializerEvaluator<'a, RT> {
+impl<RT: Runtime> InitializerEvaluator for ApplicationInitializerEvaluator<'_, RT> {
     async fn evaluate(
         &self,
         path: ComponentDefinitionPath,

crates/application/src/function_log.rs

@@ -1521,7 +1521,7 @@ impl<RT: Runtime> Inner<RT> {
             static LAST_LOGGED_ERROR: Cell<Option<SystemTime>> = const { Cell::new(None) };
         }
         let now = SystemTime::now();
-        let should_log = LAST_LOGGED_ERROR.get().map_or(true, |last_logged| {
+        let should_log = LAST_LOGGED_ERROR.get().is_none_or(|last_logged| {
             now.duration_since(last_logged).unwrap_or(Duration::ZERO) >= Duration::from_secs(10)
         });
         if !should_log {

crates/application/src/lib.rs

@@ -1,5 +1,4 @@
 #![feature(try_blocks)]
-#![feature(lazy_cell)]
 #![feature(iterator_try_collect)]
 #![feature(let_chains)]
 #![feature(coroutines)]

crates/application/src/snapshot_import/parse.rs

@@ -456,7 +456,7 @@ async fn parse_documents_jsonl<'a, R: TokioAsyncRead + Unpin>(
     }
 }
 
-async fn parse_generated_schema<'a, T: ShapeConfig, R: AsyncRead + Unpin>(
+async fn parse_generated_schema<T: ShapeConfig, R: AsyncRead + Unpin>(
     filename: &str,
     mut entry_reader: BufReader<R>,
 ) -> anyhow::Result<GeneratedSchema<T>> {

crates/application/src/snapshot_import/schema_constraints.rs

@@ -25,6 +25,7 @@ use value::{
 /// 2. import does not touch table "bar".
 /// 3. "bar" has a foreign reference to "foo", validated by schema.
 /// 4. when the import commits, "bar" is nonempty.
+///
 /// To prevent this case we throw an error if a schema'd table outside the
 /// import is nonempty and points into the import, and the import changes the
 /// table number.

crates/async_lru/src/lib.rs

@@ -1,4 +1,3 @@
 #![feature(let_chains)]
-#![feature(lazy_cell)]
 pub mod async_lru;
 mod metrics;

crates/authentication/src/lib.rs

@@ -1,4 +1,3 @@
-#![feature(lazy_cell)]
 use std::{
     str::FromStr,
     sync::LazyLock,
@@ -62,8 +61,6 @@ const CONFIG_URL_SUFFIX: &str = ".well-known/jwks.json";
 /// and not user-facing. These API access tokens are constructed from multiple
 /// clients (eg dashboard/cli)
 pub const CONVEX_CONSOLE_API_AUDIENCE: &str = "https://console.convex.dev/api/";
-/// Scopes required for an access token to be considered valid.
-/// Not really used meaningfully yet, but might be in the future.
 
 /// Extract the bearer token from an `Authorization: Bearer` header.
 pub async fn extract_bearer_token(header: Option<String>) -> anyhow::Result<Option<String>> {

crates/cmd_util/src/lib.rs

@@ -1,3 +1,2 @@
-#![feature(lazy_cell)]
 pub mod env;
 pub mod keyvalue;

crates/common/src/auth.rs

@@ -51,7 +51,7 @@ where
         .and_then(|url: IssuerUrl| {
             // Check if the input really looks like a URL,
             // to catch mistakes (e.g. putting random tokens in the domain field)
-            if !had_scheme && !url.url().host_str().map_or(false, ends_with_tld) {
+            if !had_scheme && !url.url().host_str().is_some_and(ends_with_tld) {
                 return Err(serde::de::Error::custom(
                     "Does not look like a URL (must have a scheme or end with a top-level domain)",
                 ));

crates/common/src/bootstrap_model/schema.rs

@@ -25,7 +25,7 @@ pub fn parse_schema_id(
         Err(_) => {
             // Try parsing as an IDv6 ID
             let id = DeveloperDocumentId::decode(schema_id)?;
-            id.to_resolved(&table_mapping.namespace(namespace).number_to_tablet())
+            id.to_resolved(table_mapping.namespace(namespace).number_to_tablet())
         },
     }
 }

crates/common/src/bootstrap_model/schema_state.rs

@@ -22,8 +22,7 @@ use value::codegen_convex_serialization;
 /// ```
 /// Invariants:
 /// 1. At most one schema can be in the `Pending` or `Validated` state at a
-/// time.
-///
+///    time.
 /// 2. At most one schema can be in the `Active` state at a time.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 #[cfg_attr(any(test, feature = "testing"), derive(proptest_derive::Arbitrary))]

crates/common/src/comparators/lower_bound.rs

@@ -29,21 +29,21 @@ impl<'a, Q: ?Sized, T: Borrow<Q> + 'a> Borrow<dyn LowerBoundKey<Q> + 'a> for Low
     }
 }
 
-impl<'a, T: Ord + ?Sized> Ord for dyn LowerBoundKey<T> + 'a {
+impl<T: Ord + ?Sized> Ord for dyn LowerBoundKey<T> + '_ {
     fn cmp(&self, other: &Self) -> Ordering {
         self.key().cmp(&other.key())
     }
 }
 
-impl<'a, T: Ord + ?Sized> PartialOrd for dyn LowerBoundKey<T> + 'a {
+impl<T: Ord + ?Sized> PartialOrd for dyn LowerBoundKey<T> + '_ {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 
-impl<'a, T: Eq + ?Sized> Eq for dyn LowerBoundKey<T> + 'a {}
+impl<T: Eq + ?Sized> Eq for dyn LowerBoundKey<T> + '_ {}
 
-impl<'a, T: PartialEq + ?Sized> PartialEq for dyn LowerBoundKey<T> + 'a {
+impl<T: PartialEq + ?Sized> PartialEq for dyn LowerBoundKey<T> + '_ {
     fn eq(&self, other: &Self) -> bool {
         self.key().eq(&other.key())
     }

crates/common/src/http/extract.rs

@@ -139,7 +139,7 @@ fn json_content_type(headers: &HeaderMap) -> bool {
         return false;
     };
     mime.type_() == "application"
-        && (mime.subtype() == "json" || mime.suffix().map_or(false, |name| name == "json"))
+        && (mime.subtype() == "json" || mime.suffix().is_some_and(|name| name == "json"))
 }
 
 impl<T> IntoResponse for Json<T>

crates/common/src/id_tracker.rs

@@ -39,7 +39,6 @@ pub const ID_TABLE_VERSION: u8 = 1;
 /// This implementation currently loads the full indexes into memory, but we
 /// could eventually change this to use `mmap(2)` to lazily load pieces as
 /// necessary.
-
 pub struct StaticIdTracker {
     count: usize,
     /// Convex IDs in search/vector index id order.

crates/common/src/knobs.rs

@@ -548,10 +548,10 @@ pub static WRITE_LOG_MAX_RETENTION_SECS: LazyLock<Duration> =
 
 /// The maximum size of the write log. Notes:
 /// - the write log will be trimmed based on WRITE_LOG_MAX_RETENTION_SECS, and
-/// thus it might never reach this size.
+///   thus it might never reach this size.
 /// - the write log always retains at least WRITE_LOG_MIN_RETENTION_SECS, and
-/// thus we could exceed this limit. The reason we do that is to allow some
-/// minimum buffer for queries to refresh after execution.
+///   thus we could exceed this limit. The reason we do that is to allow some
+///   minimum buffer for queries to refresh after execution.
 pub static WRITE_LOG_SOFT_MAX_SIZE_BYTES: LazyLock<usize> =
     LazyLock::new(|| env_config("WRITE_LOG_SOFT_MAX_SIZE_BYTES", 50 * 1024 * 1024));
 

crates/common/src/lib.rs

@@ -2,20 +2,16 @@
 #![feature(assert_matches)]
 #![feature(binary_heap_drain_sorted)]
 #![feature(const_for)]
-#![feature(const_mut_refs)]
-#![feature(const_option)]
 #![feature(const_type_name)]
 #![feature(coroutines)]
 #![feature(iter_intersperse)]
 #![feature(let_chains)]
 #![feature(nonzero_ops)]
-#![feature(lazy_cell)]
 #![feature(try_blocks)]
 #![feature(type_alias_impl_trait)]
 #![feature(bound_as_ref)]
 #![feature(iter_from_coroutine)]
 #![feature(iterator_try_collect)]
-#![feature(async_closure)]
 #![feature(error_iter)]
 #![feature(impl_trait_in_assoc_type)]
 #![feature(round_char_boundary)]

crates/common/src/minitrace_helpers.rs

@@ -176,6 +176,9 @@ fn validate_fraction(value: f64, context: &str) -> anyhow::Result<f64> {
     Ok(value)
 }
 
+static DOT_STAR: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(".*").expect(".* is not a valid regex"));
+
 impl TryFrom<SamplingConfigJson> for SamplingConfig {
     type Error = anyhow::Error;
 
@@ -203,7 +206,7 @@ impl TryFrom<SamplingConfigJson> for SamplingConfig {
         }
         by_regex.push((
             None,
-            Regex::new(".*").expect(".* is not a valid regex"),
+            DOT_STAR.clone(),
             validate_fraction(json.default_fraction, "default")?,
         ));
         Ok(SamplingConfig { by_regex })
@@ -238,9 +241,8 @@ impl FromStr for SamplingConfig {
                 let rate: f64 = parts[1].parse().context("Failed to parse sampling rate")?;
                 (regex, rate)
             } else {
-                let regex = Regex::new(".*").expect(".* is not a valid regex");
                 let rate: f64 = parts[0].parse().context("Failed to parse sampling rate")?;
-                (regex, rate)
+                (DOT_STAR.clone(), rate)
             };
             by_regex.push((instance_name, name_regex, rate));
         }

crates/common/src/pause.rs

@@ -74,7 +74,7 @@ mod test_pause {
         fault: Fault,
     }
 
-    impl<'a> PauseGuard<'a> {
+    impl PauseGuard<'_> {
         pub fn inject_error(&mut self, error: anyhow::Error) {
             self.fault = Fault::Error(error);
         }
@@ -101,7 +101,7 @@ mod test_pause {
         }
     }
 
-    impl<'a> Drop for PauseGuard<'a> {
+    impl Drop for PauseGuard<'_> {
         fn drop(&mut self) {
             if !self.unpaused {
                 tracing::info!("Unpausing waiter for {:?} on unclean drop", self.label);

crates/common/src/schemas/validator.rs

@@ -563,14 +563,14 @@ impl Validator {
     }
 
     fn is_valid_vector_validator(validator: &Validator) -> bool {
-        return match validator {
+        match validator {
             Validator::Array(validator) => {
                 matches!(**validator, Validator::Float64 | Validator::Any)
             },
             Validator::Any => true,
             Validator::Union(validators) => validators.iter().any(Self::is_valid_vector_validator),
             _ => false,
-        };
+        }
     }
 
     fn _overlaps_with_array_float64(&self, field_path_parts: &[IdentifierFieldName]) -> bool {

crates/common/src/types/environment_variables.rs

@@ -57,8 +57,8 @@ impl AsRef<str> for EnvVarValue {
 static NAME_REGEX: LazyLock<Regex> =
     LazyLock::new(|| Regex::new(r"^[a-zA-Z_]+[a-zA-Z0-9_]*$").unwrap());
 
-/// NOTE: Make sure to update the doc if you change any of these limits. Also
-/// don't reduce them since that might break existing projects.
+// NOTE: Make sure to update the doc if you change any of these limits. Also
+// don't reduce them since that might break existing projects.
 
 /// Maximum number of environment variables that can be stored.
 /// Also update client-side limit GenericEnvironmentVariables.tsx.

crates/common/src/utils.rs

@@ -40,11 +40,11 @@ pub fn increment_name(name: &str, amt: u64) -> String {
         .and_then(|c| c.get(2))
         .and_then(|m| m.as_str().parse::<u64>().ok())
     {
-        return NAME_NUMBER_RE
+        NAME_NUMBER_RE
             .replace(name, |caps: &regex::Captures| {
                 format!("{} ({})", &caps[1], number + amt)
             })
-            .into();
+            .into()
     } else {
         format!("{name} ({amt})")
     }

crates/common/src/version.rs

@@ -332,9 +332,7 @@ impl FromStr for ClientVersion {
                 (client_str, version)
             },
         };
-        let Ok(client) = client_str.parse::<ClientType>() else {
-            unreachable!()
-        };
+        let Ok(client) = client_str.parse::<ClientType>();
         Ok(Self { client, version })
     }
 }

crates/config_loader/src/lib.rs

@@ -2,7 +2,6 @@
 //! a signal
 
 #![feature(try_blocks)]
-#![feature(lazy_cell)]
 #![feature(trait_alias)]
 
 use std::path::PathBuf;

crates/convex/src/lib.rs

@@ -38,7 +38,7 @@
 //!
 //! Detailed examples of both use cases are documented for each struct.
 
-#![warn(missing_docs)]
+#![cfg_attr(not(test), warn(missing_docs))]
 #![warn(rustdoc::missing_crate_level_docs)]
 
 mod value;

crates/convex/sync_types/src/identifier.rs

@@ -12,21 +12,21 @@ pub const IDENTIFIER_REQUIREMENTS: &str =
 /// Check that a string can be used for a table name or field name in a
 /// document.
 ///
-/// We use a simplified ASCII version of Rust's syntax [^1] which also overlaps
-/// with JavaScript's syntax [^2].
+/// We use a simplified ASCII version of Rust's syntax[^1] which also overlaps
+/// with JavaScript's syntax[^2].
 ///
 /// ```text
 /// ident: start continue*
 /// start: a-zA-z_
 /// continue: a-zA-Z0-9_
 /// ```
-/// [^3][^4]
+/// [^3] [^4]
 /// To be conservative, let's also ban identifiers of entirely `_` too.
 ///
-/// [1]: <https://doc.rust-lang.org/reference/identifiers.html>
-/// [2]: <https://developer.mozilla.org/en-US/docs/Glossary/Identifier>
-/// [3]: <https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%3AXID_START%3A%5D&g=&i=>
-/// [4]: <https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%3AXID_CONTINUE%3A%5D&g=&i=>
+/// [^1]: <https://doc.rust-lang.org/reference/identifiers.html>
+/// [^2]: <https://developer.mozilla.org/en-US/docs/Glossary/Identifier>
+/// [^3]: <https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%3AXID_START%3A%5D&g=&i=>
+/// [^4]: <https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%3AXID_CONTINUE%3A%5D&g=&i=>
 pub fn check_valid_identifier(s: &str) -> anyhow::Result<()> {
     check_valid_identifier_inner(s).map_err(|e| anyhow::anyhow!(e))
 }

crates/convex/sync_types/src/json.rs

@@ -43,8 +43,8 @@ use crate::{
 /// by default, with loss of precision.
 ///
 /// e.g. (this number is 2^60)
-///   > JSON.parse("{\"foo\": 1152921504606846976}")
-///   { foo: 1152921504606847000 }
+///     > JSON.parse("{\"foo\": 1152921504606846976}")
+///     { foo: 1152921504606847000 }
 ///
 /// So instead we send it down as a string and unpack it ourselves.
 fn u64_to_string(x: u64) -> String {

crates/database/benches/subscriptions.rs

@@ -108,7 +108,7 @@ fn load_datasets(
     let mut terms = 0;
     for dataset in datasets {
         let mut frequency_map: BTreeMap<String, u32> = BTreeMap::new();
-        let f = File::open(&format!("{path}/{dataset}.jsonl"))?;
+        let f = File::open(format!("{path}/{dataset}.jsonl"))?;
         let f = BufReader::new(f);
         let mut documents = vec![];
         let mut m = 0;

crates/database/src/bootstrap_model/user_facing.rs

@@ -259,8 +259,7 @@ impl<'a, RT: Runtime> UserFacingModel<'a, RT> {
         self.tx.retention_validator.fail_if_falling_behind()?;
 
         let id_ = id.to_resolved(
-            &self
-                .tx
+            self.tx
                 .table_mapping()
                 .namespace(self.namespace)
                 .number_to_tablet(),
@@ -296,8 +295,7 @@ impl<'a, RT: Runtime> UserFacingModel<'a, RT> {
         }
         self.tx.retention_validator.fail_if_falling_behind()?;
         let id_ = id.to_resolved(
-            &self
-                .tx
+            self.tx
                 .table_mapping()
                 .namespace(self.namespace)
                 .number_to_tablet(),
@@ -322,8 +320,7 @@ impl<'a, RT: Runtime> UserFacingModel<'a, RT> {
         self.tx.retention_validator.fail_if_falling_behind()?;
 
         let id_ = id.to_resolved(
-            &self
-                .tx
+            self.tx
                 .table_mapping()
                 .namespace(self.namespace)
                 .number_to_tablet(),