(main) rev: upgrade to rust 2024

t-webber · t-webber · commit a5896385fa21 · 2024-12-30T17:45:13.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "c-parser"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 authors = ["Tom Webber"]
 license-file = "LICENSE"
 repository = "https://www.github.com/t-webber/c-parser"
diff --git a/src/errors/result.rs b/src/errors/result.rs
@@ -47,7 +47,7 @@ impl<T> Res<T> {
     /// ```
     /// use std::fs;
     ///
-    /// use c_parser::{lex_file, Location};
+    /// use c_parser::{Location, lex_file};
     ///
     /// let content = "int m@in() { }";
     /// let res = lex_file(&content, &mut Location::from("filename.c"));
diff --git a/src/lexer/lex_content.rs b/src/lexer/lex_content.rs
@@ -2,7 +2,7 @@
 use LexingState::*;
 
 use super::state::api::{
-    end_current, handle_escape, CommentState, EscapeState, LexingState, SymbolState
+    CommentState, EscapeState, LexingState, SymbolState, end_current, handle_escape
 };
 use super::types::api::{LexingData, Token};
 use crate::errors::api::{Location, Res};
diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs
@@ -3,7 +3,7 @@ pub mod api {
 
     pub use super::lex_content::lex_file;
     pub use super::numbers::api::Number;
-    pub use super::types::api::{display_tokens, Keyword, Symbol, Token, TokenValue};
+    pub use super::types::api::{Keyword, Symbol, Token, TokenValue, display_tokens};
 }
 
 mod lex_content;
diff --git a/src/lexer/numbers/base/binary.rs b/src/lexer/numbers/base/binary.rs
@@ -2,7 +2,7 @@ use super::super::macros::parse_int_from_radix;
 use super::super::parse::OverParseRes;
 #[allow(clippy::wildcard_imports)]
 use super::super::types::arch_types::*;
-use super::super::types::{Number, NumberType, ERR_PREFIX};
+use super::super::types::{ERR_PREFIX, Number, NumberType};
 use crate::errors::api::Location;
 
 /// Parses a binary value.
diff --git a/src/lexer/numbers/base/decimal.rs b/src/lexer/numbers/base/decimal.rs
@@ -4,7 +4,7 @@ use core::str::FromStr;
 use super::super::parse::OverParseRes;
 #[allow(clippy::wildcard_imports)]
 use super::super::types::arch_types::*;
-use super::super::types::{Number, NumberType, ERR_PREFIX};
+use super::super::types::{ERR_PREFIX, Number, NumberType};
 use crate::errors::api::{CompileError, Location};
 
 macro_rules! parse_number {
diff --git a/src/lexer/numbers/base/hexadecimal.rs b/src/lexer/numbers/base/hexadecimal.rs
@@ -4,7 +4,7 @@ use super::super::macros::parse_int_from_radix;
 use super::super::parse::OverParseRes;
 #[allow(clippy::wildcard_imports)]
 use super::super::types::arch_types::*;
-use super::super::types::{Number, NumberType, ERR_PREFIX};
+use super::super::types::{ERR_PREFIX, Number, NumberType};
 use crate::errors::api::{CompileError, Location};
 
 macro_rules! impl_floating_point {
@@ -306,10 +306,6 @@ pub fn to_hex_value(
         #[expect(clippy::float_arithmetic)]
         let res =
             parse_hexadecimal_float!(&mut overflow, nb_type, float_data, Float Double LongDouble);
-        if overflow {
-            res.add_overflow()
-        } else {
-            res
-        }
+        if overflow { res.add_overflow() } else { res }
     }
 }
diff --git a/src/lexer/numbers/base/octal.rs b/src/lexer/numbers/base/octal.rs
@@ -2,7 +2,7 @@ use super::super::macros::parse_int_from_radix;
 use super::super::parse::OverParseRes;
 #[allow(clippy::wildcard_imports)]
 use super::super::types::arch_types::*;
-use super::super::types::{Number, NumberType, ERR_PREFIX};
+use super::super::types::{ERR_PREFIX, Number, NumberType};
 use crate::errors::api::Location;
 
 /// Parses an octal value.
diff --git a/src/lexer/numbers/from_literal.rs b/src/lexer/numbers/from_literal.rs
@@ -5,7 +5,7 @@ use super::base::{binary, decimal, hexadecimal, octal};
 use super::parse::ParseRes;
 #[allow(clippy::wildcard_imports)]
 use super::types::arch_types::*;
-use super::types::{Base, Number, NumberType, ERR_PREFIX};
+use super::types::{Base, ERR_PREFIX, Number, NumberType};
 use crate::errors::api::{CompileError, Location};
 
 /// Finds a invalid character with the base found with the prefix of the
@@ -39,7 +39,6 @@ fn check_with_base(literal: &str, base: &Base) -> Option<char> {
 /// - [`Base::Hexadecimal`] if the literal starts with "0x";
 /// - [`Base::Octal`] if the literal starts with "0";
 /// - [`Base::Decimal`] in every other case.
-///  
 fn get_base(
     literal: &str,
     nb_type: &NumberType,
diff --git a/src/lexer/numbers/types.rs b/src/lexer/numbers/types.rs
@@ -92,21 +92,17 @@ define_nb_types!(Int Long LongLong Float Double LongDouble UInt ULong ULongLong)
 impl fmt::Display for Number {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                Self::Int(x) => x.to_string(),
-                Self::Long(x) => x.to_string(),
-                Self::LongLong(x) => x.to_string(),
-                Self::Float(x) => x.to_string(),
-                Self::Double(x) => x.to_string(),
-                Self::LongDouble(x) => format!("'{}'", *x as f64),
-                Self::UInt(x) => x.to_string(),
-                Self::ULong(x) => x.to_string(),
-                Self::ULongLong(x) => x.to_string(),
-            }
-        )
+        write!(f, "{}", match self {
+            Self::Int(x) => x.to_string(),
+            Self::Long(x) => x.to_string(),
+            Self::LongLong(x) => x.to_string(),
+            Self::Float(x) => x.to_string(),
+            Self::Double(x) => x.to_string(),
+            Self::LongDouble(x) => format!("'{}'", *x as f64),
+            Self::UInt(x) => x.to_string(),
+            Self::ULong(x) => x.to_string(),
+            Self::ULongLong(x) => x.to_string(),
+        })
     }
 }
 
@@ -134,7 +130,7 @@ impl NumberType {
             Self::UInt => Self::ULong,
             Self::ULong => Self::ULongLong,
             Self::ULongLong | Self::LongLong | Self::Float | Self::Double | Self::LongDouble => {
-                return None
+                return None;
             }
         })
     }
@@ -170,20 +166,16 @@ impl NumberType {
 impl fmt::Display for NumberType {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                Self::Int => "int",
-                Self::Long => "long",
-                Self::LongLong => "long long",
-                Self::Float => "float",
-                Self::Double => "double",
-                Self::LongDouble => "long double",
-                Self::UInt => "unsigned int",
-                Self::ULong => "unsigned long",
-                Self::ULongLong => "unsigned long long",
-            }
-        )
+        write!(f, "{}", match self {
+            Self::Int => "int",
+            Self::Long => "long",
+            Self::LongLong => "long long",
+            Self::Float => "float",
+            Self::Double => "double",
+            Self::LongDouble => "long double",
+            Self::UInt => "unsigned int",
+            Self::ULong => "unsigned long",
+            Self::ULongLong => "unsigned long long",
+        })
     }
 }
diff --git a/src/lexer/state/escape.rs b/src/lexer/state/escape.rs
@@ -15,7 +15,7 @@ fn end_escape_sequence(
     location: &Location,
     sequence: &EscapeSequence,
 ) -> Result<char, ()> {
-    match &sequence {
+    match *sequence {
         EscapeSequence::ShortUnicode(ref value) => {
             expect_max_length(4, value);
             expect_min_length(lex_data, 4, value, location, sequence)?;
diff --git a/src/lexer/state/mod.rs b/src/lexer/state/mod.rs
@@ -2,7 +2,7 @@ pub mod api {
     #![allow(clippy::pub_use)]
 
     pub use super::end_state::end_current;
-    pub use super::escape::{handle_escape, EscapeState};
+    pub use super::escape::{EscapeState, handle_escape};
     pub use super::lex_state::{CommentState, LexingState};
     pub use super::symbol::SymbolState;
 }
diff --git a/src/lexer/state/symbol.rs b/src/lexer/state/symbol.rs
@@ -44,15 +44,19 @@ impl SymbolState {
                 return Some((
                     "Found invalid character '#', found by replacing digraph '%:'.".to_owned(),
                     true,
-                ))
+                ));
             }
             _ => (None, false),
         };
         if let Some(symbol) = graph {
             if is_trigraph {
                 return Some((
-                    format!("Trigraphs are deprecated in C23. Please remove them: Replace \"{}{}{}\" by '{symbol}'.", self.first, self.second, self.third)
-                , false));
+                    format!(
+                        "Trigraphs are deprecated in C23. Please remove them: Replace \"{}{}{}\" by '{symbol}'.",
+                        self.first, self.second, self.third
+                    ),
+                    false,
+                ));
             }
             self.first = symbol;
             self.second = self.third;
diff --git a/src/lexer/types/mod.rs b/src/lexer/types/mod.rs
@@ -3,7 +3,7 @@ pub mod api {
 
     pub use super::escape::EscapeSequence;
     pub use super::keywords::Keyword;
-    pub use super::lex_data::{display_tokens, LexingData};
+    pub use super::lex_data::{LexingData, display_tokens};
     pub use super::symbols::Symbol;
     pub use super::tokens::{Ident, Token, TokenValue};
 }
diff --git a/src/lib.rs b/src/lib.rs
@@ -62,7 +62,7 @@ mod parser;
 #[expect(clippy::useless_attribute, clippy::pub_use)]
 pub use crate::errors::api::{CompileError, Location, Res};
 #[expect(clippy::useless_attribute, clippy::pub_use)]
-pub use crate::lexer::api::{display_tokens, lex_file, Number, TokenValue};
+pub use crate::lexer::api::{Number, TokenValue, display_tokens, lex_file};
 #[expect(clippy::useless_attribute, clippy::pub_use)]
 pub use crate::parser::api::parse_tokens;
 
diff --git a/src/parser/keyword/mod.rs b/src/parser/keyword/mod.rs
@@ -9,9 +9,9 @@ use types::{KeywordParsing, PushInNode as _};
 use super::parse_content::parse_block;
 use super::state::ParsingState;
 use super::tree::node::Ast;
+use crate::Location;
 use crate::errors::api::CompileError;
 use crate::lexer::api::{Keyword, Token};
-use crate::Location;
 
 #[allow(clippy::todo, reason = "not yet implemented")]
 pub fn handle_keyword(
diff --git a/src/parser/keyword/types/attributes.rs b/src/parser/keyword/types/attributes.rs
@@ -70,13 +70,31 @@ impl PushInNode for AttributeKeyword {
         match node {
             Ast::Empty => *node = self.into_node(),
             Ast::Leaf(Literal::Variable(var)) => var.push_keyword(self),
-            Ast::ParensBlock(_) | Ast::Leaf(_) => return Err(format!("invalid attribute. Attribute keywords can only be applied to variables, but found {node}")),
-            Ast::Unary(Unary{arg, ..}) | Ast::Binary(Binary {arg_r: arg, ..}) | Ast::Ternary(Ternary { failure: Some(arg), ..} | Ternary { success: arg, .. }) => return self.push_in_node(arg),
-            Ast::ListInitialiser(ListInitialiser{ full: true, ..}) | Ast::FunctionCall(FunctionCall{full: true, .. })  => return Err(format!("Attributes can only be placed before variables, but found {self}"))
-            ,Ast::ListInitialiser(ListInitialiser{elts , ..}) | Ast::FunctionCall(FunctionCall{args: elts,  ..}) | Ast::Block(Block{elts, ..}) => match elts.last_mut()  {
+            Ast::ParensBlock(_) | Ast::Leaf(_) => {
+                return Err(format!(
+                    "invalid attribute. Attribute keywords can only be applied to variables, but found {node}"
+                ));
+            }
+            Ast::Unary(Unary { arg, .. })
+            | Ast::Binary(Binary { arg_r: arg, .. })
+            | Ast::Ternary(
+                Ternary {
+                    failure: Some(arg), ..
+                }
+                | Ternary { success: arg, .. },
+            ) => return self.push_in_node(arg),
+            Ast::ListInitialiser(ListInitialiser { full: true, .. })
+            | Ast::FunctionCall(FunctionCall { full: true, .. }) => {
+                return Err(format!(
+                    "Attributes can only be placed before variables, but found {self}"
+                ));
+            }
+            Ast::ListInitialiser(ListInitialiser { elts, .. })
+            | Ast::FunctionCall(FunctionCall { args: elts, .. })
+            | Ast::Block(Block { elts, .. }) => match elts.last_mut() {
                 Some(last) => return self.push_in_node(last),
                 None => elts.push(self.into_node()),
-            }
+            },
         }
         Ok(())
     }
diff --git a/src/parser/state.rs b/src/parser/state.rs
@@ -1,5 +1,5 @@
-use crate::errors::api::CompileError;
 use crate::Location;
+use crate::errors::api::CompileError;
 
 #[derive(PartialEq, Eq, Debug)]
 pub enum BlockState {
diff --git a/src/parser/symbols/blocks.rs b/src/parser/symbols/blocks.rs
@@ -4,9 +4,9 @@ use core::mem;
 
 use super::super::parse_content::parse_block;
 use super::super::state::ParsingState;
+use super::super::tree::ListInitialiser;
 use super::super::tree::binary::BinaryOperator;
 use super::super::tree::node::Ast;
-use super::super::tree::ListInitialiser;
 use crate::errors::api::{CompileError, Location};
 use crate::lexer::api::Token;
 use crate::parser::state::BlockState;
diff --git a/src/parser/symbols/sort_symbols.rs b/src/parser/symbols/sort_symbols.rs
@@ -1,9 +1,9 @@
 use {BinaryOperator as BOp, Symbol as Sy, UnaryOperator as UOp};
 
+use super::super::tree::TernaryOperator;
 use super::super::tree::binary::BinaryOperator;
 use super::super::tree::node::Ast;
 use super::super::tree::unary::UnaryOperator;
-use super::super::tree::TernaryOperator;
 use super::blocks::TodoBlock;
 use super::handlers::{handle_binary_unary, handle_comma, handle_double_unary};
 use crate::lexer::api::Symbol;
diff --git a/src/parser/tree/literal.rs b/src/parser/tree/literal.rs
@@ -2,7 +2,7 @@ use core::{fmt, mem};
 
 use crate::parser::keyword::types::attributes::AttributeKeyword;
 use crate::parser::keyword::types::functions::FunctionKeyword;
-use crate::{Number, EMPTY};
+use crate::{EMPTY, Number};
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum Attribute {
@@ -16,7 +16,7 @@ impl fmt::Display for Attribute {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Self::Indirection => '*'.fmt(f),
-            Self::Keyword(keywd) => keywd.fmt(f),
+            Self::Keyword(keyword) => keyword.fmt(f),
             Self::User(val) => write!(f, "'{val}'"),
         }
     }
@@ -69,8 +69,8 @@ impl Variable {
     pub fn push_indirection(&mut self) -> Result<(), String> {
         match mem::take(&mut self.name) {
             VariableName::Empty => (),
-            VariableName::Keyword(keywd) => {
-                return Err(format!("Found '*' after function keyword {keywd}."))
+            VariableName::Keyword(keyword) => {
+                return Err(format!("Found '*' after function keyword {keyword}."));
             }
             VariableName::UserDefined(name) => self.attrs.push(Attribute::User(name)),
         }
@@ -85,13 +85,18 @@ impl Variable {
 
     pub fn push_name(&mut self, name: VariableName) -> Result<(), String> {
         match mem::take(&mut self.name) {
-            VariableName::Empty => {self.name = name; Ok(())},
-            VariableName::Keyword(keyword) => Err(format!("Found 2 succesive literals, found identifier {name} after function keuword {keyword}.")),
+            VariableName::Empty => {
+                self.name = name;
+                Ok(())
+            }
+            VariableName::Keyword(keyword) => Err(format!(
+                "Found 2 successive literals, found identifier {name} after function keuword {keyword}."
+            )),
             VariableName::UserDefined(old) => {
                 self.attrs.push(Attribute::User(old));
                 self.name = name;
                 Ok(())
-             },
+            }
         }
     }
 }
diff --git a/src/parser/tree/node.rs b/src/parser/tree/node.rs
@@ -150,7 +150,7 @@ impl Ast {
     /// Checks if a `{` is meant as a [`ListInitialiser`] or as a [`Block`].
     ///
     /// # Returns
-    ///  - `Ok(true)` if the brace is meant as a list initaliser.
+    ///  - `Ok(true)` if the brace is meant as a list initialiser.
     ///  - `Ok(false)` if the brace is meant as an opening block symbol.
     ///  - `Err(op)` if the brace is illegal, because the ast is expecting a
     ///    valid leaf. `op` is the stringified version of the operator that has
@@ -342,7 +342,7 @@ impl Ast {
 
     /// Pushes a node at the bottom of the [`Ast`].
     ///
-    /// This methods consideres `node` as a leaf, and pushes it as a leaf into
+    /// This methods considers `node` as a leaf, and pushes it as a leaf into
     /// the [`Ast`].
     pub fn push_block_as_leaf(&mut self, node: Self) -> Result<(), String> {
         match self {
@@ -447,7 +447,7 @@ impl Ast {
 
     /// Tries to push an operator in the [`Ast`]
     ///
-    /// This method finds, with the associatvities, precedences and arities,
+    /// This method finds, with the associativities, precedences and arities,
     /// were to push the `op` into the [`Ast`].
     pub fn push_op<T>(&mut self, op: T) -> Result<(), String>
     where
diff --git a/src/parser/tree/unary.rs b/src/parser/tree/unary.rs

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ pub mod api {`
`3`	`3`
`4`	`4`	`pub use super::lex_content::lex_file;`
`5`	`5`	`pub use super::numbers::api::Number;`
`6`		`- pub use super::types::api::{display_tokens, Keyword, Symbol, Token, TokenValue};`
	`6`	`+ pub use super::types::api::{Keyword, Symbol, Token, TokenValue, display_tokens};`
`7`	`7`	`}`
`8`	`8`
`9`	`9`	`mod lex_content;`