Adding upstream version 1.68.2+dfsg1.upstream/1.68.2+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 772 insertions, 0 deletions

diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
new file mode 100644
index 000000000..1fa315f3d
--- /dev/null
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
@@ -0,0 +1,772 @@
+//~ NOTE not a function
+//~| NOTE not a foreign function or static
+//~| NOTE cannot be applied to crates
+//~| NOTE not an `extern` block
+// This test enumerates as many compiler-builtin ungated attributes as
+// possible (that is, all the mutually compatible ones), and checks
+// that we get "expected" (*) warnings for each in the various weird
+// places that users might put them in the syntax.
+//
+// (*): The word "expected" is in quotes above because the cases where
+// warnings are and are not emitted might not match a user's intuition
+// nor the rustc developers' intent. I am really just trying to
+// capture today's behavior in a test, not so that it become enshrined
+// as the absolute behavior going forward, but rather so that we do
+// not change the behavior in the future without even being *aware* of
+// the change when it happens.
+//
+// At the time of authoring, the attributes here are listed in the
+// order that they occur in `librustc_feature`.
+//
+// Any builtin attributes that:
+//
+//  - are not stable, or
+//
+//  - could not be included here covering the same cases as the other
+//    attributes without raising an *error* from rustc (note though
+//    that warnings are of course expected)
+//
+// have their own test case referenced by filename in an inline
+// comment.
+//
+// The test feeds numeric inputs to each attribute that accepts them
+// without error. We do this for two reasons: (1.) to exercise how
+// inputs are handled by each, and (2.) to ease searching for related
+// occurrences in the source text.
+
+// check-pass
+
+#![feature(test)]
+#![warn(unused_attributes, unknown_lints)]
+//~^ NOTE the lint level is defined here
+//~| NOTE the lint level is defined here
+
+// UNGATED WHITE-LISTED BUILT-IN ATTRIBUTES
+
+#![warn(x5400)] //~ WARN unknown lint: `x5400`
+#![allow(x5300)] //~ WARN unknown lint: `x5300`
+#![forbid(x5200)] //~ WARN unknown lint: `x5200`
+#![deny(x5100)] //~ WARN unknown lint: `x5100`
+#![macro_use] // (allowed if no argument; see issue-43160-gating-of-macro_use.rs)
+// skipping testing of cfg
+// skipping testing of cfg_attr
+#![should_panic] //~ WARN `#[should_panic]` only has an effect
+#![ignore] //~ WARN `#[ignore]` only has an effect on functions
+#![no_implicit_prelude]
+#![reexport_test_harness_main = "2900"]
+// see gated-link-args.rs
+// see issue-43106-gating-of-macro_escape.rs for crate-level; but non crate-level is below at "2700"
+// (cannot easily test gating of crate-level #[no_std]; but non crate-level is below at "2600")
+#![proc_macro_derive()] //~ WARN `#[proc_macro_derive]` only has an effect
+#![doc = "2400"]
+#![cold] //~ WARN attribute should be applied to a function
+//~^ WARN this was previously accepted
+#![link()] //~ WARN attribute should be applied to an `extern` block
+//~^ WARN this was previously accepted
+#![link_name = "1900"]
+//~^ WARN attribute should be applied to a foreign function
+//~^^ WARN this was previously accepted by the compiler
+#![link_section = "1800"]
+//~^ WARN attribute should be applied to a function or static
+//~^^ WARN this was previously accepted by the compiler
+#![must_use]
+//~^ WARN `#[must_use]` has no effect
+// see issue-43106-gating-of-stable.rs
+// see issue-43106-gating-of-unstable.rs
+// see issue-43106-gating-of-deprecated.rs
+#![windows_subsystem = "windows"]
+
+// UNGATED CRATE-LEVEL BUILT-IN ATTRIBUTES
+
+#![crate_name = "0900"]
+#![crate_type = "bin"] // cannot pass "0800" here
+
+#![crate_id = "10"]
+//~^ WARN use of deprecated attribute
+//~| HELP remove this attribute
+//~| NOTE `#[warn(deprecated)]` on by default
+
+// FIXME(#44232) we should warn that this isn't used.
+#![feature(rust1)]
+//~^ WARN no longer requires an attribute to enable
+//~| NOTE `#[warn(stable_features)]` on by default
+
+#![no_start]
+//~^ WARN use of deprecated attribute
+//~| HELP remove this attribute
+
+// (cannot easily gating state of crate-level #[no_main]; but non crate-level is below at "0400")
+#![no_builtins]
+#![recursion_limit = "0200"]
+#![type_length_limit = "0100"]
+
+// USES OF BUILT-IN ATTRIBUTES IN OTHER ("UNUSUAL") PLACES
+
+#[warn(x5400)]
+//~^ WARN unknown lint: `x5400`
+mod warn {
+    mod inner { #![warn(x5400)] }
+    //~^ WARN unknown lint: `x5400`
+
+    #[warn(x5400)] fn f() { }
+    //~^ WARN unknown lint: `x5400`
+
+    #[warn(x5400)] struct S;
+    //~^ WARN unknown lint: `x5400`
+
+    #[warn(x5400)] type T = S;
+    //~^ WARN unknown lint: `x5400`
+
+    #[warn(x5400)] impl S { }
+    //~^ WARN unknown lint: `x5400`
+}
+
+#[allow(x5300)]
+//~^ WARN unknown lint: `x5300`
+mod allow {
+    mod inner { #![allow(x5300)] }
+    //~^ WARN unknown lint: `x5300`
+
+    #[allow(x5300)] fn f() { }
+    //~^ WARN unknown lint: `x5300`
+
+    #[allow(x5300)] struct S;
+    //~^ WARN unknown lint: `x5300`
+
+    #[allow(x5300)] type T = S;
+    //~^ WARN unknown lint: `x5300`
+
+    #[allow(x5300)] impl S { }
+    //~^ WARN unknown lint: `x5300`
+}
+
+#[forbid(x5200)]
+//~^ WARN unknown lint: `x5200`
+mod forbid {
+    mod inner { #![forbid(x5200)] }
+    //~^ WARN unknown lint: `x5200`
+
+    #[forbid(x5200)] fn f() { }
+    //~^ WARN unknown lint: `x5200`
+
+    #[forbid(x5200)] struct S;
+    //~^ WARN unknown lint: `x5200`
+
+    #[forbid(x5200)] type T = S;
+    //~^ WARN unknown lint: `x5200`
+
+    #[forbid(x5200)] impl S { }
+    //~^ WARN unknown lint: `x5200`
+}
+
+#[deny(x5100)]
+//~^ WARN unknown lint: `x5100`
+mod deny {
+    mod inner { #![deny(x5100)] }
+    //~^ WARN unknown lint: `x5100`
+
+    #[deny(x5100)] fn f() { }
+    //~^ WARN unknown lint: `x5100`
+
+    #[deny(x5100)] struct S;
+    //~^ WARN unknown lint: `x5100`
+
+    #[deny(x5100)] type T = S;
+    //~^ WARN unknown lint: `x5100`
+
+    #[deny(x5100)] impl S { }
+    //~^ WARN unknown lint: `x5100`
+}
+
+#[macro_use]
+mod macro_use {
+    mod inner { #![macro_use] }
+
+    #[macro_use] fn f() { }
+    //~^ `#[macro_use]` only has an effect
+
+    #[macro_use] struct S;
+    //~^ `#[macro_use]` only has an effect
+
+    #[macro_use] type T = S;
+    //~^ `#[macro_use]` only has an effect
+
+    #[macro_use] impl S { }
+    //~^ `#[macro_use]` only has an effect
+}
+
+#[macro_export]
+//~^ WARN `#[macro_export]` only has an effect on macro definitions
+mod macro_export {
+    mod inner { #![macro_export] }
+    //~^ WARN `#[macro_export]` only has an effect on macro definitions
+
+    #[macro_export] fn f() { }
+    //~^ WARN `#[macro_export]` only has an effect on macro definitions
+
+    #[macro_export] struct S;
+    //~^ WARN `#[macro_export]` only has an effect on macro definitions
+
+    #[macro_export] type T = S;
+    //~^ WARN `#[macro_export]` only has an effect on macro definitions
+
+    #[macro_export] impl S { }
+    //~^ WARN `#[macro_export]` only has an effect on macro definitions
+}
+
+// At time of unit test authorship, if compiling without `--test` then
+// non-crate-level #[test] attributes seem to be ignored.
+
+#[test]
+mod test { mod inner { #![test] }
+
+    fn f() { }
+
+    struct S;
+
+    type T = S;
+
+    impl S { }
+}
+
+// At time of unit test authorship, if compiling without `--test` then
+// non-crate-level #[bench] attributes seem to be ignored.
+
+#[bench]
+mod bench {
+    mod inner { #![bench] }
+
+    #[bench]
+    struct S;
+
+    #[bench]
+    type T = S;
+
+    #[bench]
+    impl S { }
+}
+
+#[path = "3800"]
+mod path {
+    mod inner { #![path="3800"] }
+
+    #[path = "3800"] fn f() { }
+    //~^ WARN `#[path]` only has an effect
+
+    #[path = "3800"]  struct S;
+    //~^ WARN `#[path]` only has an effect
+
+    #[path = "3800"] type T = S;
+    //~^ WARN `#[path]` only has an effect
+
+    #[path = "3800"] impl S { }
+    //~^ WARN `#[path]` only has an effect
+}
+
+#[automatically_derived]
+//~^ WARN `#[automatically_derived]` only has an effect
+mod automatically_derived {
+    mod inner { #![automatically_derived] }
+    //~^ WARN `#[automatically_derived]
+
+    #[automatically_derived] fn f() { }
+    //~^ WARN `#[automatically_derived]
+
+    #[automatically_derived] struct S;
+    //~^ WARN `#[automatically_derived]
+
+    #[automatically_derived] type T = S;
+    //~^ WARN `#[automatically_derived]
+
+    #[automatically_derived] impl S { }
+}
+
+#[no_mangle]
+//~^ WARN attribute should be applied to a free function, impl method or static [unused_attributes]
+//~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+mod no_mangle {
+    //~^ NOTE not a free function, impl method or static
+    mod inner { #![no_mangle] }
+    //~^ WARN attribute should be applied to a free function, impl method or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a free function, impl method or static
+
+    #[no_mangle] fn f() { }
+
+    #[no_mangle] struct S;
+    //~^ WARN attribute should be applied to a free function, impl method or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a free function, impl method or static
+
+    #[no_mangle] type T = S;
+    //~^ WARN attribute should be applied to a free function, impl method or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a free function, impl method or static
+
+    #[no_mangle] impl S { }
+    //~^ WARN attribute should be applied to a free function, impl method or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a free function, impl method or static
+
+    trait Tr {
+        #[no_mangle] fn foo();
+        //~^ WARN attribute should be applied to a free function, impl method or static [unused_attributes]
+        //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+        //~| NOTE not a free function, impl method or static
+
+        #[no_mangle] fn bar() {}
+        //~^ WARN attribute should be applied to a free function, impl method or static [unused_attributes]
+        //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+        //~| NOTE not a free function, impl method or static
+    }
+}
+
+#[should_panic]
+//~^ WARN `#[should_panic]` only has an effect on
+mod should_panic {
+    mod inner { #![should_panic] }
+    //~^ WARN `#[should_panic]` only has an effect on
+
+    #[should_panic] fn f() { }
+
+    #[should_panic] struct S;
+    //~^ WARN `#[should_panic]` only has an effect on
+
+    #[should_panic] type T = S;
+    //~^ WARN `#[should_panic]` only has an effect on
+
+    #[should_panic] impl S { }
+    //~^ WARN `#[should_panic]` only has an effect on
+}
+
+#[ignore]
+//~^ WARN `#[ignore]` only has an effect on functions
+mod ignore {
+    mod inner { #![ignore] }
+    //~^ WARN `#[ignore]` only has an effect on functions
+
+    #[ignore] fn f() { }
+
+    #[ignore] struct S;
+    //~^ WARN `#[ignore]` only has an effect on functions
+
+    #[ignore] type T = S;
+    //~^ WARN `#[ignore]` only has an effect on functions
+
+    #[ignore] impl S { }
+    //~^ WARN `#[ignore]` only has an effect on functions
+}
+
+#[no_implicit_prelude]
+mod no_implicit_prelude {
+    mod inner { #![no_implicit_prelude] }
+
+    #[no_implicit_prelude] fn f() { }
+    //~^ WARN `#[no_implicit_prelude]` only has an effect
+
+    #[no_implicit_prelude] struct S;
+    //~^ WARN `#[no_implicit_prelude]` only has an effect
+
+    #[no_implicit_prelude] type T = S;
+    //~^ WARN `#[no_implicit_prelude]` only has an effect
+
+    #[no_implicit_prelude] impl S { }
+    //~^ WARN `#[no_implicit_prelude]` only has an effect
+}
+
+#[reexport_test_harness_main = "2900"]
+//~^ WARN crate-level attribute should be
+mod reexport_test_harness_main {
+    mod inner { #![reexport_test_harness_main="2900"] }
+    //~^ WARN crate-level attribute should be
+
+    #[reexport_test_harness_main = "2900"] fn f() { }
+    //~^ WARN crate-level attribute should be
+
+    #[reexport_test_harness_main = "2900"] struct S;
+    //~^ WARN crate-level attribute should be
+
+    #[reexport_test_harness_main = "2900"] type T = S;
+    //~^ WARN crate-level attribute should be
+
+    #[reexport_test_harness_main = "2900"] impl S { }
+    //~^ WARN crate-level attribute should be
+}
+
+// Cannot feed "2700" to `#[macro_escape]` without signaling an error.
+#[macro_escape]
+//~^ WARN `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
+mod macro_escape {
+    mod inner { #![macro_escape] }
+    //~^ WARN `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
+    //~| HELP try an outer attribute: `#[macro_use]`
+
+    #[macro_escape] fn f() { }
+    //~^ WARN `#[macro_escape]` only has an effect
+
+    #[macro_escape] struct S;
+    //~^ WARN `#[macro_escape]` only has an effect
+
+    #[macro_escape] type T = S;
+    //~^ WARN `#[macro_escape]` only has an effect
+
+    #[macro_escape] impl S { }
+    //~^ WARN `#[macro_escape]` only has an effect
+}
+
+#[no_std]
+//~^ WARN crate-level attribute should be an inner attribute
+mod no_std {
+    mod inner { #![no_std] }
+//~^ WARN crate-level attribute should be in the root module
+
+    #[no_std] fn f() { }
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[no_std] struct S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[no_std] type T = S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[no_std] impl S { }
+    //~^ WARN crate-level attribute should be an inner attribute
+}
+
+// At time of authorship, #[proc_macro_derive = "2500"] signals error
+// when it occurs on a mod (apart from crate-level). Therefore it goes
+// into its own file; see issue-43106-gating-of-proc_macro_derive.rs
+
+#[doc = "2400"]
+mod doc {
+    mod inner { #![doc="2400"] }
+
+    #[doc = "2400"] fn f() { }
+
+    #[doc = "2400"] struct S;
+
+    #[doc = "2400"] type T = S;
+
+    #[doc = "2400"] impl S { }
+}
+
+#[cold]
+//~^ WARN attribute should be applied to a function
+//~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+mod cold {
+    //~^ NOTE not a function
+
+    mod inner { #![cold] }
+    //~^ WARN attribute should be applied to a function
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a function
+
+    #[cold] fn f() { }
+
+    #[cold] struct S;
+    //~^ WARN attribute should be applied to a function
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a function
+
+    #[cold] type T = S;
+    //~^ WARN attribute should be applied to a function
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a function
+
+    #[cold] impl S { }
+    //~^ WARN attribute should be applied to a function
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a function
+}
+
+#[link_name = "1900"]
+//~^ WARN attribute should be applied to a foreign function or static [unused_attributes]
+//~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+mod link_name {
+    //~^ NOTE not a foreign function or static
+
+    #[link_name = "1900"]
+    //~^ WARN attribute should be applied to a foreign function or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| HELP try `#[link(name = "1900")]` instead
+    extern "C" { }
+    //~^ NOTE not a foreign function or static
+
+    mod inner { #![link_name="1900"] }
+    //~^ WARN attribute should be applied to a foreign function or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a foreign function or static
+
+    #[link_name = "1900"] fn f() { }
+    //~^ WARN attribute should be applied to a foreign function or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a foreign function or static
+
+    #[link_name = "1900"] struct S;
+    //~^ WARN attribute should be applied to a foreign function or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a foreign function or static
+
+    #[link_name = "1900"] type T = S;
+    //~^ WARN attribute should be applied to a foreign function or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a foreign function or static
+
+    #[link_name = "1900"] impl S { }
+    //~^ WARN attribute should be applied to a foreign function or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a foreign function or static
+}
+
+#[link_section = "1800"]
+//~^ WARN attribute should be applied to a function or static [unused_attributes]
+//~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+mod link_section {
+    //~^ NOTE not a function or static
+
+    mod inner { #![link_section="1800"] }
+    //~^ WARN attribute should be applied to a function or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a function or static
+
+    #[link_section = "1800"] fn f() { }
+
+    #[link_section = "1800"] struct S;
+    //~^ WARN attribute should be applied to a function or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a function or static
+
+    #[link_section = "1800"] type T = S;
+    //~^ WARN attribute should be applied to a function or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a function or static
+
+    #[link_section = "1800"] impl S { }
+    //~^ WARN attribute should be applied to a function or static [unused_attributes]
+    //~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    //~| NOTE not a function or static
+}
+
+
+// Note that this is a `check-pass` test, so it will never invoke the linker.
+
+#[link()]
+//~^ WARN attribute should be applied to an `extern` block
+//~| WARN this was previously accepted
+mod link {
+    //~^ NOTE not an `extern` block
+
+    mod inner { #![link()] }
+    //~^ WARN attribute should be applied to an `extern` block
+    //~| WARN this was previously accepted
+    //~| NOTE not an `extern` block
+
+    #[link()] fn f() { }
+    //~^ WARN attribute should be applied to an `extern` block
+    //~| WARN this was previously accepted
+    //~| NOTE not an `extern` block
+
+    #[link()] struct S;
+    //~^ WARN attribute should be applied to an `extern` block
+    //~| WARN this was previously accepted
+    //~| NOTE not an `extern` block
+
+    #[link()] type T = S;
+    //~^ WARN attribute should be applied to an `extern` block
+    //~| WARN this was previously accepted
+    //~| NOTE not an `extern` block
+
+    #[link()] impl S { }
+    //~^ WARN attribute should be applied to an `extern` block
+    //~| WARN this was previously accepted
+    //~| NOTE not an `extern` block
+
+    #[link()] extern "Rust" {}
+    //~^ WARN attribute should be applied to an `extern` block
+    //~| WARN this was previously accepted
+}
+
+struct StructForDeprecated;
+
+#[deprecated]
+mod deprecated {
+    mod inner { #![deprecated] }
+
+    #[deprecated] fn f() { }
+
+    #[deprecated] struct S1;
+
+    #[deprecated] type T = super::StructForDeprecated;
+
+    #[deprecated] impl super::StructForDeprecated { }
+}
+
+#[must_use] //~ WARN `#[must_use]` has no effect
+mod must_use {
+    mod inner { #![must_use] } //~ WARN `#[must_use]` has no effect
+
+    #[must_use] fn f() { }
+
+    #[must_use] struct S;
+
+    #[must_use] type T = S; //~ WARN `#[must_use]` has no effect
+
+    #[must_use] impl S { } //~ WARN `#[must_use]` has no effect
+}
+
+#[windows_subsystem = "windows"]
+//~^ WARN crate-level attribute should be an inner attribute
+mod windows_subsystem {
+    mod inner { #![windows_subsystem="windows"] }
+    //~^ WARN crate-level attribute should be in the root module
+
+    #[windows_subsystem = "windows"] fn f() { }
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[windows_subsystem = "windows"] struct S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[windows_subsystem = "windows"] type T = S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[windows_subsystem = "windows"] impl S { }
+    //~^ WARN crate-level attribute should be an inner attribute
+}
+
+// BROKEN USES OF CRATE-LEVEL BUILT-IN ATTRIBUTES
+
+#[crate_name = "0900"]
+//~^ WARN crate-level attribute should be an inner attribute
+mod crate_name {
+    mod inner { #![crate_name="0900"] }
+//~^ WARN crate-level attribute should be in the root module
+
+    #[crate_name = "0900"] fn f() { }
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[crate_name = "0900"] struct S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[crate_name = "0900"] type T = S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[crate_name = "0900"] impl S { }
+    //~^ WARN crate-level attribute should be an inner attribute
+}
+
+#[crate_type = "0800"]
+//~^ WARN crate-level attribute should be an inner attribute
+mod crate_type {
+    mod inner { #![crate_type="0800"] }
+//~^ WARN crate-level attribute should be in the root module
+
+    #[crate_type = "0800"] fn f() { }
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[crate_type = "0800"] struct S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[crate_type = "0800"] type T = S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[crate_type = "0800"] impl S { }
+    //~^ WARN crate-level attribute should be an inner attribute
+}
+
+#[feature(x0600)]
+//~^ WARN crate-level attribute should be an inner attribute
+mod feature {
+    mod inner { #![feature(x0600)] }
+//~^ WARN crate-level attribute should be in the root module
+
+    #[feature(x0600)] fn f() { }
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[feature(x0600)] struct S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[feature(x0600)] type T = S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[feature(x0600)] impl S { }
+    //~^ WARN crate-level attribute should be an inner attribute
+}
+
+
+#[no_main]
+//~^ WARN crate-level attribute should be an inner attribute
+mod no_main_1 {
+    mod inner { #![no_main] }
+//~^ WARN crate-level attribute should be in the root module
+
+    #[no_main] fn f() { }
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[no_main] struct S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[no_main] type T = S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[no_main] impl S { }
+    //~^ WARN crate-level attribute should be an inner attribute
+}
+
+#[no_builtins]
+//~^ WARN crate-level attribute should be an inner attribute
+mod no_builtins {
+    mod inner { #![no_builtins] }
+    //~^ WARN crate-level attribute should be in the root module
+
+    #[no_builtins] fn f() { }
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[no_builtins] struct S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[no_builtins] type T = S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[no_builtins] impl S { }
+    //~^ WARN crate-level attribute should be an inner attribute
+}
+
+#[recursion_limit="0200"]
+//~^ WARN crate-level attribute should be an inner attribute
+mod recursion_limit {
+    mod inner { #![recursion_limit="0200"] }
+//~^ WARN crate-level attribute should be in the root module
+
+    #[recursion_limit="0200"] fn f() { }
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[recursion_limit="0200"] struct S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[recursion_limit="0200"] type T = S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[recursion_limit="0200"] impl S { }
+    //~^ WARN crate-level attribute should be an inner attribute
+}
+
+#[type_length_limit="0100"]
+//~^ WARN crate-level attribute should be an inner attribute
+mod type_length_limit {
+    mod inner { #![type_length_limit="0100"] }
+//~^ WARN crate-level attribute should be in the root module
+
+    #[type_length_limit="0100"] fn f() { }
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[type_length_limit="0100"] struct S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[type_length_limit="0100"] type T = S;
+    //~^ WARN crate-level attribute should be an inner attribute
+
+    #[type_length_limit="0100"] impl S { }
+    //~^ WARN crate-level attribute should be an inner attribute
+}
+
+fn main() {}