(keywords) add: attribute keywords for variables

t-webber · t-webber · commit bfc9697a6256 · 2024-12-28T20:16:43.000+01:00
diff --git a/src/errors/result.rs b/src/errors/result.rs
@@ -14,11 +14,11 @@ pub struct Res<T> {
 impl<T> Res<T> {
     #[inline]
     pub fn unwrap_or_display(self, files: &[(String, &str)], err_type: &str) -> T {
-        if self.errors.is_empty() {
-            self.result
-        } else {
+        if self.errors.iter().any(CompileError::is_error) {
             display_errors(self.errors, files, err_type);
             panic!(/* Fail when displaying errors */)
+        } else {
+            self.result
         }
     }
 }
diff --git a/src/lexer/end_state.rs b/src/lexer/end_state.rs
@@ -31,7 +31,7 @@ fn end_ident(literal: &mut Ident, lex_data: &mut LexingData, location: &Location
         let possible_number = literal_to_number(lex_data, literal, location);
         match possible_number {
             None => {
-                let token = Token::from_identifier(literal, location);
+                let token = Token::from_identifier(lex_data, literal, location);
                 lex_data.push_token(token);
             }
             Some(nb) => {
diff --git a/src/lexer/types/keywords.rs b/src/lexer/types/keywords.rs
@@ -8,21 +8,19 @@ macro_rules! impl_keywords {
         }
 
         impl Keyword {
+            pub fn from_value_or_res(value: &str) -> TryKeywordType {
+                match value {
+                    $($str => TryKeywordType::from_keyword($str, Keyword::$pascal),)*
+                    _ => TryKeywordType::Failure,
+                }
+            }
+
             pub const fn keyword_type(&self) -> KeywordType {
                 match self {
                     $(Self::$pascal => KeywordType::$ktype,)*
                 }
             }
-        }
 
-        impl TryFrom<&str> for Keyword {
-            type Error = ();
-            fn try_from(value: &str) -> Result<Self, Self::Error> {
-                match value {
-                    $($str => Ok(Self::$pascal),)*
-                    _ => return Err(()),
-                }
-            }
         }
 
         #[expect(clippy::min_ident_chars)]
@@ -106,3 +104,19 @@ pub enum KeywordType {
     Storage,
     Type,
 }
+
+pub enum TryKeywordType {
+    Deprecated(Keyword),
+    Failure,
+    Success(Keyword),
+}
+
+impl TryKeywordType {
+    fn from_keyword(value: &str, keyword: Keyword) -> Self {
+        if value.starts_with('_') {
+            Self::Deprecated(keyword)
+        } else {
+            Self::Success(keyword)
+        }
+    }
+}
diff --git a/src/lexer/types/tokens_types.rs b/src/lexer/types/tokens_types.rs
@@ -1,7 +1,8 @@
 use core::fmt;
 
 use super::super::numbers::api::Number;
-use super::keywords::Keyword;
+use super::keywords::{Keyword, TryKeywordType};
+use super::lexing_data::LexingData;
 use super::lexing_state::Ident;
 use crate::errors::api::Location;
 
@@ -72,13 +73,35 @@ impl Token {
         }
     }
 
-    pub(crate) fn from_identifier(identifier: &mut Ident, location: &Location) -> Self {
-        let value = identifier.take_value();
-        let token_value = Keyword::try_from(value.as_str())
-            .map_err(|()| value)
-            .map_or_else(TokenValue::Identifier, TokenValue::Keyword);
+    pub(crate) fn from_identifier(
+        lex_data: &mut LexingData,
+        literal: &mut Ident,
+        location: &Location,
+    ) -> Self {
+        let len = literal.len();
+        let value = literal.take_value();
+        let token_value = match Keyword::from_value_or_res(&value) {
+            TryKeywordType::Success(keyword) => TokenValue::Keyword(keyword),
+            TryKeywordType::Deprecated(keyword) => {
+                let new_keyword = value
+                    .char_indices()
+                    .filter_map(|(idx, ch)| {
+                        if idx == 0 {
+                            None
+                        } else if idx == 1 {
+                            Some(ch.to_ascii_lowercase())
+                        } else {
+                            Some(ch)
+                        }
+                    })
+                    .collect::<String>();
+                lex_data.push_err(location.to_owned().into_past(len).to_warning(format!("Underscore operators are deprecated since C23. Consider using the new keyword: {new_keyword}")));
+                TokenValue::Keyword(keyword)
+            }
+            TryKeywordType::Failure => TokenValue::Identifier(value),
+        };
         Self {
-            location: location.to_owned().into_past(identifier.len()),
+            location: location.to_owned().into_past(len),
             value: token_value,
         }
     }
diff --git a/src/parser/keyword/types/attributes.rs b/src/parser/keyword/types/attributes.rs
@@ -5,6 +5,10 @@ use core::fmt;
 use super::super::Ast;
 use super::PushInNode;
 use crate::lexer::api::Keyword;
+use crate::parser::tree::binary::Binary;
+use crate::parser::tree::blocks::Block;
+use crate::parser::tree::unary::Unary;
+use crate::parser::tree::{FunctionCall, ListInitialiser, Literal, Ternary, Variable};
 
 macro_rules! define_attribute_keywords {
     ($($name:ident: $($variant:ident)*,)*) => {
@@ -22,11 +26,13 @@ macro_rules! define_attribute_keywords {
             }
         }
 
-        impl PushInNode for AttributeKeyword {
-            fn push_in_node(self, node: &mut Ast) -> Result<(), String> {
-                todo!()
-            }
-        }
+        // impl PushInNode for AttributeKeyword {
+        //     fn push_in_node(self, node: &mut Ast) -> Result<(), String> {
+        //         match self {
+        //             $(Self::$name(val) => val.push_in_node(node),)*
+        //         }
+        //     }
+        // }
 
         pub enum UnsortedAttributeKeyword {
             $($($variant,)*)*
@@ -59,3 +65,27 @@ define_attribute_keywords!(
     UserDefinedTypes: Typedef Struct Union Enum,
     SpecialAttributes: UAtomic Alignas Inline Restrict UGeneric UNoreturn,
 );
+
+impl AttributeKeyword {
+    fn into_node(self) -> Ast {
+        Ast::Leaf(Literal::Variable(Variable::from(self)))
+    }
+}
+
+impl PushInNode for AttributeKeyword {
+    fn push_in_node(self, node: &mut Ast) -> Result<(), String> {
+        match node {
+            Ast::Empty => *node = self.into_node(),
+            Ast::Leaf(Literal::Variable(var)) => var.push_attr(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: Some(arg), ..}) | Ast::Binary(Binary {arg_r: Some(arg), ..}) | Ast::Ternary(Ternary { failure: Some(arg), ..} | Ternary { success: arg, .. }) => return self.push_in_node(arg),
+            Ast::Unary(Unary{arg: None, ..}) | Ast::Binary(Binary {arg_r: None, ..}) => return node.push_block_as_leaf(self.into_node()),
+            Ast::ListInitialiser(ListInitialiser{ full: true, ..}) | Ast::FunctionCall(FunctionCall{full: true, .. })  => return Err("Attributes can only be placed before variables.".to_owned())
+            ,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/tree/binary.rs b/src/parser/tree/binary.rs
@@ -43,9 +43,9 @@ macro_rules! define_binary_operator {
 
 #[derive(Debug, PartialEq)]
 pub struct Binary {
-    pub(super) op: BinaryOperator,
-    pub(super) arg_l: Box<Ast>,
-    pub(super) arg_r: Option<Box<Ast>>,
+    pub op: BinaryOperator,
+    pub arg_l: Box<Ast>,
+    pub arg_r: Option<Box<Ast>>,
 }
 
 #[expect(clippy::min_ident_chars)]
diff --git a/src/parser/tree/mod.rs b/src/parser/tree/mod.rs
@@ -45,11 +45,10 @@ impl Operator for CompoundLiteralOperator {
 
 #[derive(Debug, PartialEq)]
 pub struct FunctionCall {
-    args: Vec<Ast>,
-    full: bool,
-    name: VariableName,
-    op: FunctionOperator,
-    return_attrs: Vec<AttributeKeyword>,
+    pub args: Vec<Ast>,
+    pub full: bool,
+    pub op: FunctionOperator,
+    pub variable: Variable,
 }
 
 #[expect(clippy::min_ident_chars)]
@@ -58,7 +57,7 @@ impl fmt::Display for FunctionCall {
         write!(
             f,
             "({}\u{b0}({}{}))",
-            self.name,
+            self.variable,
             repr_vec_node(&self.args),
             if self.full { "" } else { ".." },
         )
@@ -80,8 +79,8 @@ impl Operator for FunctionOperator {
 
 #[derive(Debug, PartialEq, Default)]
 pub struct ListInitialiser {
-    elts: Vec<Ast>,
-    full: bool,
+    pub elts: Vec<Ast>,
+    pub full: bool,
 }
 
 #[expect(clippy::min_ident_chars)]
@@ -127,10 +126,10 @@ impl fmt::Display for Literal {
 
 #[derive(Debug, PartialEq, Default)]
 pub struct Ternary {
-    pub(super) condition: Box<Ast>,
-    pub(super) failure: Option<Box<Ast>>,
-    pub(super) op: TernaryOperator,
-    pub(super) success: Box<Ast>,
+    pub condition: Box<Ast>,
+    pub failure: Option<Box<Ast>>,
+    pub op: TernaryOperator,
+    pub success: Box<Ast>,
 }
 
 #[expect(clippy::min_ident_chars)]
@@ -166,7 +165,7 @@ impl fmt::Display for TernaryOperator {
     }
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Default, Eq)]
 pub struct Variable {
     attrs: Vec<AttributeKeyword>,
     name: VariableName,
@@ -179,6 +178,10 @@ impl Variable {
             attrs: vec![],
         }
     }
+
+    pub fn push_attr(&mut self, attr: AttributeKeyword) {
+        self.attrs.push(attr);
+    }
 }
 
 impl From<String> for Variable {
@@ -190,6 +193,15 @@ impl From<String> for Variable {
     }
 }
 
+impl From<AttributeKeyword> for Variable {
+    fn from(attr: AttributeKeyword) -> Self {
+        Self {
+            name: VariableName::Empty,
+            attrs: vec![attr],
+        }
+    }
+}
+
 #[expect(clippy::min_ident_chars)]
 impl fmt::Display for Variable {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -211,7 +223,7 @@ impl fmt::Display for Variable {
 }
 
 #[derive(Debug, PartialEq, Eq, Default)]
-enum VariableName {
+pub enum VariableName {
     #[default]
     Empty,
     Keyword(FunctionKeyword),
diff --git a/src/parser/tree/node.rs b/src/parser/tree/node.rs
diff --git a/src/parser/tree/unary.rs b/src/parser/tree/unary.rs
diff --git a/tests/parser.rs b/tests/parser.rs

Original file line number	Diff line number	Diff line change
`@@ -14,11 +14,11 @@ pub struct Res<T> {`
`14`	`14`	`impl<T> Res<T> {`
`15`	`15`	`#[inline]`
`16`	`16`	`pub fn unwrap_or_display(self, files: &[(String, &str)], err_type: &str) -> T {`
`17`		`- if self.errors.is_empty() {`
`18`		`- self.result`
`19`		`- } else {`
	`17`	`+ if self.errors.iter().any(CompileError::is_error) {`
`20`	`18`	`display_errors(self.errors, files, err_type);`
`21`	`19`	`panic!(/* Fail when displaying errors */)`
	`20`	`+ } else {`
	`21`	`+ self.result`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ fn end_ident(literal: &mut Ident, lex_data: &mut LexingData, location: &Location`
`31`	`31`	`let possible_number = literal_to_number(lex_data, literal, location);`
`32`	`32`	`match possible_number {`
`33`	`33`	`None => {`
`34`		`- let token = Token::from_identifier(literal, location);`
	`34`	`+ let token = Token::from_identifier(lex_data, literal, location);`
`35`	`35`	`lex_data.push_token(token);`
`36`	`36`	`}`
`37`	`37`	`Some(nb) => {`