Rename enum from Grouping to Parens

Author: benschulz

compiler/rustc_ast/src/ast.rs

@@ -1391,7 +1391,7 @@ impl Expr {
                 path.clone(),
                 TraitBoundModifiers::NONE,
                 self.span,
-                Grouping::None,
+                Parens::No,
             ))),
             _ => None,
         }
@@ -3361,11 +3361,11 @@ pub struct TraitRef {
     pub ref_id: NodeId,
 }
 
-/// Whether a `PolyTraitRef` is enclosed in parentheses or not.
+/// Whether enclosing parentheses are present or not.
 #[derive(Clone, Encodable, Decodable, Debug)]
-pub enum Grouping {
-    None,
-    Parenthesized,
+pub enum Parens {
+    Yes,
+    No,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug)]
@@ -3381,9 +3381,9 @@ pub struct PolyTraitRef {
 
     pub span: Span,
 
-    /// When `Parenthesized`, the first and last character of `span` are an opening
+    /// When `Yes`, the first and last character of `span` are an opening
     /// and a closing paren respectively.
-    pub grouping: Grouping,
+    pub parens: Parens,
 }
 
 impl PolyTraitRef {
@@ -3392,14 +3392,14 @@ impl PolyTraitRef {
         path: Path,
         modifiers: TraitBoundModifiers,
         span: Span,
-        grouping: Grouping,
+        parens: Parens,
     ) -> Self {
         PolyTraitRef {
             bound_generic_params: generic_params,
             modifiers,
             trait_ref: TraitRef { path, ref_id: DUMMY_NODE_ID },
             span,
-            grouping,
+            parens,
         }
     }
 }

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, grouping: _ } = p;
+            let PolyTraitRef { bound_generic_params, modifiers, trait_ref, span, parens: _ } = 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,
-                        grouping: ast::Grouping::None,
+                        parens: ast::Parens::No,
                     },
                     itctx,
                 );

compiler/rustc_expand/src/build.rs

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

compiler/rustc_lint/src/unused.rs

@@ -1369,7 +1369,7 @@ impl EarlyLintPass for UnusedParens {
                                 .map(|s| s.ident.name == kw::PathRoot)
                                 .unwrap_or(false);
 
-                        if let ast::Grouping::Parenthesized = poly_trait_ref.grouping
+                        if let ast::Parens::Yes = poly_trait_ref.parens
                             && (is_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,
-                        ast::Grouping::None,
+                        ast::Parens::No,
                     )?;
                     let err = self.dcx().create_err(errors::TransposeDynOrImpl {
                         span: kw.span,
@@ -343,7 +343,7 @@ impl<'a> Parser<'a> {
                         path,
                         lo,
                         parse_plus,
-                        ast::Grouping::None,
+                        ast::Parens::No,
                     )?
                 }
             }
@@ -429,7 +429,7 @@ impl<'a> Parser<'a> {
                     path,
                     lo,
                     true,
-                    ast::Grouping::Parenthesized,
+                    ast::Parens::Yes,
                 ),
                 // 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
@@ -510,14 +510,14 @@ impl<'a> Parser<'a> {
         path: ast::Path,
         lo: Span,
         parse_plus: bool,
-        grouping: ast::Grouping,
+        parens: ast::Parens,
     ) -> PResult<'a, TyKind> {
         let poly_trait_ref = PolyTraitRef::new(
             generic_params,
             path,
             TraitBoundModifiers::NONE,
             lo.to(self.prev_token.span),
-            grouping,
+            parens,
         );
         let bounds = vec![GenericBound::Trait(poly_trait_ref)];
         self.parse_remaining_bounds(bounds, parse_plus)
@@ -849,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, ast::Grouping::None)
+            self.parse_remaining_bounds_path(ThinVec::new(), path, lo, true, ast::Parens::No)
         } else {
             // Just a type path.
             Ok(TyKind::Path(None, path))
@@ -1207,7 +1207,7 @@ impl<'a> Parser<'a> {
             }
         }
 
-        let grouping = if has_parens { ast::Grouping::Parenthesized } else { ast::Grouping::None };
+        let grouping = if has_parens { ast::Parens::Yes } else { ast::Parens::No };
         let poly_trait = PolyTraitRef::new(
             lifetime_defs,
             path,

compiler/rustc_resolve/src/late/diagnostics.rs

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