2018-09-30 01:00:50 +00:00
|
|
|
#![feature(lint_reasons)]
|
|
|
|
|
2018-09-30 00:25:26 +00:00
|
|
|
#![forbid(
|
|
|
|
unsafe_code,
|
|
|
|
//~^ NOTE `forbid` level set here
|
2020-01-08 17:02:10 +00:00
|
|
|
//~| NOTE `forbid` level set here
|
|
|
|
//~| NOTE `forbid` level set here
|
Fix inconsistencies in handling of inert attributes on statements
When the 'early' and 'late' visitors visit an attribute target, they
activate any lint attributes (e.g. `#[allow]`) that apply to it.
This can affect warnings emitted on sibiling attributes. For example,
the following code does not produce an `unused_attributes` for
`#[inline]`, since the sibiling `#[allow(unused_attributes)]` suppressed
the warning.
```rust
trait Foo {
#[allow(unused_attributes)] #[inline] fn first();
#[inline] #[allow(unused_attributes)] fn second();
}
```
However, we do not do this for statements - instead, the lint attributes
only become active when we visit the struct nested inside `StmtKind`
(e.g. `Item`).
Currently, this is difficult to observe due to another issue - the
`HasAttrs` impl for `StmtKind` ignores attributes for `StmtKind::Item`.
As a result, the `unused_doc_comments` lint will never see attributes on
item statements.
This commit makes two interrelated fixes to the handling of inert
(non-proc-macro) attributes on statements:
* The `HasAttr` impl for `StmtKind` now returns attributes for
`StmtKind::Item`, treating it just like every other `StmtKind`
variant. The only place relying on the old behavior was macro
which has been updated to explicitly ignore attributes on item
statements. This allows the `unused_doc_comments` lint to fire for
item statements.
* The `early` and `late` lint visitors now activate lint attributes when
invoking the callback for `Stmt`. This ensures that a lint
attribute (e.g. `#[allow(unused_doc_comments)]`) can be applied to
sibiling attributes on an item statement.
For now, the `unused_doc_comments` lint is explicitly disabled on item
statements, which preserves the current behavior. The exact locatiosn
where this lint should fire are being discussed in PR #78306
2020-10-23 22:17:00 +00:00
|
|
|
//~| NOTE `forbid` level set here
|
|
|
|
//~| NOTE `forbid` level set here
|
|
|
|
//~| NOTE `forbid` level set here
|
2018-09-30 00:25:26 +00:00
|
|
|
reason = "our errors & omissions insurance policy doesn't cover unsafe Rust"
|
|
|
|
)]
|
|
|
|
|
|
|
|
use std::ptr;
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
let a_billion_dollar_mistake = ptr::null();
|
|
|
|
|
|
|
|
#[allow(unsafe_code)]
|
|
|
|
//~^ ERROR allow(unsafe_code) overruled by outer forbid(unsafe_code)
|
2020-01-08 17:02:10 +00:00
|
|
|
//~| ERROR allow(unsafe_code) overruled by outer forbid(unsafe_code)
|
|
|
|
//~| ERROR allow(unsafe_code) overruled by outer forbid(unsafe_code)
|
Fix inconsistencies in handling of inert attributes on statements
When the 'early' and 'late' visitors visit an attribute target, they
activate any lint attributes (e.g. `#[allow]`) that apply to it.
This can affect warnings emitted on sibiling attributes. For example,
the following code does not produce an `unused_attributes` for
`#[inline]`, since the sibiling `#[allow(unused_attributes)]` suppressed
the warning.
```rust
trait Foo {
#[allow(unused_attributes)] #[inline] fn first();
#[inline] #[allow(unused_attributes)] fn second();
}
```
However, we do not do this for statements - instead, the lint attributes
only become active when we visit the struct nested inside `StmtKind`
(e.g. `Item`).
Currently, this is difficult to observe due to another issue - the
`HasAttrs` impl for `StmtKind` ignores attributes for `StmtKind::Item`.
As a result, the `unused_doc_comments` lint will never see attributes on
item statements.
This commit makes two interrelated fixes to the handling of inert
(non-proc-macro) attributes on statements:
* The `HasAttr` impl for `StmtKind` now returns attributes for
`StmtKind::Item`, treating it just like every other `StmtKind`
variant. The only place relying on the old behavior was macro
which has been updated to explicitly ignore attributes on item
statements. This allows the `unused_doc_comments` lint to fire for
item statements.
* The `early` and `late` lint visitors now activate lint attributes when
invoking the callback for `Stmt`. This ensures that a lint
attribute (e.g. `#[allow(unused_doc_comments)]`) can be applied to
sibiling attributes on an item statement.
For now, the `unused_doc_comments` lint is explicitly disabled on item
statements, which preserves the current behavior. The exact locatiosn
where this lint should fire are being discussed in PR #78306
2020-10-23 22:17:00 +00:00
|
|
|
//~| ERROR allow(unsafe_code) overruled by outer forbid(unsafe_code)
|
|
|
|
//~| ERROR allow(unsafe_code) overruled by outer forbid(unsafe_code)
|
|
|
|
//~| ERROR allow(unsafe_code) overruled by outer forbid(unsafe_code)
|
2018-09-30 00:25:26 +00:00
|
|
|
//~| NOTE overruled by previous forbid
|
2020-01-08 17:02:10 +00:00
|
|
|
//~| NOTE overruled by previous forbid
|
|
|
|
//~| NOTE overruled by previous forbid
|
Fix inconsistencies in handling of inert attributes on statements
When the 'early' and 'late' visitors visit an attribute target, they
activate any lint attributes (e.g. `#[allow]`) that apply to it.
This can affect warnings emitted on sibiling attributes. For example,
the following code does not produce an `unused_attributes` for
`#[inline]`, since the sibiling `#[allow(unused_attributes)]` suppressed
the warning.
```rust
trait Foo {
#[allow(unused_attributes)] #[inline] fn first();
#[inline] #[allow(unused_attributes)] fn second();
}
```
However, we do not do this for statements - instead, the lint attributes
only become active when we visit the struct nested inside `StmtKind`
(e.g. `Item`).
Currently, this is difficult to observe due to another issue - the
`HasAttrs` impl for `StmtKind` ignores attributes for `StmtKind::Item`.
As a result, the `unused_doc_comments` lint will never see attributes on
item statements.
This commit makes two interrelated fixes to the handling of inert
(non-proc-macro) attributes on statements:
* The `HasAttr` impl for `StmtKind` now returns attributes for
`StmtKind::Item`, treating it just like every other `StmtKind`
variant. The only place relying on the old behavior was macro
which has been updated to explicitly ignore attributes on item
statements. This allows the `unused_doc_comments` lint to fire for
item statements.
* The `early` and `late` lint visitors now activate lint attributes when
invoking the callback for `Stmt`. This ensures that a lint
attribute (e.g. `#[allow(unused_doc_comments)]`) can be applied to
sibiling attributes on an item statement.
For now, the `unused_doc_comments` lint is explicitly disabled on item
statements, which preserves the current behavior. The exact locatiosn
where this lint should fire are being discussed in PR #78306
2020-10-23 22:17:00 +00:00
|
|
|
//~| NOTE overruled by previous forbid
|
|
|
|
//~| NOTE overruled by previous forbid
|
|
|
|
//~| NOTE overruled by previous forbid
|
|
|
|
//~| NOTE our errors & omissions insurance policy doesn't cover unsafe Rust
|
|
|
|
//~| NOTE our errors & omissions insurance policy doesn't cover unsafe Rust
|
|
|
|
//~| NOTE our errors & omissions insurance policy doesn't cover unsafe Rust
|
2020-01-08 17:02:10 +00:00
|
|
|
//~| NOTE our errors & omissions insurance policy doesn't cover unsafe Rust
|
|
|
|
//~| NOTE our errors & omissions insurance policy doesn't cover unsafe Rust
|
2018-09-30 00:25:26 +00:00
|
|
|
//~| NOTE our errors & omissions insurance policy doesn't cover unsafe Rust
|
|
|
|
unsafe {
|
|
|
|
*a_billion_dollar_mistake
|
|
|
|
}
|
|
|
|
}
|