rust/crates/libsyntax2/src/grammar.ron

Grammar(
    single_byte_tokens: [
        [";", "SEMI"],
        [",", "COMMA"],
        ["(", "L_PAREN"],
        [")", "R_PAREN"],
        ["{", "L_CURLY"],
        ["}", "R_CURLY"],
        ["[", "L_BRACK"],
        ["]", "R_BRACK"],
        ["<", "L_ANGLE"],
        [">", "R_ANGLE"],
        ["@", "AT"],
        ["#", "POUND"],
        ["~", "TILDE"],
        ["?", "QUESTION"],
        ["$", "DOLLAR"],
        ["&", "AMP"],
        ["|", "PIPE"],
        ["+", "PLUS"],
        ["*", "STAR"],
        ["/", "SLASH"],
        ["^", "CARET"],
        ["%", "PERCENT"],
    ],
    multi_byte_tokens: [
        [".", "DOT"],
        ["..", "DOTDOT"],
        ["...", "DOTDOTDOT"],
        ["..=", "DOTDOTEQ"],
        [":", "COLON"],
        ["::", "COLONCOLON"],
        ["=", "EQ"],
        ["==", "EQEQ"],
        ["=>", "FAT_ARROW"],
        ["!", "EXCL"],
        ["!=", "NEQ"],
        ["-", "MINUS"],
        ["->", "THIN_ARROW"],
        ["<=", "LTEQ"],
        [">=", "GTEQ"],
        ["+=", "PLUSEQ"],
        ["-=", "MINUSEQ"],
        ["&&", "AMPAMP"],
        ["||", "PIPEPIPE"],
        ["<<", "SHL"],
        [">>", "SHR"],
        ["<<=", "SHLEQ"],
        [">>=", "SHREQ"],
    ],
    keywords: [
        "use",
        "fn",
        "struct",
        "enum",
        "trait",
        "impl",
        "true",
        "false",
        "as",
        "extern",
        "crate",
        "mod",
        "pub",
        "self",
        "super",
        "in",
        "where",
        "for",
        "loop",
        "while",
        "if",
        "else",
        "match",
        "const",
        "static",
        "mut",
        "unsafe",
        "type",
        "ref",
        "let",
        "move",
        "return",
    ],
    contextual_keywords: [
        "auto",
        "default",
        "union",
    ],
    tokens: [
        "ERROR",
        "IDENT",
        "UNDERSCORE",
        "WHITESPACE",
        "INT_NUMBER",
        "FLOAT_NUMBER",
        "LIFETIME",
        "CHAR",
        "BYTE",
        "STRING",
        "RAW_STRING",
        "BYTE_STRING",
        "RAW_BYTE_STRING",
        "COMMENT",
        "DOC_COMMENT",
        "SHEBANG",
    ],
    nodes: [
        "FILE",

        "STRUCT",
        "ENUM",
        "FUNCTION",
        "EXTERN_CRATE_ITEM",
        "MODULE",
        "USE_ITEM",
        "STATIC_ITEM",
        "CONST_ITEM",
        "TRAIT",
        "IMPL_ITEM",
        "TYPE_ITEM",
        "MACRO_CALL",
        "TOKEN_TREE",

        "PAREN_TYPE",
        "TUPLE_TYPE",
        "NEVER_TYPE",
        "PATH_TYPE",
        "POINTER_TYPE",
        "ARRAY_TYPE",
        "SLICE_TYPE",
        "REFERENCE_TYPE",
        "PLACEHOLDER_TYPE",
        "FN_POINTER_TYPE",
        "FOR_TYPE",
        "IMPL_TRAIT_TYPE",

        "REF_PAT",
        "BIND_PAT",
        "PLACEHOLDER_PAT",
        "PATH_PAT",
        "STRUCT_PAT",
        "TUPLE_STRUCT_PAT",
        "TUPLE_PAT",
        "SLICE_PAT",
        "RANGE_PAT",

        // atoms
        "TUPLE_EXPR",
        "ARRAY_EXPR",
        "PAREN_EXPR",
        "PATH_EXPR",
        "LAMBDA_EXPR",
        "IF_EXPR",
        "WHILE_EXPR",
        "LOOP_EXPR",
        "FOR_EXPR",
        "BLOCK_EXPR",
        "RETURN_EXPR",
        "MATCH_EXPR",
        "MATCH_ARM",
        "MATCH_GUARD",
        "STRUCT_LIT",
        "STRUCT_LIT_FIELD",

        // postfix
        "CALL_EXPR",
        "INDEX_EXPR",
        "METHOD_CALL_EXPR",
        "FIELD_EXPR",
        "TRY_EXPR",
        "CAST_EXPR",

        // unary
        "REF_EXPR",
        "PREFIX_EXPR",

        "RANGE_EXPR", // just weird
        "BIN_EXPR",


        "EXTERN_BLOCK_EXPR",
        "ENUM_VARIANT",
        "NAMED_FIELD",
        "POS_FIELD",
        "ATTR",
        "META_ITEM", // not an item actually
        "USE_TREE",
        "PATH",
        "PATH_SEGMENT",
        "LITERAL",
        "ALIAS",
        "VISIBILITY",
        "WHERE_CLAUSE",
        "WHERE_PRED",
        "ABI",
        "NAME",
        "NAME_REF",

        "LET_STMT",
        "EXPR_STMT",

        "TYPE_PARAM_LIST",
        "LIFETIME_PARAM",
        "TYPE_PARAM",
        "TYPE_ARG_LIST",
        "LIFETIME_ARG",
        "TYPE_ARG",
        "ASSOC_TYPE_ARG",

        "PARAM_LIST",
        "PARAM",
        "SELF_PARAM",
        "ARG_LIST",
    ],
    ast: {
        "File": (
            collections: [
                ["functions", "Function"]
            ]
        ),
        "Function": (
            traits: ["NameOwner"]
        ),
        "Struct": (
            traits: ["NameOwner"]
        ),
        "Enum": (
            traits: ["NameOwner"]
        ),
        "Trait": (
            traits: ["NameOwner"]
        ),
        "Module": (
            traits: ["NameOwner"]
        ),
        "ConstItem": (
            traits: ["NameOwner"]
        ),
        "StaticItem": (
            traits: ["NameOwner"]
        ),
        "Name": (),
    },
)
Grammar in ron 2017-12-28 16:21:54 -06:00			`Grammar(`
generate single byte tokens 2018-07-30 09:46:50 -05:00			`single_byte_tokens: [`
			`[";", "SEMI"],`
			`[",", "COMMA"],`
			`["(", "L_PAREN"],`
			`[")", "R_PAREN"],`
			`["{", "L_CURLY"],`
			`["}", "R_CURLY"],`
			`["[", "L_BRACK"],`
			`["]", "R_BRACK"],`
			`["<", "L_ANGLE"],`
			`[">", "R_ANGLE"],`
			`["@", "AT"],`
			`["#", "POUND"],`
			`["~", "TILDE"],`
			`["?", "QUESTION"],`
			`["$", "DOLLAR"],`
ampersand -> amp 2018-08-05 10:18:02 -05:00			`["&", "AMP"],`
generate single byte tokens 2018-07-30 09:46:50 -05:00			`["\|", "PIPE"],`
			`["+", "PLUS"],`
			`["*", "STAR"],`
			`["/", "SLASH"],`
			`["^", "CARET"],`
			`["%", "PERCENT"],`
			`],`
			`multi_byte_tokens: [`
			`[".", "DOT"],`
			`["..", "DOTDOT"],`
			`["...", "DOTDOTDOT"],`
			`["..=", "DOTDOTEQ"],`
			`[":", "COLON"],`
			`["::", "COLONCOLON"],`
			`["=", "EQ"],`
			`["==", "EQEQ"],`
			`["=>", "FAT_ARROW"],`
			`["!", "EXCL"],`
			`["!=", "NEQ"],`
			`["-", "MINUS"],`
			`["->", "THIN_ARROW"],`
compound ops 2018-08-05 08:09:25 -05:00			`["<=", "LTEQ"],`
			`[">=", "GTEQ"],`
			`["+=", "PLUSEQ"],`
			`["-=", "MINUSEQ"],`
ampersand -> amp 2018-08-05 10:18:02 -05:00			`["&&", "AMPAMP"],`
Lopps && logical ops 2018-08-05 10:16:52 -05:00			`["\|\|", "PIPEPIPE"],`
full precedence 2018-08-07 06:24:03 -05:00			`["<<", "SHL"],`
			`[">>", "SHR"],`
			`["<<=", "SHLEQ"],`
			`[">>=", "SHREQ"],`
generate single byte tokens 2018-07-30 09:46:50 -05:00			`],`
Parser: guess what? Groundwork! 2018-01-01 09:58:46 -06:00			`keywords: [`
			`"use",`
			`"fn",`
			`"struct",`
			`"enum",`
			`"trait",`
			`"impl",`
L: true and false are keywords 2018-01-08 12:21:59 -06:00			`"true",`
			`"false",`
G: extern crate 2018-01-08 15:06:42 -06:00			`"as",`
			`"extern",`
			`"crate",`
G: mod item 2018-01-09 13:35:55 -06:00			`"mod",`
G: visibility 2018-01-12 13:05:46 -06:00			`"pub",`
			`"self",`
			`"super",`
G: allow self & super in paths 2018-01-13 02:55:03 -06:00			`"in",`
G: struct flavors 2018-01-13 13:00:26 -06:00			`"where",`
G: type_parameter_list 2018-01-30 13:53:19 -06:00			`"for",`
			`"loop",`
			`"while",`
			`"if",`
If expr 2018-07-31 16:14:26 -05:00			`"else",`
L: const & static keywords 2018-02-02 14:30:17 -06:00			`"match",`
			`"const",`
			`"static",`
G: static items 2018-02-02 14:45:15 -06:00			`"mut",`
G: const item 2018-02-03 03:05:25 -06:00			`"unsafe",`
G: type item 2018-02-10 03:35:40 -06:00			`"type",`
G: value_parameters, patterns & let statement 2018-02-17 16:06:48 -06:00			`"ref",`
			`"let",`
move lambdas 2018-07-31 16:30:17 -05:00			`"move",`
return expr 2018-08-01 03:27:31 -05:00			`"return",`
Parser: guess what? Groundwork! 2018-01-01 09:58:46 -06:00			`],`
Support contextual tokens 2018-02-04 07:46:26 -06:00			`contextual_keywords: [`
			`"auto",`
			`"default",`
			`"union",`
			`],`
Parser test boilerplate 2017-12-31 14:27:36 -06:00			`tokens: [`
Cleanup character classes 2017-12-29 15:48:47 -06:00			`"ERROR",`
Grammar in ron 2017-12-28 16:21:54 -06:00			`"IDENT",`
Cleanup character classes 2017-12-29 15:48:47 -06:00			`"UNDERSCORE",`
Grammar in ron 2017-12-28 16:21:54 -06:00			`"WHITESPACE",`
Lexer: start numbers 2017-12-30 06:22:40 -06:00			`"INT_NUMBER",`
			`"FLOAT_NUMBER",`
Lexer: basic chars & lifetimes 2017-12-31 01:41:42 -06:00			`"LIFETIME",`
Lexer: byte strings 2017-12-31 05:02:55 -06:00			`"CHAR",`
			`"BYTE",`
			`"STRING",`
			`"RAW_STRING",`
			`"BYTE_STRING",`
			`"RAW_BYTE_STRING",`
Lexer: comments groundwork 2017-12-31 07:42:22 -06:00			`"COMMENT",`
			`"DOC_COMMENT",`
			`"SHEBANG",`
Parser test boilerplate 2017-12-31 14:27:36 -06:00			`],`
			`nodes: [`
Parser: guess what? Groundwork! 2018-01-01 09:58:46 -06:00			`"FILE",`
G: extern functions 2018-02-02 13:08:14 -06:00
STRUCT_ITEM -> STRUCT 2018-08-11 02:04:47 -05:00			`"STRUCT",`
ENUM_ITEM -> ENUM 2018-08-11 02:05:26 -05:00			`"ENUM",`
fn_item -> function 2018-08-09 09:44:40 -05:00			`"FUNCTION",`
G: extern crate 2018-01-08 15:06:42 -06:00			`"EXTERN_CRATE_ITEM",`
more renames 2018-08-11 02:56:40 -05:00			`"MODULE",`
G: simplest use items 2018-01-09 14:32:18 -06:00			`"USE_ITEM",`
G: static items 2018-02-02 14:45:15 -06:00			`"STATIC_ITEM",`
G: const item 2018-02-03 03:05:25 -06:00			`"CONST_ITEM",`
more renames 2018-08-11 02:56:40 -05:00			`"TRAIT",`
G: unsafe impl & trait 2018-02-04 04:39:24 -06:00			`"IMPL_ITEM",`
G: type item 2018-02-10 03:35:40 -06:00			`"TYPE_ITEM",`
item-macros 2018-08-05 06:08:46 -05:00			`"MACRO_CALL",`
			`"TOKEN_TREE",`
G: extern functions 2018-02-02 13:08:14 -06:00
G: more types 2018-02-10 15:46:17 -06:00			`"PAREN_TYPE",`
			`"TUPLE_TYPE",`
			`"NEVER_TYPE",`
			`"PATH_TYPE",`
G: pointer types 2018-02-11 02:19:54 -06:00			`"POINTER_TYPE",`
G: slice & array types 2018-02-11 02:37:08 -06:00			`"ARRAY_TYPE",`
			`"SLICE_TYPE",`
G: reference types 2018-02-11 02:54:09 -06:00			`"REFERENCE_TYPE",`
G: placeholder types 2018-02-11 02:57:05 -06:00			`"PLACEHOLDER_TYPE",`
G: fn pointer type 2018-02-11 03:51:09 -06:00			`"FN_POINTER_TYPE",`
G: for type 2018-02-11 14:32:49 -06:00			`"FOR_TYPE",`
impl trait type 2018-07-31 14:41:29 -05:00			`"IMPL_TRAIT_TYPE",`
G: more types 2018-02-10 15:46:17 -06:00
G: value_parameters, patterns & let statement 2018-02-17 16:06:48 -06:00			`"REF_PAT",`
			`"BIND_PAT",`
			`"PLACEHOLDER_PAT",`
tuple patterns 2018-08-04 07:47:45 -05:00			`"PATH_PAT",`
			`"STRUCT_PAT",`
tuple patterns 2018-08-07 06:41:03 -05:00			`"TUPLE_STRUCT_PAT",`
tuple patterns 2018-08-04 07:47:45 -05:00			`"TUPLE_PAT",`
Semi statements 2018-08-07 09:00:45 -05:00			`"SLICE_PAT",`
Range patterns 2018-08-08 07:05:33 -05:00			`"RANGE_PAT",`
G: value_parameters, patterns & let statement 2018-02-17 16:06:48 -06:00
Pratt 2018-08-04 08:34:54 -05:00			`// atoms`
G: value_parameters, patterns & let statement 2018-02-17 16:06:48 -06:00			`"TUPLE_EXPR",`
for && array 2018-08-05 10:24:56 -05:00			`"ARRAY_EXPR",`
Paren expr 2018-08-05 09:19:03 -05:00			`"PAREN_EXPR",`
Path expressions 2018-07-30 09:02:51 -05:00			`"PATH_EXPR",`
lambda expressions 2018-07-31 15:13:08 -05:00			`"LAMBDA_EXPR",`
If expr 2018-07-31 16:14:26 -05:00			`"IF_EXPR",`
Conditionals 2018-08-04 17:03:22 -05:00			`"WHILE_EXPR",`
Lopps && logical ops 2018-08-05 10:16:52 -05:00			`"LOOP_EXPR",`
for && array 2018-08-05 10:24:56 -05:00			`"FOR_EXPR",`
return expr 2018-08-01 03:27:31 -05:00			`"BLOCK_EXPR",`
			`"RETURN_EXPR",`
Match expr 2018-08-04 05:39:03 -05:00			`"MATCH_EXPR",`
			`"MATCH_ARM",`
			`"MATCH_GUARD",`
Pratt 2018-08-04 08:34:54 -05:00			`"STRUCT_LIT",`
			`"STRUCT_LIT_FIELD",`

			`// postfix`
			`"CALL_EXPR",`
index expr 2018-08-05 09:24:44 -05:00			`"INDEX_EXPR",`
Pratt 2018-08-04 08:34:54 -05:00			`"METHOD_CALL_EXPR",`
			`"FIELD_EXPR",`
			`"TRY_EXPR",`
cast expr 2018-08-06 19:55:16 -05:00			`"CAST_EXPR",`
Pratt 2018-08-04 08:34:54 -05:00
			`// unary`
			`"REF_EXPR",`
simplify unary expr grammar 2018-08-07 06:52:03 -05:00			`"PREFIX_EXPR",`
Pratt 2018-08-04 08:34:54 -05:00
Range expr 2018-08-05 10:07:06 -05:00			`"RANGE_EXPR", // just weird`
Pratt 2018-08-04 08:34:54 -05:00			`"BIN_EXPR",`

G: value_parameters, patterns & let statement 2018-02-17 16:06:48 -06:00
block expr 2018-08-01 02:51:42 -05:00			`"EXTERN_BLOCK_EXPR",`
G: extern functions 2018-02-02 13:08:14 -06:00			`"ENUM_VARIANT",`
			`"NAMED_FIELD",`
			`"POS_FIELD",`
			`"ATTR",`
			`"META_ITEM", // not an item actually`
G: use trees 2018-01-13 04:42:19 -06:00			`"USE_TREE",`
G: simplest use items 2018-01-09 14:32:18 -06:00			`"PATH",`
			`"PATH_SEGMENT",`
G: inner attributes 2018-01-08 12:40:00 -06:00			`"LITERAL",`
G: extern crate 2018-01-08 15:06:42 -06:00			`"ALIAS",`
G: visibility 2018-01-12 13:05:46 -06:00			`"VISIBILITY",`
G: where clause 2018-02-10 03:53:07 -06:00			`"WHERE_CLAUSE",`
Where clauses 2018-08-08 11:26:38 -05:00			`"WHERE_PRED",`
G: extern functions 2018-02-02 13:08:14 -06:00			`"ABI",`
G: introduce names 2018-02-10 05:00:23 -06:00			`"NAME",`
			`"NAME_REF",`
expr stmt 2018-07-31 04:59:52 -05:00
G: value_parameters, patterns & let statement 2018-02-17 16:06:48 -06:00			`"LET_STMT",`
expr stmt 2018-07-31 04:59:52 -05:00			`"EXPR_STMT",`
Path expressions 2018-07-30 09:02:51 -05:00
			`"TYPE_PARAM_LIST",`
Nodes for type args 2018-07-31 11:37:40 -05:00			`"LIFETIME_PARAM",`
			`"TYPE_PARAM",`
Path expressions 2018-07-30 09:02:51 -05:00			`"TYPE_ARG_LIST",`
Nodes for type args 2018-07-31 11:37:40 -05:00			`"LIFETIME_ARG",`
			`"TYPE_ARG",`
			`"ASSOC_TYPE_ARG",`
Introduce param & arg list 2018-07-31 04:32:53 -05:00
			`"PARAM_LIST",`
Rename VALUE_PARAMETER -> PARAM 2018-07-31 15:13:55 -05:00			`"PARAM",`
impl items 2018-07-31 10:03:50 -05:00			`"SELF_PARAM",`
Introduce param & arg list 2018-07-31 04:32:53 -05:00			`"ARG_LIST",`
Generate AST 2018-08-09 09:43:39 -05:00			`],`
Use dict for AST 2018-08-11 02:11:58 -05:00			`ast: {`
			`"File": (`
bump ron 2018-08-11 01:38:27 -05:00			`collections: [`
Use dict for AST 2018-08-11 02:11:58 -05:00			`["functions", "Function"]`
bump ron 2018-08-11 01:38:27 -05:00			`]`
Generate AST 2018-08-09 09:43:39 -05:00			`),`
Use dict for AST 2018-08-11 02:11:58 -05:00			`"Function": (`
visitor 2018-08-11 04:28:59 -05:00			`traits: ["NameOwner"]`
Generate AST 2018-08-09 09:43:39 -05:00			`),`
more renames 2018-08-11 02:56:40 -05:00			`"Struct": (`
visitor 2018-08-11 04:28:59 -05:00			`traits: ["NameOwner"]`
more renames 2018-08-11 02:56:40 -05:00			`),`
			`"Enum": (`
visitor 2018-08-11 04:28:59 -05:00			`traits: ["NameOwner"]`
more renames 2018-08-11 02:56:40 -05:00			`),`
heck 2018-08-11 03:03:22 -05:00			`"Trait": (`
visitor 2018-08-11 04:28:59 -05:00			`traits: ["NameOwner"]`
heck 2018-08-11 03:03:22 -05:00			`),`
			`"Module": (`
visitor 2018-08-11 04:28:59 -05:00			`traits: ["NameOwner"]`
heck 2018-08-11 03:03:22 -05:00			`),`
			`"ConstItem": (`
visitor 2018-08-11 04:28:59 -05:00			`traits: ["NameOwner"]`
heck 2018-08-11 03:03:22 -05:00			`),`
			`"StaticItem": (`
visitor 2018-08-11 04:28:59 -05:00			`traits: ["NameOwner"]`
heck 2018-08-11 03:03:22 -05:00			`),`
Use dict for AST 2018-08-11 02:11:58 -05:00			`"Name": (),`
			`},`
Generic params in structs 2018-01-28 09:53:53 -06:00			`)`