fix labled expressions

crates/libsyntax2/src/grammar/expressions/atom.rs

@@ -62,16 +62,26 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<CompletedMark
                 LOOP_KW => loop_expr(p, Some(m)),
                 FOR_KW => for_expr(p, Some(m)),
                 WHILE_KW => while_expr(p, Some(m)),
+                L_CURLY => block_expr(p, Some(m)),
                 _ => {
+                    // test misplaced_label_err
+                    // fn main() {
+                    //     'loop: impl
+                    // }
                     p.error("expected a loop");
+                    m.complete(p, ERROR);
                     return None;
                 }
             }
         }
 
         MATCH_KW => match_expr(p),
-        UNSAFE_KW if la == L_CURLY => block_expr(p),
+        UNSAFE_KW if la == L_CURLY => {
-        L_CURLY => block_expr(p),
+            let m = p.start();
+            p.bump();
+            block_expr(p, Some(m))
+        },
+        L_CURLY => block_expr(p, None),
         RETURN_KW => return_expr(p),
         CONTINUE_KW => continue_expr(p),
         BREAK_KW => break_expr(p),
@@ -323,11 +333,11 @@ fn match_arm(p: &mut Parser) -> BlockLike {
 // fn foo() {
 //     {};
 //     unsafe {};
+//     'label: {};
 // }
-pub(super) fn block_expr(p: &mut Parser) -> CompletedMarker {
+fn block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
-    assert!(p.at(L_CURLY) || p.at(UNSAFE_KW) && p.nth(1) == L_CURLY);
+    assert!(p.at(L_CURLY));
-    let m = p.start();
+    let m = m.unwrap_or_else(|| p.start());
-    p.eat(UNSAFE_KW);
     block(p);
     m.complete(p, BLOCK_EXPR)
 }

crates/libsyntax2/tests/data/parser/inline/0067_block_expr.rs

@@ -1,4 +1,5 @@
 fn foo() {
     {};
     unsafe {};
+    'label: {};
 }

crates/libsyntax2/tests/data/parser/inline/0067_block_expr.txt

@@ -1,5 +1,5 @@
-ROOT@[0; 36)
+ROOT@[0; 52)
-  FN_DEF@[0; 35)
+  FN_DEF@[0; 51)
     FN_KW@[0; 2)
     WHITESPACE@[2; 3)
     NAME@[3; 6)
@@ -8,7 +8,7 @@ ROOT@[0; 36)
       L_PAREN@[6; 7)
       R_PAREN@[7; 8)
     WHITESPACE@[8; 9)
-    BLOCK@[9; 35)
+    BLOCK@[9; 51)
       L_CURLY@[9; 10)
       WHITESPACE@[10; 15)
       EXPR_STMT@[15; 18)
@@ -26,6 +26,17 @@ ROOT@[0; 36)
             L_CURLY@[30; 31)
             R_CURLY@[31; 32)
         SEMI@[32; 33)
-      WHITESPACE@[33; 34)
+      WHITESPACE@[33; 38)
-      R_CURLY@[34; 35)
+      EXPR_STMT@[38; 49)
-  WHITESPACE@[35; 36)
+        BLOCK_EXPR@[38; 48)
+          LABEL@[38; 45)
+            LIFETIME@[38; 44) "'label"
+            COLON@[44; 45)
+          WHITESPACE@[45; 46)
+          BLOCK@[46; 48)
+            L_CURLY@[46; 47)
+            R_CURLY@[47; 48)
+        SEMI@[48; 49)
+      WHITESPACE@[49; 50)
+      R_CURLY@[50; 51)
+  WHITESPACE@[51; 52)

crates/libsyntax2/tests/data/parser/inline/0108_misplaced_label_err.rs

@@ -0,0 +1,3 @@
+fn main() {
+    'loop: impl
+}

crates/libsyntax2/tests/data/parser/inline/0108_misplaced_label_err.txt

@@ -0,0 +1,28 @@
+ROOT@[0; 30)
+  FN_DEF@[0; 29)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK@[10; 29)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      EXPR_STMT@[16; 22)
+        ERROR@[16; 22)
+          LABEL@[16; 22)
+            LIFETIME@[16; 21) "'loop"
+            COLON@[21; 22)
+            err: `expected a loop`
+            err: `expected SEMI`
+      WHITESPACE@[22; 23)
+      IMPL_ITEM@[23; 27)
+        IMPL_KW@[23; 27)
+        err: `expected type`
+        err: `expected `{``
+      WHITESPACE@[27; 28)
+      R_CURLY@[28; 29)
+  WHITESPACE@[29; 30)

crates/libsyntax2/tests/data/parser/ok/0033_label_break.rs

@@ -0,0 +1,28 @@
+// format with label break value.
+fn main() {
+    'empty_block: {}
+
+    'block: {
+        do_thing();
+        if condition_not_met() {
+            break 'block;
+        }
+        do_next_thing();
+        if condition_not_met() {
+            break 'block;
+        }
+        do_last_thing();
+    }
+
+    let result = 'block: {
+        if foo() {
+            // comment
+            break 'block 1;
+        }
+        if bar() {
+            /* comment */
+            break 'block 2;
+        }
+        3
+    };
+}

crates/libsyntax2/tests/data/parser/ok/0033_label_break.txt

@@ -0,0 +1,215 @@
+ROOT@[0; 506)
+  COMMENT@[0; 33)
+  WHITESPACE@[33; 34)
+  FN_DEF@[34; 505)
+    FN_KW@[34; 36)
+    WHITESPACE@[36; 37)
+    NAME@[37; 41)
+      IDENT@[37; 41) "main"
+    PARAM_LIST@[41; 43)
+      L_PAREN@[41; 42)
+      R_PAREN@[42; 43)
+    WHITESPACE@[43; 44)
+    BLOCK@[44; 505)
+      L_CURLY@[44; 45)
+      WHITESPACE@[45; 50)
+      EXPR_STMT@[50; 66)
+        BLOCK_EXPR@[50; 66)
+          LABEL@[50; 63)
+            LIFETIME@[50; 62) "'empty_block"
+            COLON@[62; 63)
+          WHITESPACE@[63; 64)
+          BLOCK@[64; 66)
+            L_CURLY@[64; 65)
+            R_CURLY@[65; 66)
+      WHITESPACE@[66; 72)
+      EXPR_STMT@[72; 295)
+        BLOCK_EXPR@[72; 295)
+          LABEL@[72; 79)
+            LIFETIME@[72; 78) "'block"
+            COLON@[78; 79)
+          WHITESPACE@[79; 80)
+          BLOCK@[80; 295)
+            L_CURLY@[80; 81)
+            WHITESPACE@[81; 90)
+            EXPR_STMT@[90; 101)
+              CALL_EXPR@[90; 100)
+                PATH_EXPR@[90; 98)
+                  PATH@[90; 98)
+                    PATH_SEGMENT@[90; 98)
+                      NAME_REF@[90; 98)
+                        IDENT@[90; 98) "do_thing"
+                ARG_LIST@[98; 100)
+                  L_PAREN@[98; 99)
+                  R_PAREN@[99; 100)
+              SEMI@[100; 101)
+            WHITESPACE@[101; 110)
+            EXPR_STMT@[110; 170)
+              IF_EXPR@[110; 170)
+                IF_KW@[110; 112)
+                WHITESPACE@[112; 113)
+                CONDITION@[113; 132)
+                  CALL_EXPR@[113; 132)
+                    PATH_EXPR@[113; 130)
+                      PATH@[113; 130)
+                        PATH_SEGMENT@[113; 130)
+                          NAME_REF@[113; 130)
+                            IDENT@[113; 130) "condition_not_met"
+                    ARG_LIST@[130; 132)
+                      L_PAREN@[130; 131)
+                      R_PAREN@[131; 132)
+                WHITESPACE@[132; 133)
+                BLOCK@[133; 170)
+                  L_CURLY@[133; 134)
+                  WHITESPACE@[134; 147)
+                  EXPR_STMT@[147; 160)
+                    BREAK_EXPR@[147; 159)
+                      BREAK_KW@[147; 152)
+                      WHITESPACE@[152; 153)
+                      LIFETIME@[153; 159) "'block"
+                    SEMI@[159; 160)
+                  WHITESPACE@[160; 169)
+                  R_CURLY@[169; 170)
+            WHITESPACE@[170; 179)
+            EXPR_STMT@[179; 195)
+              CALL_EXPR@[179; 194)
+                PATH_EXPR@[179; 192)
+                  PATH@[179; 192)
+                    PATH_SEGMENT@[179; 192)
+                      NAME_REF@[179; 192)
+                        IDENT@[179; 192) "do_next_thing"
+                ARG_LIST@[192; 194)
+                  L_PAREN@[192; 193)
+                  R_PAREN@[193; 194)
+              SEMI@[194; 195)
+            WHITESPACE@[195; 204)
+            EXPR_STMT@[204; 264)
+              IF_EXPR@[204; 264)
+                IF_KW@[204; 206)
+                WHITESPACE@[206; 207)
+                CONDITION@[207; 226)
+                  CALL_EXPR@[207; 226)
+                    PATH_EXPR@[207; 224)
+                      PATH@[207; 224)
+                        PATH_SEGMENT@[207; 224)
+                          NAME_REF@[207; 224)
+                            IDENT@[207; 224) "condition_not_met"
+                    ARG_LIST@[224; 226)
+                      L_PAREN@[224; 225)
+                      R_PAREN@[225; 226)
+                WHITESPACE@[226; 227)
+                BLOCK@[227; 264)
+                  L_CURLY@[227; 228)
+                  WHITESPACE@[228; 241)
+                  EXPR_STMT@[241; 254)
+                    BREAK_EXPR@[241; 253)
+                      BREAK_KW@[241; 246)
+                      WHITESPACE@[246; 247)
+                      LIFETIME@[247; 253) "'block"
+                    SEMI@[253; 254)
+                  WHITESPACE@[254; 263)
+                  R_CURLY@[263; 264)
+            WHITESPACE@[264; 273)
+            EXPR_STMT@[273; 289)
+              CALL_EXPR@[273; 288)
+                PATH_EXPR@[273; 286)
+                  PATH@[273; 286)
+                    PATH_SEGMENT@[273; 286)
+                      NAME_REF@[273; 286)
+                        IDENT@[273; 286) "do_last_thing"
+                ARG_LIST@[286; 288)
+                  L_PAREN@[286; 287)
+                  R_PAREN@[287; 288)
+              SEMI@[288; 289)
+            WHITESPACE@[289; 294)
+            R_CURLY@[294; 295)
+      WHITESPACE@[295; 301)
+      LET_STMT@[301; 503)
+        LET_KW@[301; 304)
+        WHITESPACE@[304; 305)
+        BIND_PAT@[305; 311)
+          NAME@[305; 311)
+            IDENT@[305; 311) "result"
+        WHITESPACE@[311; 312)
+        EQ@[312; 313)
+        WHITESPACE@[313; 314)
+        BLOCK_EXPR@[314; 502)
+          LABEL@[314; 321)
+            LIFETIME@[314; 320) "'block"
+            COLON@[320; 321)
+          WHITESPACE@[321; 322)
+          BLOCK@[322; 502)
+            L_CURLY@[322; 323)
+            WHITESPACE@[323; 332)
+            EXPR_STMT@[332; 403)
+              IF_EXPR@[332; 403)
+                IF_KW@[332; 334)
+                WHITESPACE@[334; 335)
+                CONDITION@[335; 340)
+                  CALL_EXPR@[335; 340)
+                    PATH_EXPR@[335; 338)
+                      PATH@[335; 338)
+                        PATH_SEGMENT@[335; 338)
+                          NAME_REF@[335; 338)
+                            IDENT@[335; 338) "foo"
+                    ARG_LIST@[338; 340)
+                      L_PAREN@[338; 339)
+                      R_PAREN@[339; 340)
+                WHITESPACE@[340; 341)
+                BLOCK@[341; 403)
+                  L_CURLY@[341; 342)
+                  WHITESPACE@[342; 355)
+                  COMMENT@[355; 365)
+                  WHITESPACE@[365; 378)
+                  EXPR_STMT@[378; 393)
+                    BREAK_EXPR@[378; 392)
+                      BREAK_KW@[378; 383)
+                      WHITESPACE@[383; 384)
+                      LIFETIME@[384; 390) "'block"
+                      WHITESPACE@[390; 391)
+                      LITERAL@[391; 392)
+                        INT_NUMBER@[391; 392) "1"
+                    SEMI@[392; 393)
+                  WHITESPACE@[393; 402)
+                  R_CURLY@[402; 403)
+            WHITESPACE@[403; 412)
+            EXPR_STMT@[412; 486)
+              IF_EXPR@[412; 486)
+                IF_KW@[412; 414)
+                WHITESPACE@[414; 415)
+                CONDITION@[415; 420)
+                  CALL_EXPR@[415; 420)
+                    PATH_EXPR@[415; 418)
+                      PATH@[415; 418)
+                        PATH_SEGMENT@[415; 418)
+                          NAME_REF@[415; 418)
+                            IDENT@[415; 418) "bar"
+                    ARG_LIST@[418; 420)
+                      L_PAREN@[418; 419)
+                      R_PAREN@[419; 420)
+                WHITESPACE@[420; 421)
+                BLOCK@[421; 486)
+                  L_CURLY@[421; 422)
+                  WHITESPACE@[422; 435)
+                  COMMENT@[435; 448)
+                  WHITESPACE@[448; 461)
+                  EXPR_STMT@[461; 476)
+                    BREAK_EXPR@[461; 475)
+                      BREAK_KW@[461; 466)
+                      WHITESPACE@[466; 467)
+                      LIFETIME@[467; 473) "'block"
+                      WHITESPACE@[473; 474)
+                      LITERAL@[474; 475)
+                        INT_NUMBER@[474; 475) "2"
+                    SEMI@[475; 476)
+                  WHITESPACE@[476; 485)
+                  R_CURLY@[485; 486)
+            WHITESPACE@[486; 495)
+            LITERAL@[495; 496)
+              INT_NUMBER@[495; 496) "3"
+            WHITESPACE@[496; 501)
+            R_CURLY@[501; 502)
+        SEMI@[502; 503)
+      WHITESPACE@[503; 504)
+      R_CURLY@[504; 505)
+  WHITESPACE@[505; 506)

crates/server/src/main.rs

@@ -11,7 +11,8 @@
 use m::Result;
 
 fn main() -> Result<()> {
-    Logger::with_env_or_str("m=error")
+    ::std::env::set_var("RUST_BACKTRACE", "short");
+    Logger::with_env_or_str("error")
         .duplicate_to_stderr(Duplicate::All)
         .log_to_file()
         .directory("log")

crates/server/src/main_loop/mod.rs

@@ -38,7 +38,9 @@ pub fn main_loop(
     msg_sender: &mut Sender<RawMessage>,
 ) -> Result<()> {
     let pool = rayon::ThreadPoolBuilder::new()
-        .num_threads(4).build()
+        .num_threads(4)
+        .panic_handler(|_| error!("thread panicked :("))
+        .build()
         .unwrap();
     let (task_sender, task_receiver) = unbounded::<Task>();
     let (fs_sender, fs_receiver, fs_watcher) = vfs::roots_loader();