rustidy_ast/
stmt.rs

1//! Statement
2
3// Imports
4use {
5	crate::attr,
6	super::{
7		attr::WithOuterAttributes,
8		expr::{BlockExpression, Expression, ExpressionWithBlock, ExpressionWithoutBlock},
9		item::Item,
10		pat::PatternNoTopAlt,
11		token,
12		ty::Type,
13	},
14	rustidy_format::{Format, Formattable, WhitespaceFormat},
15	rustidy_parse::{Parse, ParseError, Parser, ParserError},
16	rustidy_print::Print,
17	rustidy_util::Whitespace,
18};
19
20/// `Statement`
21#[derive(PartialEq, Eq, Clone, Debug)]
22#[derive(serde::Serialize, serde::Deserialize)]
23#[derive(Parse, Formattable, Format, Print)]
24#[parse(name = "a statement")]
25pub enum Statement {
26	Empty(token::Semi),
27	Let(LetStatement),
28	Expression(ExpressionStatement),
29	Item(Item),
30}
31
32/// `LetStatement`
33#[derive(PartialEq, Eq, Clone, Debug)]
34#[derive(serde::Serialize, serde::Deserialize)]
35#[derive(Parse, Formattable, Format, Print)]
36pub struct LetStatement(
37	#[format(args = attr::with::fmt(Whitespace::INDENT))]
38	pub WithOuterAttributes<LetStatementInner>,
39);
40
41#[derive(PartialEq, Eq, Clone, Debug)]
42#[derive(serde::Serialize, serde::Deserialize)]
43#[derive(Parse, Formattable, Format, Print)]
44#[parse(name = "a let statement")]
45pub struct LetStatementInner {
46	pub super_: Option<token::Super>,
47	#[format(prefix_ws(expr = Whitespace::SINGLE, if_ = self.super_.is_some()))]
48	pub let_:   token::Let,
49	#[parse(fatal)]
50	#[format(prefix_ws = Whitespace::SINGLE)]
51	pub pat:    PatternNoTopAlt,
52	#[format(prefix_ws = Whitespace::REMOVE)]
53	pub ty:     Option<LetStatementTy>,
54	#[format(prefix_ws = Whitespace::SINGLE)]
55	pub eq:     Option<LetStatementEq>,
56	#[format(prefix_ws = Whitespace::REMOVE)]
57	pub semi:   token::Semi,
58}
59
60#[derive(PartialEq, Eq, Clone, Debug)]
61#[derive(serde::Serialize, serde::Deserialize)]
62#[derive(Parse, Formattable, Format, Print)]
63pub struct LetStatementTy {
64	pub colon: token::Colon,
65	#[parse(fatal)]
66	#[format(prefix_ws = Whitespace::SINGLE)]
67	pub ty:    Type,
68}
69
70#[derive(PartialEq, Eq, Clone, Debug)]
71#[derive(serde::Serialize, serde::Deserialize)]
72#[derive(Formattable, Format, Print)]
73pub enum LetStatementEq {
74	Else(LetStatementEqElse),
75	Normal(LetStatementEqNormal),
76}
77
78impl Parse for LetStatementEq {
79	type Error = LetStatementEqError;
80
81	#[coverage(on)]
82	fn parse_from(parser: &mut Parser) -> Result<Self, Self::Error> {
83		let eq = parser.parse()?;
84		let expr = parser.parse()?;
85
86		match parser.try_parse::<token::Else>()? {
87			Ok(else_) => {
88				let else_expr = parser.parse()?;
89				Ok(Self::Else(
90					LetStatementEqElse { eq, expr, else_, else_expr, }
91				))
92			},
93			Err(_) => Ok(Self::Normal(LetStatementEqNormal { eq, expr })),
94		}
95	}
96}
97#[derive(derive_more::Debug, derive_more::From, ParseError)]
98pub enum LetStatementEqError {
99	#[parse_error(transparent)]
100	Eq(ParserError<token::Eq>),
101
102	#[parse_error(transparent)]
103	Expr(ParserError<Expression>),
104
105	#[parse_error(transparent)]
106	Else(ParserError<token::Else>),
107
108	#[parse_error(transparent)]
109	#[parse_error(fatal)]
110	ElseExpr(ParserError<BlockExpression>),
111}
112
113#[derive(PartialEq, Eq, Clone, Debug)]
114#[derive(serde::Serialize, serde::Deserialize)]
115#[derive(Parse, Formattable, Format, Print)]
116pub struct LetStatementEqNormal {
117	pub eq:   token::Eq,
118	#[parse(fatal)]
119	#[format(prefix_ws = Whitespace::SINGLE)]
120	pub expr: Expression,
121}
122
123#[derive(PartialEq, Eq, Clone, Debug)]
124#[derive(serde::Serialize, serde::Deserialize)]
125#[derive(Parse, Formattable, Format, Print)]
126pub struct LetStatementEqElse {
127	pub eq:        token::Eq,
128	#[format(prefix_ws = Whitespace::SINGLE)]
129	// TODO: Except `LazyBooleanExpression` and ending with `}`.
130	pub expr:      Expression,
131	#[format(prefix_ws = Whitespace::SINGLE)]
132	pub else_:     token::Else,
133	#[parse(fatal)]
134	#[format(prefix_ws = Whitespace::SINGLE)]
135	pub else_expr: BlockExpression,
136}
137
138/// `ExpressionStatement`
139#[derive(PartialEq, Eq, Clone, Debug)]
140#[derive(serde::Serialize, serde::Deserialize)]
141#[derive(Parse, Formattable, Format, Print)]
142pub enum ExpressionStatement {
143	WithoutBlock(ExpressionStatementWithoutBlock),
144	WithBlock(ExpressionStatementWithBlock),
145}
146
147#[derive(PartialEq, Eq, Clone, Debug)]
148#[derive(serde::Serialize, serde::Deserialize)]
149#[derive(Parse, Formattable, Format, Print)]
150pub struct ExpressionStatementWithoutBlock {
151	pub expr: ExpressionWithoutBlock,
152	#[format(prefix_ws = Whitespace::REMOVE)]
153	pub semi: token::Semi,
154}
155
156#[derive(PartialEq, Eq, Clone, Debug)]
157#[derive(serde::Serialize, serde::Deserialize)]
158#[derive(Parse, Formattable, Format, Print)]
159pub struct ExpressionStatementWithBlock {
160	pub expr: ExpressionWithBlock,
161	#[format(prefix_ws = Whitespace::REMOVE)]
162	pub semi: Option<token::Semi>,
163}
rustidy_ast/stmt.rs

rustidy_ast/
stmt.rs
