Cached recipes

src/attribute.rs

@@ -5,6 +5,7 @@ use super::*;
 #[serde(rename_all = "kebab-case")]
 pub(crate) enum Attribute<'src> {
   Confirm(Option<StringLiteral<'src>>),
+  Cached,
   Linux,
   Macos,
   NoCd,

src/cache.rs

@@ -0,0 +1,25 @@
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub(crate) struct JustfileCache {
+  /// Only serialized for user debugging
+  pub(crate) working_directory: PathBuf,
+  pub(crate) recipe_caches: HashMap<String, RecipeCache>,
+}
+
+impl JustfileCache {
+  pub(crate) fn new(working_directory: PathBuf) -> Self {
+    Self {
+      working_directory,
+      recipe_caches: HashMap::new(),
+    }
+  }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub(crate) struct RecipeCache {
+  pub(crate) body_hash: String,
+}

src/error.rs

@@ -17,6 +17,13 @@ pub(crate) enum Error<'src> {
     token: Token<'src>,
     output_error: OutputError,
   },
+  CacheFileRead {
+    cache_filename: Option<PathBuf>,
+  },
+  CacheFileWrite {
+    cache_filename: PathBuf,
+    io_error: io::Error,
+  },
   ChooserInvoke {
     shell_binary: String,
     shell_arguments: String,
@@ -96,6 +103,10 @@ pub(crate) enum Error<'src> {
     io_error: io::Error,
   },
   Homedir,
+  InvalidCachedRecipe {
+    recipe: &'src str,
+    describe_invalid: String,
+  },
   InitExists {
     justfile: PathBuf,
   },
@@ -267,6 +278,12 @@ impl<'src> ColorDisplay for Error<'src> {
           }?,
         OutputError::Utf8(utf8_error) => write!(f, "Backtick succeeded but stdout was not utf8: {utf8_error}")?,
       }
+      CacheFileRead {cache_filename} => match cache_filename {
+        Some(cache_filename) =>
+        write!(f, "Failed to read cache file: {}", cache_filename.display())?,
+        None => write!(f, "Failed to get default cache file")?,
+      }
+      CacheFileWrite{cache_filename, io_error} => write!(f, "Failed to write cache file ({}): {io_error}", cache_filename.display())?,
       ChooserInvoke { shell_binary, shell_arguments, chooser, io_error} => {
         let chooser = chooser.to_string_lossy();
         write!(f, "Chooser `{shell_binary} {shell_arguments} {chooser}` invocation failed: {io_error}")?;
@@ -355,6 +372,9 @@ impl<'src> ColorDisplay for Error<'src> {
       Homedir => {
         write!(f, "Failed to get homedir")?;
       }
+      InvalidCachedRecipe { recipe, describe_invalid } => {
+        write!(f, "Cached recipe `{recipe}` contains {describe_invalid}, which could run multiple times.\nYou must inline it if possible or set it to a variable outside of the recipe block: my_var := ...")?;
+      }
       InitExists { justfile } => {
         write!(f, "Justfile `{}` already exists", justfile.display())?;
       }

src/expression.rs

@@ -45,6 +45,10 @@ impl<'src> Expression<'src> {
   pub(crate) fn variables<'expression>(&'expression self) -> Variables<'expression, 'src> {
     Variables::new(self)
   }
+
+  pub(crate) fn walk<'expression>(&'expression self) -> ExpressionWalker<'expression, 'src> {
+    ExpressionWalker::new(self)
+  }
 }
 
 impl<'src> Display for Expression<'src> {

src/expression_walker.rs

@@ -0,0 +1,83 @@
+use super::*;
+
+pub(crate) struct ExpressionWalker<'expression, 'src> {
+  stack: Vec<&'expression Expression<'src>>,
+}
+
+impl<'expression, 'src> ExpressionWalker<'expression, 'src> {
+  pub(crate) fn new(root: &'expression Expression<'src>) -> ExpressionWalker<'expression, 'src> {
+    ExpressionWalker { stack: vec![root] }
+  }
+}
+
+impl<'expression, 'src> Iterator for ExpressionWalker<'expression, 'src> {
+  type Item = &'expression Expression<'src>;
+
+  fn next(&mut self) -> Option<Self::Item> {
+    let top = self.stack.pop()?;
+
+    match top {
+      Expression::StringLiteral { .. }
+      | Expression::Variable { .. }
+      | Expression::Backtick { .. } => {}
+      Expression::Call { thunk } => match thunk {
+        Thunk::Nullary { .. } => {}
+        Thunk::Unary { arg, .. } => self.stack.push(arg),
+        Thunk::UnaryOpt {
+          args: (a, opt_b), ..
+        } => {
+          self.stack.push(a);
+          if let Some(b) = opt_b.as_ref() {
+            self.stack.push(b);
+          }
+        }
+        Thunk::Binary { args, .. } => {
+          for arg in args.iter().rev() {
+            self.stack.push(arg);
+          }
+        }
+        Thunk::BinaryPlus {
+          args: ([a, b], rest),
+          ..
+        } => {
+          let first: &[&Expression] = &[a, b];
+          for arg in first.iter().copied().chain(rest).rev() {
+            self.stack.push(arg);
+          }
+        }
+        Thunk::Ternary { args, .. } => {
+          for arg in args.iter().rev() {
+            self.stack.push(arg);
+          }
+        }
+      },
+      Expression::Conditional {
+        lhs,
+        rhs,
+        then,
+        otherwise,
+        ..
+      } => {
+        self.stack.push(otherwise);
+        self.stack.push(then);
+        self.stack.push(rhs);
+        self.stack.push(lhs);
+      }
+      Expression::Concatenation { lhs, rhs } => {
+        self.stack.push(rhs);
+        self.stack.push(lhs);
+      }
+      Expression::Join { lhs, rhs } => {
+        self.stack.push(rhs);
+        if let Some(lhs) = lhs {
+          self.stack.push(lhs);
+        }
+      }
+      Expression::Group { contents } => {
+        self.stack.push(contents);
+      }
+    }
+
+    Some(top)
+  }
+}

src/keyword.rs

@@ -5,6 +5,7 @@ use super::*;
 pub(crate) enum Keyword {
   Alias,
   AllowDuplicateRecipes,
+  CacheFilename,
   DotenvFilename,
   DotenvLoad,
   DotenvPath,

src/lib.rs

@@ -17,17 +17,19 @@ pub(crate) use {
   crate::{
     alias::Alias, analyzer::Analyzer, assignment::Assignment,
     assignment_resolver::AssignmentResolver, ast::Ast, attribute::Attribute, binding::Binding,
-    color::Color, color_display::ColorDisplay, command_ext::CommandExt, compilation::Compilation,
-    compile_error::CompileError, compile_error_kind::CompileErrorKind, compiler::Compiler,
+    cache::JustfileCache, cache::RecipeCache, color::Color, color_display::ColorDisplay,
+    command_ext::CommandExt, compilation::Compilation, compile_error::CompileError,
+    compile_error_kind::CompileErrorKind, compiler::Compiler,
     conditional_operator::ConditionalOperator, config::Config, config_error::ConfigError,
     count::Count, delimiter::Delimiter, dependency::Dependency, dump_format::DumpFormat,
     enclosure::Enclosure, error::Error, evaluator::Evaluator, expression::Expression,
-    fragment::Fragment, function::Function, function_context::FunctionContext,
-    interrupt_guard::InterruptGuard, interrupt_handler::InterruptHandler, item::Item,
-    justfile::Justfile, keyed::Keyed, keyword::Keyword, lexer::Lexer, line::Line, list::List,
-    load_dotenv::load_dotenv, loader::Loader, name::Name, namepath::Namepath, ordinal::Ordinal,
-    output::output, output_error::OutputError, parameter::Parameter, parameter_kind::ParameterKind,
-    parser::Parser, platform::Platform, platform_interface::PlatformInterface, position::Position,
+    expression_walker::ExpressionWalker, fragment::Fragment, function::Function,
+    function_context::FunctionContext, interrupt_guard::InterruptGuard,
+    interrupt_handler::InterruptHandler, item::Item, justfile::Justfile, keyed::Keyed,
+    keyword::Keyword, lexer::Lexer, line::Line, list::List, load_dotenv::load_dotenv,
+    loader::Loader, name::Name, namepath::Namepath, ordinal::Ordinal, output::output,
+    output_error::OutputError, parameter::Parameter, parameter_kind::ParameterKind, parser::Parser,
+    platform::Platform, platform_interface::PlatformInterface, position::Position,
     positional::Positional, ran::Ran, range_ext::RangeExt, recipe::Recipe,
     recipe_context::RecipeContext, recipe_resolver::RecipeResolver, scope::Scope, search::Search,
     search_config::SearchConfig, search_error::SearchError, set::Set, setting::Setting,
@@ -116,6 +118,7 @@ mod assignment_resolver;
 mod ast;
 mod attribute;
 mod binding;
+mod cache;
 mod color;
 mod color_display;
 mod command_ext;
@@ -135,6 +138,7 @@ mod enclosure;
 mod error;
 mod evaluator;
 mod expression;
+mod expression_walker;
 mod fragment;
 mod function;
 mod function_context;

src/node.rs

@@ -281,7 +281,10 @@ impl<'src> Node<'src> for Set<'src> {
           set.push_mut(Tree::string(&argument.cooked));
         }
       }
-      Setting::DotenvFilename(value) | Setting::DotenvPath(value) | Setting::Tempdir(value) => {
+      Setting::CacheFilename(value)
+      | Setting::DotenvFilename(value)
+      | Setting::DotenvPath(value)
+      | Setting::Tempdir(value) => {
         set.push_mut(Tree::string(value));
       }
     }

src/parser.rs

@@ -864,6 +864,7 @@ impl<'run, 'src> Parser<'run, 'src> {
     self.expect(ColonEquals)?;
 
     let set_value = match keyword {
+      Keyword::CacheFilename => Some(Setting::CacheFilename(self.parse_string_literal()?.cooked)),
       Keyword::DotenvFilename => Some(Setting::DotenvFilename(self.parse_string_literal()?.cooked)),
       Keyword::DotenvPath => Some(Setting::DotenvPath(self.parse_string_literal()?.cooked)),
       Keyword::Shell => Some(Setting::Shell(self.parse_shell()?)),