Allow arbitrary expressions as default arguments (#400)

GRAMMAR.md

@@ -63,15 +63,15 @@ value         : NAME '(' arguments? ')'
               | RAW_STRING
               | BACKTICK
               | NAME
+              | '(' expression ')'
 
 arguments     : expression ',' arguments
               | expression ','?
 
 recipe        : '@'? NAME parameter* ('+' parameter)? ':' dependencies? body?
 
 parameter     : NAME
-              | NAME '=' STRING
-              | NAME '=' RAW_STRING
+              | NAME '=' value
 
 dependencies  : NAME+
 

README.adoc

@@ -480,7 +480,9 @@ cd my-awesome-project && make
 Parameters may have default values:
 
 ```make
-test target tests='all':
+default = 'all'
+
+test target tests=default:
     @echo 'Testing {{target}}:{{tests}}...'
     ./test --tests {{tests}} {{target}}
 ```
@@ -501,6 +503,15 @@ Testing server:unit...
 ./test --tests unit server
 ```
 
+Default values may be arbitrary expressions, but concatenations must be parenthesized:
+
+```make
+arch = "wasm"
+
+test triple=(arch + "-unknown-unknown"):
+  ./test {{triple}}
+```
+
 The last parameter of a recipe may be variadic, indicated with a `+` before the argument name:
 
 ```make

src/alias.rs

@@ -1,5 +1,6 @@
 use crate::common::*;
 
+#[derive(Debug)]
 pub struct Alias<'a> {
   pub name: &'a str,
   pub target: &'a str,

src/assignment_evaluator.rs

@@ -83,7 +83,7 @@ impl<'a, 'b> AssignmentEvaluator<'a, 'b> {
     Ok(())
   }
 
-  fn evaluate_expression(
+  pub fn evaluate_expression(
     &mut self,
     expression: &Expression<'a>,
     arguments: &BTreeMap<&str, Cow<str>>,
@@ -120,7 +120,7 @@ impl<'a, 'b> AssignmentEvaluator<'a, 'b> {
         };
         evaluate_function(token, name, &context, &call_arguments)
       }
-      Expression::String { ref cooked_string } => Ok(cooked_string.cooked.clone()),
+      Expression::String { ref cooked_string } => Ok(cooked_string.cooked.to_string()),
       Expression::Backtick { raw, ref token } => {
         if self.dry_run {
           Ok(format!("`{}`", raw))
@@ -131,6 +131,7 @@ impl<'a, 'b> AssignmentEvaluator<'a, 'b> {
       Expression::Concatination { ref lhs, ref rhs } => {
         Ok(self.evaluate_expression(lhs, arguments)? + &self.evaluate_expression(rhs, arguments)?)
       }
+      Expression::Group { ref expression } => self.evaluate_expression(&expression, arguments),
     }
   }
 

src/assignment_resolver.rs

@@ -56,7 +56,7 @@ impl<'a: 'b, 'b> AssignmentResolver<'a, 'b> {
   }
 
   fn resolve_expression(&mut self, expression: &Expression<'a>) -> CompilationResult<'a, ()> {
-    match *expression {
+    match expression {
       Expression::Variable { name, ref token } => {
         if self.evaluated.contains(name) {
           return Ok(());
@@ -83,6 +83,7 @@ impl<'a: 'b, 'b> AssignmentResolver<'a, 'b> {
         self.resolve_expression(rhs)?;
       }
       Expression::String { .. } | Expression::Backtick { .. } => {}
+      Expression::Group { expression } => self.resolve_expression(expression)?,
     }
     Ok(())
   }

src/cooked_string.rs

@@ -3,7 +3,7 @@ use crate::common::*;
 #[derive(PartialEq, Debug)]
 pub struct CookedString<'a> {
   pub raw: &'a str,
-  pub cooked: String,
+  pub cooked: Cow<'a, str>,
 }
 
 impl<'a> CookedString<'a> {
@@ -12,7 +12,7 @@ impl<'a> CookedString<'a> {
 
     if let TokenKind::RawString = token.kind {
       Ok(CookedString {
-        cooked: raw.to_string(),
+        cooked: Cow::Borrowed(raw),
         raw,
       })
     } else if let TokenKind::StringToken = token.kind {
@@ -41,11 +41,23 @@ impl<'a> CookedString<'a> {
         }
         cooked.push(c);
       }
-      Ok(CookedString { raw, cooked })
+      Ok(CookedString {
+        raw,
+        cooked: Cow::Owned(cooked),
+      })
     } else {
       Err(token.error(CompilationErrorKind::Internal {
         message: "cook_string() called on non-string token".to_string(),
       }))
     }
   }
 }
+
+impl<'a> Display for CookedString<'a> {
+  fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    match self.cooked {
+      Cow::Borrowed(raw) => write!(f, "'{}'", raw),
+      Cow::Owned(_) => write!(f, "\"{}\"", self.raw),
+    }
+  }
+}

src/expression.rs

@@ -22,6 +22,9 @@ pub enum Expression<'a> {
     name: &'a str,
     token: Token<'a>,
   },
+  Group {
+    expression: Box<Expression<'a>>,
+  },
 }
 
 impl<'a> Expression<'a> {
@@ -39,7 +42,7 @@ impl<'a> Display for Expression<'a> {
     match *self {
       Expression::Backtick { raw, .. } => write!(f, "`{}`", raw)?,
       Expression::Concatination { ref lhs, ref rhs } => write!(f, "{} + {}", lhs, rhs)?,
-      Expression::String { ref cooked_string } => write!(f, "\"{}\"", cooked_string.raw)?,
+      Expression::String { ref cooked_string } => write!(f, "{}", cooked_string)?,
       Expression::Variable { name, .. } => write!(f, "{}", name)?,
       Expression::Call {
         name,
@@ -56,6 +59,7 @@ impl<'a> Display for Expression<'a> {
         }
         write!(f, ")")?;
       }
+      Expression::Group { ref expression } => write!(f, "({})", expression)?,
     }
     Ok(())
   }
@@ -71,15 +75,19 @@ impl<'a> Iterator for Variables<'a> {
   fn next(&mut self) -> Option<&'a Token<'a>> {
     match self.stack.pop() {
       None
-      | Some(&Expression::String { .. })
-      | Some(&Expression::Backtick { .. })
-      | Some(&Expression::Call { .. }) => None,
-      Some(&Expression::Variable { ref token, .. }) => Some(token),
-      Some(&Expression::Concatination { ref lhs, ref rhs }) => {
+      | Some(Expression::String { .. })
+      | Some(Expression::Backtick { .. })
+      | Some(Expression::Call { .. }) => None,
+      Some(Expression::Variable { token, .. }) => Some(token),
+      Some(Expression::Concatination { lhs, rhs }) => {
         self.stack.push(lhs);
         self.stack.push(rhs);
         self.next()
       }
+      Some(Expression::Group { expression }) => {
+        self.stack.push(expression);
+        self.next()
+      }
     }
   }
 }
@@ -94,19 +102,21 @@ impl<'a> Iterator for Functions<'a> {
   fn next(&mut self) -> Option<Self::Item> {
     match self.stack.pop() {
       None
-      | Some(&Expression::String { .. })
-      | Some(&Expression::Backtick { .. })
-      | Some(&Expression::Variable { .. }) => None,
-      Some(&Expression::Call {
-        ref token,
-        ref arguments,
-        ..
+      | Some(Expression::String { .. })
+      | Some(Expression::Backtick { .. })
+      | Some(Expression::Variable { .. }) => None,
+      Some(Expression::Call {
+        token, arguments, ..
       }) => Some((token, arguments.len())),
-      Some(&Expression::Concatination { ref lhs, ref rhs }) => {
+      Some(Expression::Concatination { lhs, rhs }) => {
         self.stack.push(lhs);
         self.stack.push(rhs);
         self.next()
       }
+      Some(Expression::Group { expression }) => {
+        self.stack.push(expression);
+        self.next()
+      }
     }
   }
 }

src/justfile.rs

@@ -1,5 +1,6 @@
 use crate::common::*;
 
+#[derive(Debug)]
 pub struct Justfile<'a> {
   pub recipes: BTreeMap<&'a str, Recipe<'a>>,
   pub assignments: BTreeMap<&'a str, Expression<'a>>,

src/lexer.rs

@@ -617,6 +617,12 @@ c: b
     "#$#$.",
   }
 
+  summary_test! {
+    multiple_recipes,
+    "a:\n  foo\nb:",
+    "N:$>^_$<N:.",
+  }
+
   error_test! {
     name:  tokenize_space_then_tab,
     input: "a:

src/parameter.rs

@@ -2,7 +2,7 @@ use crate::common::*;
 
 #[derive(PartialEq, Debug)]
 pub struct Parameter<'a> {
-  pub default: Option<String>,
+  pub default: Option<Expression<'a>>,
   pub name: &'a str,
   pub token: Token<'a>,
   pub variadic: bool,
@@ -16,11 +16,7 @@ impl<'a> Display for Parameter<'a> {
     }
     write!(f, "{}", color.parameter().paint(self.name))?;
     if let Some(ref default) = self.default {
-      let escaped = default
-        .chars()
-        .flat_map(char::escape_default)
-        .collect::<String>();;
-      write!(f, r#"='{}'"#, color.string().paint(&escaped))?;
+      write!(f, "={}", color.string().paint(&default.to_string()))?;
     }
     Ok(())
   }