(node) ref: doc & fix

Author: t-webber

.github/workflows/rust.yml

@@ -22,7 +22,7 @@ jobs:
             - name: Install nightly
               run: rustup default nightly
             - name: Build
-              run: cargo build --verbose
+              run: cargo build --release --verbose
 
     test:
         needs: build

src/errors/display.rs

@@ -14,9 +14,9 @@ pub fn display_errors(errors: Vec<CompileError>, files: &[(String, &str)], err_t
         let code_lines = files_status
             .get(&filename)
             .expect("Never happens: File of error doesn't exist");
-        let code_line = code_lines
-            .get(line_nb - 1)
-            .unwrap_or_else(|| panic!("Never happens: given line of file that doesn't exist: {filename}:{line_nb}:{column_nb}"));
+        let code_line = code_lines.get(line_nb - 1).unwrap_or_else(|| {
+            panic!("Never happens: given line of file that doesn't exist: {filename}:{line_nb}:{column_nb}")
+        });
         eprintln!("\n{filename}:{line_nb}:{column_nb}: {err_type} {err_lvl}: {message}");
         eprintln!("{line_nb:5} | {code_line}");
         eprintln!("{}^{}", " ".repeat(8 + column_nb - 1), "~".repeat(length));

src/lexer/end_state.rs

@@ -12,9 +12,11 @@ pub fn end_current(status: &mut LexingStatus, lex_data: &mut LexingData, locatio
         LexingStatus::Symbols(symbol_status) => end_symbols(symbol_status, lex_data, location),
         LexingStatus::Identifier(ident) => end_ident(ident, lex_data, location),
         LexingStatus::Char(None) => {
-            lex_data.push_err(location.to_error(
-                "Found an empty char, but chars must contain one character. Did you mean '\\''?".to_owned()
-            ));
+            lex_data.push_err(
+                location.to_error(
+                    "Found an empty char, but chars must contain one character. Did you mean '\\''?".to_owned(),
+                ),
+            );
         }
         LexingStatus::Char(Some(ch)) => lex_data.push_token(Token::from_char(*ch, location)),
         LexingStatus::Str(val) => {

src/lexer/numbers/base/binary.rs

@@ -19,6 +19,8 @@ pub fn to_bin_value(
             .chars()
             .find(|ch| matches!(ch, '0' | '1'))
             .expect("Exists according to line above");
-        OverParseRes::from(location.to_error(format!("{ERR_PREFIX}a binary constant must only contain '0's and '1's. Found invalid character '{first}'.")))
+        OverParseRes::from(location.to_error(format!(
+            "{ERR_PREFIX}a binary constant must only contain '0's and '1's. Found invalid character '{first}'."
+        )))
     }
 }

src/lexer/numbers/base/hexadecimal.rs

@@ -115,20 +115,40 @@ fn get_hex_float_state(literal: &str, location: &Location) -> Result<HexFloatPar
     let mut float_parse = HexFloatParse::default();
     for ch in literal.chars() {
         match ch {
-            '+' | '-' if float_parse.state != HexFloatParseState::Exponent => panic!("never happens: + or - always are after a p character in hex literal"),
-            '+' | '-' if float_parse.exponent_neg.is_some() => return Err(location.to_error(format!("{ERR_PREFIX}maximum one sign is allowed in a number literal."))),
+            '+' | '-' if float_parse.state != HexFloatParseState::Exponent => {
+                panic!("never happens: + or - always are after a p character in hex literal")
+            }
+            '+' | '-' if float_parse.exponent_neg.is_some() => {
+                return Err(location.to_error(format!("{ERR_PREFIX}maximum one sign is allowed in a number literal.")))
+            }
             '-' => float_parse.exponent_neg = Some(true),
             '+' => float_parse.exponent_neg = Some(false),
             _ if float_parse.state == HexFloatParseState::Exponent && ch.is_ascii_digit() => float_parse.push(ch),
-            _ if float_parse.state == HexFloatParseState::Exponent => return Err(location.to_error(format!("{ERR_PREFIX}invalid character for exponent. Expected an ascii digit, but found '{ch}'"))),
+            _ if float_parse.state == HexFloatParseState::Exponent => {
+                return Err(location.to_error(format!(
+                    "{ERR_PREFIX}invalid character for exponent. Expected an ascii digit, but found '{ch}'"
+                )))
+            }
             _ if ch.is_ascii_hexdigit() => float_parse.push(ch),
             '.' if float_parse.state == HexFloatParseState::Int => float_parse.state = HexFloatParseState::Decimal,
-            '.' if float_parse.state == HexFloatParseState::Decimal  => return Err(location.to_error(format!("{ERR_PREFIX}maximum one '.' in number constant, but 2 were found."))),
-            '.' if float_parse.state == HexFloatParseState::Exponent  => return Err(location.to_error(format!("{ERR_PREFIX}exponent must be an integer, but found a period."))),
-            'p' | 'P' if float_parse.state == HexFloatParseState::Exponent => return Err(location.to_error(format!("{ERR_PREFIX}maximum one 'p' in number constant, but 2 were found."))),
-            'p' | 'P'  => float_parse.state = HexFloatParseState::Exponent,
-            _ => return Err(location.to_error(format!("{ERR_PREFIX}invalid character '{ch}' found in number constant"))),
-                };
+            '.' if float_parse.state == HexFloatParseState::Decimal => {
+                return Err(location.to_error(format!(
+                    "{ERR_PREFIX}maximum one '.' in number constant, but 2 were found."
+                )))
+            }
+            '.' if float_parse.state == HexFloatParseState::Exponent => {
+                return Err(location.to_error(format!("{ERR_PREFIX}exponent must be an integer, but found a period.")))
+            }
+            'p' | 'P' if float_parse.state == HexFloatParseState::Exponent => {
+                return Err(location.to_error(format!(
+                    "{ERR_PREFIX}maximum one 'p' in number constant, but 2 were found."
+                )))
+            }
+            'p' | 'P' => float_parse.state = HexFloatParseState::Exponent,
+            _ => {
+                return Err(location.to_error(format!("{ERR_PREFIX}invalid character '{ch}' found in number constant")))
+            }
+        };
     }
     Ok(float_parse)
 }

src/lexer/numbers/from_literal.rs

@@ -152,8 +152,8 @@ fn literal_to_number_err(literal: &str, location: &Location, signed: bool) -> Pa
     let mut nb_type = get_number_type(literal, location)?;
     let base = get_base(literal, &nb_type, location)?;
     let value = literal
-                .get(base.prefix_size()..literal.len() - nb_type.suffix_size())
-            .expect("never happens as suffix size + prefix size <= len, as 'x' and 'b' can't be used as suffix");
+        .get(base.prefix_size()..literal.len() - nb_type.suffix_size())
+        .expect("never happens as suffix size + prefix size <= len, as 'x' and 'b' can't be used as suffix");
 
     if value.is_empty() {
         return ParseRes::Err(location.to_error(format!(

src/lexer/types/lexing_state.rs

@@ -36,7 +36,10 @@ impl Ident {
         self.is_number()
             && match self.0.chars().last() {
                 Some('p' | 'P') => self.0.starts_with("0x"),
-                Some('e' | 'E') => !self.0.starts_with("0x"), /* if the number expression starts with 0 and contains an exponent, the number is considered decimal, not octal. */
+                Some('e' | 'E') => !self.0.starts_with("0x"), /* if the number expression starts
+                                                                * with 0 and contains */
+                // an exponent, the number is considered decimal, not
+                // octal.
                 Some(_) | None => false,
             }
     }

src/parser/parse_content.rs

@@ -10,7 +10,7 @@ use crate::errors::api::{CompileError, Location, Res};
 use crate::lexer::api::{Token, TokenValue};
 
 fn clean_nodes(nodes: Vec<Node>) -> Node {
-    let mut cleaned = nodes
+    let mut cleaned: Vec<Node> = nodes
         .into_iter()
         .filter(|node| *node != Node::Empty)
         .collect::<Vec<_>>();
@@ -19,7 +19,7 @@ fn clean_nodes(nodes: Vec<Node>) -> Node {
     } else {
         Node::Block(Block {
             elts: cleaned,
-            full: true,
+            full: false,
         })
     }
 }

src/parser/tree/conversions.rs

@@ -26,6 +26,7 @@ where
     Self: Sized,
 {
     fn try_convert_and_erase_node(self, node: &mut Node) -> Result<(), String> {
+        //TODO: check that this is called only on unary operators
         *node = self.try_to_node()?;
         Ok(())
     }