(parser) fix: handle overflow errors on depth incrementation

Author: t-webber

src/parser/modifiers/functions.rs

@@ -1,12 +1,76 @@
 //! Module that modifies [`FunctionCall`] within an existing node.
 
+use core::convert::Infallible;
 use core::mem;
+use core::ops::{ControlFlow, FromResidual, Try};
 
 use crate::parser::keyword::control_flow::traits::ControlFlow as _;
 use crate::parser::operators::api::{Binary, Ternary, Unary};
 use crate::parser::symbols::api::{BracedBlock, FunctionCall, ListInitialiser};
 use crate::parser::tree::Ast;
 
+/// Result of call to `[MakeFunction::can_make_function]`, indicated whether a
+/// function can be created from a `(` and a pending variable, and if so, at
+/// what depth.
+pub enum CanMakeFnRes {
+    /// A function can be made.
+    ///
+    /// The depth of the variable that is to be turned into a function is
+    /// stored. The depth is the number of variable to descend in the
+    /// `[Ast]` before reaching the desired variable.
+    CanMakeFn(u32),
+    /// No function can be made
+    ///
+    /// No pending variable was found.
+    None,
+    /// An error occured whilst incrementing the depth.
+    ///
+    /// This means that the user has more than 2**32 nested variables.
+    TooDeep,
+}
+
+impl CanMakeFnRes {
+    /// Tries to increment the variable depth if it exists.
+    ///
+    /// If it doesn't exist it initialises the depth to 0.
+    const fn increment_or_default(self) -> Self {
+        match self {
+            Self::CanMakeFn(depth) => match depth.checked_add(1) {
+                Some(new_depth) => Self::CanMakeFn(new_depth),
+                None => Self::TooDeep,
+            },
+            Self::None => Self::CanMakeFn(0),
+            Self::TooDeep => Self::TooDeep,
+        }
+    }
+}
+
+impl FromResidual<Self> for CanMakeFnRes {
+    fn from_residual(residual: Self) -> Self {
+        residual
+    }
+}
+
+impl FromResidual<Option<Infallible>> for CanMakeFnRes {
+    fn from_residual(residual: Option<Infallible>) -> Self {
+        residual.map_or(Self::None, |_| unreachable!())
+    }
+}
+
+impl Try for CanMakeFnRes {
+    type Output = Self;
+
+    type Residual = Self;
+
+    fn branch(self) -> ControlFlow<Self, Self> {
+        ControlFlow::Continue(self)
+    }
+
+    fn from_output(output: Self) -> Self {
+        output
+    }
+}
+
 /// Trait to manipulate node to find and edit [`Variable`]s that can be
 /// transformed into functions if a `(` is read.
 pub trait MakeFunction {
@@ -15,33 +79,31 @@ pub trait MakeFunction {
     /// # Returns
     ///
     /// The depth of the variable in the AST that is to be made into a function.
-    fn can_make_function(&self) -> Option<u32>;
+    fn can_make_function(&self) -> CanMakeFnRes;
 
     /// Makes a function out of the variable found in [`can_make_function`].
     fn make_function(&mut self, depth: u32, arguments: Vec<Ast>);
 }
 
 impl MakeFunction for Ast {
-    fn can_make_function(&self) -> Option<u32> {
+    fn can_make_function(&self) -> CanMakeFnRes {
         match self {
-            Self::Variable(variable) => Some(variable.can_make_function().unwrap_or_default()),
+            Self::Variable(variable) => variable.can_make_function().increment_or_default(),
             Self::Empty
             | Self::Cast(_)
             | Self::Leaf(_)
             | Self::ParensBlock(_)
             | Self::BracedBlock(BracedBlock { full: true, .. })
             | Self::Ternary(Ternary { failure: None, .. })
             | Self::FunctionCall(_)
-            | Self::ListInitialiser(ListInitialiser { full: true, .. }) => None,
+            | Self::ListInitialiser(ListInitialiser { full: true, .. }) => CanMakeFnRes::None,
             Self::Unary(Unary { arg: child, .. })
             | Self::Binary(Binary { arg_r: child, .. })
-            | Self::Ternary(Ternary { failure: Some(child), .. }) =>
-                child.can_make_function().map(|depth| depth + 1),
+            | Self::Ternary(Ternary { failure: Some(child), .. }) => child.can_make_function(),
             Self::FunctionArgsBuild(vec)
             | Self::ListInitialiser(ListInitialiser { elts: vec, .. })
-            | Self::BracedBlock(BracedBlock { elts: vec, .. }) =>
-                vec.last()?.can_make_function().map(|depth| depth + 1),
-            Self::ControlFlow(ctrl) => ctrl.as_ast()?.can_make_function().map(|depth| depth + 1),
+            | Self::BracedBlock(BracedBlock { elts: vec, .. }) => vec.last()?.can_make_function(),
+            Self::ControlFlow(ctrl) => ctrl.as_ast()?.can_make_function(),
         }
     }
 
@@ -50,7 +112,7 @@ impl MakeFunction for Ast {
         crate::errors::api::Print::custom_print(&format!("get last var of {self}"));
         if depth == 0 {
             if let Self::Variable(variable) = mem::take(self) {
-                *self = Self::FunctionCall(FunctionCall { variable, arguments });
+                *self = Self::FunctionCall(FunctionCall { arguments, variable });
                 return;
             }
             unreachable!("must be variable at depth 0")

src/parser/symbols/blocks/recursion.rs

@@ -13,7 +13,7 @@ use crate::lexer::api::Token;
 use crate::parser::keyword::control_flow::node::{
     switch_wanting_block, try_push_semicolon_control
 };
-use crate::parser::modifiers::functions::MakeFunction as _;
+use crate::parser::modifiers::functions::{CanMakeFnRes, MakeFunction as _};
 use crate::parser::modifiers::list_initialiser::{
     apply_to_last_list_initialiser, can_push_list_initialiser
 };
@@ -148,44 +148,74 @@ fn handle_parenthesis_open(
     tokens: &mut IntoIter<Token>,
     location: ErrorLocation,
 ) -> Res<()> {
-    if let Some(function_depth) = current.can_make_function() {
-        let mut arguments_node = Ast::FunctionArgsBuild(vec![Ast::Empty]);
-        p_state.push_ctrl_flow(false);
-        parse_block(tokens, p_state, &mut arguments_node)?;
-        if p_state.pop_ctrl_flow().is_none() {
-            return Res::from(BlockType::Parenthesis.mismatched_err_end(location));
-        }
-        if p_state.pop_and_compare_block(&BlockType::Parenthesis) {
-            if let Ast::FunctionArgsBuild(vec) = &mut arguments_node {
-                let mut error = None;
-                if vec.last().is_some_and(Ast::is_empty) {
-                    vec.pop();
-                    if !vec.is_empty() {
-                        error = Some(location.to_suggestion(
-                            "Found extra comma in function argument list. Please remove the comma.".to_owned(),
-                        ));
-                    }
+    match current.can_make_function() {
+        CanMakeFnRes::CanMakeFn(variable_depth) =>
+            make_function(current, p_state, tokens, location, variable_depth),
+        CanMakeFnRes::None =>
+            handle_non_function_parenthesis_open(current, p_state, tokens, location),
+        CanMakeFnRes::TooDeep => Res::from(
+            location.into_crash("Code to complex: AST to deep to fit depth in 32 bits.".to_owned()),
+        ),
+    }
+}
+
+/// Create a function for the found '('
+///
+/// Builds a function on a variable and adds its arguments.
+fn make_function(
+    current: &mut Ast,
+    p_state: &mut ParsingState,
+    tokens: &mut IntoIter<Token>,
+    location: ErrorLocation,
+    variable_depth: u32,
+) -> Res<()> {
+    let mut arguments_node = Ast::FunctionArgsBuild(vec![Ast::Empty]);
+    p_state.push_ctrl_flow(false);
+    parse_block(tokens, p_state, &mut arguments_node)?;
+    if p_state.pop_ctrl_flow().is_none() {
+        return Res::from(BlockType::Parenthesis.mismatched_err_end(location));
+    }
+    if p_state.pop_and_compare_block(&BlockType::Parenthesis) {
+        if let Ast::FunctionArgsBuild(vec) = &mut arguments_node {
+            let mut error = None;
+            if vec.last().is_some_and(Ast::is_empty) {
+                vec.pop();
+                if !vec.is_empty() {
+                    error = Some(
+                        location.to_suggestion(
+                            "Found extra comma in function argument list. Please remove the comma."
+                                .to_owned(),
+                        ),
+                    );
                 }
-                current.make_function(function_depth, mem::take(vec));
-                parse_block(tokens, p_state, current).add_err(error)
-            } else {
-                unreachable!("a function args build cannot be dismissed as root");
             }
+            current.make_function(variable_depth, mem::take(vec));
+            parse_block(tokens, p_state, current).add_err(error)
         } else {
-            Res::from(BlockType::Parenthesis.mismatched_err_end(location))
+            unreachable!("a function args build cannot be dismissed as root");
         }
     } else {
-        let mut parenthesized_block = Ast::Empty;
-        parse_block(tokens, p_state, &mut parenthesized_block)?;
-        parenthesized_block.fill();
-        if p_state.pop_and_compare_block(&BlockType::Parenthesis) {
-            current
-                .push_block_as_leaf(ParensBlock::make_parens_ast(parenthesized_block))
-                .map_err(|err| location.into_crash(err))?;
-            parse_block(tokens, p_state, current)
-        } else {
-            Res::from(BlockType::Parenthesis.mismatched_err_end(location))
-        }
+        Res::from(BlockType::Parenthesis.mismatched_err_end(location))
+    }
+}
+
+/// Handles an opening '(', but when it can't be a function call.
+fn handle_non_function_parenthesis_open(
+    current: &mut Ast,
+    p_state: &mut ParsingState,
+    tokens: &mut IntoIter<Token>,
+    location: ErrorLocation,
+) -> Res<()> {
+    let mut parenthesized_block = Ast::Empty;
+    parse_block(tokens, p_state, &mut parenthesized_block)?;
+    parenthesized_block.fill();
+    if p_state.pop_and_compare_block(&BlockType::Parenthesis) {
+        current
+            .push_block_as_leaf(ParensBlock::make_parens_ast(parenthesized_block))
+            .map_err(|err| location.into_crash(err))?;
+        parse_block(tokens, p_state, current)
+    } else {
+        Res::from(BlockType::Parenthesis.mismatched_err_end(location))
     }
 }
 

src/parser/variable/mod.rs

@@ -31,7 +31,7 @@ use super::literal::Attribute;
 use super::modifiers::push::Push;
 use super::operators::api::OperatorConversions;
 use super::tree::api::{Ast, CanPush, PushAttribute};
-use crate::parser::modifiers::functions::MakeFunction;
+use crate::parser::modifiers::functions::{CanMakeFnRes, MakeFunction};
 use crate::utils::display;
 
 /// Different variable cases
@@ -108,7 +108,7 @@ impl Variable {
 }
 
 impl MakeFunction for Variable {
-    fn can_make_function(&self) -> Option<u32> {
+    fn can_make_function(&self) -> CanMakeFnRes {
         todo!()
     }