diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 63ba5b45f4c..92e08da7a97 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -35,7 +35,6 @@ #![feature(iter_zip)] #![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}; diff --git a/compiler/rustc_ast_passes/src/lib.rs b/compiler/rustc_ast_passes/src/lib.rs index 6da128a0374..47666670b2b 100644 --- a/compiler/rustc_ast_passes/src/lib.rs +++ b/compiler/rustc_ast_passes/src/lib.rs @@ -7,7 +7,6 @@ #![feature(iter_is_partitioned)] #![feature(box_patterns)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] pub mod ast_validation; pub mod feature_gate; diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs index 4defa378947..c4fc7e0df00 100644 --- a/compiler/rustc_borrowck/src/lib.rs +++ b/compiler/rustc_borrowck/src/lib.rs @@ -12,7 +12,6 @@ #![feature(trusted_step)] #![feature(try_blocks)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate rustc_middle; diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs index d3e2ed02c32..d1d276930b9 100644 --- a/compiler/rustc_builtin_macros/src/lib.rs +++ b/compiler/rustc_builtin_macros/src/lib.rs @@ -11,7 +11,6 @@ #![feature(proc_macro_internals)] #![feature(proc_macro_quote)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] extern crate proc_macro; diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs index f1dacc393d5..8f4d79e7147 100644 --- a/compiler/rustc_codegen_llvm/src/lib.rs +++ b/compiler/rustc_codegen_llvm/src/lib.rs @@ -13,7 +13,6 @@ #![feature(iter_zip)] #![feature(nll)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] use back::write::{create_informational_target_machine, create_target_machine}; diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs index b2b0629c4b7..4c87d4d896e 100644 --- a/compiler/rustc_codegen_ssa/src/lib.rs +++ b/compiler/rustc_codegen_ssa/src/lib.rs @@ -8,7 +8,6 @@ #![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 diff --git a/compiler/rustc_const_eval/src/lib.rs b/compiler/rustc_const_eval/src/lib.rs index 17a5313d73a..f308e764e86 100644 --- a/compiler/rustc_const_eval/src/lib.rs +++ b/compiler/rustc_const_eval/src/lib.rs @@ -24,7 +24,6 @@ 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; diff --git a/compiler/rustc_data_structures/src/lib.rs b/compiler/rustc_data_structures/src/lib.rs index bb8261b4a26..77784bf1705 100644 --- a/compiler/rustc_data_structures/src/lib.rs +++ b/compiler/rustc_data_structures/src/lib.rs @@ -27,7 +27,6 @@ #![feature(thread_id_value)] #![allow(rustc::default_hash_types)] #![deny(unaligned_references)] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate tracing; diff --git a/compiler/rustc_driver/src/lib.rs b/compiler/rustc_driver/src/lib.rs index 1a9f8961bd7..9a57ec99144 100644 --- a/compiler/rustc_driver/src/lib.rs +++ b/compiler/rustc_driver/src/lib.rs @@ -8,7 +8,6 @@ #![feature(nll)] #![feature(once_cell)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate tracing; @@ -847,7 +846,7 @@ Available lint options: let builtin = sort_lints(sess, builtin); let (plugin_groups, builtin_groups): (Vec<_>, _) = - lint_store.get_lint_groups().partition(|&(.., p)| p); + lint_store.get_lint_groups().iter().cloned().partition(|&(.., p)| p); let plugin_groups = sort_lint_groups(plugin_groups); let builtin_groups = sort_lint_groups(builtin_groups); diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs index 45b24d72886..b6cf332f511 100644 --- a/compiler/rustc_errors/src/lib.rs +++ b/compiler/rustc_errors/src/lib.rs @@ -10,7 +10,6 @@ #![feature(iter_zip)] #![feature(let_else)] #![feature(nll)] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate rustc_macros; diff --git a/compiler/rustc_expand/src/lib.rs b/compiler/rustc_expand/src/lib.rs index 49b0bb55d87..521ca2135c6 100644 --- a/compiler/rustc_expand/src/lib.rs +++ b/compiler/rustc_expand/src/lib.rs @@ -10,7 +10,6 @@ #![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; diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs index ee43dc985a0..33188d375f5 100644 --- a/compiler/rustc_feature/src/builtin_attrs.rs +++ b/compiler/rustc_feature/src/builtin_attrs.rs @@ -460,9 +460,6 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // Prevents field reads in the marked trait or method to be considered // during dead code analysis. rustc_attr!(rustc_trivial_field_reads, Normal, template!(Word), 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), INTERNAL_UNSTABLE), // ========================================================================== // Internal attributes, Const related: diff --git a/compiler/rustc_incremental/src/lib.rs b/compiler/rustc_incremental/src/lib.rs index 0478fb2baa0..dd3f8c937f8 100644 --- a/compiler/rustc_incremental/src/lib.rs +++ b/compiler/rustc_incremental/src/lib.rs @@ -5,7 +5,6 @@ #![feature(let_else)] #![feature(nll)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate rustc_middle; diff --git a/compiler/rustc_infer/src/lib.rs b/compiler/rustc_infer/src/lib.rs index 128a9428fac..d0f1ff649d0 100644 --- a/compiler/rustc_infer/src/lib.rs +++ b/compiler/rustc_infer/src/lib.rs @@ -24,7 +24,6 @@ #![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; diff --git a/compiler/rustc_interface/src/lib.rs b/compiler/rustc_interface/src/lib.rs index 969df0fbf24..2fc3759968f 100644 --- a/compiler/rustc_interface/src/lib.rs +++ b/compiler/rustc_interface/src/lib.rs @@ -5,7 +5,6 @@ #![feature(nll)] #![feature(once_cell)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] mod callbacks; pub mod interface; diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs index e34a92aba25..d235b220944 100644 --- a/compiler/rustc_lint/src/context.rs +++ b/compiler/rustc_lint/src/context.rs @@ -144,11 +144,7 @@ impl LintStore { &self.lints } - pub fn get_lint_groups<'t>( - &'t self, - ) -> impl Iterator, 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))] + pub fn get_lint_groups<'t>(&'t self) -> Vec<(&'static str, Vec, bool)> { self.lint_groups .iter() .filter(|(_, LintGroup { depr, .. })| { @@ -158,6 +154,7 @@ impl LintStore { .map(|(k, LintGroup { lint_ids, from_plugin, .. })| { (*k, lint_ids.clone(), *from_plugin) }) + .collect() } pub fn register_early_pass( diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs index e9dcc120200..50a0d211a36 100644 --- a/compiler/rustc_lint/src/internal.rs +++ b/compiler/rustc_lint/src/internal.rs @@ -5,7 +5,10 @@ use crate::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext} use rustc_ast as ast; use rustc_errors::Applicability; use rustc_hir::def::Res; -use rustc_hir::*; +use rustc_hir::{ + GenericArg, HirId, Item, ItemKind, MutTy, Mutability, Node, Path, PathSegment, QPath, Ty, + TyKind, +}; use rustc_middle::ty; use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::hygiene::{ExpnKind, MacroKind}; @@ -48,60 +51,6 @@ 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 (def_id, span) = match expr.kind { - ExprKind::Path(ref path) if let Some(def_id) = cx.qpath_res(path, expr.hir_id).opt_def_id() => { - (def_id, expr.span) - } - ExprKind::MethodCall(_, span, _, _) if let Some(def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) => { - (def_id, span) - }, - _ => return, - }; - - let substs = cx.typeck_results().node_substs(expr.hir_id); - 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, diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs index f83eaabdfef..6f684a0fe51 100644 --- a/compiler/rustc_lint/src/lib.rs +++ b/compiler/rustc_lint/src/lib.rs @@ -31,14 +31,12 @@ #![feature(box_patterns)] #![feature(crate_visibility_modifier)] #![feature(format_args_capture)] -#![feature(if_let_guard)] #![feature(iter_order_by)] #![feature(iter_zip)] #![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; @@ -486,8 +484,6 @@ 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()); @@ -498,7 +494,6 @@ 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(LINT_PASS_IMPL_WITHOUT_MACRO), LintId::of(TY_PASS_BY_REFERENCE), diff --git a/compiler/rustc_metadata/src/lib.rs b/compiler/rustc_metadata/src/lib.rs index f64f6cbeb59..6cf0dd8b1ad 100644 --- a/compiler/rustc_metadata/src/lib.rs +++ b/compiler/rustc_metadata/src/lib.rs @@ -10,7 +10,6 @@ #![feature(try_blocks)] #![feature(never_type)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] extern crate proc_macro; diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs index d90eb839cf6..0894b805075 100644 --- a/compiler/rustc_middle/src/lib.rs +++ b/compiler/rustc_middle/src/lib.rs @@ -56,7 +56,6 @@ #![feature(try_reserve_kind)] #![feature(nonzero_ops)] #![recursion_limit = "512"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate bitflags; diff --git a/compiler/rustc_mir_build/src/lib.rs b/compiler/rustc_mir_build/src/lib.rs index 6cf7c405473..b0f1e08562c 100644 --- a/compiler/rustc_mir_build/src/lib.rs +++ b/compiler/rustc_mir_build/src/lib.rs @@ -10,7 +10,6 @@ #![feature(once_cell)] #![feature(min_specialization)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate tracing; diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs index b22549ead31..f9ef3146278 100644 --- a/compiler/rustc_mir_transform/src/lib.rs +++ b/compiler/rustc_mir_transform/src/lib.rs @@ -12,7 +12,6 @@ #![feature(trusted_step)] #![feature(try_blocks)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate tracing; diff --git a/compiler/rustc_monomorphize/src/lib.rs b/compiler/rustc_monomorphize/src/lib.rs index 51a6f7e3e40..f4082153b68 100644 --- a/compiler/rustc_monomorphize/src/lib.rs +++ b/compiler/rustc_monomorphize/src/lib.rs @@ -5,7 +5,6 @@ #![feature(let_else)] #![feature(in_band_lifetimes)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate tracing; diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index 92d9e89c3a3..e5fbddda744 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -62,7 +62,7 @@ impl CheckAttrVisitor<'tcx> { fn check_attributes( &self, hir_id: HirId, - span: Span, + span: &Span, target: Target, item: Option>, ) { @@ -78,7 +78,7 @@ impl CheckAttrVisitor<'tcx> { sym::marker => self.check_marker(hir_id, attr, span, target), 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, @@ -103,9 +103,6 @@ impl CheckAttrVisitor<'tcx> { 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 @@ -233,7 +230,7 @@ impl CheckAttrVisitor<'tcx> { } /// 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 @@ -276,7 +273,7 @@ impl CheckAttrVisitor<'tcx> { 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 } @@ -315,7 +312,7 @@ impl CheckAttrVisitor<'tcx> { } /// 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, @@ -334,7 +331,7 @@ impl CheckAttrVisitor<'tcx> { 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 } @@ -342,7 +339,7 @@ impl CheckAttrVisitor<'tcx> { } /// 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, @@ -353,7 +350,7 @@ impl CheckAttrVisitor<'tcx> { 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 } @@ -364,16 +361,16 @@ impl CheckAttrVisitor<'tcx> { fn check_track_caller( &self, hir_id: HirId, - attr_span: Span, + attr_span: &Span, attrs: &'hir [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]`", ) @@ -394,11 +391,11 @@ impl CheckAttrVisitor<'tcx> { _ => { 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 } @@ -410,7 +407,7 @@ impl CheckAttrVisitor<'tcx> { &self, hir_id: HirId, attr: &Attribute, - span: Span, + span: &Span, target: Target, ) -> bool { match target { @@ -430,7 +427,7 @@ impl CheckAttrVisitor<'tcx> { 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 } @@ -438,7 +435,7 @@ impl CheckAttrVisitor<'tcx> { } /// 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 @@ -453,7 +450,7 @@ impl CheckAttrVisitor<'tcx> { 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 } @@ -465,7 +462,7 @@ impl CheckAttrVisitor<'tcx> { &self, hir_id: HirId, attr: &Attribute, - span: Span, + span: &Span, target: Target, ) -> bool { match target { @@ -481,7 +478,7 @@ impl CheckAttrVisitor<'tcx> { 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 @@ -498,7 +495,7 @@ impl CheckAttrVisitor<'tcx> { 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 } @@ -1050,14 +1047,14 @@ impl CheckAttrVisitor<'tcx> { } /// 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 } @@ -1065,7 +1062,7 @@ impl CheckAttrVisitor<'tcx> { } /// 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 @@ -1085,7 +1082,7 @@ impl CheckAttrVisitor<'tcx> { 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(); }); } @@ -1093,7 +1090,7 @@ impl CheckAttrVisitor<'tcx> { } /// 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 @@ -1127,7 +1124,7 @@ impl CheckAttrVisitor<'tcx> { } } - diag.span_label(span, "not a foreign function or static"); + diag.span_label(*span, "not a foreign function or static"); diag.emit(); }); } @@ -1135,7 +1132,7 @@ impl CheckAttrVisitor<'tcx> { } /// 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 @@ -1153,7 +1150,7 @@ impl CheckAttrVisitor<'tcx> { 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 } @@ -1169,7 +1166,7 @@ impl CheckAttrVisitor<'tcx> { &self, hir_id: HirId, attr: &Attribute, - span: Span, + span: &Span, target: Target, ) -> bool { match target { @@ -1190,7 +1187,7 @@ impl CheckAttrVisitor<'tcx> { 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 } @@ -1200,14 +1197,14 @@ impl CheckAttrVisitor<'tcx> { 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; } @@ -1232,7 +1229,7 @@ impl CheckAttrVisitor<'tcx> { fn check_rustc_legacy_const_generics( &self, attr: &Attribute, - span: Span, + span: &Span, target: Target, item: Option>, ) -> bool { @@ -1241,7 +1238,7 @@ impl CheckAttrVisitor<'tcx> { 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; } @@ -1327,25 +1324,6 @@ impl CheckAttrVisitor<'tcx> { } } - 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 { @@ -1361,7 +1339,7 @@ impl CheckAttrVisitor<'tcx> { } /// 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 @@ -1381,7 +1359,7 @@ impl CheckAttrVisitor<'tcx> { 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(); }); } @@ -1389,7 +1367,7 @@ impl CheckAttrVisitor<'tcx> { } /// 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) => {} @@ -1419,7 +1397,7 @@ impl CheckAttrVisitor<'tcx> { 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, @@ -1442,7 +1420,7 @@ impl CheckAttrVisitor<'tcx> { 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(); }); } @@ -1453,7 +1431,7 @@ impl CheckAttrVisitor<'tcx> { fn check_repr( &self, attrs: &'hir [Attribute], - span: Span, + span: &Span, target: Target, item: Option>, hir_id: HirId, @@ -1587,7 +1565,7 @@ impl CheckAttrVisitor<'tcx> { "{}", &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(); } @@ -1650,7 +1628,7 @@ impl CheckAttrVisitor<'tcx> { &self, hir_id: HirId, attr: &Attribute, - span: Span, + span: &Span, target: Target, attrs: &[Attribute], ) -> bool { @@ -1683,7 +1661,7 @@ impl CheckAttrVisitor<'tcx> { 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 } @@ -1696,7 +1674,7 @@ impl CheckAttrVisitor<'tcx> { &self, hir_id: HirId, attr: &Attribute, - span: Span, + span: &Span, target: Target, ) -> bool { match target { @@ -1717,7 +1695,7 @@ impl CheckAttrVisitor<'tcx> { 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 } @@ -1728,7 +1706,7 @@ impl CheckAttrVisitor<'tcx> { fn check_default_method_body_is_const( &self, attr: &Attribute, - span: Span, + span: &Span, target: Target, ) -> bool { match target { @@ -1740,14 +1718,14 @@ impl CheckAttrVisitor<'tcx> { 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 @@ -1760,7 +1738,7 @@ impl CheckAttrVisitor<'tcx> { } } - 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| { @@ -1832,29 +1810,29 @@ impl 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); } @@ -1862,7 +1840,7 @@ impl 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)), ); @@ -1871,14 +1849,14 @@ impl 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) } @@ -1889,7 +1867,7 @@ impl 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) } @@ -1899,12 +1877,12 @@ impl 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, ¶m.span, Target::Param, None); intravisit::walk_param(self, param); } @@ -1972,7 +1950,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()); } } diff --git a/compiler/rustc_passes/src/lib.rs b/compiler/rustc_passes/src/lib.rs index c698333c8e2..4adec3c4f60 100644 --- a/compiler/rustc_passes/src/lib.rs +++ b/compiler/rustc_passes/src/lib.rs @@ -14,7 +14,6 @@ #![feature(nll)] #![feature(try_blocks)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate rustc_middle; diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs index d228a34046c..fa34b9abc1e 100644 --- a/compiler/rustc_privacy/src/lib.rs +++ b/compiler/rustc_privacy/src/lib.rs @@ -5,7 +5,6 @@ #![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; diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs index 9cd36a77b70..440b6f1983e 100644 --- a/compiler/rustc_query_impl/src/lib.rs +++ b/compiler/rustc_query_impl/src/lib.rs @@ -8,7 +8,6 @@ #![feature(once_cell)] #![feature(rustc_attrs)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate rustc_macros; diff --git a/compiler/rustc_query_system/src/lib.rs b/compiler/rustc_query_system/src/lib.rs index 8f57855b230..1b992cdb0c9 100644 --- a/compiler/rustc_query_system/src/lib.rs +++ b/compiler/rustc_query_system/src/lib.rs @@ -6,7 +6,6 @@ #![feature(let_else)] #![feature(min_specialization)] #![feature(thread_local_const_init)] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate tracing; diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs index 4ba7e7d6f3b..23eb2d1aebb 100644 --- a/compiler/rustc_resolve/src/lib.rs +++ b/compiler/rustc_resolve/src/lib.rs @@ -20,7 +20,6 @@ #![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; diff --git a/compiler/rustc_save_analysis/src/lib.rs b/compiler/rustc_save_analysis/src/lib.rs index 8fd2011ac46..543cd0247a5 100644 --- a/compiler/rustc_save_analysis/src/lib.rs +++ b/compiler/rustc_save_analysis/src/lib.rs @@ -2,7 +2,6 @@ #![feature(if_let_guard)] #![feature(nll)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] mod dump_visitor; mod dumper; diff --git a/compiler/rustc_session/src/lib.rs b/compiler/rustc_session/src/lib.rs index 1a6cab7ecde..6c86f86ecd9 100644 --- a/compiler/rustc_session/src/lib.rs +++ b/compiler/rustc_session/src/lib.rs @@ -2,7 +2,6 @@ #![feature(min_specialization)] #![feature(once_cell)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate rustc_macros; diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs index 4eafa7cebb3..032ae73bbf3 100644 --- a/compiler/rustc_span/src/lib.rs +++ b/compiler/rustc_span/src/lib.rs @@ -21,7 +21,6 @@ #![feature(nll)] #![feature(min_specialization)] #![feature(thread_local_const_init)] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate rustc_macros; diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index c4bb82d467f..1b431589632 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -1115,7 +1115,6 @@ 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, diff --git a/compiler/rustc_symbol_mangling/src/lib.rs b/compiler/rustc_symbol_mangling/src/lib.rs index 179e47f9957..bb7b4529556 100644 --- a/compiler/rustc_symbol_mangling/src/lib.rs +++ b/compiler/rustc_symbol_mangling/src/lib.rs @@ -93,7 +93,6 @@ #![feature(in_band_lifetimes)] #![feature(iter_zip)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate rustc_middle; diff --git a/compiler/rustc_trait_selection/src/lib.rs b/compiler/rustc_trait_selection/src/lib.rs index 94c9c1f2e58..1a049e6ec64 100644 --- a/compiler/rustc_trait_selection/src/lib.rs +++ b/compiler/rustc_trait_selection/src/lib.rs @@ -22,7 +22,6 @@ #![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; diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs index 41e43321a8f..ac4bb652244 100644 --- a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs +++ b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs @@ -830,7 +830,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { self.tcx.type_of(def_id) }; let substs = self.infcx.fresh_substs_for_item(span, def_id); - self.write_substs(hir_id, substs); let ty = item_ty.subst(self.tcx, substs); self.write_resolution(hir_id, Ok((def_kind, def_id))); diff --git a/compiler/rustc_typeck/src/lib.rs b/compiler/rustc_typeck/src/lib.rs index b19008e42a4..017e7ad8ca7 100644 --- a/compiler/rustc_typeck/src/lib.rs +++ b/compiler/rustc_typeck/src/lib.rs @@ -71,7 +71,6 @@ This API is completely unstable and subject to change. #![feature(slice_partition_dedup)] #![feature(control_flow_enum)] #![recursion_limit = "256"] -#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate tracing; diff --git a/library/std/src/collections/hash/map.rs b/library/std/src/collections/hash/map.rs index d36a3eaea92..01019344f4f 100644 --- a/library/std/src/collections/hash/map.rs +++ b/library/std/src/collections/hash/map.rs @@ -414,7 +414,6 @@ impl HashMap { /// 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() } @@ -443,7 +442,6 @@ impl HashMap { /// 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() } @@ -504,7 +502,6 @@ impl HashMap { /// 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() } @@ -546,7 +543,6 @@ impl HashMap { /// 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(&mut self, pred: F) -> DrainFilter<'_, K, V, F> where @@ -953,7 +949,6 @@ where /// 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(&mut self, f: F) where @@ -983,7 +978,6 @@ where /// 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 { IntoKeys { inner: self.into_iter() } @@ -1010,7 +1004,6 @@ where /// 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 { IntoValues { inner: self.into_iter() } @@ -1976,7 +1969,6 @@ impl<'a, K, V, S> IntoIterator for &'a HashMap { 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() } @@ -1988,7 +1980,6 @@ impl<'a, K, V, S> IntoIterator for &'a mut HashMap { 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() } @@ -2017,7 +2008,6 @@ impl IntoIterator for HashMap { /// let vec: Vec<(&str, i32)> = map.into_iter().collect(); /// ``` #[inline] - #[cfg_attr(not(bootstrap), rustc_lint_query_instability)] fn into_iter(self) -> IntoIter { IntoIter { base: self.base.into_iter() } } diff --git a/library/std/src/collections/hash/set.rs b/library/std/src/collections/hash/set.rs index 76008e565b3..546c43faecf 100644 --- a/library/std/src/collections/hash/set.rs +++ b/library/std/src/collections/hash/set.rs @@ -185,7 +185,6 @@ impl HashSet { /// } /// ``` #[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() } @@ -245,7 +244,6 @@ impl HashSet { /// 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() } @@ -284,7 +282,6 @@ impl HashSet { /// 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(&mut self, pred: F) -> DrainFilter<'_, T, F> where @@ -509,7 +506,6 @@ 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) -> Difference<'a, T, S> { Difference { iter: self.iter(), other } @@ -537,7 +533,6 @@ 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, @@ -565,7 +560,6 @@ 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) -> Intersection<'a, T, S> { if self.len() <= other.len() { @@ -594,7 +588,6 @@ 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) -> Union<'a, T, S> { if self.len() >= other.len() { @@ -929,7 +922,6 @@ where /// 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(&mut self, f: F) where @@ -1411,7 +1403,6 @@ impl<'a, T, S> IntoIterator for &'a HashSet { type IntoIter = Iter<'a, T>; #[inline] - #[cfg_attr(not(bootstrap), rustc_lint_query_instability)] fn into_iter(self) -> Iter<'a, T> { self.iter() } @@ -1443,7 +1434,6 @@ impl IntoIterator for HashSet { /// } /// ``` #[inline] - #[cfg_attr(not(bootstrap), rustc_lint_query_instability)] fn into_iter(self) -> IntoIter { IntoIter { base: self.base.into_iter() } } diff --git a/src/test/ui-fulldeps/internal-lints/query_stability.rs b/src/test/ui-fulldeps/internal-lints/query_stability.rs deleted file mode 100644 index 560675b4486..00000000000 --- a/src/test/ui-fulldeps/internal-lints/query_stability.rs +++ /dev/null @@ -1,24 +0,0 @@ -// 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::::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` -} diff --git a/src/test/ui-fulldeps/internal-lints/query_stability.stderr b/src/test/ui-fulldeps/internal-lints/query_stability.stderr deleted file mode 100644 index 7e8b448f41a..00000000000 --- a/src/test/ui-fulldeps/internal-lints/query_stability.stderr +++ /dev/null @@ -1,39 +0,0 @@ -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 - diff --git a/src/test/ui-fulldeps/internal-lints/query_stability_incorrect.rs b/src/test/ui-fulldeps/internal-lints/query_stability_incorrect.rs deleted file mode 100644 index f478b73329e..00000000000 --- a/src/test/ui-fulldeps/internal-lints/query_stability_incorrect.rs +++ /dev/null @@ -1,15 +0,0 @@ -// 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() {} diff --git a/src/test/ui-fulldeps/internal-lints/query_stability_incorrect.stderr b/src/test/ui-fulldeps/internal-lints/query_stability_incorrect.stderr deleted file mode 100644 index b5156f2ac59..00000000000 --- a/src/test/ui-fulldeps/internal-lints/query_stability_incorrect.stderr +++ /dev/null @@ -1,17 +0,0 @@ -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 -