Syntactically permit attributes on 'if' expressions

Fixes rust-lang#68618

Previously, attributes on 'if' expressions (e.g. `#[attr] if true {}`)
were disallowed during parsing. This made it impossible for macros to
perform any custom handling of such attributes (e.g. stripping them
away), since a compilation error would be emitted before they ever had a
chance to run.

This PR permits attributes on 'if' expressions ('if-attrs' from here on)
syntactically, i.e. during parsing. We instead deny if-attrs
during AST validation, which occurs after all macro expansions have run.

This is a conservative change which allows more code to be processed by
macros. It does not commit us to *semantically* accepting if-attrs. For
example, the following code is not allowed even with this PR:

```rust
fn builtin_attr() {
    #[allow(warnings)] if true {}
}

fn custom_attr() {
    #[my_proc_macro_attr] if true {}
}
```

However, the following code *is* accepted

```rust
#[cfg(FALSE)]
fn foo() {
    #[allow(warnings)] if true {}
    #[my_custom_attr] if true {}
}

#[my_custom_attr]
fn use_within_body() {
    #[allow(warnings)] if true {}
    #[my_custom_attr] if true {}
}
```

src/librustc_ast_passes/ast_validation.rs

@@ -399,6 +399,15 @@ impl<'a> AstValidator<'a> {
             }
         }
     }
+
+    fn check_attr_on_if_expr(&self, attrs: &[Attribute]) {
+        if let [a0, ..] = attrs {
+            // Just point to the first attribute in there...
+            self.err_handler()
+                .struct_span_err(a0.span, "attributes are not yet allowed on `if` expressions")
+                .emit();
+        }
+    }
 }
 
 enum GenericPosition {
@@ -515,6 +524,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 )
                 .emit();
             }
+            ExprKind::If(..) => self.check_attr_on_if_expr(&*expr.attrs),
             _ => {}
         }
 

src/librustc_parse/parser/expr.rs

@@ -676,19 +676,11 @@ impl<'a> Parser<'a> {
             expr.map(|mut expr| {
                 attrs.extend::<Vec<_>>(expr.attrs.into());
                 expr.attrs = attrs;
-                self.error_attr_on_if_expr(&expr);
                 expr
             })
         })
     }
 
-    fn error_attr_on_if_expr(&self, expr: &Expr) {
-        if let (ExprKind::If(..), [a0, ..]) = (&expr.kind, &*expr.attrs) {
-            // Just point to the first attribute in there...
-            self.struct_span_err(a0.span, "attributes are not yet allowed on `if` expressions")
-                .emit();
-        }
-    }
 
     fn parse_dot_or_call_expr_with_(&mut self, mut e: P<Expr>, lo: Span) -> PResult<'a, P<Expr>> {
         loop {