classify.rs

  1// SPDX-License-Identifier: Apache-2.0 OR MIT
  2
  3#[cfg(feature = "full")]
  4use crate::expr::Expr;
  5#[cfg(any(feature = "printing", feature = "full"))]
  6use crate::generics::TypeParamBound;
  7#[cfg(any(feature = "printing", feature = "full"))]
  8use crate::path::{Path, PathArguments};
  9#[cfg(any(feature = "printing", feature = "full"))]
 10use crate::punctuated::Punctuated;
 11#[cfg(any(feature = "printing", feature = "full"))]
 12use crate::ty::{ReturnType, Type};
 13#[cfg(feature = "full")]
 14use proc_macro2::{Delimiter, TokenStream, TokenTree};
 15#[cfg(any(feature = "printing", feature = "full"))]
 16use std::ops::ControlFlow;
 17
 18#[cfg(feature = "full")]
 19pub(crate) fn requires_semi_to_be_stmt(expr: &Expr) -> bool {
 20    match expr {
 21        Expr::Macro(expr) => !expr.mac.delimiter.is_brace(),
 22        _ => requires_comma_to_be_match_arm(expr),
 23    }
 24}
 25
 26#[cfg(feature = "full")]
 27pub(crate) fn requires_comma_to_be_match_arm(expr: &Expr) -> bool {
 28    match expr {
 29        Expr::If(_)
 30        | Expr::Match(_)
 31        | Expr::Block(_) | Expr::Unsafe(_) // both under ExprKind::Block in rustc
 32        | Expr::While(_)
 33        | Expr::Loop(_)
 34        | Expr::ForLoop(_)
 35        | Expr::TryBlock(_)
 36        | Expr::Const(_) => false,
 37
 38        Expr::Array(_)
 39        | Expr::Assign(_)
 40        | Expr::Async(_)
 41        | Expr::Await(_)
 42        | Expr::Binary(_)
 43        | Expr::Break(_)
 44        | Expr::Call(_)
 45        | Expr::Cast(_)
 46        | Expr::Closure(_)
 47        | Expr::Continue(_)
 48        | Expr::Field(_)
 49        | Expr::Group(_)
 50        | Expr::Index(_)
 51        | Expr::Infer(_)
 52        | Expr::Let(_)
 53        | Expr::Lit(_)
 54        | Expr::Macro(_)
 55        | Expr::MethodCall(_)
 56        | Expr::Paren(_)
 57        | Expr::Path(_)
 58        | Expr::Range(_)
 59        | Expr::RawAddr(_)
 60        | Expr::Reference(_)
 61        | Expr::Repeat(_)
 62        | Expr::Return(_)
 63        | Expr::Struct(_)
 64        | Expr::Try(_)
 65        | Expr::Tuple(_)
 66        | Expr::Unary(_)
 67        | Expr::Yield(_)
 68        | Expr::Verbatim(_) => true,
 69    }
 70}
 71
 72#[cfg(feature = "printing")]
 73pub(crate) fn trailing_unparameterized_path(mut ty: &Type) -> bool {
 74    loop {
 75        match ty {
 76            Type::BareFn(t) => match &t.output {
 77                ReturnType::Default => return false,
 78                ReturnType::Type(_, ret) => ty = ret,
 79            },
 80            Type::ImplTrait(t) => match last_type_in_bounds(&t.bounds) {
 81                ControlFlow::Break(trailing_path) => return trailing_path,
 82                ControlFlow::Continue(t) => ty = t,
 83            },
 84            Type::Path(t) => match last_type_in_path(&t.path) {
 85                ControlFlow::Break(trailing_path) => return trailing_path,
 86                ControlFlow::Continue(t) => ty = t,
 87            },
 88            Type::Ptr(t) => ty = &t.elem,
 89            Type::Reference(t) => ty = &t.elem,
 90            Type::TraitObject(t) => match last_type_in_bounds(&t.bounds) {
 91                ControlFlow::Break(trailing_path) => return trailing_path,
 92                ControlFlow::Continue(t) => ty = t,
 93            },
 94
 95            Type::Array(_)
 96            | Type::Group(_)
 97            | Type::Infer(_)
 98            | Type::Macro(_)
 99            | Type::Never(_)
100            | Type::Paren(_)
101            | Type::Slice(_)
102            | Type::Tuple(_)
103            | Type::Verbatim(_) => return false,
104        }
105    }
106
107    fn last_type_in_path(path: &Path) -> ControlFlow<bool, &Type> {
108        match &path.segments.last().unwrap().arguments {
109            PathArguments::None => ControlFlow::Break(true),
110            PathArguments::AngleBracketed(_) => ControlFlow::Break(false),
111            PathArguments::Parenthesized(arg) => match &arg.output {
112                ReturnType::Default => ControlFlow::Break(false),
113                ReturnType::Type(_, ret) => ControlFlow::Continue(ret),
114            },
115        }
116    }
117
118    fn last_type_in_bounds(
119        bounds: &Punctuated<TypeParamBound, Token![+]>,
120    ) -> ControlFlow<bool, &Type> {
121        match bounds.last().unwrap() {
122            TypeParamBound::Trait(t) => last_type_in_path(&t.path),
123            TypeParamBound::Lifetime(_)
124            | TypeParamBound::PreciseCapture(_)
125            | TypeParamBound::Verbatim(_) => ControlFlow::Break(false),
126        }
127    }
128}
129
130/// Whether the expression's first token is the label of a loop/block.
131#[cfg(all(feature = "printing", feature = "full"))]
132pub(crate) fn expr_leading_label(mut expr: &Expr) -> bool {
133    loop {
134        match expr {
135            Expr::Block(e) => return e.label.is_some(),
136            Expr::ForLoop(e) => return e.label.is_some(),
137            Expr::Loop(e) => return e.label.is_some(),
138            Expr::While(e) => return e.label.is_some(),
139
140            Expr::Assign(e) => expr = &e.left,
141            Expr::Await(e) => expr = &e.base,
142            Expr::Binary(e) => expr = &e.left,
143            Expr::Call(e) => expr = &e.func,
144            Expr::Cast(e) => expr = &e.expr,
145            Expr::Field(e) => expr = &e.base,
146            Expr::Index(e) => expr = &e.expr,
147            Expr::MethodCall(e) => expr = &e.receiver,
148            Expr::Range(e) => match &e.start {
149                Some(start) => expr = start,
150                None => return false,
151            },
152            Expr::Try(e) => expr = &e.expr,
153
154            Expr::Array(_)
155            | Expr::Async(_)
156            | Expr::Break(_)
157            | Expr::Closure(_)
158            | Expr::Const(_)
159            | Expr::Continue(_)
160            | Expr::Group(_)
161            | Expr::If(_)
162            | Expr::Infer(_)
163            | Expr::Let(_)
164            | Expr::Lit(_)
165            | Expr::Macro(_)
166            | Expr::Match(_)
167            | Expr::Paren(_)
168            | Expr::Path(_)
169            | Expr::RawAddr(_)
170            | Expr::Reference(_)
171            | Expr::Repeat(_)
172            | Expr::Return(_)
173            | Expr::Struct(_)
174            | Expr::TryBlock(_)
175            | Expr::Tuple(_)
176            | Expr::Unary(_)
177            | Expr::Unsafe(_)
178            | Expr::Verbatim(_)
179            | Expr::Yield(_) => return false,
180        }
181    }
182}
183
184/// Whether the expression's last token is `}`.
185#[cfg(feature = "full")]
186pub(crate) fn expr_trailing_brace(mut expr: &Expr) -> bool {
187    loop {
188        match expr {
189            Expr::Async(_)
190            | Expr::Block(_)
191            | Expr::Const(_)
192            | Expr::ForLoop(_)
193            | Expr::If(_)
194            | Expr::Loop(_)
195            | Expr::Match(_)
196            | Expr::Struct(_)
197            | Expr::TryBlock(_)
198            | Expr::Unsafe(_)
199            | Expr::While(_) => return true,
200
201            Expr::Assign(e) => expr = &e.right,
202            Expr::Binary(e) => expr = &e.right,
203            Expr::Break(e) => match &e.expr {
204                Some(e) => expr = e,
205                None => return false,
206            },
207            Expr::Cast(e) => return type_trailing_brace(&e.ty),
208            Expr::Closure(e) => expr = &e.body,
209            Expr::Let(e) => expr = &e.expr,
210            Expr::Macro(e) => return e.mac.delimiter.is_brace(),
211            Expr::Range(e) => match &e.end {
212                Some(end) => expr = end,
213                None => return false,
214            },
215            Expr::RawAddr(e) => expr = &e.expr,
216            Expr::Reference(e) => expr = &e.expr,
217            Expr::Return(e) => match &e.expr {
218                Some(e) => expr = e,
219                None => return false,
220            },
221            Expr::Unary(e) => expr = &e.expr,
222            Expr::Verbatim(e) => return tokens_trailing_brace(e),
223            Expr::Yield(e) => match &e.expr {
224                Some(e) => expr = e,
225                None => return false,
226            },
227
228            Expr::Array(_)
229            | Expr::Await(_)
230            | Expr::Call(_)
231            | Expr::Continue(_)
232            | Expr::Field(_)
233            | Expr::Group(_)
234            | Expr::Index(_)
235            | Expr::Infer(_)
236            | Expr::Lit(_)
237            | Expr::MethodCall(_)
238            | Expr::Paren(_)
239            | Expr::Path(_)
240            | Expr::Repeat(_)
241            | Expr::Try(_)
242            | Expr::Tuple(_) => return false,
243        }
244    }
245
246    fn type_trailing_brace(mut ty: &Type) -> bool {
247        loop {
248            match ty {
249                Type::BareFn(t) => match &t.output {
250                    ReturnType::Default => return false,
251                    ReturnType::Type(_, ret) => ty = ret,
252                },
253                Type::ImplTrait(t) => match last_type_in_bounds(&t.bounds) {
254                    ControlFlow::Break(trailing_brace) => return trailing_brace,
255                    ControlFlow::Continue(t) => ty = t,
256                },
257                Type::Macro(t) => return t.mac.delimiter.is_brace(),
258                Type::Path(t) => match last_type_in_path(&t.path) {
259                    Some(t) => ty = t,
260                    None => return false,
261                },
262                Type::Ptr(t) => ty = &t.elem,
263                Type::Reference(t) => ty = &t.elem,
264                Type::TraitObject(t) => match last_type_in_bounds(&t.bounds) {
265                    ControlFlow::Break(trailing_brace) => return trailing_brace,
266                    ControlFlow::Continue(t) => ty = t,
267                },
268                Type::Verbatim(t) => return tokens_trailing_brace(t),
269
270                Type::Array(_)
271                | Type::Group(_)
272                | Type::Infer(_)
273                | Type::Never(_)
274                | Type::Paren(_)
275                | Type::Slice(_)
276                | Type::Tuple(_) => return false,
277            }
278        }
279    }
280
281    fn last_type_in_path(path: &Path) -> Option<&Type> {
282        match &path.segments.last().unwrap().arguments {
283            PathArguments::None | PathArguments::AngleBracketed(_) => None,
284            PathArguments::Parenthesized(arg) => match &arg.output {
285                ReturnType::Default => None,
286                ReturnType::Type(_, ret) => Some(ret),
287            },
288        }
289    }
290
291    fn last_type_in_bounds(
292        bounds: &Punctuated<TypeParamBound, Token![+]>,
293    ) -> ControlFlow<bool, &Type> {
294        match bounds.last().unwrap() {
295            TypeParamBound::Trait(t) => match last_type_in_path(&t.path) {
296                Some(t) => ControlFlow::Continue(t),
297                None => ControlFlow::Break(false),
298            },
299            TypeParamBound::Lifetime(_) | TypeParamBound::PreciseCapture(_) => {
300                ControlFlow::Break(false)
301            }
302            TypeParamBound::Verbatim(t) => ControlFlow::Break(tokens_trailing_brace(t)),
303        }
304    }
305
306    fn tokens_trailing_brace(tokens: &TokenStream) -> bool {
307        if let Some(TokenTree::Group(last)) = tokens.clone().into_iter().last() {
308            last.delimiter() == Delimiter::Brace
309        } else {
310            false
311        }
312    }
313}