fix: parse weird exprs correctly

Author: amaanq

.gitattributes

@@ -1,10 +1,6 @@
-/src/** linguist-vendored
 /examples/* linguist-vendored
 
+src/tree_sitter/* linguist-generated
 src/grammar.json linguist-generated
 src/node-types.json linguist-generated
 src/parser.c linguist-generated
-
-src/grammar.json -diff
-src/node-types.json -diff
-src/parser.c -diff

.gitignore

@@ -5,4 +5,5 @@ build
 package-lock.json
 /examples
 !examples/ast.rs
+!examples/weird-exprs.rs
 /target/

examples/weird-exprs.rs

@@ -0,0 +1,260 @@
+// run-pass
+
+#![feature(generators)]
+
+#![allow(non_camel_case_types)]
+#![allow(dead_code)]
+#![allow(redundant_semicolons)]
+#![allow(unreachable_code)]
+#![allow(unused_braces, unused_must_use, unused_parens)]
+#![allow(uncommon_codepoints, confusable_idents)]
+#![allow(unused_imports)]
+#![allow(unreachable_patterns)]
+
+#![recursion_limit = "256"]
+
+extern crate core;
+use std::cell::Cell;
+use std::mem::swap;
+use std::ops::Deref;
+
+// Just a grab bag of stuff that you wouldn't want to actually write.
+
+fn strange() -> bool { let _x: bool = return true; }
+
+fn funny() {
+    fn f(_x: ()) { }
+    f(return);
+}
+
+fn what() {
+    fn the(x: &Cell<bool>) {
+        return while !x.get() { x.set(true); };
+    }
+    let i = &Cell::new(false);
+    let dont = {||the(i)};
+    dont();
+    assert!((i.get()));
+}
+
+fn zombiejesus() {
+    loop {
+        while (return) {
+            if (return) {
+                match (return) {
+                    1 => {
+                        if (return) {
+                            return
+                        } else {
+                            return
+                        }
+                    }
+                    _ => { return }
+                };
+            } else if (return) {
+                return;
+            }
+        }
+        if (return) { break; }
+    }
+}
+
+fn notsure() {
+    let mut _x: isize;
+    let mut _y = (_x = 0) == (_x = 0);
+    let mut _z = (_x = 0) < (_x = 0);
+    let _a = (_x += 0) == (_x = 0);
+    let _b = swap(&mut _y, &mut _z) == swap(&mut _y, &mut _z);
+}
+
+fn canttouchthis() -> usize {
+    fn p() -> bool { true }
+    let _a = (assert!((true)) == (assert!(p())));
+    let _c = (assert!((p())) == ());
+    let _b: bool = (println!("{}", 0) == (return 0));
+}
+
+fn angrydome() {
+    loop { if break { } }
+    let mut i = 0;
+    loop { i += 1; if i == 1 { match (continue) { 1 => { }, _ => panic!("wat") } }
+      break; }
+}
+
+fn evil_lincoln() { let _evil: () = println!("lincoln"); }
+
+fn dots() {
+    assert_eq!(String::from(".................................................."),
+               format!("{:?}", .. .. .. .. .. .. .. .. .. .. .. .. ..
+                               .. .. .. .. .. .. .. .. .. .. .. ..));
+}
+
+fn u8(u8: u8) {
+    if u8 != 0u8 {
+        assert_eq!(8u8, {
+            macro_rules! u8 {
+                (u8) => {
+                    mod u8 {
+                        pub fn u8<'u8: 'u8 + 'u8>(u8: &'u8 u8) -> &'u8 u8 {
+                            "u8";
+                            u8
+                        }
+                    }
+                };
+            }
+
+            u8!(u8);
+            let &u8: &u8 = u8::u8(&8u8);
+            ::u8(0u8);
+            u8
+        });
+    }
+}
+
+fn fishy() {
+    assert_eq!(String::from("><>"),
+               String::<>::from::<>("><>").chars::<>().rev::<>().collect::<String>());
+}
+
+fn union() {
+    union union<'union> { union: &'union union<'union>, }
+}
+
+fn special_characters() {
+    let val = !((|(..):(_,_),(|__@_|__)|__)((&*"\\",'🤔')/**/,{})=={&[..=..][..];})//
+    ;
+    assert!(!val);
+}
+
+fn punch_card() -> impl std::fmt::Debug {
+    ..=..=.. ..    .. .. .. ..    .. .. .. ..    .. ..=.. ..
+    ..=.. ..=..    .. .. .. ..    .. .. .. ..    ..=..=..=..
+    ..=.. ..=..    ..=.. ..=..    .. ..=..=..    .. ..=.. ..
+    ..=..=.. ..    ..=.. ..=..    ..=.. .. ..    .. ..=.. ..
+    ..=.. ..=..    ..=.. ..=..    .. ..=.. ..    .. ..=.. ..
+    ..=.. ..=..    ..=.. ..=..    .. .. ..=..    .. ..=.. ..
+    ..=.. ..=..    .. ..=..=..    ..=..=.. ..    .. ..=.. ..
+}
+
+fn r#match() {
+    let val: () = match match match match match () {
+        () => ()
+    } {
+        () => ()
+    } {
+        () => ()
+    } {
+        () => ()
+    } {
+        () => ()
+    };
+    assert_eq!(val, ());
+}
+
+fn i_yield() {
+    static || {
+        yield yield yield yield yield yield yield yield yield;
+    };
+}
+
+fn match_nested_if() {
+    let val = match () {
+        () if if if if true {true} else {false} {true} else {false} {true} else {false} => true,
+        _ => false,
+    };
+    assert!(val);
+}
+
+fn monkey_barrel() {
+    let val: () = ()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=();
+    assert_eq!(val, ());
+}
+
+fn 𝚌𝚘𝚗𝚝𝚒𝚗𝚞𝚎() {
+    type 𝚕𝚘𝚘𝚙 = i32;
+    fn 𝚋𝚛𝚎𝚊𝚔() -> 𝚕𝚘𝚘𝚙 {
+        let 𝚛𝚎𝚝𝚞𝚛𝚗 = 42;
+        return 𝚛𝚎𝚝𝚞𝚛𝚗;
+    }
+    assert_eq!(loop {
+        break 𝚋𝚛𝚎𝚊𝚔 ();
+    }, 42);
+}
+
+fn function() {
+    struct foo;
+    impl Deref for foo {
+        type Target = fn() -> Self;
+        fn deref(&self) -> &Self::Target {
+            &((|| foo) as _)
+        }
+    }
+    let foo = foo () ()() ()()() ()()()() ()()()()();
+}
+
+fn bathroom_stall() {
+    let mut i = 1;
+    matches!(2, _|_|_|_|_|_ if (i+=1) != (i+=1));
+    assert_eq!(i, 13);
+}
+
+fn closure_matching() {
+    let x = |_| Some(1);
+    let (|x| x) = match x(..) {
+        |_| Some(2) => |_| Some(3),
+        |_| _ => unreachable!(),
+    };
+    assert!(matches!(x(..), |_| Some(4)));
+}
+
+fn semisemisemisemisemi() {
+    ;;;;;;; ;;;;;;; ;;;    ;;; ;;
+    ;;      ;;      ;;;;  ;;;; ;;
+    ;;;;;;; ;;;;;   ;; ;;;; ;; ;;
+         ;; ;;      ;;  ;;  ;; ;;
+    ;;;;;;; ;;;;;;; ;;      ;; ;;
+}
+
+fn useful_syntax() {
+    use {{std::{{collections::{{HashMap}}}}}};
+    use ::{{{{core}, {std}}}};
+    use {{::{{core as core2}}}};
+}
+
+fn infcx() {
+    pub mod cx {
+        pub mod cx {
+            pub use super::cx;
+            pub struct Cx;
+        }
+    }
+    let _cx: cx::cx::Cx = cx::cx::cx::cx::cx::Cx;
+}
+
+pub fn main() {
+    strange();
+    funny();
+    what();
+    zombiejesus();
+    notsure();
+    canttouchthis();
+    angrydome();
+    evil_lincoln();
+    dots();
+    u8(8u8);
+    fishy();
+    union();
+    special_characters();
+    punch_card();
+    r#match();
+    i_yield();
+    match_nested_if();
+    monkey_barrel();
+    𝚌𝚘𝚗𝚝𝚒𝚗𝚞𝚎();
+    function();
+    bathroom_stall();
+    closure_matching();
+    semisemisemisemisemi();
+    useful_syntax();
+    infcx();
+}

grammar.js

@@ -778,6 +778,7 @@ module.exports = grammar({
     generic_type: $ => prec(1, seq(
       field('type', choice(
         $._type_identifier,
+        $._reserved_identifier,
         $.scoped_type_identifier,
       )),
       field('type_arguments', $.type_arguments),
@@ -1173,15 +1174,15 @@ module.exports = grammar({
       '}',
     ),
 
-    match_arm: $ => seq(
+    match_arm: $ => prec.right(seq(
       repeat($.attribute_item),
       field('pattern', $.match_pattern),
       '=>',
       choice(
         seq(field('value', $._expression), ','),
         field('value', prec(1, $._expression_ending_with_block)),
       ),
-    ),
+    )),
 
     last_match_arm: $ => seq(
       repeat($.attribute_item),
@@ -1192,7 +1193,7 @@ module.exports = grammar({
     ),
 
     match_pattern: $ => seq(
-      $._pattern,
+      choice($._pattern, alias($.closure_expression, $.closure_pattern)),
       optional(seq('if', field('condition', $._condition))),
     ),
 
@@ -1224,14 +1225,15 @@ module.exports = grammar({
     ),
 
     closure_expression: $ => prec(PREC.closure, seq(
+      optional('static'),
       optional('move'),
       field('parameters', $.closure_parameters),
       choice(
         seq(
           optional(seq('->', field('return_type', $._type))),
           field('body', $.block),
         ),
-        field('body', $._expression),
+        field('body', choice($._expression, '_')),
       ),
     )),
 
@@ -1311,7 +1313,7 @@ module.exports = grammar({
 
     tuple_pattern: $ => seq(
       '(',
-      sepBy(',', $._pattern),
+      sepBy(',', choice($._pattern, $.closure_expression)),
       optional(','),
       ')',
     ),

script/known_failures.txt

@@ -1 +0,0 @@
-examples/tokio/examples/connect.rs