Use two-variant enum over bool

Author: benschulz

compiler/rustc_ast/src/ast.rs

@@ -1391,7 +1391,7 @@ impl Expr {
                 path.clone(),
                 TraitBoundModifiers::NONE,
                 self.span,
-                false,
+                Grouping::None,
             ))),
             _ => None,
         }
@@ -3361,6 +3361,13 @@ pub struct TraitRef {
     pub ref_id: NodeId,
 }
 
+/// Whether a `PolyTraitRef` is enclosed in parentheses or not.
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub enum Grouping {
+    None,
+    Parenthesized,
+}
+
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct PolyTraitRef {
     /// The `'a` in `for<'a> Foo<&'a T>`.
@@ -3374,8 +3381,9 @@ pub struct PolyTraitRef {
 
     pub span: Span,
 
-    /// Whether first and last character of `span` are an opening and a closing paren.
-    pub parens: bool,
+    /// When `Parenthesized`, the first and last character of `span` are an opening
+    /// and a closing paren respectively.
+    pub grouping: Grouping,
 }
 
 impl PolyTraitRef {
@@ -3384,14 +3392,14 @@ impl PolyTraitRef {
         path: Path,
         modifiers: TraitBoundModifiers,
         span: Span,
-        parens: bool,
+        grouping: Grouping,
     ) -> Self {
         PolyTraitRef {
             bound_generic_params: generic_params,
             modifiers,
             trait_ref: TraitRef { path, ref_id: DUMMY_NODE_ID },
             span,
-            parens,
+            grouping,
         }
     }
 }

compiler/rustc_ast/src/visit.rs

@@ -1142,7 +1142,7 @@ macro_rules! common_visitor_and_walkers {
             vis: &mut V,
             p: &$($lt)? $($mut)? PolyTraitRef,
         ) -> V::Result {
-            let PolyTraitRef { bound_generic_params, modifiers, trait_ref, span, parens: _ } = p;
+            let PolyTraitRef { bound_generic_params, modifiers, trait_ref, span, grouping: _ } = p;
             try_visit!(visit_modifiers(vis, modifiers));
             try_visit!(visit_generic_params(vis, bound_generic_params));
             try_visit!(vis.visit_trait_ref(trait_ref));

compiler/rustc_ast_lowering/src/lib.rs

@@ -1209,7 +1209,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         modifiers: TraitBoundModifiers::NONE,
                         trait_ref: TraitRef { path: path.clone(), ref_id: t.id },
                         span: t.span,
-                        parens: false,
+                        grouping: ast::Grouping::None,
                     },
                     itctx,
                 );

compiler/rustc_expand/src/build.rs

@@ -195,7 +195,7 @@ impl<'a> ExtCtxt<'a> {
             },
             trait_ref: self.trait_ref(path),
             span,
-            parens: false,
+            grouping: ast::Grouping::None,
         }
     }
 

compiler/rustc_lint/src/unused.rs

@@ -1344,7 +1344,7 @@ impl EarlyLintPass for UnusedParens {
                                 .map(|s| s.ident.name == kw::PathRoot)
                                 .unwrap_or(false);
 
-                        if poly_trait_ref.parens
+                        if let ast::Grouping::Parenthesized = poly_trait_ref.grouping
                             && (last || !fn_with_explicit_ret_ty)
                             && !dyn2015_exception
                         {

compiler/rustc_parse/src/parser/ty.rs

@@ -310,7 +310,7 @@ impl<'a> Parser<'a> {
                         path,
                         lo,
                         parse_plus,
-                        false,
+                        ast::Grouping::None,
                     )?;
                     let err = self.dcx().create_err(errors::TransposeDynOrImpl {
                         span: kw.span,
@@ -338,7 +338,13 @@ impl<'a> Parser<'a> {
                 } else {
                     let path = self.parse_path(PathStyle::Type)?;
                     let parse_plus = allow_plus == AllowPlus::Yes && self.check_plus();
-                    self.parse_remaining_bounds_path(lifetime_defs, path, lo, parse_plus, false)?
+                    self.parse_remaining_bounds_path(
+                        lifetime_defs,
+                        path,
+                        lo,
+                        parse_plus,
+                        ast::Grouping::None,
+                    )?
                 }
             }
         } else if self.eat_keyword(exp!(Impl)) {
@@ -418,9 +424,13 @@ impl<'a> Parser<'a> {
             let maybe_bounds = allow_plus == AllowPlus::Yes && self.token.is_like_plus();
             match ty.kind {
                 // `(TY_BOUND_NOPAREN) + BOUND + ...`.
-                TyKind::Path(None, path) if maybe_bounds => {
-                    self.parse_remaining_bounds_path(ThinVec::new(), path, lo, true, true)
-                }
+                TyKind::Path(None, path) if maybe_bounds => self.parse_remaining_bounds_path(
+                    ThinVec::new(),
+                    path,
+                    lo,
+                    true,
+                    ast::Grouping::Parenthesized,
+                ),
                 // For `('a) + …`, we know that `'a` in type position already lead to an error being
                 // emitted. To reduce output, let's indirectly suppress E0178 (bad `+` in type) and
                 // other irrelevant consequential errors.
@@ -500,14 +510,14 @@ impl<'a> Parser<'a> {
         path: ast::Path,
         lo: Span,
         parse_plus: bool,
-        has_parens: bool,
+        grouping: ast::Grouping,
     ) -> PResult<'a, TyKind> {
         let poly_trait_ref = PolyTraitRef::new(
             generic_params,
             path,
             TraitBoundModifiers::NONE,
             lo.to(self.prev_token.span),
-            has_parens,
+            grouping,
         );
         let bounds = vec![GenericBound::Trait(poly_trait_ref)];
         self.parse_remaining_bounds(bounds, parse_plus)
@@ -839,7 +849,7 @@ impl<'a> Parser<'a> {
             Ok(TyKind::MacCall(P(MacCall { path, args: self.parse_delim_args()? })))
         } else if allow_plus == AllowPlus::Yes && self.check_plus() {
             // `Trait1 + Trait2 + 'a`
-            self.parse_remaining_bounds_path(ThinVec::new(), path, lo, true, false)
+            self.parse_remaining_bounds_path(ThinVec::new(), path, lo, true, ast::Grouping::None)
         } else {
             // Just a type path.
             Ok(TyKind::Path(None, path))
@@ -1197,12 +1207,13 @@ impl<'a> Parser<'a> {
             }
         }
 
+        let grouping = if has_parens { ast::Grouping::Parenthesized } else { ast::Grouping::None };
         let poly_trait = PolyTraitRef::new(
             lifetime_defs,
             path,
             modifiers,
             lo.to(self.prev_token.span),
-            has_parens,
+            grouping,
         );
         Ok(GenericBound::Trait(poly_trait))
     }

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -3832,7 +3832,7 @@ fn mk_where_bound_predicate(
                 ref_id: DUMMY_NODE_ID,
             },
             span: DUMMY_SP,
-            parens: false,
+            grouping: ast::Grouping::None,
         })],
     };