update to Rust edition 2024

Cargo.toml

@@ -7,7 +7,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-edition = "2021"
+edition = "2024"
 version = "0.12.2" # when updating, also update `#![doc(html_root_url)]` and any inter-crate dependencies (such as `cstree`'s dependency on `cstree-derive`)
 authors = [
     "Domenic Quirl <DomenicQuirl@pm.me>",

cstree-derive/src/lib.rs

@@ -17,7 +17,7 @@ use errors::ErrorContext;
 use parsing::SyntaxKindEnum;
 use proc_macro2::TokenStream;
 use quote::{quote, quote_spanned};
-use syn::{parse_macro_input, spanned::Spanned, DeriveInput};
+use syn::{DeriveInput, parse_macro_input, spanned::Spanned};
 
 mod errors;
 mod parsing;

cstree-derive/src/parsing.rs

@@ -1,6 +1,6 @@
 mod attributes;
 
-use syn::{punctuated::Punctuated, Token};
+use syn::{Token, punctuated::Punctuated};
 
 use crate::{errors::ErrorContext, symbols::*};
 

cstree/benches/main.rs

@@ -1,9 +1,10 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput};
+use criterion::{Criterion, Throughput, black_box, criterion_group, criterion_main};
 use cstree::{
+    RawSyntaxKind,
+    Syntax,
     build::*,
     green::GreenNode,
-    interning::{new_interner, Interner},
+    interning::{Interner, new_interner},
-    RawSyntaxKind, Syntax,
 };
 
 #[derive(Debug)]

cstree/examples/math.rs

@@ -13,7 +13,7 @@
 //!     - "+" Token(Add)
 //!     - "4" Token(Number)
 
-use cstree::{build::GreenNodeBuilder, interning::Resolver, util::NodeOrToken, Syntax};
+use cstree::{Syntax, build::GreenNodeBuilder, interning::Resolver, util::NodeOrToken};
 use std::iter::Peekable;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Syntax)]
@@ -99,7 +99,7 @@ impl<'input, I: Iterator<Item = (SyntaxKind, &'input str)>> Parser<'input, I> {
         self.handle_operation(&[Add, Sub], Self::parse_mul)
     }
 
-    fn parse(mut self) -> (SyntaxNode, impl Resolver) {
+    fn parse(mut self) -> (SyntaxNode, impl Resolver + use<I>) {
         self.builder.start_node(Root);
         self.parse_add();
         self.builder.finish_node();

cstree/examples/readme.rs

@@ -208,7 +208,7 @@ impl<'input> Parser<'input> {
         Ok(())
     }
 
-    pub fn finish(mut self) -> (GreenNode, impl Interner) {
+    pub fn finish(mut self) -> (GreenNode, impl Interner + use<>) {
         assert!(self.lexer.next().map(|t| t == Token::EoF).unwrap_or(true));
         let (tree, cache) = self.builder.finish();
         (tree, cache.unwrap().into_interner().unwrap())

cstree/examples/s_expressions.rs

@@ -62,7 +62,7 @@ struct Parse<I> {
 /// Now, let's write a parser.
 /// Note that `parse` does not return a `Result`:
 /// By design, syntax trees can be built even for completely invalid source code.
-fn parse(text: &str) -> Parse<impl Resolver> {
+fn parse(text: &str) -> Parse<impl Resolver + use<>> {
     struct Parser<'input> {
         /// input tokens, including whitespace.
         tokens:  VecDeque<(SyntaxKind, &'input str)>,
@@ -83,7 +83,7 @@ fn parse(text: &str) -> Parse<impl Resolver> {
     }
 
     impl Parser<'_> {
-        fn parse(mut self) -> Parse<impl Resolver> {
+        fn parse(mut self) -> Parse<impl Resolver + use<>> {
             // Make sure that the root node covers all source
             self.builder.start_node(Root);
             // Parse zero or more S-expressions

cstree/src/green/builder.rs

@@ -4,11 +4,12 @@ use rustc_hash::{FxHashMap, FxHasher};
 use text_size::TextSize;
 
 use crate::{
+    RawSyntaxKind,
+    Syntax,
     green::{GreenElement, GreenNode, GreenToken},
-    interning::{new_interner, Interner, TokenInterner, TokenKey},
+    interning::{Interner, TokenInterner, TokenKey, new_interner},
     util::NodeOrToken,
     utility_types::MaybeOwned,
-    RawSyntaxKind, Syntax,
 };
 
 use super::{node::GreenNodeHead, token::GreenTokenData};

cstree/src/green/element.rs

@@ -5,10 +5,10 @@ use std::{fmt, hash, mem};
 type ErasedPtr = *const u8;
 
 use crate::{
+    RawSyntaxKind,
     green::{GreenNode, GreenToken},
     text::TextSize,
     util::NodeOrToken,
-    RawSyntaxKind,
 };
 
 pub(super) type GreenElement = NodeOrToken<GreenNode, GreenToken>;

cstree/src/green/iter.rs

@@ -2,7 +2,7 @@
 
 use std::{iter::FusedIterator, slice};
 
-use super::{element::PackedGreenElement, GreenElementRef};
+use super::{GreenElementRef, element::PackedGreenElement};
 
 /// An iterator over a [`GreenNode`](crate::green::GreenNode)'s children.
 #[derive(Debug, Clone)]

cstree/src/green/node.rs

@@ -6,9 +6,9 @@ use std::{
 use rustc_hash::FxHasher;
 
 use crate::{
-    green::{iter::GreenNodeChildren, GreenElement, PackedGreenElement},
-    text::TextSize,
     RawSyntaxKind,
+    green::{GreenElement, PackedGreenElement, iter::GreenNodeChildren},
+    text::TextSize,
 };
 use triomphe::{Arc, HeaderWithLength, ThinArc};
 

cstree/src/green/token.rs

@@ -1,9 +1,9 @@
 use std::{fmt, hash, mem::ManuallyDrop, ptr::NonNull};
 
 use crate::{
+    RawSyntaxKind,
     interning::{Resolver, TokenKey},
     text::TextSize,
-    RawSyntaxKind,
 };
 use triomphe::Arc;
 

cstree/src/interning/lasso_compat/traits.rs

@@ -4,8 +4,8 @@ use core::fmt;
 use std::hash::{BuildHasher, Hash};
 
 use crate::interning::{
-    traits::{InternKey, Interner, Resolver},
     TokenKey,
+    traits::{InternKey, Interner, Resolver},
 };
 
 // Safety: `InternKey` has the same invariant as `lasso::Key`

cstree/src/lib.rs

@@ -135,10 +135,11 @@ pub mod build {
 /// A convenient collection of the most used parts of `cstree`.
 pub mod prelude {
     pub use crate::{
+        RawSyntaxKind,
+        Syntax,
         build::GreenNodeBuilder,
         green::{GreenNode, GreenToken},
         syntax::{SyntaxElement, SyntaxNode, SyntaxToken},
-        RawSyntaxKind, Syntax,
     };
 }
 

cstree/src/serde_impls.rs

@@ -1,17 +1,19 @@
 //! Serialization and Deserialization for syntax trees.
 
 use crate::{
+    RawSyntaxKind,
+    Syntax,
     build::GreenNodeBuilder,
     interning::{Resolver, TokenKey},
     syntax::{ResolvedNode, SyntaxNode},
     traversal::WalkEvent,
     util::NodeOrToken,
-    RawSyntaxKind, Syntax,
 };
 use serde::{
+    Deserialize,
+    Serialize,
     de::{Error, SeqAccess, Visitor},
     ser::SerializeTuple,
-    Deserialize, Serialize,
 };
 use std::{collections::VecDeque, fmt, marker::PhantomData};
 

cstree/src/syntax/element.rs

@@ -4,10 +4,11 @@ use text_size::{TextRange, TextSize};
 
 use super::*;
 use crate::{
+    RawSyntaxKind,
+    Syntax,
     green::GreenElementRef,
     interning::{Resolver, TokenKey},
     util::{NodeOrToken, TokenAtOffset},
-    RawSyntaxKind, Syntax,
 };
 
 /// An element of the tree, can be either a node or a token.

cstree/src/syntax/iter.rs

@@ -5,9 +5,9 @@ use std::iter::FusedIterator;
 use text_size::TextSize;
 
 use crate::{
+    Syntax,
     green::{GreenElementRef, GreenNodeChildren},
     syntax::{SyntaxElementRef, SyntaxNode},
-    Syntax,
 };
 
 #[derive(Clone, Debug)]

cstree/src/syntax/node.rs

@@ -2,12 +2,13 @@ use super::*;
 #[cfg(feature = "serialize")]
 use crate::serde_impls::{SerializeWithData, SerializeWithResolver};
 use crate::{
+    RawSyntaxKind,
+    Syntax,
     green::{GreenElementRef, GreenNode},
     interning::{Resolver, TokenKey},
     text::*,
     traversal::*,
     util::*,
-    RawSyntaxKind, Syntax,
 };
 use parking_lot::RwLock;
 use std::{
@@ -17,8 +18,8 @@ use std::{
     iter,
     ptr::{self, NonNull},
     sync::{
-        atomic::{AtomicU32, Ordering},
         Arc as StdArc,
+        atomic::{AtomicU32, Ordering},
     },
 };
 use triomphe::Arc;

cstree/src/syntax/resolved.rs

@@ -13,12 +13,13 @@ use std::{
 use text_size::{TextRange, TextSize};
 
 use crate::{
+    RawSyntaxKind,
+    Syntax,
     green::GreenNode,
     interning::{Resolver, TokenKey},
     syntax::*,
     traversal::*,
     util::*,
-    RawSyntaxKind, Syntax,
 };
 
 /// Syntax tree node that is guaranteed to belong to a tree that contains an associated
@@ -35,7 +36,7 @@ impl<S: Syntax, D> ResolvedNode<S, D> {
     /// # Safety:
     /// `syntax` must belong to a tree that contains an associated inline resolver.
     pub(super) unsafe fn coerce_ref(syntax: &SyntaxNode<S, D>) -> &Self {
-        &*(syntax as *const _ as *const Self)
+        unsafe { &*(syntax as *const _ as *const Self) }
     }
 
     /// Returns this node as a [`SyntaxNode`].
@@ -91,7 +92,7 @@ impl<S: Syntax, D> ResolvedToken<S, D> {
     /// # Safety:
     /// `syntax` must belong to a tree that contains an associated inline resolver.
     pub(super) unsafe fn coerce_ref(syntax: &SyntaxToken<S, D>) -> &Self {
-        &*(syntax as *const _ as *const Self)
+        unsafe { &*(syntax as *const _ as *const Self) }
     }
 
     /// Returns this token as a [`SyntaxToken`].
@@ -172,9 +173,11 @@ impl<'a, S: Syntax, D> ResolvedElementRef<'a, S, D> {
     /// # Safety:
     /// `syntax` must belong to a tree that contains an associated inline resolver.
     pub(super) unsafe fn coerce_ref(syntax: SyntaxElementRef<'a, S, D>) -> Self {
-        match syntax {
+        unsafe {
-            NodeOrToken::Node(node) => Self::Node(ResolvedNode::coerce_ref(node)),
+            match syntax {
-            NodeOrToken::Token(token) => Self::Token(ResolvedToken::coerce_ref(token)),
+                NodeOrToken::Node(node) => Self::Node(ResolvedNode::coerce_ref(node)),
+                NodeOrToken::Token(token) => Self::Token(ResolvedToken::coerce_ref(token)),
+            }
         }
     }
 }

cstree/src/syntax/text.rs

@@ -3,10 +3,10 @@
 use std::fmt;
 
 use crate::{
+    Syntax,
     interning::{Resolver, TokenKey},
     syntax::{SyntaxNode, SyntaxToken},
     text::{TextRange, TextSize},
-    Syntax,
 };
 
 /// An efficient representation of the text that is covered by a [`SyntaxNode`], i.e. the combined
@@ -383,7 +383,7 @@ mod private {
 
 #[cfg(test)]
 mod tests {
-    use crate::{build::GreenNodeBuilder, interning::TokenInterner, RawSyntaxKind};
+    use crate::{RawSyntaxKind, build::GreenNodeBuilder, interning::TokenInterner};
 
     use super::*;
 
@@ -409,7 +409,7 @@ mod tests {
         }
     }
 
-    fn build_tree(chunks: &[&str]) -> (SyntaxNode<SyntaxKind, ()>, impl Resolver<TokenKey>) {
+    fn build_tree(chunks: &[&str]) -> (SyntaxNode<SyntaxKind, ()>, impl Resolver<TokenKey> + use<>) {
         let mut builder: GreenNodeBuilder<SyntaxKind> = GreenNodeBuilder::new();
         builder.start_node(SyntaxKind(62));
         for &chunk in chunks.iter() {

cstree/src/syntax/token.rs

@@ -9,10 +9,11 @@ use text_size::{TextRange, TextSize};
 
 use super::*;
 use crate::{
+    RawSyntaxKind,
+    Syntax,
     green::{GreenNode, GreenToken},
     interning::{Resolver, TokenKey},
     traversal::Direction,
-    RawSyntaxKind, Syntax,
 };
 
 /// Syntax tree token.
@@ -284,7 +285,7 @@ impl<S: Syntax, D> SyntaxToken<S, D> {
     /// implementation by re-using the interner in both.
     /// ```
     /// # use cstree::testing::*;
-    /// use cstree::interning::{new_interner, TokenInterner, TokenKey};
+    /// use cstree::interning::{TokenInterner, TokenKey, new_interner};
     /// struct TypeTable {
     ///     // ...
     /// }

cstree/tests/it/basic.rs

@@ -1,12 +1,12 @@
 use super::*;
 use cstree::{
-    build::{GreenNodeBuilder, NodeCache},
-    interning::{new_interner, Resolver},
-    text::TextRange,
     RawSyntaxKind,
+    build::{GreenNodeBuilder, NodeCache},
+    interning::{Resolver, new_interner},
+    text::TextRange,
 };
 
-fn build_tree<D>(root: &Element<'_>) -> (SyntaxNode<D>, impl Resolver) {
+fn build_tree<D>(root: &Element<'_>) -> (SyntaxNode<D>, impl Resolver + use<D>) {
     let mut builder: GreenNodeBuilder<SyntaxKind> = GreenNodeBuilder::new();
     build_recursive(root, &mut builder, 0);
     let (node, cache) = builder.finish();

cstree/tests/it/main.rs

@@ -6,11 +6,12 @@ mod sendsync;
 mod serde;
 
 use cstree::{
+    RawSyntaxKind,
+    Syntax,
     build::{GreenNodeBuilder, NodeCache},
     green::GreenNode,
     interning::{Interner, Resolver},
     util::NodeOrToken,
-    RawSyntaxKind, Syntax,
 };
 
 pub type SyntaxNode<D = ()> = cstree::syntax::SyntaxNode<SyntaxKind, D>;

cstree/tests/it/sendsync.rs

@@ -3,13 +3,13 @@
 use crossbeam_utils::thread::scope;
 use std::{thread, time::Duration};
 
-use super::{build_recursive, Element, ResolvedNode, SyntaxKind, SyntaxNode};
+use super::{Element, ResolvedNode, SyntaxKind, SyntaxNode, build_recursive};
 use cstree::build::GreenNodeBuilder;
 
 // Excercise the multi-threaded interner when the corresponding feature is enabled.
 
 #[cfg(feature = "multi_threaded_interning")]
-use cstree::interning::{new_threaded_interner, MultiThreadedTokenInterner};
+use cstree::interning::{MultiThreadedTokenInterner, new_threaded_interner};
 
 #[cfg(not(feature = "multi_threaded_interning"))]
 fn get_builder() -> GreenNodeBuilder<'static, 'static, SyntaxKind> {

cstree/tests/it/serde.rs

@@ -1,4 +1,4 @@
-use crate::{build_recursive, build_tree_with_cache, ResolvedNode};
+use crate::{ResolvedNode, build_recursive, build_tree_with_cache};
 
 use super::{Element, SyntaxKind, SyntaxNode};
 use cstree::{

rustfmt.toml

@@ -1,6 +1,6 @@
 unstable_features = true
 
-edition = "2021"
+edition = "2024"
 
 max_width     = 120
 comment_width = 120
@@ -10,6 +10,7 @@ format_code_in_doc_comments = true
 format_macro_matchers       = true
 
 imports_granularity = "Crate"
+imports_layout      = "HorizontalVertical"
 
 reorder_impl_items = true