Add guard sigil ? (#2547)

Author: casey

README.md

@@ -1617,24 +1617,61 @@ Use `{{{{` to include a literal `{{` in a format string:
 foo := f'I {{{{LOVE} curly braces!'
 ```
 
-### Ignoring Errors
+### Sigils
 
-Normally, if a command returns a non-zero exit status, execution will stop. To
-continue execution after a command, even if it fails, prefix the command with
-`-`:
+Commands in linewise recipes may be prefixed with any combination of the sigils
+`-`, `@`, and `?`.
+
+The `@` sigil toggles command echoing:
 
 ```just
 foo:
-  -cat foo
-  echo 'Done!'
+  @echo "This line won't be echoed!"
+  echo "This line will be echoed!"
+
+@bar:
+  @echo "This line will be echoed!"
+  echo "This line won't be echoed!"
+```
+
+The `-` sigil cause recipe execution to continue even if the command returns a
+nonzero exit status:
+
+```just
+# execution will continue, even if bar doesn't exist
+foo:
+  -rmdir bar
+  mkdir bar
+  echo 'so much good stuff' > bar/stuff.txt
+```
+
+The `?` sigil<sup>master</sup> causes the current recipe to stop executing if
+the command exits with status code `1`, however execution of other recipes will
+continue. Exit status `0` causes the current recipe to continue execution as
+normal. All other exit codes are reserved and should not be used, as they may
+be given meaning in a future version of `just`.
+
+If the `guards` setting is unset or false, `?` sigils are ignored and instead
+treated as part of the command.
+
+```just
+set guards
+
+@foo: bar
+  echo FOO
+
+@bar:
+  ?[[ -f baz ]]
+  echo BAR
 ```
 
 ```console
 $ just foo
-cat foo
-cat: foo: No such file or directory
-echo 'Done!'
-Done!
+FOO
+$ touch baz
+$ just foo
+BAR
+FOO
 ```
 
 ### Functions

src/analyzer.rs

@@ -177,6 +177,23 @@ impl<'run, 'src> Analyzer<'run, 'src> {
       {
         deduplicated_recipes.insert(recipe.clone());
       }
+
+      if !recipe.is_script() {
+        for line in &recipe.body {
+          let sigils = line.sigils(&settings);
+
+          if sigils.contains(&Sigil::Guard) && sigils.contains(&Sigil::Infallible) {
+            let Fragment::Text { token } = line.fragments.first().unwrap() else {
+              unreachable!();
+            };
+            return Err(
+              token
+                .error(CompileErrorKind::GuardAndInfallibleSigil)
+                .into(),
+            );
+          }
+        }
+      }
     }
 
     let recipes = RecipeResolver::resolve_recipes(

src/compile_error.rs

@@ -195,6 +195,10 @@ impl Display for CompileError<'_> {
         Count("argument", *found),
         expected.display(),
       ),
+      GuardAndInfallibleSigil => write!(
+        f,
+        "The guard `?` and infallible `-` sigils may not be used together"
+      ),
       Include => write!(
         f,
         "The `!include` directive has been stabilized as `import`"

src/compile_error_kind.rs

@@ -83,6 +83,7 @@ pub(crate) enum CompileErrorKind<'src> {
     found: usize,
     expected: RangeInclusive<usize>,
   },
+  GuardAndInfallibleSigil,
   Include,
   InconsistentLeadingWhitespace {
     expected: &'src str,

src/error.rs

@@ -120,6 +120,11 @@ pub(crate) enum Error<'src> {
   GetConfirmation {
     io_error: io::Error,
   },
+  GuardCode {
+    recipe: &'src str,
+    line_number: usize,
+    code: i32,
+  },
   Homedir,
   InitExists {
     justfile: PathBuf,
@@ -353,10 +358,6 @@ impl ColorDisplay for Error<'_> {
     write!(f, "{error}: {message}")?;
 
     match self {
-      Const { const_error } => write!(
-        f,
-        "{const_error}",
-      )?,
       AmbiguousModuleFile { module, found } => write!(
         f,
         "Found multiple source files for module `{module}`: {}",
@@ -469,6 +470,10 @@ impl ColorDisplay for Error<'_> {
       }
       Compile { compile_error } => Display::fmt(compile_error, f)?,
       Config { config_error } => Display::fmt(config_error, f)?,
+      Const { const_error } => write!(
+        f,
+        "{const_error}",
+      )?,
       Cygpath {
         recipe,
         output_error,
@@ -574,6 +579,16 @@ impl ColorDisplay for Error<'_> {
       GetConfirmation { io_error } => {
         write!(f, "Failed to read confirmation from stdin: {io_error}")?;
       }
+      GuardCode {
+        recipe,
+        line_number,
+        code,
+      } => {
+        write!(
+          f,
+          "Guard line in recipe `{recipe}` on line {line_number} returned reserved exit code {code}",
+        )?;
+      }
       Homedir => {
         write!(f, "Failed to get homedir")?;
       }

src/evaluator.rs

@@ -103,6 +103,9 @@ impl<'src, 'run> Evaluator<'src, 'run> {
         Setting::Fallback(value) => {
           settings.fallback = value;
         }
+        Setting::Guards(guards) => {
+          settings.guards = guards;
+        }
         Setting::IgnoreComments(value) => {
           settings.ignore_comments = value;
         }

src/keyword.rs

@@ -17,6 +17,7 @@ pub(crate) enum Keyword {
   F,
   Fallback,
   False,
+  Guards,
   If,
   IgnoreComments,
   Import,

src/lib.rs

@@ -82,6 +82,7 @@ pub(crate) use {
     settings::Settings,
     shebang::Shebang,
     show_whitespace::ShowWhitespace,
+    sigil::Sigil,
     signal::Signal,
     signal_handler::SignalHandler,
     source::Source,
@@ -268,6 +269,7 @@ mod setting;
 mod settings;
 mod shebang;
 mod show_whitespace;
+mod sigil;
 mod signal;
 mod signal_handler;
 #[cfg(unix)]

src/line.rs

@@ -18,6 +18,27 @@ impl Line<'_> {
     }
   }
 
+  pub(crate) fn sigils(&self, settings: &Settings) -> BTreeSet<Sigil> {
+    let mut sigils = BTreeSet::new();
+
+    if let Some(first) = self.first() {
+      for c in first.chars() {
+        let sigil = match c {
+          '-' => Sigil::Infallible,
+          '?' if settings.guards => Sigil::Guard,
+          '@' => Sigil::Quiet,
+          _ => break,
+        };
+
+        if !sigils.insert(sigil) {
+          break;
+        }
+      }
+    }
+
+    sigils
+  }
+
   pub(crate) fn is_comment(&self) -> bool {
     self.first().is_some_and(|text| text.starts_with('#'))
   }
@@ -33,18 +54,6 @@ impl Line<'_> {
     self.fragments.is_empty()
   }
 
-  pub(crate) fn is_infallible(&self) -> bool {
-    self
-      .first()
-      .is_some_and(|text| text.starts_with('-') || text.starts_with("@-"))
-  }
-
-  pub(crate) fn is_quiet(&self) -> bool {
-    self
-      .first()
-      .is_some_and(|text| text.starts_with('@') || text.starts_with("-@"))
-  }
-
   pub(crate) fn is_shebang(&self) -> bool {
     self.first().is_some_and(|text| text.starts_with("#!"))
   }

src/node.rs

@@ -317,12 +317,13 @@ impl<'src> Node<'src> for Set<'src> {
       | Setting::DotenvRequired(value)
       | Setting::Export(value)
       | Setting::Fallback(value)
+      | Setting::Guards(value)
+      | Setting::IgnoreComments(value)
       | Setting::NoExitMessage(value)
       | Setting::PositionalArguments(value)
       | Setting::Quiet(value)
       | Setting::Unstable(value)
-      | Setting::WindowsPowerShell(value)
-      | Setting::IgnoreComments(value) => {
+      | Setting::WindowsPowerShell(value) => {
         set.push_mut(value.to_string());
       }
       Setting::DotenvFilename(value)