Auto merge of #57321 - petrochenkov:atokens, r=<try>

Implement basic input validation for built-in attributes + Stabilize `unrestricted_attribute_tokens`

Based on #57272

---

In accordance with the plan in https://internals.rust-lang.org/t/unrestricted-attribute-tokens-feature-status/8561:
- The correct top-level shape (`#[attr]` vs `#[attr(...)]` vs `#[attr = ...]`) is enforced for built-in attributes.
- For non-built-in non-macro attributes:
    - The key-value form is restricted to bare minimum required to support what we support on stable - unsuffixed literals (#34981).
    - Arbitrary token streams in remaining forms (`#[attr(token_stream)]`, `#[attr{token_stream}]`, `#[attr[token_stream]]` ) are now allowed without a feature gate, like in macro attributes.

This will close #55208 once completed.
Need to go through crater first.

Author: bors

src/librustc/diagnostics.rs

@@ -1180,27 +1180,6 @@ fn main() {
 ```
 "##,
 
-E0296: r##"
-This error indicates that the given recursion limit could not be parsed. Ensure
-that the value provided is a positive integer between quotes.
-
-Erroneous code example:
-
-```compile_fail,E0296
-#![recursion_limit]
-
-fn main() {}
-```
-
-And a working example:
-
-```
-#![recursion_limit="1000"]
-
-fn main() {}
-```
-"##,
-
 E0308: r##"
 This error occurs when the compiler was unable to infer the concrete type of a
 variable. It can occur for several cases, the most common of which is a
@@ -2093,20 +2072,6 @@ trait Foo { }
 ```
 "##,
 
-E0702: r##"
-This error indicates that a `#[non_exhaustive]` attribute had a value. The
-`#[non_exhaustive]` should be empty.
-
-Examples of erroneous code:
-
-```compile_fail,E0702
-# #![feature(non_exhaustive)]
-
-#[non_exhaustive(anything)]
-struct Foo;
-```
-"##,
-
 E0718: r##"
 This error indicates that a `#[lang = ".."]` attribute was placed
 on the wrong type of item.
@@ -2138,6 +2103,7 @@ register_diagnostics! {
     E0280, // requirement is not satisfied
     E0284, // cannot resolve type
 //  E0285, // overflow evaluation builtin bounds
+//  E0296, // replaced with a generic attribute input check
 //  E0300, // unexpanded macro
 //  E0304, // expected signed integer constant
 //  E0305, // expected constant
@@ -2180,4 +2146,5 @@ register_diagnostics! {
     E0709, // multiple different lifetimes used in arguments of `async fn`
     E0710, // an unknown tool name found in scoped lint
     E0711, // a feature has been declared with conflicting stability attributes
+//  E0702, // replaced with a generic attribute input check
 }

src/librustc/hir/check_attr.rs

@@ -137,15 +137,6 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
                 return;
             }
         }
-
-        if attr.meta_item_list().is_some() || attr.value_str().is_some() {
-            struct_span_err!(self.tcx.sess,
-                             attr.span,
-                             E0702,
-                             "attribute should be empty")
-                .span_label(item.span, "not empty")
-                .emit();
-        }
     }
 
     /// Check if the `#[marker]` attribute on an `item` is valid.
@@ -160,12 +151,6 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
                 return;
             }
         }
-
-        if !attr.is_word() {
-            self.tcx.sess
-                .struct_span_err(attr.span, "attribute should be empty")
-                .emit();
-        }
     }
 
     /// Check if the `#[repr]` attributes on `item` are valid.

src/librustc/lint/levels.rs

@@ -204,8 +204,6 @@ impl<'a> LintLevelsBuilder<'a> {
             let mut metas = if let Some(metas) = meta.meta_item_list() {
                 metas
             } else {
-                let mut err = bad_attr(meta.span);
-                err.emit();
                 continue;
             };
 

src/librustc/middle/recursion_limit.rs

@@ -11,14 +11,11 @@ use syntax::ast;
 use rustc_data_structures::sync::Once;
 
 pub fn update_limits(sess: &Session, krate: &ast::Crate) {
-    update_limit(sess, krate, &sess.recursion_limit, "recursion_limit",
-                 "recursion limit", 64);
-    update_limit(sess, krate, &sess.type_length_limit, "type_length_limit",
-                 "type length limit", 1048576);
+    update_limit(krate, &sess.recursion_limit, "recursion_limit", 64);
+    update_limit(krate, &sess.type_length_limit, "type_length_limit", 1048576);
 }
 
-fn update_limit(sess: &Session, krate: &ast::Crate, limit: &Once<usize>,
-                name: &str, description: &str, default: usize) {
+fn update_limit(krate: &ast::Crate, limit: &Once<usize>, name: &str, default: usize) {
     for attr in &krate.attrs {
         if !attr.check_name(name) {
             continue;
@@ -30,10 +27,6 @@ fn update_limit(sess: &Session, krate: &ast::Crate, limit: &Once<usize>,
                 return;
             }
         }
-
-        span_err!(sess, attr.span, E0296,
-                  "malformed {} attribute, expected #![{}=\"N\"]",
-                  description, name);
     }
     limit.set(default);
 }

src/librustc/traits/on_unimplemented.rs

@@ -157,10 +157,7 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedDirective {
                 note: None,
             }))
         } else {
-            return Err(parse_error(tcx, attr.span,
-                                   "`#[rustc_on_unimplemented]` requires a value",
-                                   "value required here",
-                                   Some(r#"eg `#[rustc_on_unimplemented(message="foo")]`"#)));
+            return Err(ErrorReported);
         };
         debug!("of_item({:?}/{:?}) = {:?}", trait_def_id, impl_def_id, result);
         result

src/librustc/ty/mod.rs

@@ -2801,16 +2801,14 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             self.impl_polarity(def_id1) == self.impl_polarity(def_id2)
                 && trait1_is_empty
                 && trait2_is_empty
-        } else if self.features().marker_trait_attr {
+        } else {
             let is_marker_impl = |def_id: DefId| -> bool {
                 let trait_ref = self.impl_trait_ref(def_id);
                 trait_ref.map_or(false, |tr| self.trait_def(tr.def_id).is_marker)
             };
             self.impl_polarity(def_id1) == self.impl_polarity(def_id2)
                 && is_marker_impl(def_id1)
                 && is_marker_impl(def_id2)
-        } else {
-            false
         }
     }
 

src/librustc_driver/driver.rs

@@ -1101,23 +1101,20 @@ where
         ast_validation::check_crate(sess, &krate)
     });
 
-    time(sess, "name resolution", || -> CompileResult {
+    time(sess, "name resolution", || {
         resolver.resolve_crate(&krate);
-        Ok(())
-    })?;
+    });
 
     // Needs to go *after* expansion to be able to check the results of macro expansion.
     time(sess, "complete gated feature checking", || {
-        sess.track_errors(|| {
-            syntax::feature_gate::check_crate(
-                &krate,
-                &sess.parse_sess,
-                &sess.features_untracked(),
-                &attributes,
-                sess.opts.unstable_features,
-            );
-        })
-    })?;
+        syntax::feature_gate::check_crate(
+            &krate,
+            &sess.parse_sess,
+            &sess.features_untracked(),
+            &attributes,
+            sess.opts.unstable_features,
+        );
+    });
 
     // Lower ast -> hir.
     // First, we need to collect the dep_graph.
@@ -1530,13 +1527,7 @@ pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<c
                         }
                         None
                     }
-                    None => {
-                        session
-                            .struct_span_err(a.span, "`crate_type` requires a value")
-                            .note("for example: `#![crate_type=\"lib\"]`")
-                            .emit();
-                        None
-                    }
+                    None => None
                 }
             } else {
                 None

src/librustc_lint/builtin.rs

@@ -35,7 +35,8 @@ use syntax::ast::Expr;
 use syntax::attr;
 use syntax::source_map::Spanned;
 use syntax::edition::Edition;
-use syntax::feature_gate::{AttributeGate, AttributeType, Stability, deprecated_attributes};
+use syntax::feature_gate::{AttributeGate, AttributeMeta, AttributeType};
+use syntax::feature_gate::{Stability, deprecated_attributes};
 use syntax_pos::{BytePos, Span, SyntaxContext};
 use syntax::symbol::keywords;
 use syntax::errors::{Applicability, DiagnosticBuilder};
@@ -752,7 +753,7 @@ impl EarlyLintPass for BadRepr {
 pub struct DeprecatedAttr {
     // This is not free to compute, so we want to keep it around, rather than
     // compute it for every attribute.
-    depr_attrs: Vec<&'static (&'static str, AttributeType, AttributeGate)>,
+    depr_attrs: Vec<&'static (&'static str, AttributeType, AttributeMeta::Type, AttributeGate)>,
 }
 
 impl DeprecatedAttr {
@@ -771,7 +772,7 @@ impl LintPass for DeprecatedAttr {
 
 impl EarlyLintPass for DeprecatedAttr {
     fn check_attribute(&mut self, cx: &EarlyContext, attr: &ast::Attribute) {
-        for &&(n, _, ref g) in &self.depr_attrs {
+        for &&(n, _, _, ref g) in &self.depr_attrs {
             if attr.name() == n {
                 if let &AttributeGate::Gated(Stability::Deprecated(link, suggestion),
                                              ref name,

src/librustc_lint/unused.rs

@@ -232,7 +232,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedAttributes {
     fn check_attribute(&mut self, cx: &LateContext, attr: &ast::Attribute) {
         debug!("checking attribute: {:?}", attr);
         // Note that check_name() marks the attribute as used if it matches.
-        for &(ref name, ty, _) in BUILTIN_ATTRIBUTES {
+        for &(ref name, ty, ..) in BUILTIN_ATTRIBUTES {
             match ty {
                 AttributeType::Whitelisted if attr.check_name(name) => {
                     debug!("{:?} is Whitelisted", name);
@@ -256,7 +256,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedAttributes {
             cx.span_lint(UNUSED_ATTRIBUTES, attr.span, "unused attribute");
             // Is it a builtin attribute that must be used at the crate level?
             let known_crate = BUILTIN_ATTRIBUTES.iter()
-                .find(|&&(builtin, ty, _)| name == builtin && ty == AttributeType::CrateLevel)
+                .find(|&&(builtin, ty, ..)| name == builtin && ty == AttributeType::CrateLevel)
                 .is_some();
 
             // Has a plugin registered this attribute as one that must be used at

src/librustc_plugin/load.rs

@@ -50,10 +50,7 @@ pub fn load_plugins(sess: &Session,
 
             let plugins = match attr.meta_item_list() {
                 Some(xs) => xs,
-                None => {
-                    call_malformed_plugin_attribute(sess, attr.span);
-                    continue;
-                }
+                None => continue,
             };
 
             for plugin in plugins {