2020-02-27 04:07:26 -06:00
|
|
|
//! Defines input for code generation process.
|
|
|
|
|
2020-01-03 13:37:02 -06:00
|
|
|
pub(crate) struct KindsSrc<'a> {
|
|
|
|
pub(crate) punct: &'a [(&'a str, &'a str)],
|
|
|
|
pub(crate) keywords: &'a [&'a str],
|
|
|
|
pub(crate) contextual_keywords: &'a [&'a str],
|
|
|
|
pub(crate) literals: &'a [&'a str],
|
|
|
|
pub(crate) tokens: &'a [&'a str],
|
|
|
|
pub(crate) nodes: &'a [&'a str],
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) const KINDS_SRC: KindsSrc = KindsSrc {
|
|
|
|
punct: &[
|
2020-04-10 10:06:57 -05:00
|
|
|
(";", "SEMICOLON"),
|
2020-01-03 13:37:02 -06:00
|
|
|
(",", "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"),
|
|
|
|
("_", "UNDERSCORE"),
|
|
|
|
(".", "DOT"),
|
2020-04-10 10:06:57 -05:00
|
|
|
("..", "DOT2"),
|
|
|
|
("...", "DOT3"),
|
|
|
|
("..=", "DOT2EQ"),
|
2020-01-03 13:37:02 -06:00
|
|
|
(":", "COLON"),
|
2020-04-10 10:06:57 -05:00
|
|
|
("::", "COLON2"),
|
2020-01-03 13:37:02 -06:00
|
|
|
("=", "EQ"),
|
2020-04-10 10:06:57 -05:00
|
|
|
("==", "EQ2"),
|
2020-01-03 13:37:02 -06:00
|
|
|
("=>", "FAT_ARROW"),
|
2020-04-10 10:06:57 -05:00
|
|
|
("!", "BANG"),
|
2020-01-03 13:37:02 -06:00
|
|
|
("!=", "NEQ"),
|
|
|
|
("-", "MINUS"),
|
|
|
|
("->", "THIN_ARROW"),
|
|
|
|
("<=", "LTEQ"),
|
|
|
|
(">=", "GTEQ"),
|
|
|
|
("+=", "PLUSEQ"),
|
|
|
|
("-=", "MINUSEQ"),
|
|
|
|
("|=", "PIPEEQ"),
|
|
|
|
("&=", "AMPEQ"),
|
|
|
|
("^=", "CARETEQ"),
|
|
|
|
("/=", "SLASHEQ"),
|
|
|
|
("*=", "STAREQ"),
|
|
|
|
("%=", "PERCENTEQ"),
|
2020-04-10 10:06:57 -05:00
|
|
|
("&&", "AMP2"),
|
|
|
|
("||", "PIPE2"),
|
2020-01-03 13:37:02 -06:00
|
|
|
("<<", "SHL"),
|
|
|
|
(">>", "SHR"),
|
|
|
|
("<<=", "SHLEQ"),
|
|
|
|
(">>=", "SHREQ"),
|
|
|
|
],
|
|
|
|
keywords: &[
|
|
|
|
"as", "async", "await", "box", "break", "const", "continue", "crate", "dyn", "else",
|
|
|
|
"enum", "extern", "false", "fn", "for", "if", "impl", "in", "let", "loop", "macro",
|
|
|
|
"match", "mod", "move", "mut", "pub", "ref", "return", "self", "static", "struct", "super",
|
|
|
|
"trait", "true", "try", "type", "unsafe", "use", "where", "while",
|
|
|
|
],
|
2020-04-03 14:12:09 -05:00
|
|
|
contextual_keywords: &["auto", "default", "existential", "union", "raw"],
|
2020-01-03 13:37:02 -06:00
|
|
|
literals: &[
|
|
|
|
"INT_NUMBER",
|
|
|
|
"FLOAT_NUMBER",
|
|
|
|
"CHAR",
|
|
|
|
"BYTE",
|
|
|
|
"STRING",
|
|
|
|
"RAW_STRING",
|
|
|
|
"BYTE_STRING",
|
|
|
|
"RAW_BYTE_STRING",
|
|
|
|
],
|
|
|
|
tokens: &[
|
|
|
|
"ERROR",
|
|
|
|
"IDENT",
|
|
|
|
"WHITESPACE",
|
|
|
|
"LIFETIME",
|
|
|
|
"COMMENT",
|
|
|
|
"SHEBANG",
|
|
|
|
"L_DOLLAR",
|
|
|
|
"R_DOLLAR",
|
|
|
|
],
|
|
|
|
nodes: &[
|
|
|
|
"SOURCE_FILE",
|
|
|
|
"STRUCT_DEF",
|
|
|
|
"UNION_DEF",
|
|
|
|
"ENUM_DEF",
|
|
|
|
"FN_DEF",
|
|
|
|
"RET_TYPE",
|
|
|
|
"EXTERN_CRATE_ITEM",
|
|
|
|
"MODULE",
|
|
|
|
"USE_ITEM",
|
|
|
|
"STATIC_DEF",
|
|
|
|
"CONST_DEF",
|
|
|
|
"TRAIT_DEF",
|
2020-02-29 14:24:40 -06:00
|
|
|
"IMPL_DEF",
|
2020-01-03 13:37:02 -06:00
|
|
|
"TYPE_ALIAS_DEF",
|
|
|
|
"MACRO_CALL",
|
|
|
|
"TOKEN_TREE",
|
|
|
|
"MACRO_DEF",
|
|
|
|
"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",
|
|
|
|
"DYN_TRAIT_TYPE",
|
2020-02-09 12:57:01 -06:00
|
|
|
"OR_PAT",
|
|
|
|
"PAREN_PAT",
|
2020-01-03 13:37:02 -06:00
|
|
|
"REF_PAT",
|
|
|
|
"BOX_PAT",
|
|
|
|
"BIND_PAT",
|
|
|
|
"PLACEHOLDER_PAT",
|
|
|
|
"DOT_DOT_PAT",
|
|
|
|
"PATH_PAT",
|
|
|
|
"RECORD_PAT",
|
|
|
|
"RECORD_FIELD_PAT_LIST",
|
|
|
|
"RECORD_FIELD_PAT",
|
|
|
|
"TUPLE_STRUCT_PAT",
|
|
|
|
"TUPLE_PAT",
|
|
|
|
"SLICE_PAT",
|
|
|
|
"RANGE_PAT",
|
|
|
|
"LITERAL_PAT",
|
2020-04-03 08:38:42 -05:00
|
|
|
"MACRO_PAT",
|
2020-01-03 13:37:02 -06:00
|
|
|
// atoms
|
|
|
|
"TUPLE_EXPR",
|
|
|
|
"ARRAY_EXPR",
|
|
|
|
"PAREN_EXPR",
|
|
|
|
"PATH_EXPR",
|
|
|
|
"LAMBDA_EXPR",
|
|
|
|
"IF_EXPR",
|
|
|
|
"WHILE_EXPR",
|
|
|
|
"CONDITION",
|
|
|
|
"LOOP_EXPR",
|
|
|
|
"FOR_EXPR",
|
|
|
|
"CONTINUE_EXPR",
|
|
|
|
"BREAK_EXPR",
|
|
|
|
"LABEL",
|
|
|
|
"BLOCK_EXPR",
|
|
|
|
"RETURN_EXPR",
|
|
|
|
"MATCH_EXPR",
|
|
|
|
"MATCH_ARM_LIST",
|
|
|
|
"MATCH_ARM",
|
|
|
|
"MATCH_GUARD",
|
|
|
|
"RECORD_LIT",
|
|
|
|
"RECORD_FIELD_LIST",
|
|
|
|
"RECORD_FIELD",
|
2020-05-01 18:18:19 -05:00
|
|
|
"EFFECT_EXPR",
|
2020-01-03 13:37:02 -06:00
|
|
|
"BOX_EXPR",
|
|
|
|
// postfix
|
|
|
|
"CALL_EXPR",
|
|
|
|
"INDEX_EXPR",
|
|
|
|
"METHOD_CALL_EXPR",
|
|
|
|
"FIELD_EXPR",
|
|
|
|
"AWAIT_EXPR",
|
|
|
|
"TRY_EXPR",
|
|
|
|
"CAST_EXPR",
|
|
|
|
// unary
|
|
|
|
"REF_EXPR",
|
|
|
|
"PREFIX_EXPR",
|
|
|
|
"RANGE_EXPR", // just weird
|
|
|
|
"BIN_EXPR",
|
|
|
|
"EXTERN_BLOCK",
|
|
|
|
"EXTERN_ITEM_LIST",
|
|
|
|
"ENUM_VARIANT",
|
|
|
|
"RECORD_FIELD_DEF_LIST",
|
|
|
|
"RECORD_FIELD_DEF",
|
|
|
|
"TUPLE_FIELD_DEF_LIST",
|
|
|
|
"TUPLE_FIELD_DEF",
|
|
|
|
"ENUM_VARIANT_LIST",
|
|
|
|
"ITEM_LIST",
|
|
|
|
"ATTR",
|
|
|
|
"META_ITEM", // not an item actually
|
|
|
|
"USE_TREE",
|
|
|
|
"USE_TREE_LIST",
|
|
|
|
"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",
|
|
|
|
"CONST_PARAM",
|
|
|
|
"TYPE_ARG_LIST",
|
|
|
|
"LIFETIME_ARG",
|
|
|
|
"TYPE_ARG",
|
|
|
|
"ASSOC_TYPE_ARG",
|
2020-01-06 16:59:03 -06:00
|
|
|
"CONST_ARG",
|
2020-01-03 13:37:02 -06:00
|
|
|
"PARAM_LIST",
|
|
|
|
"PARAM",
|
|
|
|
"SELF_PARAM",
|
|
|
|
"ARG_LIST",
|
|
|
|
"TYPE_BOUND",
|
|
|
|
"TYPE_BOUND_LIST",
|
|
|
|
// macro related
|
|
|
|
"MACRO_ITEMS",
|
|
|
|
"MACRO_STMTS",
|
|
|
|
],
|
|
|
|
};
|
|
|
|
|
|
|
|
pub(crate) struct AstSrc<'a> {
|
2020-04-10 08:53:09 -05:00
|
|
|
pub(crate) tokens: &'a [&'a str],
|
2020-01-03 13:37:02 -06:00
|
|
|
pub(crate) nodes: &'a [AstNodeSrc<'a>],
|
|
|
|
pub(crate) enums: &'a [AstEnumSrc<'a>],
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) struct AstNodeSrc<'a> {
|
2020-04-21 20:15:55 -05:00
|
|
|
pub(crate) doc: &'a [&'a str],
|
2020-01-03 13:37:02 -06:00
|
|
|
pub(crate) name: &'a str,
|
|
|
|
pub(crate) traits: &'a [&'a str],
|
2020-04-10 03:07:09 -05:00
|
|
|
pub(crate) fields: &'a [Field<'a>],
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) enum Field<'a> {
|
|
|
|
Token(&'a str),
|
|
|
|
Node { name: &'a str, src: FieldSrc<'a> },
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
|
|
|
|
2020-04-10 02:14:14 -05:00
|
|
|
pub(crate) enum FieldSrc<'a> {
|
2020-01-03 13:37:02 -06:00
|
|
|
Shorthand,
|
2020-04-10 02:14:14 -05:00
|
|
|
Optional(&'a str),
|
|
|
|
Many(&'a str),
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) struct AstEnumSrc<'a> {
|
2020-04-21 20:15:55 -05:00
|
|
|
pub(crate) doc: &'a [&'a str],
|
2020-01-03 13:37:02 -06:00
|
|
|
pub(crate) name: &'a str,
|
|
|
|
pub(crate) traits: &'a [&'a str],
|
|
|
|
pub(crate) variants: &'a [&'a str],
|
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! ast_nodes {
|
|
|
|
($(
|
2020-04-21 20:15:55 -05:00
|
|
|
$(#[doc = $doc:expr])+
|
2020-01-03 13:37:02 -06:00
|
|
|
struct $name:ident$(: $($trait:ident),*)? {
|
2020-04-10 03:07:09 -05:00
|
|
|
$($field_name:ident $(![$token:tt])? $(: $ty:tt)?),*$(,)?
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
|
|
|
)*) => {
|
|
|
|
[$(
|
|
|
|
AstNodeSrc {
|
2020-04-21 20:15:55 -05:00
|
|
|
doc: &[$($doc),*],
|
2020-01-03 13:37:02 -06:00
|
|
|
name: stringify!($name),
|
|
|
|
traits: &[$($(stringify!($trait)),*)?],
|
2020-04-10 03:07:09 -05:00
|
|
|
fields: &[
|
|
|
|
$(field!($(T![$token])? $field_name $($ty)?)),*
|
|
|
|
],
|
2020-01-03 13:37:02 -06:00
|
|
|
|
|
|
|
}
|
|
|
|
),*]
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2020-04-10 03:07:09 -05:00
|
|
|
macro_rules! field {
|
|
|
|
(T![$token:tt] T) => {
|
|
|
|
Field::Token(stringify!($token))
|
|
|
|
};
|
2020-01-03 13:37:02 -06:00
|
|
|
($field_name:ident) => {
|
2020-04-10 03:07:09 -05:00
|
|
|
Field::Node { name: stringify!($field_name), src: FieldSrc::Shorthand }
|
2020-01-03 13:37:02 -06:00
|
|
|
};
|
|
|
|
($field_name:ident [$ty:ident]) => {
|
2020-04-10 03:07:09 -05:00
|
|
|
Field::Node { name: stringify!($field_name), src: FieldSrc::Many(stringify!($ty)) }
|
2020-01-03 13:37:02 -06:00
|
|
|
};
|
|
|
|
($field_name:ident $ty:ident) => {
|
2020-04-10 03:07:09 -05:00
|
|
|
Field::Node { name: stringify!($field_name), src: FieldSrc::Optional(stringify!($ty)) }
|
2020-01-03 13:37:02 -06:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! ast_enums {
|
|
|
|
($(
|
2020-04-21 20:15:55 -05:00
|
|
|
$(#[doc = $doc:expr])+
|
2020-01-03 13:37:02 -06:00
|
|
|
enum $name:ident $(: $($trait:ident),*)? {
|
|
|
|
$($variant:ident),*$(,)?
|
|
|
|
}
|
|
|
|
)*) => {
|
|
|
|
[$(
|
|
|
|
AstEnumSrc {
|
2020-04-21 20:15:55 -05:00
|
|
|
doc: &[$($doc),*],
|
2020-01-03 13:37:02 -06:00
|
|
|
name: stringify!($name),
|
|
|
|
traits: &[$($(stringify!($trait)),*)?],
|
|
|
|
variants: &[$(stringify!($variant)),*],
|
|
|
|
}
|
|
|
|
),*]
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) const AST_SRC: AstSrc = AstSrc {
|
2020-04-10 08:53:09 -05:00
|
|
|
tokens: &["Whitespace", "Comment", "String", "RawString"],
|
2020-01-03 13:37:02 -06:00
|
|
|
nodes: &ast_nodes! {
|
2020-04-21 20:15:55 -05:00
|
|
|
/// The entire Rust source file. Includes all top-level inner attributes and module items.
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/crates-and-source-files.html)
|
2020-05-03 05:00:27 -05:00
|
|
|
struct SourceFile: ModuleItemOwner, AttrsOwner, DocCommentsOwner {
|
2020-01-03 13:37:02 -06:00
|
|
|
modules: [Module],
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Function definition either with body or not.
|
|
|
|
/// Includes all of its attributes and doc comments.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// pub extern "C" fn foo<T>(#[attr] Patern {p}: Pattern) -> u32
|
|
|
|
/// where
|
|
|
|
/// T: Debug
|
|
|
|
/// {
|
|
|
|
/// 42
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
///
|
|
|
|
/// extern "C" {
|
|
|
|
/// ❰ fn fn_decl(also_variadic_ffi: u32, ...) -> u32; ❱
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// - [Reference](https://doc.rust-lang.org/reference/items/functions.html)
|
|
|
|
/// - [Nomicon](https://doc.rust-lang.org/nomicon/ffi.html#variadic-functions)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct FnDef: VisibilityOwner, NameOwner, TypeParamsOwner, DocCommentsOwner, AttrsOwner {
|
2020-04-03 14:12:09 -05:00
|
|
|
Abi,
|
2020-04-10 03:07:09 -05:00
|
|
|
T![const],
|
|
|
|
T![default],
|
|
|
|
T![async],
|
|
|
|
T![unsafe],
|
|
|
|
T![fn],
|
2020-01-03 13:37:02 -06:00
|
|
|
ParamList,
|
|
|
|
RetType,
|
2020-05-10 13:46:26 -05:00
|
|
|
body: BlockExpr,
|
|
|
|
T![;]
|
|
|
|
}
|
2020-01-03 13:37:02 -06:00
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Return type annotation.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// fn foo(a: u32) ❰ -> Option<u32> ❱ { Some(a) }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/functions.html)
|
2020-04-10 03:18:43 -05:00
|
|
|
struct RetType { T![->], TypeRef }
|
2020-01-03 13:37:02 -06:00
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Struct definition.
|
|
|
|
/// Includes all of its attributes and doc comments.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// struct Foo<T> where T: Debug {
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// pub a: u32,
|
|
|
|
/// b: T,
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
///
|
|
|
|
/// ❰ struct Foo; ❱
|
|
|
|
/// ❰ struct Foo<T>(#[attr] T) where T: Debug; ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct StructDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner {
|
2020-04-10 03:07:09 -05:00
|
|
|
T![struct],
|
2020-04-03 14:12:09 -05:00
|
|
|
FieldDefList,
|
2020-04-10 03:11:05 -05:00
|
|
|
T![;]
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Union definition.
|
|
|
|
/// Includes all of its attributes and doc comments.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// pub union Foo<T> where T: Debug {
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// a: T,
|
|
|
|
/// b: u32,
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/unions.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct UnionDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner {
|
2020-04-10 03:07:09 -05:00
|
|
|
T![union],
|
2020-01-03 13:37:02 -06:00
|
|
|
RecordFieldDefList,
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Record field definition list including enclosing curly braces.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// struct Foo // same for union
|
|
|
|
/// ❰
|
|
|
|
/// {
|
|
|
|
/// a: u32,
|
|
|
|
/// b: bool,
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
|
2020-04-10 03:27:23 -05:00
|
|
|
struct RecordFieldDefList { T!['{'], fields: [RecordFieldDef], T!['}'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Record field definition including its attributes and doc comments.
|
|
|
|
///
|
|
|
|
/// ` ``
|
|
|
|
/// same for union
|
|
|
|
/// struct Foo {
|
|
|
|
/// ❰
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// pub a: u32
|
|
|
|
/// ❱
|
|
|
|
///
|
|
|
|
/// ❰ b: bool ❱
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct RecordFieldDef: VisibilityOwner, NameOwner, AttrsOwner, DocCommentsOwner, TypeAscriptionOwner { }
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Tuple field definition list including enclosing parens.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// struct Foo ❰ (u32, String, Vec<u32>) ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
|
2020-04-10 03:29:59 -05:00
|
|
|
struct TupleFieldDefList { T!['('], fields: [TupleFieldDef], T![')'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Tuple field definition including its attributes.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// struct Foo(❰ #[attr] u32 ❱);
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct TupleFieldDef: VisibilityOwner, AttrsOwner {
|
|
|
|
TypeRef,
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Enum definition.
|
|
|
|
/// Includes all of its attributes and doc comments.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// pub enum Foo<T> where T: Debug {
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// Bar,
|
|
|
|
/// Baz(#[attr] u32),
|
|
|
|
/// Bruh {
|
|
|
|
/// a: u32,
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// b: T,
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct EnumDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner {
|
2020-04-10 03:07:09 -05:00
|
|
|
T![enum],
|
2020-01-03 13:37:02 -06:00
|
|
|
variant_list: EnumVariantList,
|
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Enum variant definition list including enclosing curly braces.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// enum Foo
|
|
|
|
/// ❰
|
|
|
|
/// {
|
|
|
|
/// Bar,
|
|
|
|
/// Baz(u32),
|
|
|
|
/// Bruh {
|
|
|
|
/// a: u32
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct EnumVariantList {
|
2020-04-10 03:27:23 -05:00
|
|
|
T!['{'],
|
2020-01-03 13:37:02 -06:00
|
|
|
variants: [EnumVariant],
|
2020-04-10 03:27:23 -05:00
|
|
|
T!['}']
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Enum variant definition including its attributes and discriminant value definition.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// enum Foo {
|
|
|
|
/// ❰
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// Bar
|
|
|
|
/// ❱
|
|
|
|
///
|
|
|
|
/// // same for tuple and record variants
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html)
|
2020-04-03 14:12:09 -05:00
|
|
|
struct EnumVariant: VisibilityOwner, NameOwner, DocCommentsOwner, AttrsOwner {
|
|
|
|
FieldDefList,
|
2020-04-10 03:35:39 -05:00
|
|
|
T![=],
|
2020-01-03 13:37:02 -06:00
|
|
|
Expr
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Trait definition.
|
|
|
|
/// Includes all of its attributes and doc comments.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// pub unsafe trait Foo<T>: Debug where T: Debug {
|
|
|
|
/// // ...
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/traits.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct TraitDef: VisibilityOwner, NameOwner, AttrsOwner, DocCommentsOwner, TypeParamsOwner, TypeBoundsOwner {
|
2020-04-10 03:07:09 -05:00
|
|
|
T![unsafe],
|
|
|
|
T![auto],
|
|
|
|
T![trait],
|
2020-01-03 13:37:02 -06:00
|
|
|
ItemList,
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Module definition either with body or not.
|
|
|
|
/// Includes all of its inner and outer attributes, module items, doc comments.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// pub mod foo;
|
|
|
|
/// ❱
|
|
|
|
///
|
|
|
|
/// ❰
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// pub mod bar {
|
|
|
|
/// //! Inner docs
|
|
|
|
/// #![inner_attr]
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/modules.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct Module: VisibilityOwner, NameOwner, AttrsOwner, DocCommentsOwner {
|
2020-04-10 03:07:09 -05:00
|
|
|
T![mod],
|
2020-01-03 13:37:02 -06:00
|
|
|
ItemList,
|
2020-04-10 03:11:05 -05:00
|
|
|
T![;]
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Item defintion list.
|
|
|
|
/// This is used for both top-level items and impl block items.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// fn foo {}
|
|
|
|
/// struct Bar;
|
|
|
|
/// enum Baz;
|
|
|
|
/// trait Bruh;
|
|
|
|
/// const BRUUH: u32 = 42;
|
|
|
|
/// ❱
|
|
|
|
///
|
|
|
|
/// impl Foo
|
|
|
|
/// ❰
|
|
|
|
/// {
|
|
|
|
/// fn bar() {}
|
|
|
|
/// const BAZ: u32 = 42;
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items.html)
|
2020-04-09 16:02:10 -05:00
|
|
|
struct ItemList: ModuleItemOwner {
|
2020-04-10 03:27:23 -05:00
|
|
|
T!['{'],
|
2020-05-05 10:56:10 -05:00
|
|
|
assoc_items: [AssocItem],
|
2020-04-10 03:27:23 -05:00
|
|
|
T!['}']
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Constant variable definition.
|
|
|
|
/// Includes all of its attributes and doc comments.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// pub const FOO: u32 = 42;
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/constant-items.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct ConstDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner, TypeAscriptionOwner {
|
2020-04-10 03:07:09 -05:00
|
|
|
T![default],
|
|
|
|
T![const],
|
2020-04-10 03:35:39 -05:00
|
|
|
T![=],
|
2020-01-03 13:37:02 -06:00
|
|
|
body: Expr,
|
2020-04-10 03:11:05 -05:00
|
|
|
T![;]
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Static variable definition.
|
|
|
|
/// Includes all of its attributes and doc comments.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// pub static mut FOO: u32 = 42;
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/static-items.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct StaticDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner, TypeAscriptionOwner {
|
2020-04-10 03:07:09 -05:00
|
|
|
T![static],
|
|
|
|
T![mut],
|
2020-04-10 03:35:39 -05:00
|
|
|
T![=],
|
2020-01-03 13:37:02 -06:00
|
|
|
body: Expr,
|
2020-04-10 03:11:05 -05:00
|
|
|
T![;]
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Type alias definition.
|
|
|
|
/// Includes associated type clauses with type bounds.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// pub type Foo<T> where T: Debug = T;
|
|
|
|
/// ❱
|
|
|
|
///
|
|
|
|
/// trait Bar {
|
|
|
|
/// ❰ type Baz: Debug; ❱
|
|
|
|
/// ❰ type Bruh = String; ❱
|
|
|
|
/// ❰ type Bruuh: Debug = u32; ❱
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/type-aliases.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct TypeAliasDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner, TypeBoundsOwner {
|
2020-04-10 03:07:09 -05:00
|
|
|
T![default],
|
|
|
|
T![type],
|
2020-04-10 03:35:39 -05:00
|
|
|
T![=],
|
2020-01-03 13:37:02 -06:00
|
|
|
TypeRef,
|
2020-04-10 03:11:05 -05:00
|
|
|
T![;]
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Inherent and trait impl definition.
|
|
|
|
/// Includes all of its inner and outer attributes.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// #[attr]
|
2020-05-10 11:17:46 -05:00
|
|
|
/// unsafe impl<T> const !Foo for Bar where T: Debug {
|
2020-04-21 20:15:55 -05:00
|
|
|
/// #![inner_attr]
|
|
|
|
/// // ...
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/implementations.html)
|
2020-05-03 05:00:27 -05:00
|
|
|
struct ImplDef: TypeParamsOwner, AttrsOwner, DocCommentsOwner {
|
2020-04-10 03:07:09 -05:00
|
|
|
T![default],
|
2020-05-10 11:17:46 -05:00
|
|
|
T![const],
|
2020-04-10 03:07:09 -05:00
|
|
|
T![unsafe],
|
|
|
|
T![impl],
|
2020-04-10 03:35:39 -05:00
|
|
|
T![!],
|
2020-04-10 03:07:09 -05:00
|
|
|
T![for],
|
2020-01-03 13:37:02 -06:00
|
|
|
ItemList,
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Parenthesized type reference.
|
|
|
|
/// Note: parens are only used for grouping, this is not a tuple type.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// // This is effectively just `u32`.
|
|
|
|
/// // Single-item tuple must be defined with a trailing comma: `(u32,)`
|
|
|
|
/// type Foo = ❰ (u32) ❱;
|
|
|
|
///
|
|
|
|
/// let bar: &'static ❰ (dyn Debug) ❱ = "bruh";
|
|
|
|
/// ```
|
2020-04-10 03:29:59 -05:00
|
|
|
struct ParenType { T!['('], TypeRef, T![')'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Unnamed tuple type.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let foo: ❰ (u32, bool) ❱ = (42, true);
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/types/tuple.html)
|
2020-04-10 03:29:59 -05:00
|
|
|
struct TupleType { T!['('], fields: [TypeRef], T![')'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// The never type (i.e. the exclamation point).
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// type T = ❰ ! ❱;
|
|
|
|
///
|
|
|
|
/// fn no_return() -> ❰ ! ❱ {
|
|
|
|
/// loop {}
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/types/never.html)
|
2020-04-10 03:35:39 -05:00
|
|
|
struct NeverType { T![!] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Path to a type.
|
|
|
|
/// Includes single identifier type names and elaborate paths with
|
|
|
|
/// generic parameters.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// type Foo = ❰ String ❱;
|
|
|
|
/// type Bar = ❰ std::vec::Vec<T> ❱;
|
|
|
|
/// type Baz = ❰ ::bruh::<Bruuh as Iterator>::Item ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/paths.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct PathType { Path }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Raw pointer type.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// type Foo = ❰ *const u32 ❱;
|
|
|
|
/// type Bar = ❰ *mut u32 ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/types/pointer.html#raw-pointers-const-and-mut)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct PointerType { T![*], T![const], T![mut], TypeRef }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Array type.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// type Foo = ❰ [u32; 24 - 3] ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/types/array.html)
|
2020-04-10 03:29:59 -05:00
|
|
|
struct ArrayType { T!['['], TypeRef, T![;], Expr, T![']'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Slice type.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// type Foo = ❰ [u8] ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/types/slice.html)
|
2020-04-10 03:29:59 -05:00
|
|
|
struct SliceType { T!['['], TypeRef, T![']'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Reference type.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// type Foo = ❰ &'static str ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/types/pointer.html)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct ReferenceType { T![&], T![lifetime], T![mut], TypeRef }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Placeholder type (i.e. the underscore).
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let foo: ❰ _ ❱ = 42_u32;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/types/inferred.html)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct PlaceholderType { T![_] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Function pointer type (not to be confused with `Fn*` family of traits).
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// type Foo = ❰ async fn(#[attr] u32, named: bool) -> u32 ❱;
|
|
|
|
///
|
|
|
|
/// type Bar = ❰ extern "C" fn(variadic: u32, #[attr] ...) ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/types/function-pointer.html)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct FnPointerType { Abi, T![unsafe], T![fn], ParamList, RetType }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Higher order type.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// type Foo = ❰ for<'a> fn(&'a str) ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/nomicon/hrtb.html)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct ForType { T![for], TypeParamList, TypeRef }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Opaque `impl Trait` type.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// fn foo(bar: ❰ impl Debug + Eq ❱) {}
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/types/impl-trait.html)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct ImplTraitType: TypeBoundsOwner { T![impl] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Trait object type.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// type Foo = ❰ dyn Debug ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/types/trait-object.html)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct DynTraitType: TypeBoundsOwner { T![dyn] }
|
2020-04-03 14:12:09 -05:00
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Tuple literal.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ (42, true) ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/tuple-expr.html)
|
2020-04-10 03:29:59 -05:00
|
|
|
struct TupleExpr: AttrsOwner { T!['('], exprs: [Expr], T![')'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Array literal.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ [#![inner_attr] true, false, true] ❱;
|
|
|
|
///
|
|
|
|
/// ❰ ["baz"; 24] ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/array-expr.html)
|
2020-04-10 03:29:59 -05:00
|
|
|
struct ArrayExpr: AttrsOwner { T!['['], exprs: [Expr], T![;], T![']'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Parenthesized expression.
|
|
|
|
/// Note: parens are only used for grouping, this is not a tuple literal.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ (#![inner_attr] 2 + 2) ❱ * 2;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/grouped-expr.html)
|
2020-04-10 03:29:59 -05:00
|
|
|
struct ParenExpr: AttrsOwner { T!['('], Expr, T![')'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Path to a symbol in expression context.
|
|
|
|
/// Includes single identifier variable names and elaborate paths with
|
|
|
|
/// generic parameters.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ Some::<i32> ❱;
|
|
|
|
/// ❰ foo ❱ + 42;
|
|
|
|
/// ❰ Vec::<i32>::push ❱;
|
|
|
|
/// ❰ <[i32]>::reverse ❱;
|
|
|
|
/// ❰ <String as std::borrow::Borrow<str>>::borrow ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/path-expr.html)
|
|
|
|
struct PathExpr { Path }
|
|
|
|
|
|
|
|
/// Anonymous callable object literal a.k.a. closure, lambda or functor.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ || 42 ❱;
|
|
|
|
/// ❰ |a: u32| val + 1 ❱;
|
|
|
|
/// ❰ async |#[attr] Pattern(_): Pattern| { bar } ❱;
|
|
|
|
/// ❰ move || baz ❱;
|
|
|
|
/// ❰ || -> u32 { closure_with_ret_type_annotation_requires_block_expr } ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/closure-expr.html)
|
2020-04-03 14:12:09 -05:00
|
|
|
struct LambdaExpr: AttrsOwner {
|
2020-04-21 20:15:55 -05:00
|
|
|
// T![static], // TODO: what's this?
|
2020-04-10 03:07:09 -05:00
|
|
|
T![async],
|
|
|
|
T![move],
|
2020-01-03 13:37:02 -06:00
|
|
|
ParamList,
|
|
|
|
RetType,
|
|
|
|
body: Expr,
|
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// If expression. Includes both regular `if` and `if let` forms.
|
|
|
|
/// Beware that `else if` is a special case syntax sugar, because in general
|
|
|
|
/// there has to be block expression after `else`.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ if bool_cond { 42 } ❱
|
|
|
|
/// ❰ if bool_cond { 42 } else { 24 } ❱
|
|
|
|
/// ❰ if bool_cond { 42 } else if bool_cond2 { 42 } ❱
|
|
|
|
///
|
|
|
|
/// ❰
|
|
|
|
/// if let Pattern(foo) = bar {
|
|
|
|
/// foo
|
|
|
|
/// } else {
|
|
|
|
/// panic!();
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/if-expr.html)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct IfExpr: AttrsOwner { T![if], Condition }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Unconditional loop expression.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// loop {
|
|
|
|
/// // yeah, it's that simple...
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct LoopExpr: AttrsOwner, LoopBodyOwner { T![loop] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Block expression with an optional prefix (label, try ketword,
|
|
|
|
/// unsafe keyword, async keyword...).
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// 'label: try {
|
|
|
|
/// None?
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// - [try block](https://doc.rust-lang.org/unstable-book/language-features/try-blocks.html)
|
|
|
|
/// - [unsafe block](https://doc.rust-lang.org/reference/expressions/block-expr.html#unsafe-blocks)
|
|
|
|
/// - [async block](https://doc.rust-lang.org/reference/expressions/block-expr.html#async-blocks)
|
2020-05-01 18:18:19 -05:00
|
|
|
struct EffectExpr: AttrsOwner { Label, T![try], T![unsafe], T![async], BlockExpr }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
|
|
|
|
/// For loop expression.
|
|
|
|
/// Note: record struct literals are not valid as iterable expression
|
|
|
|
/// due to ambiguity.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// for i in (0..4) {
|
|
|
|
/// dbg!(i);
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#iterator-loops)
|
2020-04-03 14:12:09 -05:00
|
|
|
struct ForExpr: AttrsOwner, LoopBodyOwner {
|
2020-04-10 03:07:09 -05:00
|
|
|
T![for],
|
2020-01-03 13:37:02 -06:00
|
|
|
Pat,
|
2020-04-10 03:07:09 -05:00
|
|
|
T![in],
|
2020-01-03 13:37:02 -06:00
|
|
|
iterable: Expr,
|
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// While loop expression. Includes both regular `while` and `while let` forms.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// while bool_cond {
|
|
|
|
/// 42;
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ❰
|
|
|
|
/// while let Pattern(foo) = bar {
|
|
|
|
/// bar += 1;
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-loops)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct WhileExpr: AttrsOwner, LoopBodyOwner { T![while], Condition }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Continue expression.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// while bool_cond {
|
|
|
|
/// ❰ continue ❱;
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// 'outer: loop {
|
|
|
|
/// loop {
|
|
|
|
/// ❰ continue 'outer ❱;
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#continue-expressions)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct ContinueExpr: AttrsOwner { T![continue], T![lifetime] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Break expression.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// while bool_cond {
|
|
|
|
/// ❰ break ❱;
|
|
|
|
/// }
|
|
|
|
/// 'outer: loop {
|
|
|
|
/// for foo in bar {
|
|
|
|
/// ❰ break 'outer ❱;
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// 'outer: loop {
|
|
|
|
/// loop {
|
|
|
|
/// ❰ break 'outer 42 ❱;
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Refernce](https://doc.rust-lang.org/reference/expressions/loop-expr.html#break-expressions)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct BreakExpr: AttrsOwner { T![break], T![lifetime], Expr }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Label.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ 'outer: ❱ loop {}
|
|
|
|
///
|
|
|
|
/// let foo = ❰ 'bar: ❱ loop {}
|
|
|
|
///
|
|
|
|
/// ❰ 'baz: ❱ {
|
|
|
|
/// break 'baz;
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html?highlight=label#loop-labels)
|
|
|
|
/// [Labels for blocks RFC](https://github.com/rust-lang/rfcs/blob/master/text/2046-label-break-value.md)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct Label { T![lifetime] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Block expression. Includes unsafe blocks and block labels.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let foo = ❰
|
|
|
|
/// {
|
|
|
|
/// #![inner_attr]
|
|
|
|
/// ❰ { } ❱
|
|
|
|
///
|
|
|
|
/// ❰ 'label: { break 'label } ❱
|
|
|
|
/// }
|
|
|
|
/// ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/block-expr.html)
|
|
|
|
/// [Labels for blocks RFC](https://github.com/rust-lang/rfcs/blob/master/text/2046-label-break-value.md)
|
2020-05-01 18:18:19 -05:00
|
|
|
struct BlockExpr: AttrsOwner, ModuleItemOwner {
|
|
|
|
T!['{'], statements: [Stmt], Expr, T!['}'],
|
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Return expression.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// || ❰ return 42 ❱;
|
|
|
|
///
|
|
|
|
/// fn bar() {
|
|
|
|
/// ❰ return ❱;
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/return-expr.html)
|
2020-04-03 14:12:09 -05:00
|
|
|
struct ReturnExpr: AttrsOwner { Expr }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Call expression (not to be confused with method call expression, it is
|
|
|
|
/// a separate ast node).
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ foo() ❱;
|
|
|
|
/// ❰ &str::len("bar") ❱;
|
|
|
|
/// ❰ <&str as PartialEq<&str>>::eq(&"", &"") ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/call-expr.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct CallExpr: ArgListOwner { Expr }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Method call expression.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ receiver_expr.method() ❱;
|
|
|
|
/// ❰ receiver_expr.method::<T>(42, true) ❱;
|
|
|
|
///
|
|
|
|
/// ❰ ❰ ❰ foo.bar() ❱ .baz() ❱ .bruh() ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/method-call-expr.html)
|
2020-04-03 14:12:09 -05:00
|
|
|
struct MethodCallExpr: AttrsOwner, ArgListOwner {
|
2020-04-10 04:49:13 -05:00
|
|
|
Expr, T![.], NameRef, TypeArgList,
|
2020-04-03 14:12:09 -05:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Index expression a.k.a. subscript operator call.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ foo[42] ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/array-expr.html)
|
2020-04-10 03:29:59 -05:00
|
|
|
struct IndexExpr: AttrsOwner { T!['['], T![']'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Field access expression.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ expr.bar ❱;
|
|
|
|
///
|
|
|
|
/// ❰ ❰ ❰ foo.bar ❱ .baz ❱ .bruh ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/field-expr.html)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct FieldExpr: AttrsOwner { Expr, T![.], NameRef }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Await operator call expression.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ expr.await ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/await-expr.html)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct AwaitExpr: AttrsOwner { Expr, T![.], T![await] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// The question mark operator call.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ expr? ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-question-mark-operator)
|
2020-05-01 18:18:19 -05:00
|
|
|
struct TryExpr: AttrsOwner { Expr, T![?] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Type cast expression.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ expr as T ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct CastExpr: AttrsOwner { Expr, T![as], TypeRef }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
|
|
|
|
/// Borrow operator call.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ &foo ❱;
|
|
|
|
/// ❰ &mut bar ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#borrow-operators)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct RefExpr: AttrsOwner { T![&], T![raw], T![mut], Expr }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Prefix operator call. This is either `!` or `*` or `-`.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ !foo ❱;
|
|
|
|
/// ❰ *bar ❱;
|
|
|
|
/// ❰ -42 ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct PrefixExpr: AttrsOwner { /*PrefixOp,*/ Expr }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Box operator call.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ box 42 ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [RFC](https://github.com/rust-lang/rfcs/blob/0806be4f282144cfcd55b1d20284b43f87cbe1c6/text/0809-box-and-in-for-stdlib.md)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct BoxExpr: AttrsOwner { T![box], Expr }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Range operator call.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ 0..42 ❱;
|
|
|
|
/// ❰ ..42 ❱;
|
|
|
|
/// ❰ 0.. ❱;
|
|
|
|
/// ❰ .. ❱;
|
|
|
|
/// ❰ 0..=42 ❱;
|
|
|
|
/// ❰ ..=42 ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/range-expr.html)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct RangeExpr: AttrsOwner { /*RangeOp*/ }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
|
|
|
|
/// Binary operator call.
|
|
|
|
/// Includes all arithmetic, logic, bitwise and assignment operators.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ 2 + ❰ 2 * 2 ❱ ❱;
|
|
|
|
/// ❰ ❰ true && false ❱ || true ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)
|
2020-04-10 03:35:39 -05:00
|
|
|
struct BinExpr: AttrsOwner { /*BinOp*/ }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
|
|
|
|
/// [Raw] string, [raw] byte string, char, byte, integer, float or bool literal.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ "str" ❱;
|
|
|
|
/// ❰ br##"raw byte str"## ❱;
|
|
|
|
/// ❰ 'c' ❱;
|
|
|
|
/// ❰ b'c' ❱;
|
|
|
|
/// ❰ 42 ❱;
|
|
|
|
/// ❰ 1e9 ❱;
|
|
|
|
/// ❰ true ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/literal-expr.html)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct Literal { /*LiteralToken*/ }
|
2020-04-03 14:12:09 -05:00
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Match expression.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// match expr {
|
|
|
|
/// Pat1 => {}
|
|
|
|
/// Pat2(_) => 42,
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct MatchExpr: AttrsOwner { T![match], Expr, MatchArmList }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Match arm list part of match expression. Includes its inner attributes.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// match expr
|
|
|
|
/// ❰
|
|
|
|
/// {
|
|
|
|
/// #![inner_attr]
|
|
|
|
/// Pat1 => {}
|
|
|
|
/// Pat2(_) => 42,
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html)
|
2020-04-10 03:27:23 -05:00
|
|
|
struct MatchArmList: AttrsOwner { T!['{'], arms: [MatchArm], T!['}'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
|
|
|
|
/// Match arm.
|
|
|
|
/// Note: record struct literals are not valid as target match expression
|
|
|
|
/// due to ambiguity.
|
|
|
|
/// ```
|
|
|
|
/// match expr {
|
|
|
|
/// ❰ #[attr] Pattern(it) if bool_cond => it ❱,
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct MatchArm: AttrsOwner {
|
2020-02-09 12:57:01 -06:00
|
|
|
pat: Pat,
|
2020-01-03 13:37:02 -06:00
|
|
|
guard: MatchGuard,
|
2020-04-10 04:49:13 -05:00
|
|
|
T![=>],
|
2020-01-03 13:37:02 -06:00
|
|
|
Expr,
|
2020-02-11 15:33:11 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Match guard.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// match expr {
|
|
|
|
/// Pattern(it) ❰ if bool_cond ❱ => it,
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html#match-guards)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct MatchGuard { T![if], Expr }
|
2020-01-03 13:37:02 -06:00
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Record literal expression. The same syntax is used for structs,
|
|
|
|
/// unions and record enum variants.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// foo::Bar {
|
|
|
|
/// #![inner_attr]
|
|
|
|
/// baz: 42,
|
|
|
|
/// bruh: true,
|
|
|
|
/// ..spread
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/struct-expr.html)
|
2020-04-03 14:12:09 -05:00
|
|
|
struct RecordLit { Path, RecordFieldList}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Record field list including enclosing curly braces.
|
|
|
|
///
|
|
|
|
/// foo::Bar ❰
|
|
|
|
/// {
|
|
|
|
/// baz: 42,
|
|
|
|
/// ..spread
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/struct-expr.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct RecordFieldList {
|
2020-04-10 03:27:23 -05:00
|
|
|
T!['{'],
|
2020-01-03 13:37:02 -06:00
|
|
|
fields: [RecordField],
|
2020-04-10 04:49:13 -05:00
|
|
|
T![..],
|
2020-01-03 13:37:02 -06:00
|
|
|
spread: Expr,
|
2020-04-10 03:27:23 -05:00
|
|
|
T!['}']
|
2020-02-11 15:33:11 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Record field.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// foo::Bar {
|
|
|
|
/// ❰ #[attr] baz: 42 ❱
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/struct-expr.html)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct RecordField: AttrsOwner { NameRef, T![:], Expr }
|
2020-01-03 13:37:02 -06:00
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Disjunction of patterns.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let ❰ Foo(it) | Bar(it) | Baz(it) ❱ = bruh;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html)
|
2020-02-09 12:57:01 -06:00
|
|
|
struct OrPat { pats: [Pat] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Parenthesized pattern.
|
|
|
|
/// Note: parens are only used for grouping, this is not a tuple pattern.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// if let ❰ &(0..=42) ❱ = foo {}
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// https://doc.rust-lang.org/reference/patterns.html#grouped-patterns
|
2020-04-10 03:29:59 -05:00
|
|
|
struct ParenPat { T!['('], Pat, T![')'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Reference pattern.
|
|
|
|
/// Note: this has nothing to do with `ref` keyword, the latter is used in bind patterns.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let ❰ &mut foo ❱ = bar;
|
2020-05-10 13:44:14 -05:00
|
|
|
///
|
|
|
|
/// let ❰ & ❰ &mut ❰ &_ ❱ ❱ ❱ = baz;
|
2020-04-21 20:15:55 -05:00
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html#reference-patterns)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct RefPat { T![&], T![mut], Pat }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Box pattern.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let ❰ box foo ❱ = box 42;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Unstable book](https://doc.rust-lang.org/unstable-book/language-features/box-patterns.html)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct BoxPat { T![box], Pat }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Bind pattern.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// match foo {
|
|
|
|
/// Some(❰ ref mut bar ❱) => {}
|
|
|
|
/// ❰ baz @ None ❱ => {}
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html#identifier-patterns)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct BindPat: AttrsOwner, NameOwner { T![ref], T![mut], T![@], Pat }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Placeholder pattern a.k.a. the wildcard pattern or the underscore.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let ❰ _ ❱ = foo;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html#wildcard-pattern)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct PlaceholderPat { T![_] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Rest-of-the record/tuple pattern.
|
|
|
|
/// Note: this is not the unbonded range pattern (even more: it doesn't exist).
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let Foo { bar, ❰ .. ❱ } = baz;
|
|
|
|
/// let (❰ .. ❱, bruh) = (42, 24, 42);
|
|
|
|
/// let Bruuh(❰ .. ❱) = bruuuh;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct DotDotPat { T![..] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Path pattern.
|
|
|
|
/// Doesn't include the underscore pattern (it is a special case, namely `PlaceholderPat`).
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let ❰ foo::bar::Baz ❱ { .. } = bruh;
|
|
|
|
/// if let ❰ CONST ❱ = 42 {}
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html#path-patterns)
|
2020-02-11 15:33:11 -06:00
|
|
|
struct PathPat { Path }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Slice pattern.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let ❰ [foo, bar, baz] ❱ = [1, 2, 3];
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html#slice-patterns)
|
2020-04-10 03:29:59 -05:00
|
|
|
struct SlicePat { T!['['], args: [Pat], T![']'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Range pattern.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// match foo {
|
|
|
|
/// ❰ 0..42 ❱ => {}
|
|
|
|
/// ❰ 0..=42 ❱ => {}
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html#range-patterns)
|
|
|
|
struct RangePat { /*RangeSeparator*/ } // TODO: where is RangeSeparator?
|
|
|
|
|
|
|
|
/// Literal pattern.
|
|
|
|
/// Includes only bool, number, char, and string literals.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// match foo {
|
|
|
|
/// Number(❰ 42 ❱) => {}
|
|
|
|
/// String(❰ "42" ❱) => {}
|
|
|
|
/// Bool(❰ true ❱) => {}
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html#literal-patterns)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct LiteralPat { Literal }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Macro invocation in pattern position.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let ❰ foo!(my custom syntax) ❱ = baz;
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/macros.html#macro-invocation)
|
2020-04-03 08:38:42 -05:00
|
|
|
struct MacroPat { MacroCall }
|
2020-01-03 13:37:02 -06:00
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Record literal pattern.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let ❰ foo::Bar { baz, .. } ❱ = bruh;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct RecordPat { RecordFieldPatList, Path }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Record literal's field patterns list including enclosing curly braces.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let foo::Bar ❰ { baz, bind @ bruh, .. } ❱ = bruuh;
|
|
|
|
/// ``
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct RecordFieldPatList {
|
2020-04-10 03:27:23 -05:00
|
|
|
T!['{'],
|
2020-04-03 14:12:09 -05:00
|
|
|
pats: [RecordInnerPat],
|
2020-01-03 13:37:02 -06:00
|
|
|
record_field_pats: [RecordFieldPat],
|
|
|
|
bind_pats: [BindPat],
|
2020-04-10 04:49:13 -05:00
|
|
|
T![..],
|
2020-04-10 03:27:23 -05:00
|
|
|
T!['}']
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Record literal's field pattern.
|
|
|
|
/// Note: record literal can also match tuple structs.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let Foo { ❰ bar: _ ❱ } = baz;
|
|
|
|
/// let TupleStruct { ❰ 0: _ ❱ } = bruh;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns)
|
2020-04-11 16:33:17 -05:00
|
|
|
struct RecordFieldPat: AttrsOwner { NameRef, T![:], Pat }
|
2020-01-03 13:37:02 -06:00
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Tuple struct literal pattern.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let ❰ foo::Bar(baz, bruh) ❱ = bruuh;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html#tuple-struct-patterns)
|
2020-04-10 03:29:59 -05:00
|
|
|
struct TupleStructPat { Path, T!['('], args: [Pat], T![')'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Tuple pattern.
|
|
|
|
/// Note: this doesn't include tuple structs (see `TupleStructPat`)
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let ❰ (foo, bar, .., baz) ❱ = bruh;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/patterns.html#tuple-patterns)
|
2020-04-10 03:29:59 -05:00
|
|
|
struct TuplePat { T!['('], args: [Pat], T![')'] }
|
2020-01-03 13:37:02 -06:00
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Visibility.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ pub mod ❱ foo;
|
|
|
|
/// ❰ pub(crate) ❱ struct Bar;
|
|
|
|
/// ❰ pub(self) ❱ enum Baz {}
|
|
|
|
/// ❰ pub(super) ❱ fn bruh() {}
|
|
|
|
/// ❰ pub(in bruuh::bruuuh) ❱ type T = u64;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/visibility-and-privacy.html)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct Visibility { T![pub], T![super], T![self], T![crate] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Single identifier.
|
2020-05-12 15:31:37 -05:00
|
|
|
/// Note(@matklad): `Name` is for things that install a new name into the scope,
|
|
|
|
/// `NameRef` is a usage of a name. Most of the time, this definition/reference
|
|
|
|
/// distinction can be determined purely syntactically, ie in
|
|
|
|
/// ```
|
|
|
|
/// fn foo() { foo() }
|
|
|
|
/// ```
|
|
|
|
/// the first foo is `Name`, the second one is `NameRef`.
|
|
|
|
/// The notable exception are patterns, where in
|
|
|
|
/// ``
|
|
|
|
/// let x = 92
|
|
|
|
/// ```
|
|
|
|
/// `x` can be semantically either a name or a name ref, depeding on
|
|
|
|
/// wether there's an `x` constant in scope.
|
|
|
|
/// We use `Name` for patterns, and disambiguate semantically (see `NameClass` in ide_db).
|
2020-04-21 20:15:55 -05:00
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let ❰ foo ❱ = bar;
|
|
|
|
/// struct ❰ Baz ❱;
|
|
|
|
/// fn ❰ bruh ❱() {}
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/identifiers.html)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct Name { T![ident] }
|
2020-01-03 13:37:02 -06:00
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Reference to a name.
|
2020-05-12 15:31:37 -05:00
|
|
|
/// See the explanation on the difference between `Name` and `NameRef`
|
|
|
|
/// in `Name` ast node docs.
|
2020-04-21 20:15:55 -05:00
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// let foo = ❰ bar ❱(❰ Baz(❰ bruh ❱) ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/identifiers.html)
|
|
|
|
struct NameRef { /*NameRefToken*/ } // TODO: where is NameRefToken?
|
|
|
|
|
|
|
|
/// Macro call.
|
|
|
|
/// Includes all of its attributes and doc comments.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// /// Docs
|
|
|
|
/// #[attr]
|
|
|
|
/// macro_rules! foo { // macro rules is also a macro call
|
|
|
|
/// ($bar: tt) => {}
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
///
|
2020-05-10 13:57:49 -05:00
|
|
|
/// // semicolon is a part of `MacroCall` when it is used in item positions
|
|
|
|
/// ❰ foo!(); ❱
|
|
|
|
///
|
|
|
|
/// fn main() {
|
2020-05-10 13:59:15 -05:00
|
|
|
/// ❰ foo!() ❱; // macro call in expression positions doesn't include the semi
|
2020-05-10 13:57:49 -05:00
|
|
|
/// }
|
2020-04-21 20:15:55 -05:00
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/macros.html)
|
|
|
|
struct MacroCall: NameOwner, AttrsOwner, DocCommentsOwner {
|
2020-05-10 13:57:49 -05:00
|
|
|
Path, T![!], TokenTree, T![;]
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Attribute.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ #![inner_attr] ❱
|
|
|
|
///
|
|
|
|
/// ❰ #[attr] ❱
|
|
|
|
/// ❰ #[foo = "bar"] ❱
|
|
|
|
/// ❰ #[baz(bruh::bruuh = "42")] ❱
|
|
|
|
/// struct Foo;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/attributes.html)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct Attr { T![#], T![!], T!['['], Path, T![=], input: AttrInput, T![']'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
2020-05-10 11:09:36 -05:00
|
|
|
/// Stores a list of lexer tokens and other `TokenTree`s.
|
|
|
|
/// It appears in attributes, macro_rules and macro call (foo!)
|
2020-04-21 20:15:55 -05:00
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// macro_call! ❰ { my syntax here } ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/macros.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct TokenTree {}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Generic lifetime, type and constants parameters list **declaration**.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// fn foo❰ <'a, 'b, T, U, const BAR: u64> ❱() {}
|
|
|
|
///
|
|
|
|
/// struct Baz❰ <T> ❱(T);
|
|
|
|
///
|
|
|
|
/// impl❰ <T> ❱ Bruh<T> {}
|
|
|
|
///
|
|
|
|
/// type Bruuh = for❰ <'a> ❱ fn(&'a str) -> &'a str;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/generics.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct TypeParamList {
|
2020-04-10 04:49:13 -05:00
|
|
|
T![<],
|
2020-04-03 14:12:09 -05:00
|
|
|
generic_params: [GenericParam],
|
2020-01-03 13:37:02 -06:00
|
|
|
type_params: [TypeParam],
|
|
|
|
lifetime_params: [LifetimeParam],
|
2020-04-03 14:12:09 -05:00
|
|
|
const_params: [ConstParam],
|
2020-04-10 04:49:13 -05:00
|
|
|
T![>]
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Single type parameter **declaration**.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// fn foo<❰ K ❱, ❰ I ❱, ❰ E: Debug ❱, ❰ V = DefaultType ❱>() {}
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/generics.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct TypeParam: NameOwner, AttrsOwner, TypeBoundsOwner {
|
2020-04-10 03:35:39 -05:00
|
|
|
T![=],
|
2020-01-03 13:37:02 -06:00
|
|
|
default_type: TypeRef,
|
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Const generic parameter **declaration**.
|
|
|
|
/// ```
|
|
|
|
/// fn foo<T, U, ❰ const BAR: usize ❱, ❰ const BAZ: bool ❱>() {}
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [RFC](https://github.com/rust-lang/rfcs/blob/master/text/2000-const-generics.md#declaring-a-const-parameter)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct ConstParam: NameOwner, AttrsOwner, TypeAscriptionOwner {
|
2020-04-10 03:35:39 -05:00
|
|
|
T![=],
|
2020-01-03 13:37:02 -06:00
|
|
|
default_val: Expr,
|
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Lifetime parameter **declaration**.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// fn foo<❰ 'a ❱, ❰ 'b ❱, V, G, D>(bar: &'a str, baz: &'b mut str) {}
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/generics.html)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct LifetimeParam: AttrsOwner { T![lifetime] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Type bound declaration clause.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// fn foo<T: ❰ ?Sized ❱ + ❰ Debug ❱>() {}
|
|
|
|
///
|
|
|
|
/// trait Bar<T>
|
|
|
|
/// where
|
|
|
|
/// T: ❰ Send ❱ + ❰ Sync ❱
|
|
|
|
/// {
|
2020-05-10 11:24:06 -05:00
|
|
|
/// type Baz: ❰ !Sync ❱ + ❰ Debug ❱ + ❰ ?const Add ❱;
|
2020-04-21 20:15:55 -05:00
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/trait-bounds.html)
|
2020-05-10 11:24:06 -05:00
|
|
|
struct TypeBound { T![lifetime], /* Question, */ T![const], /* Question, */ TypeRef }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Type bounds list.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// fn foo<T: ❰ ?Sized + Debug ❱>() {}
|
|
|
|
///
|
|
|
|
/// trait Bar<T>
|
|
|
|
/// where
|
|
|
|
/// T: ❰ Send + Sync ❱
|
|
|
|
/// {
|
|
|
|
/// type Baz: ❰ !Sync + Debug ❱;
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/trait-bounds.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct TypeBoundList { bounds: [TypeBound] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Single where predicate.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// trait Foo<'a, 'b, T>
|
|
|
|
/// where
|
|
|
|
/// ❰ 'a: 'b ❱,
|
|
|
|
/// ❰ T: IntoIterator ❱,
|
|
|
|
/// ❰ for<'c> <T as IntoIterator>::Item: Bar<'c> ❱
|
|
|
|
/// {}
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/generics.html#where-clauses)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct WherePred: TypeBoundsOwner { T![lifetime], TypeRef }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Where clause.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// trait Foo<'a, T> ❰ where 'a: 'static, T: Debug ❱ {}
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/generics.html#where-clauses)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct WhereClause { T![where], predicates: [WherePred] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Abi declaration.
|
|
|
|
/// Note: the abi string is optional.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ extern "C" ❱ {
|
|
|
|
/// fn foo() {}
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// type Bar = ❰ extern ❱ fn() -> u32;
|
|
|
|
///
|
|
|
|
/// type Baz = ❰ extern r#"stdcall"# ❱ fn() -> bool;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// - [Extern blocks reference](https://doc.rust-lang.org/reference/items/external-blocks.html)
|
|
|
|
/// - [FFI function pointers reference](https://doc.rust-lang.org/reference/items/functions.html#functions)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct Abi { /*String*/ }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Expression statement.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ 42; ❱
|
|
|
|
/// ❰ foo(); ❱
|
|
|
|
/// ❰ (); ❱
|
|
|
|
/// ❰ {}; ❱
|
|
|
|
///
|
2020-05-10 13:50:24 -05:00
|
|
|
/// // constructions with trailing curly brace can omit the semicolon
|
|
|
|
/// // but only when there are satements immediately after them (this is important!)
|
2020-04-21 20:15:55 -05:00
|
|
|
/// ❰ if bool_cond { } ❱
|
|
|
|
/// ❰ loop {} ❱
|
2020-05-10 13:50:24 -05:00
|
|
|
/// ❰ somestatment; ❱
|
2020-04-21 20:15:55 -05:00
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/statements.html)
|
2020-04-10 03:11:05 -05:00
|
|
|
struct ExprStmt: AttrsOwner { Expr, T![;] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Let statement.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ #[attr] let foo; ❱
|
|
|
|
/// ❰ let bar: u64; ❱
|
|
|
|
/// ❰ let baz = 42; ❱
|
|
|
|
/// ❰ let bruh: bool = true; ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/statements.html#let-statements)
|
2020-04-03 14:12:09 -05:00
|
|
|
struct LetStmt: AttrsOwner, TypeAscriptionOwner {
|
2020-04-10 03:07:09 -05:00
|
|
|
T![let],
|
2020-01-03 13:37:02 -06:00
|
|
|
Pat,
|
2020-04-10 03:35:39 -05:00
|
|
|
T![=],
|
2020-01-03 13:37:02 -06:00
|
|
|
initializer: Expr,
|
2020-04-10 03:11:05 -05:00
|
|
|
T![;],
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Condition of `if` or `while` expression.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// if ❰ true ❱ {}
|
|
|
|
/// if ❰ let Pat(foo) = bar ❱ {}
|
|
|
|
///
|
|
|
|
/// while ❰ true ❱ {}
|
|
|
|
/// while ❰ let Pat(baz) = bruh ❱ {}
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [If expression reference](https://doc.rust-lang.org/reference/expressions/if-expr.html)
|
|
|
|
/// [While expression reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-loops)
|
2020-04-10 03:35:39 -05:00
|
|
|
struct Condition { T![let], Pat, T![=], Expr }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
// TODO: this one is used by closure expressions too, but hey use pipes instead of parens
|
|
|
|
/// Parameter list **declaration**.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// fn foo❰ (a: u32, b: bool) ❱ -> u32 {}
|
|
|
|
/// let bar = ❰ |a, b| ❱ {};
|
|
|
|
///
|
|
|
|
/// impl Baz {
|
|
|
|
/// fn bruh❰ (&self, a: u32) ❱ {}
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/functions.html)ocs to codegen script
|
2020-01-03 13:37:02 -06:00
|
|
|
struct ParamList {
|
2020-04-10 03:29:59 -05:00
|
|
|
T!['('],
|
2020-01-03 13:37:02 -06:00
|
|
|
SelfParam,
|
|
|
|
params: [Param],
|
2020-04-10 03:29:59 -05:00
|
|
|
T![')']
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Self parameter **declaration**.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// impl Bruh {
|
|
|
|
/// fn foo(❰ self ❱) {}
|
|
|
|
/// fn bar(❰ &self ❱) {}
|
|
|
|
/// fn baz(❰ &mut self ❱) {}
|
|
|
|
/// fn blah<'a>(❰ &'a self ❱) {}
|
|
|
|
/// fn blin(❰ self: Box<Self> ❱) {}
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/functions.html)
|
2020-04-10 10:47:49 -05:00
|
|
|
struct SelfParam: TypeAscriptionOwner, AttrsOwner { T![&], T![mut], T![lifetime], T![self] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Parameter **declaration**.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// fn foo(❰ #[attr] Pat(bar): Pat(u32) ❱, ❰ #[attr] _: bool ❱) {}
|
|
|
|
///
|
|
|
|
/// extern "C" {
|
|
|
|
/// fn bar(❰ baz: u32 ❱, ❰ ... ❱) -> u32;
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/functions.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct Param: TypeAscriptionOwner, AttrsOwner {
|
|
|
|
Pat,
|
2020-04-10 04:49:13 -05:00
|
|
|
T![...]
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Use declaration.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ #[attr] pub use foo; ❱
|
|
|
|
/// ❰ use bar as baz; ❱
|
|
|
|
/// ❰ use bruh::{self, bruuh}; ❱
|
|
|
|
/// ❰ use { blin::blen, blah::* };
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct UseItem: AttrsOwner, VisibilityOwner {
|
2020-04-10 03:07:09 -05:00
|
|
|
T![use],
|
2020-01-03 13:37:02 -06:00
|
|
|
UseTree,
|
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Use tree.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// pub use ❰ foo::❰ * ❱ ❱;
|
|
|
|
/// use ❰ bar as baz ❱;
|
|
|
|
/// use ❰ bruh::bruuh::{ ❰ self ❱, ❰ blin ❱ } ❱;
|
2020-05-10 12:52:25 -05:00
|
|
|
/// use ❰ { ❰ blin::blen ❱ } ❱
|
2020-04-21 20:15:55 -05:00
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct UseTree {
|
2020-04-10 04:49:13 -05:00
|
|
|
Path, T![*], UseTreeList, Alias
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Item alias.
|
|
|
|
/// Note: this is not the type alias.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use foo ❰ as bar ❱;
|
|
|
|
/// use baz::{bruh ❰ as _ ❱};
|
|
|
|
/// extern crate bruuh ❰ as blin ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html)
|
2020-04-10 03:07:09 -05:00
|
|
|
struct Alias: NameOwner { T![as] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Sublist of use trees.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use bruh::bruuh::❰ { ❰ self ❱, ❰ blin ❱ } ❱;
|
|
|
|
/// use ❰ { blin::blen::❰ {} ❱ } ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html)
|
2020-04-10 03:27:23 -05:00
|
|
|
struct UseTreeList { T!['{'], use_trees: [UseTree], T!['}'] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Extern crate item.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰ #[attr] pub extern crate foo; ❱
|
|
|
|
/// ❰ extern crate self as bar; ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/extern-crates.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct ExternCrateItem: AttrsOwner, VisibilityOwner {
|
2020-04-10 03:07:09 -05:00
|
|
|
T![extern], T![crate], NameRef, Alias,
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Call site arguments list.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// foo::<T, U>❰ (42, true) ❱;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/expressions/call-expr.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct ArgList {
|
2020-04-10 03:29:59 -05:00
|
|
|
T!['('],
|
2020-01-03 13:37:02 -06:00
|
|
|
args: [Expr],
|
2020-04-10 03:29:59 -05:00
|
|
|
T![')']
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Path to a symbol. Includes single identifier names and elaborate paths with
|
|
|
|
/// generic parameters.
|
|
|
|
///
|
|
|
|
/// ```
|
2020-05-10 11:59:48 -05:00
|
|
|
/// (0..10).❰ ❰ collect ❱ ::<Vec<_>> ❱();
|
|
|
|
/// ❰ ❰ ❰ Vec ❱ ::<u8> ❱ ::with_capacity ❱(1024);
|
|
|
|
/// ❰ ❰ <❰ Foo ❱ as ❰ ❰ bar ❱ ::Bar ❱> ❱ ::baz ❱();
|
|
|
|
/// ❰ ❰ <❰ bruh ❱> ❱ ::bruuh ❱();
|
2020-04-21 20:15:55 -05:00
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/paths.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct Path {
|
|
|
|
segment: PathSegment,
|
2020-05-10 11:59:48 -05:00
|
|
|
T![::],
|
2020-01-03 13:37:02 -06:00
|
|
|
qualifier: Path,
|
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Segment of the path to a symbol.
|
2020-05-10 11:59:48 -05:00
|
|
|
/// Only path segment of an absolute path holds the `::` token,
|
|
|
|
/// all other `::` tokens that connect path segments reside under `Path` itself.`
|
2020-04-21 20:15:55 -05:00
|
|
|
///
|
|
|
|
/// ```
|
2020-05-10 11:59:48 -05:00
|
|
|
/// (0..10).❰ collect ❱ :: ❰ <Vec<_>> ❱();
|
|
|
|
/// ❰ Vec ❱ :: ❰ <u8> ❱ :: ❰ with_capacity ❱(1024);
|
|
|
|
/// ❰ <❰ Foo ❱ as ❰ bar ❱ :: ❰ Bar ❱> ❱ :: ❰ baz ❱();
|
|
|
|
/// ❰ <❰ bruh ❱> ❱ :: ❰ bruuh ❱();
|
|
|
|
///
|
|
|
|
/// // Note that only in this case `::` token is inlcuded:
|
|
|
|
/// ❰ ::foo ❱;
|
2020-04-21 20:15:55 -05:00
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/paths.html)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct PathSegment {
|
2020-05-01 10:59:24 -05:00
|
|
|
T![::], T![crate], T![self], T![super], T![<], NameRef, TypeArgList, ParamList, RetType, PathType, T![>]
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// List of type arguments that are passed at generic instantiation site.
|
|
|
|
///
|
|
|
|
/// ```
|
2020-05-10 12:52:25 -05:00
|
|
|
/// type _ = Foo ❰ ::<'a, u64, Item = Bar, 42, {true}> ❱::Bar;
|
2020-04-21 20:15:55 -05:00
|
|
|
///
|
|
|
|
/// Vec❰ ::<bool> ❱::();
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/paths.html#paths-in-expressions)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct TypeArgList {
|
2020-04-10 04:49:13 -05:00
|
|
|
T![::],
|
|
|
|
T![<],
|
2020-04-03 14:12:09 -05:00
|
|
|
generic_args: [GenericArg],
|
2020-01-03 13:37:02 -06:00
|
|
|
type_args: [TypeArg],
|
|
|
|
lifetime_args: [LifetimeArg],
|
|
|
|
assoc_type_args: [AssocTypeArg],
|
2020-04-03 14:12:09 -05:00
|
|
|
const_args: [ConstArg],
|
2020-04-10 04:49:13 -05:00
|
|
|
T![>]
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Type argument that is passed at generic instantiation site.
|
|
|
|
///
|
|
|
|
/// ```
|
2020-05-10 12:52:25 -05:00
|
|
|
/// type _ = Foo::<'a, ❰ u64 ❱, ❰ bool ❱, Item = Bar, 42>::Baz;
|
2020-04-21 20:15:55 -05:00
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/paths.html#paths-in-expressions)
|
2020-01-03 13:37:02 -06:00
|
|
|
struct TypeArg { TypeRef }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Associated type argument that is passed at generic instantiation site.
|
|
|
|
/// ```
|
2020-05-10 12:23:29 -05:00
|
|
|
/// type Foo = Bar::<'a, u64, bool, ❰ Item = Baz ❱, 42>::Bruh;
|
2020-04-21 20:15:55 -05:00
|
|
|
///
|
|
|
|
/// trait Bruh<T>: Iterator<❰ Item: Debug ❱> {}
|
|
|
|
/// ```
|
|
|
|
///
|
2020-04-10 03:35:39 -05:00
|
|
|
struct AssocTypeArg : TypeBoundsOwner { NameRef, T![=], TypeRef }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Lifetime argument that is passed at generic instantiation site.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// fn foo<'a>(s: &'a str) {
|
|
|
|
/// bar::<❰ 'a ❱>(s);
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/paths.html#paths-in-expressions)
|
2020-04-10 04:49:13 -05:00
|
|
|
struct LifetimeArg { T![lifetime] }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
2020-05-10 13:02:10 -05:00
|
|
|
|
|
|
|
// TODO: What does equal sign do here?
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Constant value argument that is passed at generic instantiation site.
|
|
|
|
///
|
|
|
|
/// ```
|
2020-05-10 13:02:10 -05:00
|
|
|
/// foo::<u32, ❰ { true } ❱>();
|
2020-04-21 20:15:55 -05:00
|
|
|
///
|
|
|
|
/// bar::<❰ { 2 + 2} ❱>();
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [RFC](https://github.com/rust-lang/rfcs/blob/master/text/2000-const-generics.md#declaring-a-const-parameter)
|
2020-04-10 03:35:39 -05:00
|
|
|
struct ConstArg { Literal, T![=], BlockExpr }
|
2020-01-03 13:37:02 -06:00
|
|
|
|
2020-05-10 13:06:12 -05:00
|
|
|
|
|
|
|
/// FIXME: (@edwin0cheng) Remove it to use ItemList instead
|
|
|
|
/// https://github.com/rust-analyzer/rust-analyzer/pull/4083#discussion_r422666243
|
2020-04-21 20:15:55 -05:00
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/macros.html)
|
|
|
|
struct MacroItems: ModuleItemOwner { }
|
2020-01-03 13:37:02 -06:00
|
|
|
|
2020-05-12 15:33:56 -05:00
|
|
|
/// FIXME: (@edwin0cheng) add some documentation here. As per the writing
|
|
|
|
/// of this comment this ast node is not used.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// // FIXME: example here
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/macros.html)
|
|
|
|
struct MacroStmts {
|
|
|
|
statements: [Stmt],
|
|
|
|
Expr,
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// List of items in an extern block.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// extern "C" ❰
|
|
|
|
/// {
|
|
|
|
/// fn foo();
|
|
|
|
/// static var: u32;
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/external-blocks.html)
|
2020-04-09 16:02:10 -05:00
|
|
|
struct ExternItemList: ModuleItemOwner {
|
2020-04-10 03:27:23 -05:00
|
|
|
T!['{'],
|
2020-04-03 14:12:09 -05:00
|
|
|
extern_items: [ExternItem],
|
2020-04-10 03:27:23 -05:00
|
|
|
T!['}']
|
2020-04-03 14:12:09 -05:00
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Extern block.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// ❰
|
|
|
|
/// extern "C" {
|
|
|
|
/// fn foo();
|
|
|
|
/// }
|
|
|
|
/// ❱
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/items/external-blocks.html)
|
2020-04-03 14:12:09 -05:00
|
|
|
struct ExternBlock {
|
|
|
|
Abi,
|
|
|
|
ExternItemList
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Meta item in an attribute.
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// #[❰ bar::baz = "42" ❱]
|
|
|
|
/// #[❰ bruh(bruuh("true")) ❱]
|
|
|
|
/// struct Foo;
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// [Reference](https://doc.rust-lang.org/reference/attributes.html?highlight=meta,item#meta-item-attribute-syntax)
|
2020-04-03 14:12:09 -05:00
|
|
|
struct MetaItem {
|
2020-04-10 03:35:39 -05:00
|
|
|
Path, T![=], AttrInput, nested_meta_items: [MetaItem]
|
2020-04-03 14:12:09 -05:00
|
|
|
}
|
|
|
|
|
2020-05-10 14:08:06 -05:00
|
|
|
/// Macro 2.0 definition.
|
|
|
|
/// Their syntax is still WIP by rustc team...
|
2020-04-21 20:15:55 -05:00
|
|
|
/// ```
|
|
|
|
/// ❰
|
2020-05-10 14:08:06 -05:00
|
|
|
/// macro foo { }
|
2020-04-21 20:15:55 -05:00
|
|
|
/// ❱
|
|
|
|
/// ```
|
|
|
|
///
|
2020-05-10 14:08:06 -05:00
|
|
|
/// [RFC](https://github.com/rust-lang/rfcs/blob/master/text/1584-macros.md)
|
2020-04-03 14:12:09 -05:00
|
|
|
struct MacroDef {
|
|
|
|
Name, TokenTree
|
|
|
|
}
|
2020-01-03 13:37:02 -06:00
|
|
|
},
|
|
|
|
enums: &ast_enums! {
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Any kind of nominal type definition.
|
2020-01-03 13:37:02 -06:00
|
|
|
enum NominalDef: NameOwner, TypeParamsOwner, AttrsOwner {
|
|
|
|
StructDef, EnumDef, UnionDef,
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Any kind of **declared** generic parameter
|
2020-04-03 14:12:09 -05:00
|
|
|
enum GenericParam {
|
|
|
|
LifetimeParam,
|
|
|
|
TypeParam,
|
|
|
|
ConstParam
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Any kind of generic argument passed at instantiation site
|
2020-04-03 14:12:09 -05:00
|
|
|
enum GenericArg {
|
|
|
|
LifetimeArg,
|
|
|
|
TypeArg,
|
|
|
|
ConstArg,
|
|
|
|
AssocTypeArg
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Any kind of construct valid in type context
|
2020-01-03 13:37:02 -06:00
|
|
|
enum TypeRef {
|
|
|
|
ParenType,
|
|
|
|
TupleType,
|
|
|
|
NeverType,
|
|
|
|
PathType,
|
|
|
|
PointerType,
|
|
|
|
ArrayType,
|
|
|
|
SliceType,
|
|
|
|
ReferenceType,
|
|
|
|
PlaceholderType,
|
|
|
|
FnPointerType,
|
|
|
|
ForType,
|
|
|
|
ImplTraitType,
|
|
|
|
DynTraitType,
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Any kind of top-level item that may appear in a module
|
2020-04-03 14:12:09 -05:00
|
|
|
enum ModuleItem: NameOwner, AttrsOwner, VisibilityOwner {
|
2020-01-03 13:37:02 -06:00
|
|
|
StructDef,
|
|
|
|
UnionDef,
|
|
|
|
EnumDef,
|
|
|
|
FnDef,
|
|
|
|
TraitDef,
|
|
|
|
TypeAliasDef,
|
2020-02-29 14:24:40 -06:00
|
|
|
ImplDef,
|
2020-01-03 13:37:02 -06:00
|
|
|
UseItem,
|
|
|
|
ExternCrateItem,
|
|
|
|
ConstDef,
|
|
|
|
StaticDef,
|
|
|
|
Module,
|
2020-03-26 10:10:01 -05:00
|
|
|
MacroCall,
|
2020-04-03 14:12:09 -05:00
|
|
|
ExternBlock
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
|
|
|
|
/// Any kind of item that may appear in an impl block
|
|
|
|
///
|
|
|
|
/// // TODO: is the following a fixme?
|
|
|
|
/// impl blocks can also contain MacroCall
|
2020-05-05 10:56:10 -05:00
|
|
|
enum AssocItem: NameOwner, AttrsOwner {
|
2020-04-03 14:12:09 -05:00
|
|
|
FnDef, TypeAliasDef, ConstDef
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Any kind of item that may appear in an extern block
|
|
|
|
///
|
|
|
|
/// // TODO: is the following a fixme?
|
|
|
|
/// extern blocks can also contain MacroCall
|
2020-04-03 14:12:09 -05:00
|
|
|
enum ExternItem: NameOwner, AttrsOwner, VisibilityOwner {
|
|
|
|
FnDef, StaticDef
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Any kind of expression
|
2020-04-03 14:12:09 -05:00
|
|
|
enum Expr: AttrsOwner {
|
2020-01-03 13:37:02 -06:00
|
|
|
TupleExpr,
|
|
|
|
ArrayExpr,
|
|
|
|
ParenExpr,
|
|
|
|
PathExpr,
|
|
|
|
LambdaExpr,
|
|
|
|
IfExpr,
|
|
|
|
LoopExpr,
|
|
|
|
ForExpr,
|
|
|
|
WhileExpr,
|
|
|
|
ContinueExpr,
|
|
|
|
BreakExpr,
|
|
|
|
Label,
|
|
|
|
BlockExpr,
|
|
|
|
ReturnExpr,
|
|
|
|
MatchExpr,
|
|
|
|
RecordLit,
|
|
|
|
CallExpr,
|
|
|
|
IndexExpr,
|
|
|
|
MethodCallExpr,
|
|
|
|
FieldExpr,
|
|
|
|
AwaitExpr,
|
|
|
|
TryExpr,
|
2020-05-01 18:18:19 -05:00
|
|
|
EffectExpr,
|
2020-01-03 13:37:02 -06:00
|
|
|
CastExpr,
|
|
|
|
RefExpr,
|
|
|
|
PrefixExpr,
|
|
|
|
RangeExpr,
|
|
|
|
BinExpr,
|
|
|
|
Literal,
|
|
|
|
MacroCall,
|
|
|
|
BoxExpr,
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Any kind of pattern
|
2020-01-03 13:37:02 -06:00
|
|
|
enum Pat {
|
2020-02-09 12:57:01 -06:00
|
|
|
OrPat,
|
|
|
|
ParenPat,
|
2020-01-03 13:37:02 -06:00
|
|
|
RefPat,
|
|
|
|
BoxPat,
|
|
|
|
BindPat,
|
|
|
|
PlaceholderPat,
|
|
|
|
DotDotPat,
|
|
|
|
PathPat,
|
|
|
|
RecordPat,
|
|
|
|
TupleStructPat,
|
|
|
|
TuplePat,
|
|
|
|
SlicePat,
|
|
|
|
RangePat,
|
|
|
|
LiteralPat,
|
2020-04-03 08:38:42 -05:00
|
|
|
MacroPat,
|
2020-01-03 13:37:02 -06:00
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Any kind of pattern that appears directly inside of the curly
|
|
|
|
/// braces of a record pattern
|
2020-04-03 14:12:09 -05:00
|
|
|
enum RecordInnerPat {
|
|
|
|
RecordFieldPat,
|
|
|
|
BindPat
|
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Any kind of input to an attribute
|
2020-01-03 13:37:02 -06:00
|
|
|
enum AttrInput { Literal, TokenTree }
|
2020-04-21 20:15:55 -05:00
|
|
|
|
|
|
|
/// Any kind of statement
|
2020-05-10 13:44:14 -05:00
|
|
|
/// Note: there are no empty statements, these are just represented as
|
|
|
|
/// bare semicolons without a dedicated statement ast node.
|
2020-04-03 14:12:09 -05:00
|
|
|
enum Stmt {
|
|
|
|
LetStmt,
|
|
|
|
ExprStmt,
|
2020-04-21 20:15:55 -05:00
|
|
|
// macro calls are parsed as expression statements
|
2020-04-03 14:12:09 -05:00
|
|
|
}
|
|
|
|
|
2020-04-21 20:15:55 -05:00
|
|
|
/// Any kind of fields list (record or tuple field lists)
|
2020-04-09 10:58:15 -05:00
|
|
|
enum FieldDefList {
|
|
|
|
RecordFieldDefList,
|
|
|
|
TupleFieldDefList,
|
|
|
|
}
|
|
|
|
},
|
2020-01-03 13:37:02 -06:00
|
|
|
};
|