Disallow attributes on range expression

src/expr.rs

@@ -1213,7 +1213,7 @@ pub(crate) mod parsing {
     use crate::ty::{ReturnType, Type};
     use crate::verbatim;
     #[cfg(feature = "full")]
-    use proc_macro2::TokenStream;
+    use proc_macro2::{Span, TokenStream};
     use std::mem;
 
     // When we're parsing expressions which occur before blocks, like in an if
@@ -1599,7 +1599,18 @@ pub(crate) mod parsing {
 
         if let Expr::Verbatim(tokens) = &mut e {
             *tokens = verbatim::between(&begin, input);
-        } else {
+        } else if !attrs.is_empty() {
+            if let Expr::Range(range) = e {
+                let spans: &[Span] = match &range.limits {
+                    RangeLimits::HalfOpen(limits) => &limits.spans,
+                    RangeLimits::Closed(limits) => &limits.spans,
+                };
+                return Err(crate::error::new2(
+                    spans[0],
+                    *spans.last().unwrap(),
+                    "attributes are not allowed on range expressions starting with `..`",
+                ));
+            }
             let inner_attrs = e.replace_attrs(Vec::new());
             attrs.extend(inner_attrs);
             e.replace_attrs(attrs);
@@ -3833,18 +3844,37 @@ pub(crate) mod printing {
     }
 
     #[cfg(feature = "full")]
-    fn print_expr_range(e: &ExprRange, tokens: &mut TokenStream, fixup: FixupContext) {
+    fn print_expr_range(e: &ExprRange, tokens: &mut TokenStream, mut fixup: FixupContext) {
         outer_attrs_to_tokens(&e.attrs, tokens);
-        if let Some(start) = &e.start {
-            let (left_prec, left_fixup) =
-                fixup.leftmost_subexpression_with_operator(start, true, false, Precedence::Range);
-            print_subexpression(start, left_prec <= Precedence::Range, tokens, left_fixup);
-        }
-        e.limits.to_tokens(tokens);
-        if let Some(end) = &e.end {
-            let right_fixup = fixup.rightmost_subexpression_fixup(false, true, Precedence::Range);
-            let right_prec = right_fixup.rightmost_subexpression_precedence(end);
-            print_subexpression(end, right_prec <= Precedence::Range, tokens, right_fixup);
+
+        let needs_group = !e.attrs.is_empty();
+        if needs_group {
+            fixup = FixupContext::NONE;
+        }
+
+        let do_print_expr = |tokens: &mut TokenStream| {
+            if let Some(start) = &e.start {
+                let (left_prec, left_fixup) = fixup.leftmost_subexpression_with_operator(
+                    start,
+                    true,
+                    false,
+                    Precedence::Range,
+                );
+                print_subexpression(start, left_prec <= Precedence::Range, tokens, left_fixup);
+            }
+            e.limits.to_tokens(tokens);
+            if let Some(end) = &e.end {
+                let right_fixup =
+                    fixup.rightmost_subexpression_fixup(false, true, Precedence::Range);
+                let right_prec = right_fixup.rightmost_subexpression_precedence(end);
+                print_subexpression(end, right_prec <= Precedence::Range, tokens, right_fixup);
+            }
+        };
+
+        if needs_group {
+            token::Paren::default().surround(tokens, do_print_expr);
+        } else {
+            do_print_expr(tokens);
         }
     }
 

src/fixup.rs

@@ -612,7 +612,7 @@ fn scan_right(
                 Scan::Bailout
             }
         }
-        Expr::Range(e) => match &e.end {
+        Expr::Range(e) if e.attrs.is_empty() => match &e.end {
             Some(end) => {
                 if fail_offset >= 2 {
                     return Scan::Consume;
@@ -754,6 +754,7 @@ fn scan_right(
         | Expr::MethodCall(_)
         | Expr::Paren(_)
         | Expr::Path(_)
+        | Expr::Range(_)
         | Expr::Repeat(_)
         | Expr::Struct(_)
         | Expr::Try(_)

tests/test_expr.rs

@@ -424,6 +424,53 @@ fn test_range_precedence() {
     syn::parse_str::<Expr>("x .. x ..").unwrap_err();
 }
 
+#[test]
+fn test_range_attrs() {
+    // Attributes are not allowed on range expressions starting with `..`
+    syn::parse_str::<Expr>("#[allow()] ..").unwrap_err();
+    syn::parse_str::<Expr>("#[allow()] .. hi").unwrap_err();
+
+    snapshot!("#[allow()] lo .. hi" as Expr, @r#"
+    Expr::Range {
+        start: Some(Expr::Path {
+            attrs: [
+                Attribute {
+                    style: AttrStyle::Outer,
+                    meta: Meta::List {
+                        path: Path {
+                            segments: [
+                                PathSegment {
+                                    ident: "allow",
+                                },
+                            ],
+                        },
+                        delimiter: MacroDelimiter::Paren,
+                        tokens: TokenStream(``),
+                    },
+                },
+            ],
+            path: Path {
+                segments: [
+                    PathSegment {
+                        ident: "lo",
+                    },
+                ],
+            },
+        }),
+        limits: RangeLimits::HalfOpen,
+        end: Some(Expr::Path {
+            path: Path {
+                segments: [
+                    PathSegment {
+                        ident: "hi",
+                    },
+                ],
+            },
+        }),
+    }
+    "#);
+}
+
 #[test]
 fn test_ranges_bailout() {
     syn::parse_str::<Expr>(".. ?").unwrap_err();