1 files changed, 33 insertions, 5 deletions
diff --git a/src/stages/semantic_tokens.rs b/src/stages/semantic_tokens.rs
index dfbea1a..bdbc0f9 100644
--- a/src/stages/semantic_tokens.rs
+++ b/src/stages/semantic_tokens.rs
@@ -17,10 +17,11 @@ pub struct ArgumentDefinition {
     pub variant: ArgumentType,
 }
 
-#[derive(PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 pub enum ArgumentType {
     Integer,
     Block,
+    String,
 }
 
 impl std::fmt::Display for ArgumentType {
@@ -28,6 +29,7 @@ impl std::fmt::Display for ArgumentType {
         match self {
             ArgumentType::Integer => write!(f, "an integer"),
             ArgumentType::Block => write!(f, "a block"),
+            ArgumentType::String => write!(f, "a string"),
         }
     }
 }
@@ -35,6 +37,7 @@ impl std::fmt::Display for ArgumentType {
 pub enum MacroDefinitionBody {
     Integer(Tracked<IntegerToken>),
     Block(Vec<Tracked<BlockToken>>),
+    String(Tracked<StringToken>),
     Invocation(Tracked<Invocation>),
 }
 
@@ -68,15 +71,20 @@ pub enum BlockToken {
     Invocation(Invocation),
 }
 
+pub enum StringToken {
+    StringLiteral(StringLiteral),
+    Invocation(Invocation),
+}
+
 pub struct Invocation {
     pub name: String,
     pub arguments: Vec<Tracked<InvocationArgument>>,
 }
 
 pub enum InvocationArgument {
-    String(StringLiteral),
     IntegerToken(IntegerToken),
     BlockToken(BlockToken),
+    StringToken(StringToken),
     Invocation(Invocation),
 }
 
@@ -88,6 +96,7 @@ pub enum SemanticError {
 
     ExpectedInteger(SemanticLocation),
     ExpectedBlock(SemanticLocation),
+    ExpectedString(SemanticLocation),
 
     InvalidArgumentDefinition,
     InvalidInvocationArgument,
@@ -153,9 +162,11 @@ fn report_semantic_error(error: &Tracked<SemanticError>, source_code: &str) {
             &format!("An integer value was expected {location}"),
         SemanticError::ExpectedBlock(location) =>
             &format!("A block value was expected {location}"),
+        SemanticError::ExpectedString(location) =>
+            &format!("A string value was expected {location}"),
 
         SemanticError::InvalidArgumentDefinition =>
-            "Argument definitions must be in the form 'name' or '{{name}}'",
+            "Argument definitions must be in the form name, {name}, or \"name\"",
         SemanticError::InvalidInvocationArgument =>
             "This token cannot be used in an invocation argument",
 
@@ -185,6 +196,9 @@ pub fn print_semantic_token(i: usize, token: &SemanticToken) {
                 MacroDefinitionBody::Block(tokens) => {
                     print_block(i+1, tokens);
                 }
+                MacroDefinitionBody::String(string) => {
+                    print_string_token(i+1, string);
+                }
                 MacroDefinitionBody::Invocation(invocation) => {
                     print_invocation(i+1, invocation);
                 }
@@ -202,6 +216,9 @@ fn print_argument_definition(i: usize, argument: &ArgumentDefinition) {
         ArgumentType::Block => {
             indent!(i, "Argument({}, block)", argument.name)
         }
+        ArgumentType::String => {
+            indent!(i, "Argument({}, string)", argument.name)
+        }
     }
 }
 
@@ -249,8 +266,8 @@ fn print_invocation(i: usize, invocation: &Invocation) {
 
 fn print_invocation_argument(i: usize, argument: &InvocationArgument) {
     match &argument {
-        InvocationArgument::String(string_literal) => {
-            indent!(i, "String({string_literal})")
+        InvocationArgument::StringToken(string) => {
+            print_string_token(i, string)
         }
         InvocationArgument::IntegerToken(integer) => {
             print_integer_token(i, integer)
@@ -278,6 +295,17 @@ fn print_integer_token(i: usize, integer: &IntegerToken) {
     }
 }
 
+fn print_string_token(i: usize, string: &StringToken) {
+    match string {
+        StringToken::StringLiteral(string_literal) => {
+            indent!(i, "String({string_literal})")
+        }
+        StringToken::Invocation(invocation) => {
+            print_invocation(i, invocation)
+        }
+    }
+}
+
 fn print_expression(i: usize, expression: &Expression) {
     indent!(i, "Expression");
     for token in &expression.tokens {