diff options
Diffstat (limited to 'compiler')
36 files changed, 187 insertions, 77 deletions
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index f21f0b895ad..a594339296f 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -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}; diff --git a/compiler/rustc_ast_passes/src/lib.rs b/compiler/rustc_ast_passes/src/lib.rs index adc4d117b80..f4863137bdd 100644 --- a/compiler/rustc_ast_passes/src/lib.rs +++ b/compiler/rustc_ast_passes/src/lib.rs @@ -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; diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs index 1e9acb114b7..c288cc96990 100644 --- a/compiler/rustc_borrowck/src/lib.rs +++ b/compiler/rustc_borrowck/src/lib.rs @@ -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; diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs index 6c16c285492..eda9be58d94 100644 --- a/compiler/rustc_builtin_macros/src/lib.rs +++ b/compiler/rustc_builtin_macros/src/lib.rs @@ -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; diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs index f0612eaba80..75836e14385 100644 --- a/compiler/rustc_codegen_llvm/src/lib.rs +++ b/compiler/rustc_codegen_llvm/src/lib.rs @@ -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}; diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs index 350199f4e98..9bb8db076a8 100644 --- a/compiler/rustc_codegen_ssa/src/lib.rs +++ b/compiler/rustc_codegen_ssa/src/lib.rs @@ -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 diff --git a/compiler/rustc_const_eval/src/lib.rs b/compiler/rustc_const_eval/src/lib.rs index 92854af55bb..838484876c7 100644 --- a/compiler/rustc_const_eval/src/lib.rs +++ b/compiler/rustc_const_eval/src/lib.rs @@ -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; diff --git a/compiler/rustc_data_structures/src/lib.rs b/compiler/rustc_data_structures/src/lib.rs index 181e5180d53..205f1cd77c0 100644 --- a/compiler/rustc_data_structures/src/lib.rs +++ b/compiler/rustc_data_structures/src/lib.rs @@ -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; diff --git a/compiler/rustc_driver/src/lib.rs b/compiler/rustc_driver/src/lib.rs index 2b64312dbef..0f490c33102 100644 --- a/compiler/rustc_driver/src/lib.rs +++ b/compiler/rustc_driver/src/lib.rs @@ -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); diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs index 7582f317b85..a5c954cca13 100644 --- a/compiler/rustc_errors/src/lib.rs +++ b/compiler/rustc_errors/src/lib.rs @@ -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; diff --git a/compiler/rustc_expand/src/lib.rs b/compiler/rustc_expand/src/lib.rs index dfc07da9169..43a310f4eaf 100644 --- a/compiler/rustc_expand/src/lib.rs +++ b/compiler/rustc_expand/src/lib.rs @@ -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; diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs index 25601ffb37d..3933746c319 100644 --- a/compiler/rustc_feature/src/builtin_attrs.rs +++ b/compiler/rustc_feature/src/builtin_attrs.rs @@ -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: diff --git a/compiler/rustc_incremental/src/lib.rs b/compiler/rustc_incremental/src/lib.rs index df64534ce54..b4df3e1e396 100644 --- a/compiler/rustc_incremental/src/lib.rs +++ b/compiler/rustc_incremental/src/lib.rs @@ -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; diff --git a/compiler/rustc_infer/src/lib.rs b/compiler/rustc_infer/src/lib.rs index 5f228d1e203..ae79e14db18 100644 --- a/compiler/rustc_infer/src/lib.rs +++ b/compiler/rustc_infer/src/lib.rs @@ -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; diff --git a/compiler/rustc_interface/src/lib.rs b/compiler/rustc_interface/src/lib.rs index b911b108a73..eebeabbd452 100644 --- a/compiler/rustc_interface/src/lib.rs +++ b/compiler/rustc_interface/src/lib.rs @@ -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; diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs index cb08e952586..5da77b9f946 100644 --- a/compiler/rustc_lint/src/context.rs +++ b/compiler/rustc_lint/src/context.rs @@ -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( diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs index d8e1162890c..b4b75bf64c9 100644 --- a/compiler/rustc_lint/src/internal.rs +++ b/compiler/rustc_lint/src/internal.rs @@ -5,7 +5,7 @@ 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::*; use rustc_middle::ty; use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::hygiene::{ExpnKind, MacroKind}; @@ -49,6 +49,58 @@ 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(_, span, _, _) if let Some(def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) => { + (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, "usage of `ty::TyKind` outside of the `ty::sty` module", diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs index a87f2b2768d..69863b5ff82 100644 --- a/compiler/rustc_lint/src/lib.rs +++ b/compiler/rustc_lint/src/lib.rs @@ -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), diff --git a/compiler/rustc_metadata/src/lib.rs b/compiler/rustc_metadata/src/lib.rs index 918c3b9daf1..046245080de 100644 --- a/compiler/rustc_metadata/src/lib.rs +++ b/compiler/rustc_metadata/src/lib.rs @@ -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; diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs index 920eca7a717..e85cb413deb 100644 --- a/compiler/rustc_middle/src/lib.rs +++ b/compiler/rustc_middle/src/lib.rs @@ -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; diff --git a/compiler/rustc_mir_build/src/lib.rs b/compiler/rustc_mir_build/src/lib.rs index 38bb00f985a..12ea740d48a 100644 --- a/compiler/rustc_mir_build/src/lib.rs +++ b/compiler/rustc_mir_build/src/lib.rs @@ -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; diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs index 8e1601fb719..129efc2b523 100644 --- a/compiler/rustc_mir_transform/src/lib.rs +++ b/compiler/rustc_mir_transform/src/lib.rs @@ -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; diff --git a/compiler/rustc_monomorphize/src/lib.rs b/compiler/rustc_monomorphize/src/lib.rs index 21ac174ba90..bbc65b09ece 100644 --- a/compiler/rustc_monomorphize/src/lib.rs +++ b/compiler/rustc_monomorphize/src/lib.rs @@ -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; diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index ec4cefa3537..50d2c64ae78 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -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 } @@ -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, ¶m.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()); } } diff --git a/compiler/rustc_passes/src/lib.rs b/compiler/rustc_passes/src/lib.rs index 2075fee7171..89404804098 100644 --- a/compiler/rustc_passes/src/lib.rs +++ b/compiler/rustc_passes/src/lib.rs @@ -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; diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs index d59c12fc2fa..7c511ccbd57 100644 --- a/compiler/rustc_privacy/src/lib.rs +++ b/compiler/rustc_privacy/src/lib.rs @@ -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; diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs index de9d4253537..bf859decc70 100644 --- a/compiler/rustc_query_impl/src/lib.rs +++ b/compiler/rustc_query_impl/src/lib.rs @@ -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; diff --git a/compiler/rustc_query_system/src/lib.rs b/compiler/rustc_query_system/src/lib.rs index 0436e07e2d4..750ac76a771 100644 --- a/compiler/rustc_query_system/src/lib.rs +++ b/compiler/rustc_query_system/src/lib.rs @@ -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; diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs index 45cc64ea194..d5ad95ace97 100644 --- a/compiler/rustc_resolve/src/lib.rs +++ b/compiler/rustc_resolve/src/lib.rs @@ -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; diff --git a/compiler/rustc_save_analysis/src/lib.rs b/compiler/rustc_save_analysis/src/lib.rs index 570fa873a23..c14b459570f 100644 --- a/compiler/rustc_save_analysis/src/lib.rs +++ b/compiler/rustc_save_analysis/src/lib.rs @@ -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; diff --git a/compiler/rustc_session/src/lib.rs b/compiler/rustc_session/src/lib.rs index 399b616915e..383250cd68f 100644 --- a/compiler/rustc_session/src/lib.rs +++ b/compiler/rustc_session/src/lib.rs @@ -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; diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs index 2c3db35bb66..823a927fd8c 100644 --- a/compiler/rustc_span/src/lib.rs +++ b/compiler/rustc_span/src/lib.rs @@ -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; diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index 198391cbe9c..18627cd2c09 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -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, diff --git a/compiler/rustc_symbol_mangling/src/lib.rs b/compiler/rustc_symbol_mangling/src/lib.rs index c5e85b14421..f4d1f41902a 100644 --- a/compiler/rustc_symbol_mangling/src/lib.rs +++ b/compiler/rustc_symbol_mangling/src/lib.rs @@ -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; diff --git a/compiler/rustc_trait_selection/src/lib.rs b/compiler/rustc_trait_selection/src/lib.rs index 17e7b481890..0041f596405 100644 --- a/compiler/rustc_trait_selection/src/lib.rs +++ b/compiler/rustc_trait_selection/src/lib.rs @@ -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; diff --git a/compiler/rustc_typeck/src/lib.rs b/compiler/rustc_typeck/src/lib.rs index 6a9f154844a..7b004fa086b 100644 --- a/compiler/rustc_typeck/src/lib.rs +++ b/compiler/rustc_typeck/src/lib.rs @@ -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; |