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

t-webber · t-webber · commit 329ffbc14a27 · 2024-12-29T23:10:19.000+01:00
diff --git a/src/lib.rs b/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)]
diff --git a/src/parser/keyword/types/attributes.rs b/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)*,)*) => {
@@ -68,7 +69,7 @@ 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::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("Attributes can only be placed before variables.".to_owned())
diff --git a/src/parser/keyword/types/functions.rs b/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 {
diff --git a/src/parser/keyword/types/mod.rs b/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),
diff --git a/src/parser/parse_content.rs b/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};
 
diff --git a/src/parser/symbols/blocks.rs b/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
     {
diff --git a/src/parser/symbols/handlers.rs b/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,
diff --git a/src/parser/symbols/sort_symbols.rs b/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
diff --git a/src/parser/tree/binary.rs b/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
+    }
+}
diff --git a/src/parser/tree/conversions.rs b/src/parser/tree/conversions.rs
@@ -13,14 +13,20 @@ impl OperatorConversions for BinaryOperator {
     }
 
     fn try_to_node_with_arg(self, arg: Ast) -> Result<Ast, String> {
+        let lvalue = if self.precedence() == 14 {
+            let mut old = arg;
+            old.make_lhs()?;
+            old
+        } else {
+            arg
+        };
         Ok(Ast::Binary(Binary {
             op: self,
-            arg_l: Box::new(arg),
+            arg_l: Box::new(lvalue),
             arg_r: Box::new(Ast::Empty),
         }))
     }
 }
-
 pub trait OperatorConversions: Operator
 where
     Self: Sized,
diff --git a/src/parser/tree/literal.rs b/src/parser/tree/literal.rs
@@ -0,0 +1,160 @@
+use core::{fmt, mem};
+
+use crate::parser::keyword::types::attributes::AttributeKeyword;
+use crate::parser::keyword::types::functions::FunctionKeyword;
+use crate::{Number, EMPTY};
+
+#[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: Attribute) {
+        self.attrs.push(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)),
+        }
+        assert!(self.name == VariableName::Empty, "???");
+        self.attrs.push(Attribute::Indirection);
+        Ok(())
+    }
+
+    pub fn push_keyword(&mut self, keyword: AttributeKeyword) {
+        self.attrs.push(Attribute::Keyword(keyword));
+    }
+
+    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::UserDefined(old) => {
+                self.attrs.push(Attribute::User(old));
+                self.name = name;
+                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),
+        }
+    }
+}
diff --git a/src/parser/tree/mod.rs b/src/parser/tree/mod.rs
diff --git a/src/parser/tree/node.rs b/src/parser/tree/node.rs
diff --git a/src/parser/tree/traits.rs b/src/parser/tree/traits.rs
diff --git a/src/parser/tree/unary.rs b/src/parser/tree/unary.rs
diff --git a/tests/strings.rs b/tests/strings.rs

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ pub fn blocks_handler(`
`35`	`35`	`match block_state {`
`36`	`36`	`// semi-colon`
`37`	`37`	`TodoBlock::SemiColon => {`
`38`		`- handle_colon(current);`
	`38`	`+ handle_semicolon(current);`
`39`	`39`	`parse_block(tokens, p_state, current)`
`40`	`40`	`}`
`41`	`41`	`// parenthesis`
`@@ -135,7 +135,7 @@ fn handle_brace_block_open(`
`135`	`135`	`parse_block(tokens, p_state, current)`
`136`	`136`	`}`
`137`	`137`
`138`		`-fn handle_colon(current: &mut Ast) {`
	`138`	`+fn handle_semicolon(current: &mut Ast) {`
`139`	`139`	`if let Ast::Block(Block { elts, full }) = current`
`140`	`140`	`&& !*full`
`141`	`141`	`{`