(github) fix: deny warning on GitHub CI for cargo doc

Author: t-webber

.github/workflows/rust.yml

@@ -1,4 +1,4 @@
-name: Rust nightly
+name: Rust
 
 on:
     push:
@@ -56,4 +56,4 @@ jobs:
         steps:
             - uses: actions/checkout@v4
             - name: Check doc
-              run: cargo doc --document-private-items --all --verbose --release
+              run: RUSTDOCFLAGS="-D warnings" cargo doc --document-private-items --all --verbose --release

src/lexer/lex_content.rs

@@ -103,10 +103,10 @@ fn lex_char(
             end_current(state, lex_data, location);
             lex_data.set_end_line();
         }
-        ('.', Identifier(ident), _) if !ident.contains('.') && ident.is_number() => {
+        ('.', Ident(ident), _) if !ident.contains('.') && ident.is_number() => {
             ident.push('.');
         }
-        ('+' | '-', Identifier(ident), _)
+        ('+' | '-', Ident(ident), _)
             if !ident.contains('-') && !ident.contains('+') && ident.last_is_exp() =>
         {
             ident.push(ch);
@@ -133,7 +133,7 @@ fn lex_char(
         }
 
         // Whitespace: end of everyone
-        (_, Identifier(val), _) if ch.is_alphanumeric() || matches!(ch, '_' | '.' | '+' | '-') => {
+        (_, Ident(val), _) if ch.is_alphanumeric() || matches!(ch, '_' | '.' | '+' | '-') => {
             // dbg!("here", &val, ch);
             val.push(ch);
             // dbg!("there", &val);
@@ -160,7 +160,9 @@ fn lex_char(
 /// Function that lexes a whole source file.
 ///
 /// This function creates the automaton and the data to be modified by the other
-/// functions. Every character is parsed one by one by [`lex_char`].
+/// functions. Every character is parsed one by one, and the state is modified
+/// accordingly. When the state changes, the buffers of the state are empty into
+/// the data.
 #[inline]
 pub fn lex_file(content: &str, location: &mut Location) -> Res<Vec<Token>> {
     let mut lex_data = LexingData::default();

src/lexer/state/end_state.rs

@@ -16,7 +16,7 @@ pub fn end_current(state: &mut LexingState, lex_data: &mut LexingData, location:
     match state {
         LexingState::Comment(_) | LexingState::Unset | LexingState::StartOfLine => return,
         LexingState::Symbols(symbol_state) => end_symbols(symbol_state, lex_data, location),
-        LexingState::Identifier(ident) => end_ident(ident, lex_data, location),
+        LexingState::Ident(ident) => end_ident(ident, lex_data, location),
         LexingState::Char(None) => {
             lex_data.push_err(
                 location.to_error(

src/lexer/state/lex_state.rs

@@ -33,7 +33,7 @@ pub enum LexingState {
     /// Reading a block comment.
     Comment(CommentState),
     /// Reading an identifier.
-    Identifier(Ident),
+    Ident(Ident),
     /// No specific state: just started parsing.
     #[default]
     StartOfLine,
@@ -57,12 +57,12 @@ impl LexingState {
 
     /// Creates an identifier from a char.
     pub fn new_ident(&mut self, ch: char) {
-        *self = Self::Identifier(Ident::from(ch.to_string()));
+        *self = Self::Ident(Ident::from(ch.to_string()));
     }
 
     /// Creates an identifier from a string.
     pub fn new_ident_str(&mut self, str: String) {
-        *self = Self::Identifier(Ident::from(str));
+        *self = Self::Ident(Ident::from(str));
     }
 
     /// Gets a user-readable representation for displaying user errors.
@@ -71,7 +71,7 @@ impl LexingState {
             Self::StartOfLine => "start of line",
             Self::Unset => "no context",
             Self::Symbols(_) => "symbols",
-            Self::Identifier(_) => "identifier",
+            Self::Ident(_) => "identifier",
             Self::Char(_) => "char",
             Self::Str(_) => "string",
             Self::Comment(_) => "comment",

src/lexer/types/keywords.rs

@@ -6,9 +6,9 @@ use core::fmt;
 macro_rules! impl_keywords {
     ($($pascal:ident $type:ident $str:expr ,)*) => {
 
-        /// Keyword type
+        /// Keywords of the language
         ///
-        /// Type to store and manage the C keywords.
+        /// See [CppReference](https://en.cppreference.com/w/c/keyword) for the list of C keywords.
         #[derive(Debug, PartialEq, Eq)]
         pub enum Keyword {
             $($pascal,)*

src/lexer/types/tokens.rs

@@ -128,7 +128,7 @@ impl Token {
                 lex_data.push_err(location.to_owned().into_past_with_length(len).to_warning(format!("Underscore operators are deprecated since C23. Consider using the new keyword: {new_keyword}")));
                 TokenValue::Keyword(keyword)
             }
-            TryKeyword::Failure => TokenValue::Identifier(value),
+            TryKeyword::Failure => TokenValue::Ident(value),
         };
         Self {
             location: location.to_owned().into_past_with_length(len),
@@ -213,12 +213,12 @@ pub enum TokenValue {
     /// # Examples
     ///
     /// `_Hello` and `STRUCT_NAME`.
-    Identifier(String),
+    Ident(String),
     /// Keywords
     ///
     /// # Rules
     ///
-    /// For the list of keywords, see [`Keyword`].
+    /// See [CppReference](https://en.cppreference.com/w/c/keyword) for the list of C keywords.
     ///
     /// # Examples
     ///
@@ -249,7 +249,7 @@ pub enum TokenValue {
     ///
     /// # Rules
     ///
-    /// See [`Symbol`] for the list of valid symbols.
+    /// - All characters that don't fit in the other types.
     ///
     /// # Examples
     ///
@@ -266,7 +266,7 @@ impl fmt::Display for TokenValue {
             Self::Keyword(arg0) => write!(f, "Keyword({arg0})"),
             Self::Number(arg0) => write!(f, "{arg0}"),
             Self::Symbol(arg0) => write!(f, "{arg0:?}"),
-            Self::Identifier(arg0) => write!(f, "Ident({arg0})"),
+            Self::Ident(arg0) => write!(f, "Ident({arg0})"),
             Self::Str(arg0) => write!(f, "\"{arg0}\""),
         }
     }

src/parser/parse_content.rs

@@ -59,7 +59,7 @@ pub fn parse_block(
             TokenValue::Char(ch) => {
                 handle_literal(current, Literal::Char(ch), location, p_state, tokens)
             }
-            TokenValue::Identifier(val) => handle_literal(
+            TokenValue::Ident(val) => handle_literal(
                 current,
                 Literal::Variable(Variable::from(val)),
                 location,