crates/parser/src/tests/top_entries.rs

   1 use expect_test::expect;
   2
   3 use crate::TopEntryPoint;
   4
   5 #[test]
   6 fn source_file() {
   7     check(
   8         TopEntryPoint::SourceFile,
   9         "",
  10         expect![[r#"
  11         SOURCE_FILE
  12     "#]],
  13     );
  14
  15     check(
  16         TopEntryPoint::SourceFile,
  17         "struct S;",
  18         expect![[r#"
  19         SOURCE_FILE
  20           STRUCT
  21             STRUCT_KW "struct"
  22             WHITESPACE " "
  23             NAME
  24               IDENT "S"
  25             SEMICOLON ";"
  26     "#]],
  27     );
  28
  29     check(
  30         TopEntryPoint::SourceFile,
  31         "@error@",
  32         expect![[r#"
  33         SOURCE_FILE
  34           ERROR
  35             AT "@"
  36           MACRO_CALL
  37             PATH
  38               PATH_SEGMENT
  39                 NAME_REF
  40                   IDENT "error"
  41           ERROR
  42             AT "@"
  43         error 0: expected an item
  44         error 6: expected BANG
  45         error 6: expected `{`, `[`, `(`
  46         error 6: expected SEMICOLON
  47         error 6: expected an item
  48     "#]],
  49     );
  50 }
  51
  52 #[test]
  53 fn macro_stmt() {
  54     check(
  55         TopEntryPoint::MacroStmts,
  56         "#!/usr/bin/rust",
  57         expect![[r##"
  58             MACRO_STMTS
  59               ERROR
  60                 SHEBANG "#!/usr/bin/rust"
  61             error 0: expected expression
  62         "##]],
  63     );
  64     check(
  65         TopEntryPoint::MacroStmts,
  66         "let x = 1 2 struct S;",
  67         expect![[r#"
  68             MACRO_STMTS
  69               LET_STMT
  70                 LET_KW "let"
  71                 WHITESPACE " "
  72                 IDENT_PAT
  73                   NAME
  74                     IDENT "x"
  75                 WHITESPACE " "
  76                 EQ "="
  77                 WHITESPACE " "
  78                 LITERAL
  79                   INT_NUMBER "1"
  80               WHITESPACE " "
  81               EXPR_STMT
  82                 LITERAL
  83                   INT_NUMBER "2"
  84               WHITESPACE " "
  85               STRUCT
  86                 STRUCT_KW "struct"
  87                 WHITESPACE " "
  88                 NAME
  89                   IDENT "S"
  90                 SEMICOLON ";"
  91         "#]],
  92     );
  93 }
  94
  95 #[test]
  96 fn macro_items() {
  97     check(
  98         TopEntryPoint::MacroItems,
  99         "#!/usr/bin/rust",
 100         expect![[r##"
 101             MACRO_ITEMS
 102               ERROR
 103                 SHEBANG "#!/usr/bin/rust"
 104             error 0: expected an item
 105         "##]],
 106     );
 107     check(
 108         TopEntryPoint::MacroItems,
 109         "struct S; foo!{}",
 110         expect![[r#"
 111             MACRO_ITEMS
 112               STRUCT
 113                 STRUCT_KW "struct"
 114                 WHITESPACE " "
 115                 NAME
 116                   IDENT "S"
 117                 SEMICOLON ";"
 118               WHITESPACE " "
 119               MACRO_CALL
 120                 PATH
 121                   PATH_SEGMENT
 122                     NAME_REF
 123                       IDENT "foo"
 124                 BANG "!"
 125                 TOKEN_TREE
 126                   L_CURLY "{"
 127                   R_CURLY "}"
 128         "#]],
 129     );
 130 }
 131
 132 #[test]
 133 fn macro_pattern() {
 134     check(
 135         TopEntryPoint::Pattern,
 136         "Some(_)",
 137         expect![[r#"
 138             TUPLE_STRUCT_PAT
 139               PATH
 140                 PATH_SEGMENT
 141                   NAME_REF
 142                     IDENT "Some"
 143               L_PAREN "("
 144               WILDCARD_PAT
 145                 UNDERSCORE "_"
 146               R_PAREN ")"
 147         "#]],
 148     );
 149
 150     check(
 151         TopEntryPoint::Pattern,
 152         "None leftover tokens",
 153         expect![[r#"
 154             ERROR
 155               IDENT_PAT
 156                 NAME
 157                   IDENT "None"
 158               WHITESPACE " "
 159               IDENT "leftover"
 160               WHITESPACE " "
 161               IDENT "tokens"
 162         "#]],
 163     );
 164
 165     check(
 166         TopEntryPoint::Pattern,
 167         "@err",
 168         expect![[r#"
 169             ERROR
 170               ERROR
 171                 AT "@"
 172               IDENT "err"
 173             error 0: expected pattern
 174         "#]],
 175     );
 176 }
 177
 178 #[track_caller]
 179 fn check(entry: TopEntryPoint, input: &str, expect: expect_test::Expect) {
 180     let (parsed, _errors) = super::parse(entry, input);
 181     expect.assert_eq(&parsed)
 182 }