try and get tests working...

Author: ratmice

src/lex.rs

@@ -80,8 +80,22 @@ pub enum LexToken {
     #[token = ")"]
     RParen,
 
-    // Name ↔ Name
-    #[regex = r"[a-zA-Z][_a-zA-Z0-9]*"]
+
+    // Ideally we would have:
+    //   // Name ↔ Name
+    //   #[regex = r"[a-zA-Z][_a-zA-Z0-9]*"]
+    //   Name,
+    //
+    // as well as
+    //
+    //   // FancyNameUnicode ↔ FancyNameAscii
+    //   #[regex = r"[a-zA-Z ... \p{Greek} ...]"]
+    //   FancyNameUnicode,
+    //
+    // But these regular expressions overlap, and its ambiguous
+    // which one a merely ascii string would match
+
+    #[regex = r"[a-zA-Z\p{Greek}\x{1d49c}-\x{1d59f}\x{2100}-\x{214f}][_a-zA-Z0-9\x{207f}-\x{2089}\x{2090}-\x{209c}\x{1d62}-\x{1d6a}]*"]
     Name,
 
     // Since this uses Coptic letters for keywords all greek letters can be used as variable names.
@@ -111,8 +125,6 @@ pub enum LexToken {
     // FancyNameAscii ↔ FancyNameUnicode
     #[regex = r"[\\][a-zA-Z][_a-zA-Z0-9]*"]
     FancyNameAscii,
-    #[regex = r"[a-zA-Z\p{Greek}\x{1d49c}-\x{1d59f}\x{2100}-\x{214f}][_a-zA-Z0-9\x{207f}-\x{2089}\x{2090}-\x{209c}\x{1d62}-\x{1d6a}]*"]
-    FancyNameUnicode,
 
     #[token = ":"]
     Colon,

src/main.rs

@@ -122,7 +122,9 @@ fn bad_unicode() -> () {
     ];
 
     for s in invalid_source.iter() {
-        match parser::propParser::new().parse(token_wrap::Tokens::from_string(s)) {
+        let tokens = token_wrap::Tokens::from_string(s);
+        let tokens = tokens.map(|x| { println!("{:?}", x); x});
+        match parser::propParser::new().parse(tokens) {
             Ok(_) => panic!(format!("accepted '{}'", s)),
             Err(e) => println!("got an expected error: {:?}", e),
         }
@@ -174,7 +176,6 @@ fn bad_ascii() -> Result<(), &'static str> {
     }
 }
 
-
 fn from_rowan<'a>(s: &'a str) -> Result<(), MainError> {
     let tokens = rowan_token::Tokens::from_string(&s);
     let mut builder = rowan::GreenNodeBuilder::new();

src/rowan_prop.lalrpop

@@ -6,7 +6,6 @@ use crate::rowan_token::TokenWrap;
 use TokenWrap::Token;
 grammar<'a>(gb: &mut GreenNodeBuilder<'static>);
 
-
 extern {
   type Location = usize;
   type Error = LexicalError;
@@ -32,14 +31,12 @@ extern {
 	")" => Token{token: LexToken::RParen, string: <SmolStr>},
 	Name => Token{token: LexToken::Name, string: <SmolStr>},
 	FancyNameAscii => Token{token: LexToken::FancyNameAscii, string: <SmolStr>},
-	FancyNameUnicode => Token{token: LexToken::FancyNameUnicode, string: <SmolStr>},
   }
 }
 
 name: (LexToken, SmolStr) = {
   Name => (LexToken::Name.into(), <>),
   FancyNameAscii => (LexToken::FancyNameAscii.into(), <>),
-  FancyNameUnicode => (LexToken::FancyNameUnicode.into(), <>),
 }
 
 pub prop = Semi<Binding>;
@@ -112,5 +109,6 @@ BinaryProp: Prop = {
 Term: Prop = {
   "⊤" => Prop::True,
   "(" <p:Prop> ")" => p,
+  <n:name> => Prop::Var(n.1.into()),
 };
 

src/rowan_token.rs

@@ -66,19 +66,29 @@ impl<'a> Iterator for Tokens<'a> {
     }
 }
 
+
+#[cfg(test)]
+use crate::{error, lex, test_util, rowan_parser};
+
 #[test]
 fn rowan_lex() -> Result<(), error::MainError> {
-    let s = "X := X";
-    let lexer = token_wrap::TokensRowan::from_string(&s);
+    let s = "trivial ≔ ⊤; X ≔ ⊤; Y := Z;";
+    test_util::expect_success(test_util::do_test(&[s]))?;
+
+    let tokens = Tokens::from_string(s);
+    let tokens = tokens.map(|x| { println!("{:?}", x); x});
+
     let mut builder = rowan::GreenNodeBuilder::new();
 
     builder.start_node(lex::LexToken::Root.into());
-    let parse_result = rowan_parser::propParser::new().parse(&mut builder, tokens)?;
-    /*    for thing in lexer {
-            let checkpoint = self.builder.checkpoint();
-            println!("{:?}", thing);
+    let parse_result = rowan_parser::propParser::new().parse(&mut builder, tokens);
+    match parse_result {
+        Ok(_) => (),
+        Err(e) => {
+            println!("{:?}", e);
+            return Err(error::MainError::SomethingWentAwryAndStuffWasPrinted);
         }
-    */
+    }
     builder.finish_node();
     Ok(())
 }

src/test_util.rs

@@ -1,7 +1,5 @@
-use crate::codespan;
 use crate::error::*;
-use crate::lex;
-use crate::parser;
+use crate::{codespan, parser, token_wrap};
 use codespan_reporting::term;
 use codespan_reporting::term::termcolor::{ColorChoice, StandardStream};
 
@@ -12,7 +10,10 @@ pub fn do_test<'a>(sources: &[&'a str]) -> Result<(), Vec<(&'a str, Error<'a>)>>
         .map(|(index, s)| {
             (
                 index,
-                parser::propParser::new().parse(lex::Tokens::from_string(s)),
+                { let tokens = token_wrap::Tokens::from_string(s);
+                  let tokens = tokens.map(|x| { println!("{:?}", x); x});
+                  parser::propParser::new().parse(tokens)
+                }
             )
         })
         .partition(|(_, r)| r.is_ok());

src/token_wrap.rs

@@ -64,7 +64,6 @@ impl<'a> Iterator for Tokens<'a> {
                 LexToken::LexError => break Err(LexicalError(range)),
                 LexToken::Name => break ok(Token::Name(lex.slice())),
                 LexToken::FancyNameAscii => break ok(Token::Name(lex.slice())),
-                LexToken::FancyNameUnicode => break ok(Token::Name(lex.slice())),
                 // And the rest are all unary members
                 LexToken::Dot => break ok(Token::Dot),
                 LexToken::Abs => break ok(Token::Abs),