Adding a few unit tests

trilogy-parser/src/syntax/handler.rs

···
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    test_parse!(handler_given: "given hello(1)" => Handler::parse => "(Handler::Given (GivenHandler (RuleHead _ [_]) ()))");
+    test_parse!(handler_when: "when 'NAN resume 5" => Handler::parse => "(Handler::When (WhenHandler _ _ _ _))");
+    test_parse!(handler_else: "else n resume 5" => Handler::parse => "(Handler::Else (ElseHandler _ _ _))");
+}

trilogy-parser/src/syntax/handler_body.rs

···
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    test_parse!(handlerbody_block: "{ let x = 5; resume x }" => HandlerBody::parse => "(HandlerBody::Block (Block _))");
+    test_parse!(handlerbody_expr: "let y = 5, resume y" => HandlerBody::parse => "(HandlerBody::Expression _)");
+}

trilogy-parser/src/syntax/handler_strategy.rs

···
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    test_parse!(handler_strategy_yield: "yield" => HandlerStrategy::parse => "(HandlerStrategy::Yield _)");
+    test_parse!(handler_strategy_cancel: "cancel" => HandlerStrategy::parse => "(HandlerStrategy::Cancel _)");
+    test_parse!(handler_strategy_invert: "invert" => HandlerStrategy::parse => "(HandlerStrategy::Invert _)");
+    test_parse!(handler_strategy_resume: "resume" => HandlerStrategy::parse => "(HandlerStrategy::Resume _)");
+}

trilogy-parser/src/syntax/identifier.rs

···
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    test_parse!(identifier_normal: "hello" => Identifier::parse => "(Identifier)");
+    test_parse!(identifier_underscored: "_hello" => Identifier::parse => "(Identifier)");
+    test_parse!(identifier_numbers: "hello123" => Identifier::parse => "(Identifier)");
+    test_parse_error!(identifier_keyword: "for" => Identifier::parse);
+
+    test_parse!(identifiereq_normal: "hello=" => Identifier::parse_eq => "(Identifier)");
+    test_parse!(identifiereq_underscored: "_hello=" => Identifier::parse_eq => "(Identifier)");
+    test_parse!(identifiereq_numbers: "hello123=" => Identifier::parse_eq => "(Identifier)");
+    test_parse_error!(identifiereq_keyword: "for=" => Identifier::parse_eq);
+}

trilogy-parser/src/test.rs

···
     ($name:ident : $src:literal |$parser:ident| $parse:expr => $sexp:literal) => {
         #[test]
         fn $name() {
-            use crate::{Parser, PrettyPrintSExpr};
-            use trilogy_scanner::TokenType::*;
+            use crate::PrettyPrintSExpr as _;
             let scanner = trilogy_scanner::Scanner::new($src);
-            let mut $parser = Parser::new(scanner);
-            $parser.expect(StartOfFile).unwrap();
+            let mut $parser = crate::Parser::new(scanner);
+            $parser.expect(trilogy_scanner::TokenType::StartOfFile).unwrap();
             let parse = $parse;
             let mut allocator = pretty::RcAllocator;
             let sexpr = format!("{}", parse.pretty_print_sexpr(&mut allocator).pretty(100));
             let parsed = crate::test::normalize_sexpr(&sexpr);
             let expected = crate::test::normalize_sexpr($sexp);
-            $parser.expect(EndOfFile).unwrap();
+            $parser.expect(trilogy_scanner::TokenType::EndOfFile).unwrap();
             assert!($parser.errors.is_empty());
             assert_eq!(parsed.split_ascii_whitespace().collect::<crate::test::SExpr>(), expected.split_ascii_whitespace().collect::<crate::test::SExpr>());
         }
···
     ($name:ident : $src:literal |$parser:ident| $parse:expr => $error:literal) => {
         #[test]
         fn $name() {
-            use crate::Parser;
-            use trilogy_scanner::TokenType::*;
             let scanner = trilogy_scanner::Scanner::new($src);
-            let mut $parser = Parser::new(scanner);
-            $parser.expect(StartOfFile).unwrap();
+            let mut $parser = crate::Parser::new(scanner);
+            $parser.expect(trilogy_scanner::TokenType::StartOfFile).unwrap();
             let _ = $parse;
             assert_eq!($parser.errors.first().expect("parse should have reported an error message").message(), $error);
         }
···
     ($name:ident : $src:literal |$parser:ident| $parse:expr) => {
         #[test]
         fn $name() {
-            use crate::Parser;
-            use trilogy_scanner::TokenType::*;
             let scanner = trilogy_scanner::Scanner::new($src);
-            let mut $parser = Parser::new(scanner);
-            $parser.expect(StartOfFile).unwrap();
+            let mut $parser = crate::Parser::new(scanner);
+            $parser.expect(trilogy_scanner::TokenType::StartOfFile).unwrap();
             let result = $parse;
             if result.is_ok() && $parser.errors.is_empty() {
-                assert!($parser.expect(EndOfFile).is_err());
+                assert!($parser.expect(trilogy_scanner::TokenType::EndOfFile).is_err());
             } else {
                 assert!(!$parser.errors.is_empty());
             }
···
     ($name:ident : $src:literal |$parser:ident| $parse:expr => $sexp:literal) => {
         #[test]
         fn $name() {
-            use crate::{Parser, PrettyPrintSExpr};
+            use crate::PrettyPrintSExpr as _;
             let scanner = trilogy_scanner::Scanner::new($src);
-            let mut $parser = Parser::new(scanner);
+            let mut $parser = crate::Parser::new(scanner);
             let parse = $parse;
             let mut allocator = pretty::RcAllocator;
             let sexpr = format!("{}", parse.pretty_print_sexpr(&mut allocator).pretty(100));
···
     ($name:ident : $src:literal |$parser:ident| $parse:expr => $error:literal) => {
         #[test]
         fn $name() {
-            use crate::Parser;
             let scanner = trilogy_scanner::Scanner::new($src);
-            let mut $parser = Parser::new(scanner);
+            let mut $parser = crate::Parser::new(scanner);
             $parse;
             assert_eq!($parser.errors.first().expect("parse should have reported an error message").message(), $error);
         }
···
     ($name:ident : $src:literal |$parser:ident| $parse:expr) => {
         #[test]
         fn $name() {
-            use crate::Parser;
             use trilogy_scanner::TokenType::*;
             let scanner = trilogy_scanner::Scanner::new($src);
-            let mut $parser = Parser::new(scanner);
+            let mut $parser = crate::Parser::new(scanner);
             $parse;
             assert!(!$parser.errors.is_empty());
         }

trilogy-scanner/src/scanner.rs

···
 
     fn identifier_or_keyword(&mut self, starts_with: char) -> Token {
         let identifier = self.identifier(starts_with.into());
-        if self.expect('=').is_some() {
-            return self.make_token(IdentifierEq).with_value(identifier);
-        }
-        self.make_token(Identifier)
-            .with_value(identifier)
+        let token = if self.expect('=').is_some() {
+            self.make_token(IdentifierEq).with_value(identifier)
+        } else {
+            self.make_token(Identifier).with_value(identifier)
+        };
+
+        token
             .resolve_keywords()
+            .unwrap_or_else(|err| self.make_error(err))
     }
 
     fn unicode_escape_sequence(&mut self) -> Option<char> {

trilogy-scanner/src/test.rs

···
     };
 }
 
+#[test]
+fn identifier_eq_keyword_error() {
+    let tokens = Scanner::new("for=")
+        .into_iter()
+        .map(|token| token.token_type)
+        .collect::<Vec<_>>();
+    assert_eq!(tokens.as_slice(), [StartOfFile, Error, EndOfFile]);
+}
+
 test_tokenize!(discard => "_" = [Discard]);
 test_tokenize!(underscore_ident => "_abc" = [Identifier]);
 

trilogy-scanner/src/token.rs

···
         self
     }
 
-    pub(crate) fn resolve_keywords(mut self) -> Self {
-        if self.token_type != TokenType::Identifier {
-            return self;
+    pub(crate) fn resolve_keywords(mut self) -> Result<Self, &'static str> {
+        if self.token_type != TokenType::Identifier && self.token_type != TokenType::IdentifierEq {
+            return Ok(self);
         }
+        let is_eq = self.token_type == TokenType::IdentifierEq;
+
         self.token_type = match self.value.as_ref().unwrap().as_str().unwrap() {
             "_" => TokenType::Discard,
             "and" => TokenType::KwAnd,
···
             "while" => TokenType::KwWhile,
             "with" => TokenType::KwWith,
             "yield" => TokenType::KwYield,
-            _ => TokenType::Identifier,
+            _ => self.token_type,
         };
-        self
+
+        if is_eq && self.token_type != TokenType::IdentifierEq {
+            return Err("cannot use keyword as an assignment function");
+        }
+
+        Ok(self)
     }
 }