Merge pull request #1411 from epage/edition2024

epage · web-flow · commit c28df19fa3b6 · 2025-11-03T09:47:24.000-06:00
chore: Migrate to 2024 edition
diff --git a/Cargo.toml b/Cargo.toml
@@ -8,8 +8,8 @@ resolver = "2"
 [workspace.package]
 repository = "https://github.com/crate-ci/typos"
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.80"  # MSRV
+edition = "2024"
+rust-version = "1.87"  # MSRV
 include = [
   "build.rs",
   "src/**/*",
diff --git a/crates/dictgen/src/aho_corasick.rs b/crates/dictgen/src/aho_corasick.rs
@@ -8,7 +8,7 @@ pub use ::aho_corasick::StartKind;
 
 #[cfg(feature = "codegen")]
 pub struct AhoCorasickGen<'g> {
-    pub(crate) gen: crate::DictGen<'g>,
+    pub(crate) r#gen: crate::DictGen<'g>,
 }
 
 #[cfg(feature = "codegen")]
@@ -21,8 +21,8 @@ impl AhoCorasickGen<'_> {
         let mut data: Vec<_> = data.collect();
         data.sort_unstable_by_key(|v| unicase::UniCase::new(v.0.as_ref().to_owned()));
 
-        let name = self.gen.name;
-        let value_type = self.gen.value_type;
+        let name = self.r#gen.name;
+        let value_type = self.r#gen.value_type;
 
         writeln!(file, "pub struct {name} {{")?;
         writeln!(file, "    dfa: dictgen::aho_corasick::DFA,")?;
diff --git a/crates/dictgen/src/gen.rs b/crates/dictgen/src/gen.rs
@@ -37,34 +37,34 @@ impl<'g> DictGen<'g> {
     #[cfg(feature = "map")]
     pub fn map(self) -> crate::MapGen<'g> {
         crate::MapGen {
-            gen: self,
+            r#gen: self,
             unicode: true,
             unicase: true,
         }
     }
 
     pub fn ordered_map(self) -> crate::OrderedMapGen<'g> {
         crate::OrderedMapGen {
-            gen: self,
+            r#gen: self,
             unicode: true,
             unicase: true,
         }
     }
 
     pub fn trie(self) -> crate::TrieGen<'g> {
         crate::TrieGen {
-            gen: self,
+            r#gen: self,
             limit: 64,
         }
     }
 
     pub fn r#match(self) -> crate::MatchGen<'g> {
-        crate::MatchGen { gen: self }
+        crate::MatchGen { r#gen: self }
     }
 
     #[cfg(feature = "aho-corasick")]
     pub fn aho_corasick(self) -> crate::AhoCorasickGen<'g> {
-        crate::AhoCorasickGen { gen: self }
+        crate::AhoCorasickGen { r#gen: self }
     }
 }
 
diff --git a/crates/dictgen/src/lib.rs b/crates/dictgen/src/lib.rs
@@ -5,7 +5,7 @@
 #[cfg(feature = "aho-corasick")]
 pub mod aho_corasick;
 #[cfg(feature = "codegen")]
-mod gen;
+mod r#gen;
 mod insensitive;
 #[cfg(feature = "map")]
 mod map;
@@ -17,12 +17,12 @@ mod trie;
 #[cfg(feature = "aho-corasick")]
 #[cfg(feature = "codegen")]
 pub use aho_corasick::AhoCorasickGen;
-#[cfg(feature = "codegen")]
-pub use gen::*;
 pub use insensitive::*;
 #[cfg(feature = "map")]
 pub use map::*;
 pub use ordered_map::*;
 #[cfg(feature = "codegen")]
+pub use r#gen::*;
+#[cfg(feature = "codegen")]
 pub use r#match::*;
 pub use trie::*;
diff --git a/crates/dictgen/src/map.rs b/crates/dictgen/src/map.rs
@@ -1,6 +1,6 @@
 #[cfg(feature = "codegen")]
 pub struct MapGen<'g> {
-    pub(crate) gen: crate::DictGen<'g>,
+    pub(crate) r#gen: crate::DictGen<'g>,
     pub(crate) unicase: bool,
     pub(crate) unicode: bool,
 }
@@ -25,9 +25,9 @@ impl MapGen<'_> {
         let mut data: Vec<_> = data.collect();
         data.sort_unstable_by_key(|v| unicase::UniCase::new(v.0.as_ref().to_owned()));
 
-        let name = self.gen.name;
+        let name = self.r#gen.name;
         let key_type = self.key_type();
-        let value_type = self.gen.value_type;
+        let value_type = self.r#gen.value_type;
 
         let mut smallest = usize::MAX;
         let mut largest = usize::MIN;
diff --git a/crates/dictgen/src/match.rs b/crates/dictgen/src/match.rs
@@ -1,6 +1,6 @@
 #[cfg(feature = "codegen")]
 pub struct MatchGen<'g> {
-    pub(crate) gen: crate::DictGen<'g>,
+    pub(crate) r#gen: crate::DictGen<'g>,
 }
 
 #[cfg(feature = "codegen")]
@@ -13,8 +13,8 @@ impl MatchGen<'_> {
         let mut data: Vec<_> = data.collect();
         data.sort_unstable_by_key(|v| unicase::UniCase::new(v.0.as_ref().to_owned()));
 
-        let name = self.gen.name;
-        let value_type = self.gen.value_type;
+        let name = self.r#gen.name;
+        let value_type = self.r#gen.value_type;
 
         writeln!(file, "pub struct {name};")?;
         writeln!(file, "impl {name} {{")?;
diff --git a/crates/dictgen/src/ordered_map.rs b/crates/dictgen/src/ordered_map.rs
@@ -1,6 +1,6 @@
 #[cfg(feature = "codegen")]
 pub struct OrderedMapGen<'g> {
-    pub(crate) gen: crate::DictGen<'g>,
+    pub(crate) r#gen: crate::DictGen<'g>,
     pub(crate) unicase: bool,
     pub(crate) unicode: bool,
 }
@@ -25,9 +25,9 @@ impl OrderedMapGen<'_> {
         let mut data: Vec<_> = data.collect();
         data.sort_unstable_by_key(|v| unicase::UniCase::new(v.0.as_ref().to_owned()));
 
-        let name = self.gen.name;
+        let name = self.r#gen.name;
         let key_type = self.key_type();
-        let value_type = self.gen.value_type;
+        let value_type = self.r#gen.value_type;
 
         let mut smallest = usize::MAX;
         let mut largest = usize::MIN;
diff --git a/crates/dictgen/src/trie.rs b/crates/dictgen/src/trie.rs
@@ -1,6 +1,6 @@
 #[cfg(feature = "codegen")]
 pub struct TrieGen<'g> {
-    pub(crate) gen: crate::DictGen<'g>,
+    pub(crate) r#gen: crate::DictGen<'g>,
     pub(crate) limit: usize,
 }
 
@@ -19,8 +19,8 @@ impl TrieGen<'_> {
         file: &mut W,
         data: impl Iterator<Item = (&'d str, V)>,
     ) -> Result<(), std::io::Error> {
-        let name = self.gen.name;
-        let value_type = self.gen.value_type;
+        let name = self.r#gen.name;
+        let value_type = self.r#gen.value_type;
         codegen::generate_trie(file, name, value_type, data, self.limit)
     }
 }
@@ -310,7 +310,7 @@ mod codegen {
                                 DynChild::Nested(_) => {
                                     unreachable!("Only overflow at this point")
                                 }
-                                DynChild::Flat(ref mut v) => {
+                                DynChild::Flat(v) => {
                                     v.push((remaining, value));
                                 }
                             }
diff --git a/crates/typos-cli/src/config.rs b/crates/typos-cli/src/config.rs
@@ -317,7 +317,7 @@ impl TypeEngineConfig {
         }
     }
 
-    pub fn patterns(&self) -> impl Iterator<Item = (KString, GlobEngineConfig)> {
+    pub fn patterns(&self) -> impl Iterator<Item = (KString, GlobEngineConfig)> + use<> {
         let mut engine = Self::from_defaults();
         engine.update(self);
         engine.patterns.into_iter()
@@ -619,23 +619,23 @@ impl std::fmt::Display for Locale {
 }
 
 #[cfg(feature = "unstable-schema")]
-fn vec_string(gen: &mut schemars::SchemaGenerator) -> schemars::Schema {
+fn vec_string(r#gen: &mut schemars::SchemaGenerator) -> schemars::Schema {
     type Type = Vec<String>;
-    <Type as schemars::JsonSchema>::json_schema(gen)
+    <Type as schemars::JsonSchema>::json_schema(r#gen)
 }
 
 #[cfg(feature = "unstable-schema")]
-fn hashmap_string_string(gen: &mut schemars::SchemaGenerator) -> schemars::Schema {
+fn hashmap_string_string(r#gen: &mut schemars::SchemaGenerator) -> schemars::Schema {
     type Type = HashMap<String, String>;
-    <Type as schemars::JsonSchema>::json_schema(gen)
+    <Type as schemars::JsonSchema>::json_schema(r#gen)
 }
 
 #[cfg(feature = "unstable-schema")]
 fn hashmap_string_t<T: schemars::JsonSchema>(
-    gen: &mut schemars::SchemaGenerator,
+    r#gen: &mut schemars::SchemaGenerator,
 ) -> schemars::Schema {
     type Type<T> = HashMap<String, T>;
-    <Type<T> as schemars::JsonSchema>::json_schema(gen)
+    <Type<T> as schemars::JsonSchema>::json_schema(r#gen)
 }
 
 #[cfg(test)]
diff --git a/crates/typos-cli/src/dict.rs b/crates/typos-cli/src/dict.rs
@@ -250,7 +250,7 @@ impl<'i, 'w, D: typos::Dictionary> Override<'i, 'w, D> {
 
     fn interpret<'z, I: Iterator<Item = (&'z str, &'z str)>>(
         cases: I,
-    ) -> impl Iterator<Item = (&'z str, Status<'z>)> {
+    ) -> impl Iterator<Item = (&'z str, Status<'z>)> + use<'z, I, D> {
         cases.map(|(typo, correction)| {
             let correction = if typo == correction {
                 Status::Valid
diff --git a/crates/typos/src/tokens.rs b/crates/typos/src/tokens.rs
@@ -751,7 +751,7 @@ impl<'t> Identifier<'t> {
 
     /// Split into individual Words.
     #[inline]
-    pub fn split(&self) -> impl Iterator<Item = Word<'t>> {
+    pub fn split(&self) -> impl Iterator<Item = Word<'t>> + use<'t> {
         match self.case {
             Case::None => itertools::Either::Left(SplitIdent::new(self.token, self.offset)),
             _ => itertools::Either::Right(

Original file line number	Diff line number	Diff line change
`@@ -37,34 +37,34 @@ impl<'g> DictGen<'g> {`
`37`	`37`	`#[cfg(feature = "map")]`
`38`	`38`	`pub fn map(self) -> crate::MapGen<'g> {`
`39`	`39`	`crate::MapGen {`
`40`		`- gen: self,`
	`40`	`+ r#gen: self,`
`41`	`41`	`unicode: true,`
`42`	`42`	`unicase: true,`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`pub fn ordered_map(self) -> crate::OrderedMapGen<'g> {`
`47`	`47`	`crate::OrderedMapGen {`
`48`		`- gen: self,`
	`48`	`+ r#gen: self,`
`49`	`49`	`unicode: true,`
`50`	`50`	`unicase: true,`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`pub fn trie(self) -> crate::TrieGen<'g> {`
`55`	`55`	`crate::TrieGen {`
`56`		`- gen: self,`
	`56`	`+ r#gen: self,`
`57`	`57`	`limit: 64,`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`pub fn r#match(self) -> crate::MatchGen<'g> {`
`62`		`- crate::MatchGen { gen: self }`
	`62`	`+ crate::MatchGen { r#gen: self }`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`#[cfg(feature = "aho-corasick")]`
`66`	`66`	`pub fn aho_corasick(self) -> crate::AhoCorasickGen<'g> {`
`67`		`- crate::AhoCorasickGen { gen: self }`
	`67`	`+ crate::AhoCorasickGen { r#gen: self }`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`#[cfg(feature = "codegen")]`
`2`	`2`	`pub struct TrieGen<'g> {`
`3`		`- pub(crate) gen: crate::DictGen<'g>,`
	`3`	`+ pub(crate) r#gen: crate::DictGen<'g>,`
`4`	`4`	`pub(crate) limit: usize,`
`5`	`5`	`}`
`6`	`6`
`@@ -19,8 +19,8 @@ impl TrieGen<'_> {`
`19`	`19`	`file: &mut W,`
`20`	`20`	`data: impl Iterator<Item = (&'d str, V)>,`
`21`	`21`	`) -> Result<(), std::io::Error> {`
`22`		`- let name = self.gen.name;`
`23`		`- let value_type = self.gen.value_type;`
	`22`	`+ let name = self.r#gen.name;`
	`23`	`+ let value_type = self.r#gen.value_type;`
`24`	`24`	`codegen::generate_trie(file, name, value_type, data, self.limit)`
`25`	`25`	`}`
`26`	`26`	`}`
`@@ -310,7 +310,7 @@ mod codegen {`
`310`	`310`	`DynChild::Nested(_) => {`
`311`	`311`	`unreachable!("Only overflow at this point")`
`312`	`312`	`}`
`313`		`- DynChild::Flat(ref mut v) => {`
	`313`	`+ DynChild::Flat(v) => {`
`314`	`314`	`v.push((remaining, value));`
`315`	`315`	`}`
`316`	`316`	`}`
Original file line number	Diff line number	Diff line change
`@@ -317,7 +317,7 @@ impl TypeEngineConfig {`
`317`	`317`	`}`
`318`	`318`	`}`
`319`	`319`
`320`		`- pub fn patterns(&self) -> impl Iterator<Item = (KString, GlobEngineConfig)> {`
	`320`	`+ pub fn patterns(&self) -> impl Iterator<Item = (KString, GlobEngineConfig)> + use<> {`
`321`	`321`	`let mut engine = Self::from_defaults();`
`322`	`322`	`engine.update(self);`
`323`	`323`	`engine.patterns.into_iter()`
`@@ -619,23 +619,23 @@ impl std::fmt::Display for Locale {`
`619`	`619`	`}`
`620`	`620`
`621`	`621`	`#[cfg(feature = "unstable-schema")]`
`622`		`-fn vec_string(gen: &mut schemars::SchemaGenerator) -> schemars::Schema {`
	`622`	`+fn vec_string(r#gen: &mut schemars::SchemaGenerator) -> schemars::Schema {`
`623`	`623`	`type Type = Vec<String>;`
`624`		`- <Type as schemars::JsonSchema>::json_schema(gen)`
	`624`	`+ <Type as schemars::JsonSchema>::json_schema(r#gen)`
`625`	`625`	`}`
`626`	`626`
`627`	`627`	`#[cfg(feature = "unstable-schema")]`
`628`		`-fn hashmap_string_string(gen: &mut schemars::SchemaGenerator) -> schemars::Schema {`
	`628`	`+fn hashmap_string_string(r#gen: &mut schemars::SchemaGenerator) -> schemars::Schema {`
`629`	`629`	`type Type = HashMap<String, String>;`
`630`		`- <Type as schemars::JsonSchema>::json_schema(gen)`
	`630`	`+ <Type as schemars::JsonSchema>::json_schema(r#gen)`
`631`	`631`	`}`
`632`	`632`
`633`	`633`	`#[cfg(feature = "unstable-schema")]`
`634`	`634`	`fn hashmap_string_t<T: schemars::JsonSchema>(`
`635`		`- gen: &mut schemars::SchemaGenerator,`
	`635`	`+ r#gen: &mut schemars::SchemaGenerator,`
`636`	`636`	`) -> schemars::Schema {`
`637`	`637`	`type Type<T> = HashMap<String, T>;`
`638`		`- <Type<T> as schemars::JsonSchema>::json_schema(gen)`
	`638`	`+ <Type<T> as schemars::JsonSchema>::json_schema(r#gen)`
`639`	`639`	`}`
`640`	`640`
`641`	`641`	`#[cfg(test)]`