nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-26 00:34:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #92584 - lcnr:query-stable-lint, r=estebank

Browse Source 
add rustc lint, warning when iterating over hashmaps 2

first introduced in #89558 and reverted in #90380 due to its perf impact

r? ``@estebank``
This commit is contained in:
Matthias Krüger 2022-02-01 16:08:03 +01:00 committed by GitHub
commit 741b62af07
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
42 changed files with 310 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
compiler/rustc_ast_lowering/src/lib.rs
View File

@ -34,6 +34,7 @@
#![feature(box_patterns)]
#![feature(never_type)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
use rustc_ast::token::{self, Token};
use rustc_ast::tokenstream::{CanSynthesizeMissingTokens, TokenStream, TokenTree};

1
compiler/rustc_ast_passes/src/lib.rs
View File

@ -8,6 +8,7 @@
#![feature(box_patterns)]
#![feature(let_else)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
pub mod ast_validation;
pub mod feature_gate;

1
compiler/rustc_borrowck/src/lib.rs
View File

@ -9,6 +9,7 @@
#![feature(trusted_step)]
#![feature(try_blocks)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate rustc_middle;

1
compiler/rustc_builtin_macros/src/lib.rs
View File

@ -12,6 +12,7 @@
#![feature(proc_macro_internals)]
#![feature(proc_macro_quote)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
extern crate proc_macro;

1
compiler/rustc_codegen_llvm/src/lib.rs
View File

@ -11,6 +11,7 @@
#![feature(extern_types)]
#![feature(nll)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
use back::write::{create_informational_target_machine, create_target_machine};

1
compiler/rustc_codegen_ssa/src/lib.rs
View File

@ -7,6 +7,7 @@
#![feature(nll)]
#![feature(associated_type_bounds)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
//! This crate contains codegen code that is used by all codegen backends (LLVM and others).
//! The backend-agnostic functions of this crate use functions defined in various traits that

1
compiler/rustc_const_eval/src/lib.rs
View File

@ -22,6 +22,7 @@ Rust MIR: a lowered representation of Rust.
#![feature(trusted_step)]
#![feature(try_blocks)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate tracing;

1
compiler/rustc_data_structures/src/lib.rs
View File

@ -26,6 +26,7 @@
#![feature(vec_into_raw_parts)]
#![allow(rustc::default_hash_types)]
#![deny(unaligned_references)]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate tracing;

3
compiler/rustc_driver/src/lib.rs
View File

@ -8,6 +8,7 @@
#![feature(nll)]
#![feature(once_cell)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate tracing;
@ -845,7 +846,7 @@ Available lint options:
let builtin = sort_lints(sess, builtin);
let (plugin_groups, builtin_groups): (Vec<_>, _) =
lint_store.get_lint_groups().iter().cloned().partition(|&(.., p)| p);
lint_store.get_lint_groups().partition(|&(.., p)| p);
let plugin_groups = sort_lint_groups(plugin_groups);
let builtin_groups = sort_lint_groups(builtin_groups);

1
compiler/rustc_errors/src/lib.rs
View File

@ -8,6 +8,7 @@
#![feature(if_let_guard)]
#![feature(let_else)]
#![feature(nll)]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate rustc_macros;

1
compiler/rustc_expand/src/lib.rs
View File

@ -9,6 +9,7 @@
#![feature(proc_macro_span)]
#![feature(try_blocks)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate rustc_macros;

3
compiler/rustc_feature/src/builtin_attrs.rs
View File

@ -581,6 +581,9 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
rustc_attr!(
rustc_trivial_field_reads, Normal, template!(Word), WarnFollowing, INTERNAL_UNSTABLE
),
// Used by the `rustc::potential_query_instability` lint to warn methods which
// might not be stable during incremental compilation.
rustc_attr!(rustc_lint_query_instability, Normal, template!(Word), WarnFollowing, INTERNAL_UNSTABLE),
// ==========================================================================
// Internal attributes, Const related:

1
compiler/rustc_incremental/src/lib.rs
View File

@ -5,6 +5,7 @@
#![feature(let_else)]
#![feature(nll)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate rustc_middle;

1
compiler/rustc_infer/src/lib.rs
View File

@ -23,6 +23,7 @@
#![feature(min_specialization)]
#![feature(label_break_value)]
#![recursion_limit = "512"] // For rustdoc
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate rustc_macros;

1
compiler/rustc_interface/src/lib.rs
View File

@ -6,6 +6,7 @@
#![feature(nll)]
#![feature(once_cell)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
mod callbacks;
pub mod interface;

7
compiler/rustc_lint/src/context.rs
View File

@ -143,7 +143,11 @@ impl LintStore {
&self.lints
}
pub fn get_lint_groups<'t>(&'t self) -> Vec<(&'static str, Vec<LintId>, bool)> {
pub fn get_lint_groups<'t>(
&'t self,
) -> impl Iterator<Item = (&'static str, Vec<LintId>, bool)> + 't {
// This function is not used in a way which observes the order of lints.
#[cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
self.lint_groups
.iter()
.filter(|(_, LintGroup { depr, .. })| {
@ -153,7 +157,6 @@ impl LintStore {
.map(|(k, LintGroup { lint_ids, from_plugin, .. })| {
(*k, lint_ids.clone(), *from_plugin)
})
.collect()
}
pub fn register_early_pass(

60
compiler/rustc_lint/src/internal.rs
View File

@ -5,7 +5,8 @@ use crate::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext}
use rustc_ast as ast;
use rustc_errors::Applicability;
use rustc_hir::def::Res;
use rustc_hir::{GenericArg, HirId, Item, ItemKind, Node, Path, PathSegment, QPath, Ty, TyKind};
use rustc_hir::{Expr, ExprKind, GenericArg, Path, PathSegment, QPath};
use rustc_hir::{HirId, Item, ItemKind, Node, Ty, TyKind};
use rustc_middle::ty;
use rustc_session::{declare_lint_pass, declare_tool_lint};
use rustc_span::hygiene::{ExpnKind, MacroKind};
@ -48,6 +49,63 @@ impl LateLintPass<'_> for DefaultHashTypes {
}
}
declare_tool_lint! {
pub rustc::POTENTIAL_QUERY_INSTABILITY,
Allow,
"require explicit opt-in when using potentially unstable methods or functions",
report_in_external_macro: true
}
declare_lint_pass!(QueryStability => [POTENTIAL_QUERY_INSTABILITY]);
impl LateLintPass<'_> for QueryStability {
fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
// FIXME(rustdoc): This lint uses typecheck results, causing rustdoc to
// error if there are resolution failures.
//
// As internal lints are currently always run if there are `unstable_options`,
// they are added to the lint store of rustdoc. Internal lints are also
// not used via the `lint_mod` query. Crate lints run outside of a query
// so rustdoc currently doesn't disable them.
//
// Instead of relying on this, either change crate lints to a query disabled by
// rustdoc, only run internal lints if the user is explicitly opting in
// or figure out a different way to avoid running lints for rustdoc.
if cx.tcx.sess.opts.actually_rustdoc {
return;
}
let (span, def_id, substs) = match expr.kind {
ExprKind::MethodCall(segment, _, _)
if let Some(def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) =>
{
(segment.ident.span, def_id, cx.typeck_results().node_substs(expr.hir_id))
},
_ => {
let &ty::FnDef(def_id, substs) =
cx.typeck_results()
.node_type(expr.hir_id)
.kind() else { return };
(expr.span, def_id, substs)
}
};
if let Ok(Some(instance)) = ty::Instance::resolve(cx.tcx, cx.param_env, def_id, substs) {
let def_id = instance.def_id();
if cx.tcx.has_attr(def_id, sym::rustc_lint_query_instability) {
cx.struct_span_lint(POTENTIAL_QUERY_INSTABILITY, span, |lint| {
let msg = format!(
"using `{}` can result in unstable query results",
cx.tcx.item_name(def_id)
);
lint.build(&msg)
.note("if you believe this case to be fine, allow this lint and add a comment explaining your rationale")
.emit();
})
}
}
}
}
declare_tool_lint! {
pub rustc::USAGE_OF_TY_TYKIND,
Allow,

5
compiler/rustc_lint/src/lib.rs
View File

@ -30,12 +30,14 @@
#![feature(bool_to_option)]
#![feature(box_patterns)]
#![feature(crate_visibility_modifier)]
#![feature(if_let_guard)]
#![feature(iter_order_by)]
#![feature(let_else)]
#![feature(never_type)]
#![feature(nll)]
#![feature(control_flow_enum)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate rustc_middle;
@ -493,6 +495,8 @@ fn register_internals(store: &mut LintStore) {
store.register_early_pass(|| Box::new(LintPassImpl));
store.register_lints(&DefaultHashTypes::get_lints());
store.register_late_pass(|| Box::new(DefaultHashTypes));
store.register_lints(&QueryStability::get_lints());
store.register_late_pass(|| Box::new(QueryStability));
store.register_lints(&ExistingDocKeyword::get_lints());
store.register_late_pass(|| Box::new(ExistingDocKeyword));
store.register_lints(&TyTyKind::get_lints());
@ -505,6 +509,7 @@ fn register_internals(store: &mut LintStore) {
None,
vec![
LintId::of(DEFAULT_HASH_TYPES),
LintId::of(POTENTIAL_QUERY_INSTABILITY),
LintId::of(USAGE_OF_TY_TYKIND),
LintId::of(PASS_BY_VALUE),
LintId::of(LINT_PASS_IMPL_WITHOUT_MACRO),

1
compiler/rustc_metadata/src/lib.rs
View File

@ -9,6 +9,7 @@
#![feature(try_blocks)]
#![feature(never_type)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
extern crate proc_macro;

1
compiler/rustc_middle/src/lib.rs
View File

@ -56,6 +56,7 @@
#![feature(nonzero_ops)]
#![feature(unwrap_infallible)]
#![recursion_limit = "512"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate bitflags;

1
compiler/rustc_mir_build/src/lib.rs
View File

@ -9,6 +9,7 @@
#![feature(once_cell)]
#![feature(min_specialization)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate tracing;

1
compiler/rustc_mir_transform/src/lib.rs
View File

@ -10,6 +10,7 @@
#![feature(trusted_step)]
#![feature(try_blocks)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate tracing;

1
compiler/rustc_monomorphize/src/lib.rs
View File

@ -4,6 +4,7 @@
#![feature(control_flow_enum)]
#![feature(let_else)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate tracing;

166
compiler/rustc_passes/src/check_attr.rs
View File

@ -62,7 +62,7 @@ impl CheckAttrVisitor<'_> {
fn check_attributes(
&self,
hir_id: HirId,
span: &Span,
span: Span,
target: Target,
item: Option<ItemLike<'_>>,
) {
@ -81,7 +81,7 @@ impl CheckAttrVisitor<'_> {
}
sym::target_feature => self.check_target_feature(hir_id, attr, span, target),
sym::track_caller => {
self.check_track_caller(hir_id, &attr.span, attrs, span, target)
self.check_track_caller(hir_id, attr.span, attrs, span, target)
}
sym::doc => self.check_doc_attrs(
attr,
@ -106,6 +106,9 @@ impl CheckAttrVisitor<'_> {
sym::rustc_legacy_const_generics => {
self.check_rustc_legacy_const_generics(&attr, span, target, item)
}
sym::rustc_lint_query_instability => {
self.check_rustc_lint_query_instability(&attr, span, target)
}
sym::rustc_clean
| sym::rustc_dirty
| sym::rustc_if_this_changed
@ -253,7 +256,7 @@ impl CheckAttrVisitor<'_> {
}
/// Checks if an `#[inline]` is applied to a function or a closure. Returns `true` if valid.
fn check_inline(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) -> bool {
fn check_inline(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
match target {
Target::Fn
| Target::Closure
@ -296,7 +299,7 @@ impl CheckAttrVisitor<'_> {
E0518,
"attribute should be applied to function or closure",
)
.span_label(*span, "not a function or closure")
.span_label(span, "not a function or closure")
.emit();
false
}
@ -335,7 +338,7 @@ impl CheckAttrVisitor<'_> {
}
/// Checks if `#[naked]` is applied to a function definition.
fn check_naked(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) -> bool {
fn check_naked(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
match target {
Target::Fn
| Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent) => true,
@ -354,7 +357,7 @@ impl CheckAttrVisitor<'_> {
attr.span,
"attribute should be applied to a function definition",
)
.span_label(*span, "not a function definition")
.span_label(span, "not a function definition")
.emit();
false
}
@ -362,7 +365,7 @@ impl CheckAttrVisitor<'_> {
}
/// Checks if `#[cmse_nonsecure_entry]` is applied to a function definition.
fn check_cmse_nonsecure_entry(&self, attr: &Attribute, span: &Span, target: Target) -> bool {
fn check_cmse_nonsecure_entry(&self, attr: &Attribute, span: Span, target: Target) -> bool {
match target {
Target::Fn
| Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent) => true,
@ -373,7 +376,7 @@ impl CheckAttrVisitor<'_> {
attr.span,
"attribute should be applied to a function definition",
)
.span_label(*span, "not a function definition")
.span_label(span, "not a function definition")
.emit();
false
}
@ -384,16 +387,16 @@ impl CheckAttrVisitor<'_> {
fn check_track_caller(
&self,
hir_id: HirId,
attr_span: &Span,
attr_span: Span,
attrs: &[Attribute],
span: &Span,
span: Span,
target: Target,
) -> bool {
match target {
_ if attrs.iter().any(|attr| attr.has_name(sym::naked)) => {
struct_span_err!(
self.tcx.sess,
*attr_span,
attr_span,
E0736,
"cannot use `#[track_caller]` with `#[naked]`",
)
@ -414,11 +417,11 @@ impl CheckAttrVisitor<'_> {
_ => {
struct_span_err!(
self.tcx.sess,
*attr_span,
attr_span,
E0739,
"attribute should be applied to function"
)
.span_label(*span, "not a function")
.span_label(span, "not a function")
.emit();
false
}
@ -430,7 +433,7 @@ impl CheckAttrVisitor<'_> {
&self,
hir_id: HirId,
attr: &Attribute,
span: &Span,
span: Span,
target: Target,
) -> bool {
match target {
@ -450,7 +453,7 @@ impl CheckAttrVisitor<'_> {
E0701,
"attribute can only be applied to a struct or enum"
)
.span_label(*span, "not a struct or enum")
.span_label(span, "not a struct or enum")
.emit();
false
}
@ -458,7 +461,7 @@ impl CheckAttrVisitor<'_> {
}
/// Checks if the `#[marker]` attribute on an `item` is valid. Returns `true` if valid.
fn check_marker(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) -> bool {
fn check_marker(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
match target {
Target::Trait => true,
// FIXME(#80564): We permit struct fields, match arms and macro defs to have an
@ -473,7 +476,7 @@ impl CheckAttrVisitor<'_> {
self.tcx
.sess
.struct_span_err(attr.span, "attribute can only be applied to a trait")
.span_label(*span, "not a trait")
.span_label(span, "not a trait")
.emit();
false
}
@ -484,7 +487,7 @@ impl CheckAttrVisitor<'_> {
fn check_rustc_must_implement_one_of(
&self,
attr: &Attribute,
span: &Span,
span: Span,
target: Target,
) -> bool {
match target {
@ -493,7 +496,7 @@ impl CheckAttrVisitor<'_> {
self.tcx
.sess
.struct_span_err(attr.span, "attribute can only be applied to a trait")
.span_label(*span, "not a trait")
.span_label(span, "not a trait")
.emit();
false
}
@ -505,7 +508,7 @@ impl CheckAttrVisitor<'_> {
&self,
hir_id: HirId,
attr: &Attribute,
span: &Span,
span: Span,
target: Target,
) -> bool {
match target {
@ -521,7 +524,7 @@ impl CheckAttrVisitor<'_> {
being phased out; it will become a hard error in \
a future release!",
)
.span_label(*span, "not a function")
.span_label(span, "not a function")
.emit();
});
true
@ -538,7 +541,7 @@ impl CheckAttrVisitor<'_> {
self.tcx
.sess
.struct_span_err(attr.span, "attribute should be applied to a function")
.span_label(*span, "not a function")
.span_label(span, "not a function")
.emit();
false
}
@ -1090,7 +1093,7 @@ impl CheckAttrVisitor<'_> {
}
/// Warns against some misuses of `#[pass_by_value]`
fn check_pass_by_value(&self, attr: &Attribute, span: &Span, target: Target) -> bool {
fn check_pass_by_value(&self, attr: &Attribute, span: Span, target: Target) -> bool {
match target {
Target::Struct | Target::Enum | Target::TyAlias => true,
_ => {
@ -1100,7 +1103,7 @@ impl CheckAttrVisitor<'_> {
attr.span,
"`pass_by_value` attribute should be applied to a struct, enum or type alias.",
)
.span_label(*span, "is not a struct, enum or type alias")
.span_label(span, "is not a struct, enum or type alias")
.emit();
false
}
@ -1108,13 +1111,7 @@ impl CheckAttrVisitor<'_> {
}
/// Warns against some misuses of `#[must_use]`
fn check_must_use(
&self,
hir_id: HirId,
attr: &Attribute,
span: &Span,
_target: Target,
) -> bool {
fn check_must_use(&self, hir_id: HirId, attr: &Attribute, span: Span, _target: Target) -> bool {
let node = self.tcx.hir().get(hir_id);
if let Some(fn_node) = node.fn_kind() {
if let rustc_hir::IsAsync::Async = fn_node.asyncness() {
@ -1125,7 +1122,7 @@ impl CheckAttrVisitor<'_> {
function, not the value within",
)
.span_label(
*span,
span,
"this attribute does nothing, the `Future`s \
returned by async functions are already `must_use`",
)
@ -1139,14 +1136,14 @@ impl CheckAttrVisitor<'_> {
}
/// Checks if `#[must_not_suspend]` is applied to a function. Returns `true` if valid.
fn check_must_not_suspend(&self, attr: &Attribute, span: &Span, target: Target) -> bool {
fn check_must_not_suspend(&self, attr: &Attribute, span: Span, target: Target) -> bool {
match target {
Target::Struct | Target::Enum | Target::Union | Target::Trait => true,
_ => {
self.tcx
.sess
.struct_span_err(attr.span, "`must_not_suspend` attribute should be applied to a struct, enum, or trait")
.span_label(*span, "is not a struct, enum, or trait")
.span_label(span, "is not a struct, enum, or trait")
.emit();
false
}
@ -1154,7 +1151,7 @@ impl CheckAttrVisitor<'_> {
}
/// Checks if `#[cold]` is applied to a non-function. Returns `true` if valid.
fn check_cold(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) {
fn check_cold(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
match target {
Target::Fn | Target::Method(..) | Target::ForeignFn | Target::Closure => {}
// FIXME(#80564): We permit struct fields, match arms and macro defs to have an
@ -1174,7 +1171,7 @@ impl CheckAttrVisitor<'_> {
being phased out; it will become a hard error in \
a future release!",
)
.span_label(*span, "not a function")
.span_label(span, "not a function")
.emit();
});
}
@ -1182,7 +1179,7 @@ impl CheckAttrVisitor<'_> {
}
/// Checks if `#[link]` is applied to an item other than a foreign module.
fn check_link(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) {
fn check_link(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
match target {
Target::ForeignMod => {}
_ => {
@ -1194,7 +1191,7 @@ impl CheckAttrVisitor<'_> {
a future release!",
);
diag.span_label(*span, "not an `extern` block");
diag.span_label(span, "not an `extern` block");
diag.emit();
});
}
@ -1202,7 +1199,7 @@ impl CheckAttrVisitor<'_> {
}
/// Checks if `#[link_name]` is applied to an item other than a foreign function or static.
fn check_link_name(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) {
fn check_link_name(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
match target {
Target::ForeignFn | Target::ForeignStatic => {}
// FIXME(#80564): We permit struct fields, match arms and macro defs to have an
@ -1236,7 +1233,7 @@ impl CheckAttrVisitor<'_> {
}
}
diag.span_label(*span, "not a foreign function or static");
diag.span_label(span, "not a foreign function or static");
diag.emit();
});
}
@ -1244,7 +1241,7 @@ impl CheckAttrVisitor<'_> {
}
/// Checks if `#[no_link]` is applied to an `extern crate`. Returns `true` if valid.
fn check_no_link(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) -> bool {
fn check_no_link(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
match target {
Target::ExternCrate => true,
// FIXME(#80564): We permit struct fields, match arms and macro defs to have an
@ -1262,7 +1259,7 @@ impl CheckAttrVisitor<'_> {
attr.span,
"attribute should be applied to an `extern crate` item",
)
.span_label(*span, "not an `extern crate` item")
.span_label(span, "not an `extern crate` item")
.emit();
false
}
@ -1278,7 +1275,7 @@ impl CheckAttrVisitor<'_> {
&self,
hir_id: HirId,
attr: &Attribute,
span: &Span,
span: Span,
target: Target,
) -> bool {
match target {
@ -1299,7 +1296,7 @@ impl CheckAttrVisitor<'_> {
attr.span,
"attribute should be applied to a free function, impl method or static",
)
.span_label(*span, "not a free function, impl method or static")
.span_label(span, "not a free function, impl method or static")
.emit();
false
}
@ -1309,14 +1306,14 @@ impl CheckAttrVisitor<'_> {
fn check_rustc_layout_scalar_valid_range(
&self,
attr: &Attribute,
span: &Span,
span: Span,
target: Target,
) -> bool {
if target != Target::Struct {
self.tcx
.sess
.struct_span_err(attr.span, "attribute should be applied to a struct")
.span_label(*span, "not a struct")
.span_label(span, "not a struct")
.emit();
return false;
}
@ -1341,7 +1338,7 @@ impl CheckAttrVisitor<'_> {
fn check_rustc_legacy_const_generics(
&self,
attr: &Attribute,
span: &Span,
span: Span,
target: Target,
item: Option<ItemLike<'_>>,
) -> bool {
@ -1350,7 +1347,7 @@ impl CheckAttrVisitor<'_> {
self.tcx
.sess
.struct_span_err(attr.span, "attribute should be applied to a function")
.span_label(*span, "not a function")
.span_label(span, "not a function")
.emit();
return false;
}
@ -1436,6 +1433,25 @@ impl CheckAttrVisitor<'_> {
}
}
fn check_rustc_lint_query_instability(
&self,
attr: &Attribute,
span: Span,
target: Target,
) -> bool {
let is_function = matches!(target, Target::Fn | Target::Method(..));
if !is_function {
self.tcx
.sess
.struct_span_err(attr.span, "attribute should be applied to a function")
.span_label(span, "not a function")
.emit();
false
} else {
true
}
}
/// Checks that the dep-graph debugging attributes are only present when the query-dep-graph
/// option is passed to the compiler.
fn check_rustc_dirty_clean(&self, attr: &Attribute) -> bool {
@ -1451,7 +1467,7 @@ impl CheckAttrVisitor<'_> {
}
/// Checks if `#[link_section]` is applied to a function or static.
fn check_link_section(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) {
fn check_link_section(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
match target {
Target::Static | Target::Fn | Target::Method(..) => {}
// FIXME(#80564): We permit struct fields, match arms and macro defs to have an
@ -1471,7 +1487,7 @@ impl CheckAttrVisitor<'_> {
being phased out; it will become a hard error in \
a future release!",
)
.span_label(*span, "not a function or static")
.span_label(span, "not a function or static")
.emit();
});
}
@ -1479,7 +1495,7 @@ impl CheckAttrVisitor<'_> {
}
/// Checks if `#[no_mangle]` is applied to a function or static.
fn check_no_mangle(&self, hir_id: HirId, attr: &Attribute, span: &Span, target: Target) {
fn check_no_mangle(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
match target {
Target::Static | Target::Fn => {}
Target::Method(..) if self.is_impl_item(hir_id) => {}
@ -1509,7 +1525,7 @@ impl CheckAttrVisitor<'_> {
being phased out; it will become a hard error in \
a future release!",
)
.span_label(*span, format!("foreign {}", foreign_item_kind))
.span_label(span, format!("foreign {}", foreign_item_kind))
.note("symbol names in extern blocks are not mangled")
.span_suggestion(
attr.span,
@ -1532,7 +1548,7 @@ impl CheckAttrVisitor<'_> {
being phased out; it will become a hard error in \
a future release!",
)
.span_label(*span, "not a free function, impl method or static")
.span_label(span, "not a free function, impl method or static")
.emit();
});
}
@ -1543,7 +1559,7 @@ impl CheckAttrVisitor<'_> {
fn check_repr(
&self,
attrs: &[Attribute],
span: &Span,
span: Span,
target: Target,
item: Option<ItemLike<'_>>,
hir_id: HirId,
@ -1677,7 +1693,7 @@ impl CheckAttrVisitor<'_> {
"{}",
&format!("attribute should be applied to {} {}", article, allowed_targets)
)
.span_label(*span, &format!("not {} {}", article, allowed_targets))
.span_label(span, &format!("not {} {}", article, allowed_targets))
.emit();
}
@ -1740,7 +1756,7 @@ impl CheckAttrVisitor<'_> {
&self,
hir_id: HirId,
attr: &Attribute,
span: &Span,
span: Span,
target: Target,
attrs: &[Attribute],
) -> bool {
@ -1773,7 +1789,7 @@ impl CheckAttrVisitor<'_> {
self.tcx
.sess
.struct_span_err(attr.span, "attribute should be applied to a macro")
.span_label(*span, "not a macro")
.span_label(span, "not a macro")
.emit();
false
}
@ -1786,7 +1802,7 @@ impl CheckAttrVisitor<'_> {
&self,
hir_id: HirId,
attr: &Attribute,
span: &Span,
span: Span,
target: Target,
) -> bool {
match target {
@ -1807,7 +1823,7 @@ impl CheckAttrVisitor<'_> {
self.tcx
.sess
.struct_span_err(attr.span, "attribute should be applied to `const fn`")
.span_label(*span, "not a `const fn`")
.span_label(span, "not a `const fn`")
.emit();
false
}
@ -1818,7 +1834,7 @@ impl CheckAttrVisitor<'_> {
fn check_default_method_body_is_const(
&self,
attr: &Attribute,
span: &Span,
span: Span,
target: Target,
) -> bool {
match target {
@ -1830,14 +1846,14 @@ impl CheckAttrVisitor<'_> {
attr.span,
"attribute should be applied to a trait method with body",
)
.span_label(*span, "not a trait method or missing a body")
.span_label(span, "not a trait method or missing a body")
.emit();
false
}
}
}
fn check_stability_promotable(&self, attr: &Attribute, _span: &Span, target: Target) -> bool {
fn check_stability_promotable(&self, attr: &Attribute, _span: Span, target: Target) -> bool {
match target {
Target::Expression => {
self.tcx
@ -1850,7 +1866,7 @@ impl CheckAttrVisitor<'_> {
}
}
fn check_deprecated(&self, hir_id: HirId, attr: &Attribute, _span: &Span, target: Target) {
fn check_deprecated(&self, hir_id: HirId, attr: &Attribute, _span: Span, target: Target) {
match target {
Target::Closure | Target::Expression | Target::Statement | Target::Arm => {
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
@ -1912,29 +1928,29 @@ impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
}
let target = Target::from_item(item);
self.check_attributes(item.hir_id(), &item.span, target, Some(ItemLike::Item(item)));
self.check_attributes(item.hir_id(), item.span, target, Some(ItemLike::Item(item)));
intravisit::walk_item(self, item)
}
fn visit_generic_param(&mut self, generic_param: &'tcx hir::GenericParam<'tcx>) {
let target = Target::from_generic_param(generic_param);
self.check_attributes(generic_param.hir_id, &generic_param.span, target, None);
self.check_attributes(generic_param.hir_id, generic_param.span, target, None);
intravisit::walk_generic_param(self, generic_param)
}
fn visit_trait_item(&mut self, trait_item: &'tcx TraitItem<'tcx>) {
let target = Target::from_trait_item(trait_item);
self.check_attributes(trait_item.hir_id(), &trait_item.span, target, None);
self.check_attributes(trait_item.hir_id(), trait_item.span, target, None);
intravisit::walk_trait_item(self, trait_item)
}
fn visit_field_def(&mut self, struct_field: &'tcx hir::FieldDef<'tcx>) {
self.check_attributes(struct_field.hir_id, &struct_field.span, Target::Field, None);
self.check_attributes(struct_field.hir_id, struct_field.span, Target::Field, None);
intravisit::walk_field_def(self, struct_field);
}
fn visit_arm(&mut self, arm: &'tcx hir::Arm<'tcx>) {
self.check_attributes(arm.hir_id, &arm.span, Target::Arm, None);
self.check_attributes(arm.hir_id, arm.span, Target::Arm, None);
intravisit::walk_arm(self, arm);
}
@ -1942,7 +1958,7 @@ impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
let target = Target::from_foreign_item(f_item);
self.check_attributes(
f_item.hir_id(),
&f_item.span,
f_item.span,
target,
Some(ItemLike::ForeignItem(f_item)),
);
@ -1951,14 +1967,14 @@ impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) {
let target = target_from_impl_item(self.tcx, impl_item);
self.check_attributes(impl_item.hir_id(), &impl_item.span, target, None);
self.check_attributes(impl_item.hir_id(), impl_item.span, target, None);
intravisit::walk_impl_item(self, impl_item)
}
fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt<'tcx>) {
// When checking statements ignore expressions, they will be checked later.
if let hir::StmtKind::Local(ref l) = stmt.kind {
self.check_attributes(l.hir_id, &stmt.span, Target::Statement, None);
self.check_attributes(l.hir_id, stmt.span, Target::Statement, None);
}
intravisit::walk_stmt(self, stmt)
}
@ -1969,7 +1985,7 @@ impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
_ => Target::Expression,
};
self.check_attributes(expr.hir_id, &expr.span, target, None);
self.check_attributes(expr.hir_id, expr.span, target, None);
intravisit::walk_expr(self, expr)
}
@ -1979,12 +1995,12 @@ impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
generics: &'tcx hir::Generics<'tcx>,
item_id: HirId,
) {
self.check_attributes(variant.id, &variant.span, Target::Variant, None);
self.check_attributes(variant.id, variant.span, Target::Variant, None);
intravisit::walk_variant(self, variant, generics, item_id)
}
fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) {
self.check_attributes(param.hir_id, &param.span, Target::Param, None);
self.check_attributes(param.hir_id, param.span, Target::Param, None);
intravisit::walk_param(self, param);
}
@ -2076,7 +2092,7 @@ fn check_mod_attrs(tcx: TyCtxt<'_>, module_def_id: LocalDefId) {
let check_attr_visitor = &mut CheckAttrVisitor { tcx };
tcx.hir().visit_item_likes_in_module(module_def_id, &mut check_attr_visitor.as_deep_visitor());
if module_def_id.is_top_level_module() {
check_attr_visitor.check_attributes(CRATE_HIR_ID, &DUMMY_SP, Target::Mod, None);
check_attr_visitor.check_attributes(CRATE_HIR_ID, DUMMY_SP, Target::Mod, None);
check_invalid_crate_level_attr(tcx, tcx.hir().krate_attrs());
}
}

1
compiler/rustc_passes/src/lib.rs
View File

@ -13,6 +13,7 @@
#![feature(nll)]
#![feature(try_blocks)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate rustc_middle;

1
compiler/rustc_privacy/src/lib.rs
View File

@ -4,6 +4,7 @@
#![feature(try_blocks)]
#![feature(associated_type_defaults)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
use rustc_ast::MacroDef;
use rustc_attr as attr;

1
compiler/rustc_query_impl/src/lib.rs
View File

@ -7,6 +7,7 @@
#![feature(once_cell)]
#![feature(rustc_attrs)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate rustc_macros;

1
compiler/rustc_query_system/src/lib.rs
View File

@ -5,6 +5,7 @@
#![feature(let_else)]
#![feature(min_specialization)]
#![feature(extern_types)]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate tracing;

1
compiler/rustc_resolve/src/lib.rs
View File

@ -18,6 +18,7 @@
#![feature(nll)]
#![recursion_limit = "256"]
#![allow(rustdoc::private_intra_doc_links)]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate tracing;

1
compiler/rustc_save_analysis/src/lib.rs
View File

@ -2,6 +2,7 @@
#![feature(if_let_guard)]
#![feature(nll)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
mod dump_visitor;
mod dumper;

1
compiler/rustc_session/src/lib.rs
View File

@ -3,6 +3,7 @@
#![feature(min_specialization)]
#![feature(once_cell)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate rustc_macros;

1
compiler/rustc_span/src/lib.rs
View File

@ -21,6 +21,7 @@
#![feature(negative_impls)]
#![feature(nll)]
#![feature(min_specialization)]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate rustc_macros;

1
compiler/rustc_span/src/symbol.rs
View File

@ -1171,6 +1171,7 @@ symbols! {
rustc_layout_scalar_valid_range_end,
rustc_layout_scalar_valid_range_start,
rustc_legacy_const_generics,
rustc_lint_query_instability,
rustc_macro_transparency,
rustc_main,
rustc_mir,

1
compiler/rustc_symbol_mangling/src/lib.rs
View File

@ -91,6 +91,7 @@
#![feature(never_type)]
#![feature(nll)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate rustc_middle;

1
compiler/rustc_trait_selection/src/lib.rs
View File

@ -22,6 +22,7 @@
#![feature(crate_visibility_modifier)]
#![feature(control_flow_enum)]
#![recursion_limit = "512"] // For rustdoc
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate rustc_macros;

1
compiler/rustc_typeck/src/lib.rs
View File

@ -69,6 +69,7 @@ This API is completely unstable and subject to change.
#![feature(control_flow_enum)]
#![feature(hash_drain_filter)]
#![recursion_limit = "256"]
#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))]
#[macro_use]
extern crate tracing;

10
library/std/src/collections/hash/map.rs
View File

@ -371,6 +371,7 @@ impl<K, V, S> HashMap<K, V, S> {
/// assert_eq!(vec, ["a", "b", "c"]);
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[stable(feature = "map_into_keys_values", since = "1.54.0")]
pub fn into_keys(self) -> IntoKeys<K, V> {
IntoKeys { inner: self.into_iter() }
@ -448,6 +449,7 @@ impl<K, V, S> HashMap<K, V, S> {
/// assert_eq!(vec, [1, 2, 3]);
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[stable(feature = "map_into_keys_values", since = "1.54.0")]
pub fn into_values(self) -> IntoValues<K, V> {
IntoValues { inner: self.into_iter() }
@ -471,6 +473,7 @@ impl<K, V, S> HashMap<K, V, S> {
/// println!("key: {} val: {}", key, val);
/// }
/// ```
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter(&self) -> Iter<'_, K, V> {
Iter { base: self.base.iter() }
@ -500,6 +503,7 @@ impl<K, V, S> HashMap<K, V, S> {
/// println!("key: {} val: {}", key, val);
/// }
/// ```
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
IterMut { base: self.base.iter_mut() }
@ -560,6 +564,7 @@ impl<K, V, S> HashMap<K, V, S> {
/// assert!(a.is_empty());
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[stable(feature = "drain", since = "1.6.0")]
pub fn drain(&mut self) -> Drain<'_, K, V> {
Drain { base: self.base.drain() }
@ -601,6 +606,7 @@ impl<K, V, S> HashMap<K, V, S> {
/// assert_eq!(odds, vec![1, 3, 5, 7]);
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[unstable(feature = "hash_drain_filter", issue = "59618")]
pub fn drain_filter<F>(&mut self, pred: F) -> DrainFilter<'_, K, V, F>
where
@ -624,6 +630,7 @@ impl<K, V, S> HashMap<K, V, S> {
/// assert_eq!(map.len(), 4);
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[stable(feature = "retain_hash_collection", since = "1.18.0")]
pub fn retain<F>(&mut self, f: F)
where
@ -1990,6 +1997,7 @@ impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S> {
type IntoIter = Iter<'a, K, V>;
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
fn into_iter(self) -> Iter<'a, K, V> {
self.iter()
}
@ -2001,6 +2009,7 @@ impl<'a, K, V, S> IntoIterator for &'a mut HashMap<K, V, S> {
type IntoIter = IterMut<'a, K, V>;
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
fn into_iter(self) -> IterMut<'a, K, V> {
self.iter_mut()
}
@ -2030,6 +2039,7 @@ impl<K, V, S> IntoIterator for HashMap<K, V, S> {
/// let vec: Vec<(&str, i32)> = map.into_iter().collect();
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
fn into_iter(self) -> IntoIter<K, V> {
IntoIter { base: self.base.into_iter() }
}

10
library/std/src/collections/hash/set.rs
View File

@ -185,6 +185,7 @@ impl<T, S> HashSet<T, S> {
/// }
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter(&self) -> Iter<'_, T> {
Iter { base: self.base.iter() }
@ -244,6 +245,7 @@ impl<T, S> HashSet<T, S> {
/// assert!(set.is_empty());
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[stable(feature = "drain", since = "1.6.0")]
pub fn drain(&mut self) -> Drain<'_, T> {
Drain { base: self.base.drain() }
@ -282,6 +284,7 @@ impl<T, S> HashSet<T, S> {
/// assert_eq!(odds, vec![1, 3, 5, 7]);
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[unstable(feature = "hash_drain_filter", issue = "59618")]
pub fn drain_filter<F>(&mut self, pred: F) -> DrainFilter<'_, T, F>
where
@ -304,6 +307,7 @@ impl<T, S> HashSet<T, S> {
/// set.retain(|&k| k % 2 == 0);
/// assert_eq!(set.len(), 3);
/// ```
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[stable(feature = "retain_hash_collection", since = "1.18.0")]
pub fn retain<F>(&mut self, f: F)
where
@ -528,6 +532,7 @@ where
/// assert_eq!(diff, [4].iter().collect());
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn difference<'a>(&'a self, other: &'a HashSet<T, S>) -> Difference<'a, T, S> {
Difference { iter: self.iter(), other }
@ -555,6 +560,7 @@ where
/// assert_eq!(diff1, [1, 4].iter().collect());
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn symmetric_difference<'a>(
&'a self,
@ -582,6 +588,7 @@ where
/// assert_eq!(intersection, [2, 3].iter().collect());
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn intersection<'a>(&'a self, other: &'a HashSet<T, S>) -> Intersection<'a, T, S> {
if self.len() <= other.len() {
@ -610,6 +617,7 @@ where
/// assert_eq!(union, [1, 2, 3, 4].iter().collect());
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn union<'a>(&'a self, other: &'a HashSet<T, S>) -> Union<'a, T, S> {
if self.len() >= other.len() {
@ -1410,6 +1418,7 @@ impl<'a, T, S> IntoIterator for &'a HashSet<T, S> {
type IntoIter = Iter<'a, T>;
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
fn into_iter(self) -> Iter<'a, T> {
self.iter()
}
@ -1441,6 +1450,7 @@ impl<T, S> IntoIterator for HashSet<T, S> {
/// }
/// ```
#[inline]
#[cfg_attr(not(bootstrap), rustc_lint_query_instability)]
fn into_iter(self) -> IntoIter<T> {
IntoIter { base: self.base.into_iter() }
}

24
src/test/ui-fulldeps/internal-lints/query_stability.rs Normal file
View File

@ -0,0 +1,24 @@
// compile-flags: -Z unstable-options
#![feature(rustc_private)]
#![deny(rustc::potential_query_instability)]
extern crate rustc_data_structures;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
fn main() {
let mut x = FxHashMap::<u32, i32>::default();
for _ in x.drain() {}
//~^ ERROR using `drain` can result in unstable
for _ in x.iter() {}
//~^ ERROR using `iter`
for _ in Some(&mut x).unwrap().iter_mut() {}
//~^ ERROR using `iter_mut`
for _ in x {}
//~^ ERROR using `into_iter`
}

39
src/test/ui-fulldeps/internal-lints/query_stability.stderr Normal file
View File

@ -0,0 +1,39 @@
error: using `drain` can result in unstable query results
--> $DIR/query_stability.rs:13:16
|
LL | for _ in x.drain() {}
| ^^^^^
|
note: the lint level is defined here
--> $DIR/query_stability.rs:4:9
|
LL | #![deny(rustc::potential_query_instability)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: if you believe this case to be fine, allow this lint and add a comment explaining your rationale
error: using `iter` can result in unstable query results
--> $DIR/query_stability.rs:16:16
|
LL | for _ in x.iter() {}
| ^^^^
|
= note: if you believe this case to be fine, allow this lint and add a comment explaining your rationale
error: using `iter_mut` can result in unstable query results
--> $DIR/query_stability.rs:19:36
|
LL | for _ in Some(&mut x).unwrap().iter_mut() {}
| ^^^^^^^^
|
= note: if you believe this case to be fine, allow this lint and add a comment explaining your rationale
error: using `into_iter` can result in unstable query results
--> $DIR/query_stability.rs:22:14
|
LL | for _ in x {}
| ^
|
= note: if you believe this case to be fine, allow this lint and add a comment explaining your rationale
error: aborting due to 4 previous errors

15
src/test/ui-fulldeps/internal-lints/query_stability_incorrect.rs Normal file
View File

@ -0,0 +1,15 @@
// compile-flags: -Z unstable-options
#![feature(rustc_attrs)]
#[rustc_lint_query_instability]
//~^ ERROR attribute should be applied to a function
struct Foo;
impl Foo {
#[rustc_lint_query_instability(a)]
//~^ ERROR malformed `rustc_lint_query_instability`
fn bar() {}
}
fn main() {}

17
src/test/ui-fulldeps/internal-lints/query_stability_incorrect.stderr Normal file
View File

@ -0,0 +1,17 @@
error: malformed `rustc_lint_query_instability` attribute input
--> $DIR/query_stability_incorrect.rs:10:5
|
LL | #[rustc_lint_query_instability(a)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[rustc_lint_query_instability]`
error: attribute should be applied to a function
--> $DIR/query_stability_incorrect.rs:5:1
|
LL | #[rustc_lint_query_instability]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL |
LL | struct Foo;
| ----------- not a function
error: aborting due to 2 previous errors