Fail on deep recursion instead of overflowing stack

Author: casey

src/error.rs

@@ -173,6 +173,9 @@ pub(crate) enum Error<'src> {
     min: usize,
     max: usize,
   },
+  RecursionLimit {
+    last: Name<'src>,
+  },
   RegexCompile {
     source: regex::Error,
   },
@@ -721,6 +724,10 @@ impl ColorDisplay for Error<'_> {
           )?;
         }
       }
+      RecursionLimit { last } => write!(
+        f,
+        "maximum recursion depth of {RECURSION_LIMIT} exceeded while calling function {last}"
+      )?,
       RegexCompile { source } => write!(f, "{source}")?,
       RuntimeDirIo { io_error, path } => {
         write!(

src/evaluator.rs

@@ -7,6 +7,7 @@ pub(crate) struct Evaluator<'src: 'run, 'run> {
   is_dependency: bool,
   non_const_assignments: Table<'src, Name<'src>>,
   overrides: &'run HashMap<Number, String>,
+  recursion_depth: usize,
   scope: Scope<'src, 'run>,
 }
 
@@ -26,6 +27,7 @@ impl<'src, 'run> Evaluator<'src, 'run> {
   ) -> RunResult<'src, Settings> {
     let mut evaluator = Self {
       assignments: Some(assignments),
+      recursion_depth: 0,
       context: None,
       env: BTreeMap::new(),
       is_dependency: false,
@@ -173,6 +175,7 @@ impl<'src, 'run> Evaluator<'src, 'run> {
 
     let mut evaluator = Self {
       assignments: Some(&module.assignments),
+      recursion_depth: 0,
       context: Some(context),
       env: BTreeMap::new(),
       is_dependency: false,
@@ -237,6 +240,14 @@ impl<'src, 'run> Evaluator<'src, 'run> {
     function: &FunctionDefinition<'src>,
     arguments: &[Expression<'src>],
   ) -> RunResult<'src, String> {
+    let recursion_depth = self.recursion_depth + 1;
+
+    if recursion_depth == RECURSION_LIMIT {
+      return Err(Error::RecursionLimit {
+        last: function.name,
+      });
+    }
+
     let context = *self.context.as_ref().unwrap();
 
     let mut scope = Scope::root();
@@ -261,6 +272,7 @@ impl<'src, 'run> Evaluator<'src, 'run> {
       is_dependency: false,
       non_const_assignments: Table::new(),
       overrides: self.overrides,
+      recursion_depth,
       scope,
     };
 
@@ -611,6 +623,7 @@ impl<'src, 'run> Evaluator<'src, 'run> {
       is_dependency,
       non_const_assignments: Table::new(),
       overrides: context.overrides,
+      recursion_depth: 0,
       scope: scope.child(),
     }
   }

src/lib.rs

@@ -171,6 +171,8 @@ type FunctionResult = Result<String, String>;
 type RunResult<'a, T = ()> = Result<T, Error<'a>>;
 type SearchResult<T> = Result<T, SearchError>;
 
+const RECURSION_LIMIT: usize = if cfg!(windows) { 48 } else { 256 };
+
 #[cfg(test)]
 #[macro_use]
 pub mod testing;

src/parser.rs

@@ -653,7 +653,7 @@ impl<'run, 'src> Parser<'run, 'src> {
 
   /// Parse an expression, e.g. `1 + 2`
   fn parse_expression(&mut self) -> CompileResult<'src, Expression<'src>> {
-    if self.recursion_depth == if cfg!(windows) { 48 } else { 256 } {
+    if self.recursion_depth == RECURSION_LIMIT {
       let token = self.next()?;
       return Err(CompileError::new(
         token,

tests/recursion_limit.rs

@@ -12,6 +12,26 @@ fn bugfix() {
     .failure();
 }
 
+#[test]
+fn user_defined_function_recursion_limit() {
+  Test::new()
+    .justfile(
+      "
+        set unstable
+
+        foo() := foo()
+
+        bar:
+          echo {{foo()}}
+      ",
+    )
+    .stderr(format!(
+      "error: maximum recursion depth of {} exceeded while calling function foo\n",
+      if cfg!(windows) { 48 } else { 256 },
+    ))
+    .failure();
+}
+
 const RECURSION_LIMIT_REACHED: &str = if cfg!(windows) {
   "
 error: Parsing recursion depth exceeded