mirror of
				https://github.com/rust-lang/rust-analyzer.git
				synced 2025-11-03 13:13:18 +00:00 
			
		
		
		
	Add tests and only traverse in the crates directory
This commit is contained in:
		
							parent
							
								
									db67741430
								
							
						
					
					
						commit
						a3b842fb8b
					
				@ -73,6 +73,10 @@ pub(crate) fn block(p: &mut Parser) {
 | 
				
			|||||||
                            //     for _ in () {}
 | 
					                            //     for _ in () {}
 | 
				
			||||||
                            //     {}
 | 
					                            //     {}
 | 
				
			||||||
                            //     {}
 | 
					                            //     {}
 | 
				
			||||||
 | 
					                            //     macro_rules! test {
 | 
				
			||||||
 | 
					                            //          () => {}
 | 
				
			||||||
 | 
					                            //     }
 | 
				
			||||||
 | 
					                            //     test!{}
 | 
				
			||||||
                            // }
 | 
					                            // }
 | 
				
			||||||
                            if is_blocklike {
 | 
					                            if is_blocklike {
 | 
				
			||||||
                                p.eat(SEMI);
 | 
					                                p.eat(SEMI);
 | 
				
			||||||
@ -168,13 +172,13 @@ fn current_op(p: &Parser) -> (u8, Op) {
 | 
				
			|||||||
// Parses expression with binding power of at least bp.
 | 
					// Parses expression with binding power of at least bp.
 | 
				
			||||||
fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike {
 | 
					fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike {
 | 
				
			||||||
    let mut lhs = match lhs(p, r) {
 | 
					    let mut lhs = match lhs(p, r) {
 | 
				
			||||||
        Some((lhs, macro_blocklike)) => {
 | 
					        Some((lhs, blocklike)) => {
 | 
				
			||||||
            // test stmt_bin_expr_ambiguity
 | 
					            // test stmt_bin_expr_ambiguity
 | 
				
			||||||
            // fn foo() {
 | 
					            // fn foo() {
 | 
				
			||||||
            //     let _ = {1} & 2;
 | 
					            //     let _ = {1} & 2;
 | 
				
			||||||
            //     {1} &2;
 | 
					            //     {1} &2;
 | 
				
			||||||
            // }
 | 
					            // }
 | 
				
			||||||
            if r.prefer_stmt && macro_blocklike.is_block() {
 | 
					            if r.prefer_stmt && blocklike.is_block() {
 | 
				
			||||||
                return BlockLike::Block;
 | 
					                return BlockLike::Block;
 | 
				
			||||||
            }
 | 
					            }
 | 
				
			||||||
            lhs
 | 
					            lhs
 | 
				
			||||||
 | 
				
			|||||||
@ -353,6 +353,7 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
 | 
				
			|||||||
// fn foo() {
 | 
					// fn foo() {
 | 
				
			||||||
//     match () {
 | 
					//     match () {
 | 
				
			||||||
//         _ => (),
 | 
					//         _ => (),
 | 
				
			||||||
 | 
					//         _ if Test>{field: 0} => (),
 | 
				
			||||||
//         X | Y if Z => (),
 | 
					//         X | Y if Z => (),
 | 
				
			||||||
//         | X | Y if Z => (),
 | 
					//         | X | Y if Z => (),
 | 
				
			||||||
//         | X => (),
 | 
					//         | X => (),
 | 
				
			||||||
 | 
				
			|||||||
@ -1,6 +1,7 @@
 | 
				
			|||||||
fn foo() {
 | 
					fn foo() {
 | 
				
			||||||
    match () {
 | 
					    match () {
 | 
				
			||||||
        _ => (),
 | 
					        _ => (),
 | 
				
			||||||
 | 
					        _ if Test>{field: 0} => (),
 | 
				
			||||||
        X | Y if Z => (),
 | 
					        X | Y if Z => (),
 | 
				
			||||||
        | X | Y if Z => (),
 | 
					        | X | Y if Z => (),
 | 
				
			||||||
        | X => (),
 | 
					        | X => (),
 | 
				
			||||||
 | 
				
			|||||||
@ -1,5 +1,5 @@
 | 
				
			|||||||
SOURCE_FILE@[0; 125)
 | 
					SOURCE_FILE@[0; 161)
 | 
				
			||||||
  FN_DEF@[0; 124)
 | 
					  FN_DEF@[0; 160)
 | 
				
			||||||
    FN_KW@[0; 2)
 | 
					    FN_KW@[0; 2)
 | 
				
			||||||
    WHITESPACE@[2; 3)
 | 
					    WHITESPACE@[2; 3)
 | 
				
			||||||
    NAME@[3; 6)
 | 
					    NAME@[3; 6)
 | 
				
			||||||
@ -8,18 +8,18 @@ SOURCE_FILE@[0; 125)
 | 
				
			|||||||
      L_PAREN@[6; 7)
 | 
					      L_PAREN@[6; 7)
 | 
				
			||||||
      R_PAREN@[7; 8)
 | 
					      R_PAREN@[7; 8)
 | 
				
			||||||
    WHITESPACE@[8; 9)
 | 
					    WHITESPACE@[8; 9)
 | 
				
			||||||
    BLOCK@[9; 124)
 | 
					    BLOCK@[9; 160)
 | 
				
			||||||
      L_CURLY@[9; 10)
 | 
					      L_CURLY@[9; 10)
 | 
				
			||||||
      WHITESPACE@[10; 15)
 | 
					      WHITESPACE@[10; 15)
 | 
				
			||||||
      EXPR_STMT@[15; 122)
 | 
					      EXPR_STMT@[15; 158)
 | 
				
			||||||
        MATCH_EXPR@[15; 121)
 | 
					        MATCH_EXPR@[15; 157)
 | 
				
			||||||
          MATCH_KW@[15; 20)
 | 
					          MATCH_KW@[15; 20)
 | 
				
			||||||
          WHITESPACE@[20; 21)
 | 
					          WHITESPACE@[20; 21)
 | 
				
			||||||
          TUPLE_EXPR@[21; 23)
 | 
					          TUPLE_EXPR@[21; 23)
 | 
				
			||||||
            L_PAREN@[21; 22)
 | 
					            L_PAREN@[21; 22)
 | 
				
			||||||
            R_PAREN@[22; 23)
 | 
					            R_PAREN@[22; 23)
 | 
				
			||||||
          WHITESPACE@[23; 24)
 | 
					          WHITESPACE@[23; 24)
 | 
				
			||||||
          MATCH_ARM_LIST@[24; 121)
 | 
					          MATCH_ARM_LIST@[24; 157)
 | 
				
			||||||
            L_CURLY@[24; 25)
 | 
					            L_CURLY@[24; 25)
 | 
				
			||||||
            WHITESPACE@[25; 34)
 | 
					            WHITESPACE@[25; 34)
 | 
				
			||||||
            MATCH_ARM@[34; 41)
 | 
					            MATCH_ARM@[34; 41)
 | 
				
			||||||
@ -33,76 +33,116 @@ SOURCE_FILE@[0; 125)
 | 
				
			|||||||
                R_PAREN@[40; 41)
 | 
					                R_PAREN@[40; 41)
 | 
				
			||||||
            COMMA@[41; 42)
 | 
					            COMMA@[41; 42)
 | 
				
			||||||
            WHITESPACE@[42; 51)
 | 
					            WHITESPACE@[42; 51)
 | 
				
			||||||
            MATCH_ARM@[51; 67)
 | 
					            MATCH_ARM@[51; 77)
 | 
				
			||||||
              BIND_PAT@[51; 52)
 | 
					              PLACEHOLDER_PAT@[51; 52)
 | 
				
			||||||
                NAME@[51; 52)
 | 
					                UNDERSCORE@[51; 52)
 | 
				
			||||||
                  IDENT@[51; 52) "X"
 | 
					 | 
				
			||||||
              WHITESPACE@[52; 53)
 | 
					              WHITESPACE@[52; 53)
 | 
				
			||||||
              PIPE@[53; 54)
 | 
					              IF_KW@[53; 55)
 | 
				
			||||||
              WHITESPACE@[54; 55)
 | 
					              WHITESPACE@[55; 56)
 | 
				
			||||||
              BIND_PAT@[55; 56)
 | 
					              BIN_EXPR@[56; 71)
 | 
				
			||||||
                NAME@[55; 56)
 | 
					                PATH_EXPR@[56; 60)
 | 
				
			||||||
                  IDENT@[55; 56) "Y"
 | 
					                  PATH@[56; 60)
 | 
				
			||||||
              WHITESPACE@[56; 57)
 | 
					                    PATH_SEGMENT@[56; 60)
 | 
				
			||||||
              IF_KW@[57; 59)
 | 
					                      NAME_REF@[56; 60)
 | 
				
			||||||
              WHITESPACE@[59; 60)
 | 
					                        IDENT@[56; 60) "Test"
 | 
				
			||||||
              PATH_EXPR@[60; 61)
 | 
					                R_ANGLE@[60; 61)
 | 
				
			||||||
                PATH@[60; 61)
 | 
					                BLOCK_EXPR@[61; 71)
 | 
				
			||||||
                  PATH_SEGMENT@[60; 61)
 | 
					                  BLOCK@[61; 71)
 | 
				
			||||||
                    NAME_REF@[60; 61)
 | 
					                    L_CURLY@[61; 62)
 | 
				
			||||||
                      IDENT@[60; 61) "Z"
 | 
					                    EXPR_STMT@[62; 67)
 | 
				
			||||||
              WHITESPACE@[61; 62)
 | 
					                      PATH_EXPR@[62; 67)
 | 
				
			||||||
              FAT_ARROW@[62; 64)
 | 
					                        PATH@[62; 67)
 | 
				
			||||||
              WHITESPACE@[64; 65)
 | 
					                          PATH_SEGMENT@[62; 67)
 | 
				
			||||||
              TUPLE_EXPR@[65; 67)
 | 
					                            NAME_REF@[62; 67)
 | 
				
			||||||
                L_PAREN@[65; 66)
 | 
					                              IDENT@[62; 67) "field"
 | 
				
			||||||
                R_PAREN@[66; 67)
 | 
					                              err: `expected SEMI`
 | 
				
			||||||
            COMMA@[67; 68)
 | 
					                              err: `expected expression`
 | 
				
			||||||
            WHITESPACE@[68; 77)
 | 
					                    EXPR_STMT@[67; 68)
 | 
				
			||||||
            MATCH_ARM@[77; 95)
 | 
					                      ERROR@[67; 68)
 | 
				
			||||||
              PIPE@[77; 78)
 | 
					                        COLON@[67; 68)
 | 
				
			||||||
              WHITESPACE@[78; 79)
 | 
					                        err: `expected SEMI`
 | 
				
			||||||
              BIND_PAT@[79; 80)
 | 
					                    WHITESPACE@[68; 69)
 | 
				
			||||||
                NAME@[79; 80)
 | 
					                    LITERAL@[69; 70)
 | 
				
			||||||
                  IDENT@[79; 80) "X"
 | 
					                      INT_NUMBER@[69; 70) "0"
 | 
				
			||||||
              WHITESPACE@[80; 81)
 | 
					                    R_CURLY@[70; 71)
 | 
				
			||||||
              PIPE@[81; 82)
 | 
					              WHITESPACE@[71; 72)
 | 
				
			||||||
              WHITESPACE@[82; 83)
 | 
					              FAT_ARROW@[72; 74)
 | 
				
			||||||
              BIND_PAT@[83; 84)
 | 
					              WHITESPACE@[74; 75)
 | 
				
			||||||
                NAME@[83; 84)
 | 
					              TUPLE_EXPR@[75; 77)
 | 
				
			||||||
                  IDENT@[83; 84) "Y"
 | 
					                L_PAREN@[75; 76)
 | 
				
			||||||
              WHITESPACE@[84; 85)
 | 
					                R_PAREN@[76; 77)
 | 
				
			||||||
              IF_KW@[85; 87)
 | 
					            COMMA@[77; 78)
 | 
				
			||||||
              WHITESPACE@[87; 88)
 | 
					            WHITESPACE@[78; 87)
 | 
				
			||||||
              PATH_EXPR@[88; 89)
 | 
					            MATCH_ARM@[87; 103)
 | 
				
			||||||
                PATH@[88; 89)
 | 
					              BIND_PAT@[87; 88)
 | 
				
			||||||
                  PATH_SEGMENT@[88; 89)
 | 
					                NAME@[87; 88)
 | 
				
			||||||
                    NAME_REF@[88; 89)
 | 
					                  IDENT@[87; 88) "X"
 | 
				
			||||||
                      IDENT@[88; 89) "Z"
 | 
					              WHITESPACE@[88; 89)
 | 
				
			||||||
              WHITESPACE@[89; 90)
 | 
					              PIPE@[89; 90)
 | 
				
			||||||
              FAT_ARROW@[90; 92)
 | 
					              WHITESPACE@[90; 91)
 | 
				
			||||||
 | 
					              BIND_PAT@[91; 92)
 | 
				
			||||||
 | 
					                NAME@[91; 92)
 | 
				
			||||||
 | 
					                  IDENT@[91; 92) "Y"
 | 
				
			||||||
              WHITESPACE@[92; 93)
 | 
					              WHITESPACE@[92; 93)
 | 
				
			||||||
              TUPLE_EXPR@[93; 95)
 | 
					              IF_KW@[93; 95)
 | 
				
			||||||
                L_PAREN@[93; 94)
 | 
					              WHITESPACE@[95; 96)
 | 
				
			||||||
                R_PAREN@[94; 95)
 | 
					              PATH_EXPR@[96; 97)
 | 
				
			||||||
            COMMA@[95; 96)
 | 
					                PATH@[96; 97)
 | 
				
			||||||
            WHITESPACE@[96; 105)
 | 
					                  PATH_SEGMENT@[96; 97)
 | 
				
			||||||
            MATCH_ARM@[105; 114)
 | 
					                    NAME_REF@[96; 97)
 | 
				
			||||||
              PIPE@[105; 106)
 | 
					                      IDENT@[96; 97) "Z"
 | 
				
			||||||
              WHITESPACE@[106; 107)
 | 
					              WHITESPACE@[97; 98)
 | 
				
			||||||
              BIND_PAT@[107; 108)
 | 
					              FAT_ARROW@[98; 100)
 | 
				
			||||||
                NAME@[107; 108)
 | 
					              WHITESPACE@[100; 101)
 | 
				
			||||||
                  IDENT@[107; 108) "X"
 | 
					              TUPLE_EXPR@[101; 103)
 | 
				
			||||||
              WHITESPACE@[108; 109)
 | 
					                L_PAREN@[101; 102)
 | 
				
			||||||
              FAT_ARROW@[109; 111)
 | 
					                R_PAREN@[102; 103)
 | 
				
			||||||
              WHITESPACE@[111; 112)
 | 
					            COMMA@[103; 104)
 | 
				
			||||||
              TUPLE_EXPR@[112; 114)
 | 
					            WHITESPACE@[104; 113)
 | 
				
			||||||
                L_PAREN@[112; 113)
 | 
					            MATCH_ARM@[113; 131)
 | 
				
			||||||
                R_PAREN@[113; 114)
 | 
					              PIPE@[113; 114)
 | 
				
			||||||
            COMMA@[114; 115)
 | 
					              WHITESPACE@[114; 115)
 | 
				
			||||||
            WHITESPACE@[115; 120)
 | 
					              BIND_PAT@[115; 116)
 | 
				
			||||||
            R_CURLY@[120; 121)
 | 
					                NAME@[115; 116)
 | 
				
			||||||
        SEMI@[121; 122)
 | 
					                  IDENT@[115; 116) "X"
 | 
				
			||||||
      WHITESPACE@[122; 123)
 | 
					              WHITESPACE@[116; 117)
 | 
				
			||||||
      R_CURLY@[123; 124)
 | 
					              PIPE@[117; 118)
 | 
				
			||||||
  WHITESPACE@[124; 125)
 | 
					              WHITESPACE@[118; 119)
 | 
				
			||||||
 | 
					              BIND_PAT@[119; 120)
 | 
				
			||||||
 | 
					                NAME@[119; 120)
 | 
				
			||||||
 | 
					                  IDENT@[119; 120) "Y"
 | 
				
			||||||
 | 
					              WHITESPACE@[120; 121)
 | 
				
			||||||
 | 
					              IF_KW@[121; 123)
 | 
				
			||||||
 | 
					              WHITESPACE@[123; 124)
 | 
				
			||||||
 | 
					              PATH_EXPR@[124; 125)
 | 
				
			||||||
 | 
					                PATH@[124; 125)
 | 
				
			||||||
 | 
					                  PATH_SEGMENT@[124; 125)
 | 
				
			||||||
 | 
					                    NAME_REF@[124; 125)
 | 
				
			||||||
 | 
					                      IDENT@[124; 125) "Z"
 | 
				
			||||||
 | 
					              WHITESPACE@[125; 126)
 | 
				
			||||||
 | 
					              FAT_ARROW@[126; 128)
 | 
				
			||||||
 | 
					              WHITESPACE@[128; 129)
 | 
				
			||||||
 | 
					              TUPLE_EXPR@[129; 131)
 | 
				
			||||||
 | 
					                L_PAREN@[129; 130)
 | 
				
			||||||
 | 
					                R_PAREN@[130; 131)
 | 
				
			||||||
 | 
					            COMMA@[131; 132)
 | 
				
			||||||
 | 
					            WHITESPACE@[132; 141)
 | 
				
			||||||
 | 
					            MATCH_ARM@[141; 150)
 | 
				
			||||||
 | 
					              PIPE@[141; 142)
 | 
				
			||||||
 | 
					              WHITESPACE@[142; 143)
 | 
				
			||||||
 | 
					              BIND_PAT@[143; 144)
 | 
				
			||||||
 | 
					                NAME@[143; 144)
 | 
				
			||||||
 | 
					                  IDENT@[143; 144) "X"
 | 
				
			||||||
 | 
					              WHITESPACE@[144; 145)
 | 
				
			||||||
 | 
					              FAT_ARROW@[145; 147)
 | 
				
			||||||
 | 
					              WHITESPACE@[147; 148)
 | 
				
			||||||
 | 
					              TUPLE_EXPR@[148; 150)
 | 
				
			||||||
 | 
					                L_PAREN@[148; 149)
 | 
				
			||||||
 | 
					                R_PAREN@[149; 150)
 | 
				
			||||||
 | 
					            COMMA@[150; 151)
 | 
				
			||||||
 | 
					            WHITESPACE@[151; 156)
 | 
				
			||||||
 | 
					            R_CURLY@[156; 157)
 | 
				
			||||||
 | 
					        SEMI@[157; 158)
 | 
				
			||||||
 | 
					      WHITESPACE@[158; 159)
 | 
				
			||||||
 | 
					      R_CURLY@[159; 160)
 | 
				
			||||||
 | 
					  WHITESPACE@[160; 161)
 | 
				
			||||||
 | 
				
			|||||||
@ -6,4 +6,8 @@ fn foo() {
 | 
				
			|||||||
    for _ in () {}
 | 
					    for _ in () {}
 | 
				
			||||||
    {}
 | 
					    {}
 | 
				
			||||||
    {}
 | 
					    {}
 | 
				
			||||||
 | 
					    macro_rules! test {
 | 
				
			||||||
 | 
					         () => {}
 | 
				
			||||||
 | 
					    }
 | 
				
			||||||
 | 
					    test!{}
 | 
				
			||||||
}
 | 
					}
 | 
				
			||||||
 | 
				
			|||||||
@ -1,5 +1,5 @@
 | 
				
			|||||||
SOURCE_FILE@[0; 107)
 | 
					SOURCE_FILE@[0; 167)
 | 
				
			||||||
  FN_DEF@[0; 106)
 | 
					  FN_DEF@[0; 166)
 | 
				
			||||||
    FN_KW@[0; 2)
 | 
					    FN_KW@[0; 2)
 | 
				
			||||||
    WHITESPACE@[2; 3)
 | 
					    WHITESPACE@[2; 3)
 | 
				
			||||||
    NAME@[3; 6)
 | 
					    NAME@[3; 6)
 | 
				
			||||||
@ -8,7 +8,7 @@ SOURCE_FILE@[0; 107)
 | 
				
			|||||||
      L_PAREN@[6; 7)
 | 
					      L_PAREN@[6; 7)
 | 
				
			||||||
      R_PAREN@[7; 8)
 | 
					      R_PAREN@[7; 8)
 | 
				
			||||||
    WHITESPACE@[8; 9)
 | 
					    WHITESPACE@[8; 9)
 | 
				
			||||||
    BLOCK@[9; 106)
 | 
					    BLOCK@[9; 166)
 | 
				
			||||||
      L_CURLY@[9; 10)
 | 
					      L_CURLY@[9; 10)
 | 
				
			||||||
      WHITESPACE@[10; 15)
 | 
					      WHITESPACE@[10; 15)
 | 
				
			||||||
      EXPR_STMT@[15; 25)
 | 
					      EXPR_STMT@[15; 25)
 | 
				
			||||||
@ -78,10 +78,46 @@ SOURCE_FILE@[0; 107)
 | 
				
			|||||||
            L_CURLY@[95; 96)
 | 
					            L_CURLY@[95; 96)
 | 
				
			||||||
            R_CURLY@[96; 97)
 | 
					            R_CURLY@[96; 97)
 | 
				
			||||||
      WHITESPACE@[97; 102)
 | 
					      WHITESPACE@[97; 102)
 | 
				
			||||||
      BLOCK_EXPR@[102; 104)
 | 
					      EXPR_STMT@[102; 104)
 | 
				
			||||||
        BLOCK@[102; 104)
 | 
					        BLOCK_EXPR@[102; 104)
 | 
				
			||||||
          L_CURLY@[102; 103)
 | 
					          BLOCK@[102; 104)
 | 
				
			||||||
          R_CURLY@[103; 104)
 | 
					            L_CURLY@[102; 103)
 | 
				
			||||||
      WHITESPACE@[104; 105)
 | 
					            R_CURLY@[103; 104)
 | 
				
			||||||
      R_CURLY@[105; 106)
 | 
					      WHITESPACE@[104; 109)
 | 
				
			||||||
  WHITESPACE@[106; 107)
 | 
					      EXPR_STMT@[109; 152)
 | 
				
			||||||
 | 
					        MACRO_CALL@[109; 152)
 | 
				
			||||||
 | 
					          PATH@[109; 120)
 | 
				
			||||||
 | 
					            PATH_SEGMENT@[109; 120)
 | 
				
			||||||
 | 
					              NAME_REF@[109; 120)
 | 
				
			||||||
 | 
					                IDENT@[109; 120) "macro_rules"
 | 
				
			||||||
 | 
					          EXCL@[120; 121)
 | 
				
			||||||
 | 
					          WHITESPACE@[121; 122)
 | 
				
			||||||
 | 
					          IDENT@[122; 126) "test"
 | 
				
			||||||
 | 
					          WHITESPACE@[126; 127)
 | 
				
			||||||
 | 
					          TOKEN_TREE@[127; 152)
 | 
				
			||||||
 | 
					            L_CURLY@[127; 128)
 | 
				
			||||||
 | 
					            WHITESPACE@[128; 138)
 | 
				
			||||||
 | 
					            TOKEN_TREE@[138; 140)
 | 
				
			||||||
 | 
					              L_PAREN@[138; 139)
 | 
				
			||||||
 | 
					              R_PAREN@[139; 140)
 | 
				
			||||||
 | 
					            WHITESPACE@[140; 141)
 | 
				
			||||||
 | 
					            FAT_ARROW@[141; 143)
 | 
				
			||||||
 | 
					            WHITESPACE@[143; 144)
 | 
				
			||||||
 | 
					            TOKEN_TREE@[144; 146)
 | 
				
			||||||
 | 
					              L_CURLY@[144; 145)
 | 
				
			||||||
 | 
					              R_CURLY@[145; 146)
 | 
				
			||||||
 | 
					            WHITESPACE@[146; 151)
 | 
				
			||||||
 | 
					            R_CURLY@[151; 152)
 | 
				
			||||||
 | 
					      WHITESPACE@[152; 157)
 | 
				
			||||||
 | 
					      MACRO_CALL@[157; 164)
 | 
				
			||||||
 | 
					        PATH@[157; 161)
 | 
				
			||||||
 | 
					          PATH_SEGMENT@[157; 161)
 | 
				
			||||||
 | 
					            NAME_REF@[157; 161)
 | 
				
			||||||
 | 
					              IDENT@[157; 161) "test"
 | 
				
			||||||
 | 
					        EXCL@[161; 162)
 | 
				
			||||||
 | 
					        TOKEN_TREE@[162; 164)
 | 
				
			||||||
 | 
					          L_CURLY@[162; 163)
 | 
				
			||||||
 | 
					          R_CURLY@[163; 164)
 | 
				
			||||||
 | 
					      WHITESPACE@[164; 165)
 | 
				
			||||||
 | 
					      R_CURLY@[165; 166)
 | 
				
			||||||
 | 
					  WHITESPACE@[166; 167)
 | 
				
			||||||
 | 
				
			|||||||
@ -41,8 +41,10 @@ fn parser_fuzz_tests() {
 | 
				
			|||||||
/// TODO: Use this as a benchmark
 | 
					/// TODO: Use this as a benchmark
 | 
				
			||||||
#[test]
 | 
					#[test]
 | 
				
			||||||
fn self_hosting_parsing() {
 | 
					fn self_hosting_parsing() {
 | 
				
			||||||
 | 
					    use std::ffi::OsStr;
 | 
				
			||||||
    let empty_vec = vec![];
 | 
					    let empty_vec = vec![];
 | 
				
			||||||
    let dir = project_dir();
 | 
					    let dir = project_dir().join("crates");
 | 
				
			||||||
 | 
					    let mut count = 0;
 | 
				
			||||||
    for entry in walkdir::WalkDir::new(dir)
 | 
					    for entry in walkdir::WalkDir::new(dir)
 | 
				
			||||||
        .into_iter()
 | 
					        .into_iter()
 | 
				
			||||||
        .filter_entry(|entry| {
 | 
					        .filter_entry(|entry| {
 | 
				
			||||||
@ -52,17 +54,16 @@ fn self_hosting_parsing() {
 | 
				
			|||||||
                // TODO: this more neatly
 | 
					                // TODO: this more neatly
 | 
				
			||||||
                .any(|component| {
 | 
					                .any(|component| {
 | 
				
			||||||
                    // Get all files which are not in the crates/ra_syntax/tests/data folder
 | 
					                    // Get all files which are not in the crates/ra_syntax/tests/data folder
 | 
				
			||||||
                    (component == Component::Normal(std::ffi::OsStr::new("data"))
 | 
					                    component == Component::Normal(OsStr::new("data"))
 | 
				
			||||||
                    // or the .git folder
 | 
					 | 
				
			||||||
                        || component == Component::Normal(std::ffi::OsStr::new(".git")))
 | 
					 | 
				
			||||||
                })
 | 
					                })
 | 
				
			||||||
        })
 | 
					        })
 | 
				
			||||||
        .map(|e| e.unwrap())
 | 
					        .map(|e| e.unwrap())
 | 
				
			||||||
        .filter(|entry| {
 | 
					        .filter(|entry| {
 | 
				
			||||||
            // Get all `.rs ` files
 | 
					            // Get all `.rs ` files
 | 
				
			||||||
            !entry.path().is_dir() && (entry.path().extension() == Some(std::ffi::OsStr::new("rs")))
 | 
					            !entry.path().is_dir() && (entry.path().extension() == Some(OsStr::new("rs")))
 | 
				
			||||||
        })
 | 
					        })
 | 
				
			||||||
    {
 | 
					    {
 | 
				
			||||||
 | 
					        count += 1;
 | 
				
			||||||
        let text = read_text(entry.path());
 | 
					        let text = read_text(entry.path());
 | 
				
			||||||
        let node = SourceFileNode::parse(&text);
 | 
					        let node = SourceFileNode::parse(&text);
 | 
				
			||||||
        let errors = node.errors();
 | 
					        let errors = node.errors();
 | 
				
			||||||
@ -72,6 +73,10 @@ fn self_hosting_parsing() {
 | 
				
			|||||||
            entry
 | 
					            entry
 | 
				
			||||||
        );
 | 
					        );
 | 
				
			||||||
    }
 | 
					    }
 | 
				
			||||||
 | 
					    assert!(
 | 
				
			||||||
 | 
					        count > 30,
 | 
				
			||||||
 | 
					        "self_hosting_parsing found too few files - is it running in the right directory?"
 | 
				
			||||||
 | 
					    )
 | 
				
			||||||
}
 | 
					}
 | 
				
			||||||
/// Read file and normalize newlines.
 | 
					/// Read file and normalize newlines.
 | 
				
			||||||
///
 | 
					///
 | 
				
			||||||
 | 
				
			|||||||
		Loading…
	
	
			
			x
			
			
		
	
		Reference in New Issue
	
	Block a user