(parser) fix: indirections can be part of type declaration

Author: t-webber

src/lib.rs

@@ -10,11 +10,12 @@
     clippy::nursery,
     clippy::cargo
 )]
-//
+// lints that are not meant to be used
 #![allow(clippy::single_call_fn)]
 #![allow(clippy::implicit_return)]
 #![allow(clippy::pattern_type_mismatch)]
 #![allow(clippy::blanket_clippy_restriction_lints)]
+#![allow(clippy::missing_trait_methods)]
 //
 #![allow(clippy::missing_docs_in_private_items)]
 #![allow(clippy::arithmetic_side_effects)]

src/parser/keyword/types/attributes.rs

@@ -7,8 +7,9 @@ use super::PushInNode;
 use crate::lexer::api::Keyword;
 use crate::parser::tree::binary::Binary;
 use crate::parser::tree::blocks::Block;
+use crate::parser::tree::literal::{Literal, Variable};
 use crate::parser::tree::unary::Unary;
-use crate::parser::tree::{FunctionCall, ListInitialiser, Literal, Ternary, Variable};
+use crate::parser::tree::{FunctionCall, ListInitialiser, Ternary};
 
 macro_rules! define_attribute_keywords {
     ($($name:ident: $($variant:ident)*,)*) => {

src/parser/keyword/types/functions.rs

@@ -2,7 +2,7 @@ use core::fmt;
 
 use super::super::Ast;
 use super::PushInNode;
-use crate::parser::tree::{Literal, Variable};
+use crate::parser::tree::literal::{Literal, Variable};
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum FunctionKeyword {

src/parser/keyword/types/mod.rs

@@ -15,7 +15,7 @@ use functions::FunctionKeyword as Func;
 
 use super::super::tree::node::Ast;
 use crate::lexer::api::Keyword;
-use crate::parser::tree::Literal;
+use crate::parser::tree::literal::Literal;
 
 pub enum KeywordParsing {
     Attr(Attr),

src/parser/parse_content.rs

@@ -5,8 +5,8 @@ use super::keyword::handle_keyword;
 use super::state::{BlockState, ParsingState};
 use super::symbols::handle_symbol;
 use super::tree::blocks::Block;
+use super::tree::literal::{Literal, Variable};
 use super::tree::node::Ast;
-use super::tree::{Literal, Variable};
 use crate::errors::api::{CompileError, Location, Res};
 use crate::lexer::api::{Token, TokenValue};
 

src/parser/symbols/blocks.rs

@@ -35,7 +35,7 @@ pub fn blocks_handler(
     match block_state {
         // semi-colon
         TodoBlock::SemiColon => {
-            handle_colon(current);
+            handle_semicolon(current);
             parse_block(tokens, p_state, current)
         }
         // parenthesis
@@ -135,7 +135,7 @@ fn handle_brace_block_open(
     parse_block(tokens, p_state, current)
 }
 
-fn handle_colon(current: &mut Ast) {
+fn handle_semicolon(current: &mut Ast) {
     if let Ast::Block(Block { elts, full }) = current
         && !*full
     {

src/parser/symbols/handlers.rs

@@ -2,6 +2,16 @@ use super::super::tree::binary::BinaryOperator;
 use super::super::tree::node::Ast;
 use super::super::tree::unary::UnaryOperator;
 
+pub fn handle_binary_unary(
+    current: &mut Ast,
+    bin_op: BinaryOperator,
+    un_op: UnaryOperator,
+) -> Result<(), String> {
+    current
+        .push_op(bin_op)
+        .map_or_else(|_| current.push_op(un_op), |()| Ok(()))
+}
+
 pub fn handle_comma(current: &mut Ast) -> Result<(), String> {
     if current
         .apply_to_last_list_initialiser(&|vec, _| vec.push(Ast::Empty))
@@ -12,16 +22,6 @@ pub fn handle_comma(current: &mut Ast) -> Result<(), String> {
     Ok(())
 }
 
-pub fn handle_double_binary(
-    current: &mut Ast,
-    bin_op: BinaryOperator,
-    un_op: UnaryOperator,
-) -> Result<(), String> {
-    current
-        .push_op(bin_op)
-        .map_or_else(|_| current.push_op(un_op), |()| Ok(()))
-}
-
 pub fn handle_double_unary(
     current: &mut Ast,
     first: UnaryOperator,

src/parser/symbols/sort_symbols.rs

@@ -5,7 +5,7 @@ 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_comma, handle_double_binary, handle_double_unary};
+use super::handlers::{handle_binary_unary, handle_comma, handle_double_unary};
 use crate::lexer::api::Symbol;
 
 enum SymbolParsing {
@@ -86,7 +86,7 @@ pub fn handle_one_symbol(symbol: Symbol, current: &mut Ast) -> Result<TodoBlock,
         SymbolParsing::UniqueBinary(op) => current.push_op(op)?,
         // doubles
         SymbolParsing::DoubleUnary(first, second) => handle_double_unary(current, first, second)?,
-        SymbolParsing::BinaryUnary(bin_op, un_op) => handle_double_binary(current, bin_op, un_op)?,
+        SymbolParsing::BinaryUnary(bin_op, un_op) => handle_binary_unary(current, bin_op, un_op)?,
         // blocks
         SymbolParsing::Block(block) => return Ok(block),
         // special

src/parser/tree/binary.rs

@@ -2,6 +2,7 @@
 
 use core::fmt;
 
+use super::unary::UnaryOperator;
 use super::{Associativity, Ast, Operator};
 
 macro_rules! define_binary_operator {
@@ -96,3 +97,9 @@ define_binary_operator!(
     XorAssign 14, "^="
     OrAssign 14, "|="
 );
+
+impl PartialEq<UnaryOperator> for BinaryOperator {
+    fn eq(&self, _: &UnaryOperator) -> bool {
+        false
+    }
+}

src/parser/tree/literal.rs

@@ -0,0 +1,152 @@
+use crate::{parser::keyword::types::{attributes::AttributeKeyword, functions::FunctionKeyword}, Number, EMPTY};
+use core::{fmt, mem};
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum Attribute {
+    Indirection, 
+    Keyword(AttributeKeyword), 
+    User(String),
+}
+
+#[expect(clippy::min_ident_chars)]
+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::User(val) => write!(f, "'{val}'"),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum Literal {
+    Char(char),
+    ConstantBool(bool),
+    Empty,
+    Nullptr,
+    Number(Number),
+    Str(String),
+    Variable(Variable),
+}
+
+#[expect(clippy::min_ident_chars)]
+impl fmt::Display for Literal {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Empty => EMPTY.fmt(f),
+            Self::Nullptr => "NULL".fmt(f),
+            Self::Char(val) => write!(f, "'{val}'"),
+            Self::Str(val) => write!(f, "\"{val}\""),
+            Self::Number(val) => val.fmt(f),
+            Self::ConstantBool(val) => val.fmt(f),
+            Self::Variable(val) => val.fmt(f),
+        }
+    }
+}
+
+
+#[derive(Debug, PartialEq, Default, Eq)]
+pub struct Variable {
+    pub attrs: Vec<Attribute>,
+    pub name: VariableName,
+}
+
+impl Variable {
+    pub const fn from_keyword(keyword: FunctionKeyword) -> Self {
+        Self {
+            name: VariableName::Keyword(keyword),
+            attrs: vec![],
+        }
+    }
+
+    pub fn push_attr(&mut self, attr: AttributeKeyword) {
+        self.attrs.push(Attribute::Keyword(attr));
+    }
+    
+    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::UserDefined(name) => self.attrs.push(Attribute::User(name)),
+        }
+        self.attrs.push(Attribute::Indirection);
+        Ok(())
+    }
+    
+    pub fn push_str(&mut self, value: String) -> Result<(), String> {
+        match mem::take(&mut self.name) {
+            VariableName::Empty => {self.name = VariableName::UserDefined(value); Ok(())}, 
+            VariableName::Keyword(keyword) => Err(format!("Found 2 successive literals, found identifier {value} after function keyword {keyword}.")),
+            VariableName::UserDefined(old) => {
+                self.attrs.push(Attribute::User(old));
+                self.name = VariableName::UserDefined(value);
+                Ok(())
+            }
+        }   
+    }
+
+}
+
+impl From<String> for Variable {
+    fn from(name: String) -> Self {
+        Self {
+            name: VariableName::UserDefined(name),
+            attrs: vec![],
+        }
+    }
+}
+
+impl From<AttributeKeyword> for Variable {
+    fn from(attr: AttributeKeyword) -> Self {
+        Self {
+            name: VariableName::Empty,
+            attrs: vec![Attribute::Keyword(attr)],
+        }
+    }
+}
+
+#[expect(clippy::min_ident_chars)]
+impl fmt::Display for Variable {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.attrs.is_empty() {
+            self.name.fmt(f)
+        } else {
+            write!(
+                f,
+                "({} {})",
+                self.attrs
+                    .iter()
+                    .map(|attr| format!("{attr}"))
+                    .collect::<Vec<_>>()
+                    .join(" "),
+                self.name
+            )
+        } 
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Default)]
+pub enum VariableName {
+    #[default]
+    Empty,
+    Keyword(FunctionKeyword),
+    UserDefined(String),
+}
+
+impl From<&str> for VariableName {
+    fn from(name: &str) -> Self {
+        Self::UserDefined(name.to_owned())
+    }
+}
+
+#[expect(clippy::min_ident_chars)]
+impl fmt::Display for VariableName {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Empty => EMPTY.fmt(f),
+            Self::UserDefined(val) => val.fmt(f),
+            Self::Keyword(val) => val.fmt(f),
+        }
+    }
+}