From 7f7915347dce231e0adc3cd8b95c1d6d977cab6b Mon Sep 17 00:00:00 2001 From: lcnr Date: Tue, 5 Oct 2021 15:59:13 +0200 Subject: [PATCH 01/13] write substs for lang item paths --- compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs index 7b9629e534bf9..2354d9a605eaa 100644 --- a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs +++ b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs @@ -830,6 +830,7 @@ 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))); From 80fe0bb76e601054398eb3c4763a6e9125d8101c Mon Sep 17 00:00:00 2001 From: lcnr Date: Tue, 5 Oct 2021 16:20:43 +0200 Subject: [PATCH 02/13] add a `rustc::query_stability` lint --- compiler/rustc_feature/src/builtin_attrs.rs | 3 + compiler/rustc_lint/src/internal.rs | 44 +++++- compiler/rustc_lint/src/lib.rs | 4 + compiler/rustc_passes/src/check_attr.rs | 144 ++++++++++-------- compiler/rustc_span/src/symbol.rs | 1 + library/std/src/collections/hash/map.rs | 10 ++ library/std/src/collections/hash/set.rs | 10 ++ .../internal-lints/query_stability.rs | 24 +++ .../internal-lints/query_stability.stderr | 39 +++++ .../query_stability_incorrect.rs | 15 ++ .../query_stability_incorrect.stderr | 17 +++ 11 files changed, 246 insertions(+), 65 deletions(-) create mode 100644 src/test/ui-fulldeps/internal-lints/query_stability.rs create mode 100644 src/test/ui-fulldeps/internal-lints/query_stability.stderr create mode 100644 src/test/ui-fulldeps/internal-lints/query_stability_incorrect.rs create mode 100644 src/test/ui-fulldeps/internal-lints/query_stability_incorrect.stderr diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs index 85b0db468d125..8e91c651a3110 100644 --- a/compiler/rustc_feature/src/builtin_attrs.rs +++ b/compiler/rustc_feature/src/builtin_attrs.rs @@ -460,6 +460,9 @@ 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_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs index 50a0d211a366a..93823aca8ec24 100644 --- a/compiler/rustc_lint/src/internal.rs +++ b/compiler/rustc_lint/src/internal.rs @@ -5,10 +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, MutTy, Mutability, 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}; @@ -51,6 +48,45 @@ 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<'_>) { + 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 6f684a0fe5128..7a3d99068012f 100644 --- a/compiler/rustc_lint/src/lib.rs +++ b/compiler/rustc_lint/src/lib.rs @@ -31,6 +31,7 @@ #![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)] @@ -484,6 +485,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()); @@ -494,6 +497,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(LINT_PASS_IMPL_WITHOUT_MACRO), LintId::of(TY_PASS_BY_REFERENCE), diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index e5fbddda74427..92d9e89c3a383 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,6 +103,9 @@ 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 @@ -230,7 +233,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 @@ -273,7 +276,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 } @@ -312,7 +315,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, @@ -331,7 +334,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 } @@ -339,7 +342,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, @@ -350,7 +353,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 } @@ -361,16 +364,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]`", ) @@ -391,11 +394,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 } @@ -407,7 +410,7 @@ impl CheckAttrVisitor<'tcx> { &self, hir_id: HirId, attr: &Attribute, - span: &Span, + span: Span, target: Target, ) -> bool { match target { @@ -427,7 +430,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 } @@ -435,7 +438,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 @@ -450,7 +453,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 } @@ -462,7 +465,7 @@ impl CheckAttrVisitor<'tcx> { &self, hir_id: HirId, attr: &Attribute, - span: &Span, + span: Span, target: Target, ) -> bool { match target { @@ -478,7 +481,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 @@ -495,7 +498,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 } @@ -1047,14 +1050,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 } @@ -1062,7 +1065,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 @@ -1082,7 +1085,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(); }); } @@ -1090,7 +1093,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 @@ -1124,7 +1127,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(); }); } @@ -1132,7 +1135,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 @@ -1150,7 +1153,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 } @@ -1166,7 +1169,7 @@ impl CheckAttrVisitor<'tcx> { &self, hir_id: HirId, attr: &Attribute, - span: &Span, + span: Span, target: Target, ) -> bool { match target { @@ -1187,7 +1190,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 } @@ -1197,14 +1200,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; } @@ -1229,7 +1232,7 @@ impl CheckAttrVisitor<'tcx> { fn check_rustc_legacy_const_generics( &self, attr: &Attribute, - span: &Span, + span: Span, target: Target, item: Option>, ) -> bool { @@ -1238,7 +1241,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; } @@ -1324,6 +1327,25 @@ 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 { @@ -1339,7 +1361,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 @@ -1359,7 +1381,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(); }); } @@ -1367,7 +1389,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) => {} @@ -1397,7 +1419,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, @@ -1420,7 +1442,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(); }); } @@ -1431,7 +1453,7 @@ impl CheckAttrVisitor<'tcx> { fn check_repr( &self, attrs: &'hir [Attribute], - span: &Span, + span: Span, target: Target, item: Option>, hir_id: HirId, @@ -1565,7 +1587,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(); } @@ -1628,7 +1650,7 @@ impl CheckAttrVisitor<'tcx> { &self, hir_id: HirId, attr: &Attribute, - span: &Span, + span: Span, target: Target, attrs: &[Attribute], ) -> bool { @@ -1661,7 +1683,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 } @@ -1674,7 +1696,7 @@ impl CheckAttrVisitor<'tcx> { &self, hir_id: HirId, attr: &Attribute, - span: &Span, + span: Span, target: Target, ) -> bool { match target { @@ -1695,7 +1717,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 } @@ -1706,7 +1728,7 @@ impl CheckAttrVisitor<'tcx> { fn check_default_method_body_is_const( &self, attr: &Attribute, - span: &Span, + span: Span, target: Target, ) -> bool { match target { @@ -1718,14 +1740,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 @@ -1738,7 +1760,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| { @@ -1810,29 +1832,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); } @@ -1840,7 +1862,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)), ); @@ -1849,14 +1871,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) } @@ -1867,7 +1889,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) } @@ -1877,12 +1899,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, ¶m.span, Target::Param, None); + self.check_attributes(param.hir_id, param.span, Target::Param, None); intravisit::walk_param(self, param); } @@ -1950,7 +1972,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_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index fddb225345f49..eba9f386af7db 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -1115,6 +1115,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/library/std/src/collections/hash/map.rs b/library/std/src/collections/hash/map.rs index 01019344f4f67..d36a3eaea9257 100644 --- a/library/std/src/collections/hash/map.rs +++ b/library/std/src/collections/hash/map.rs @@ -414,6 +414,7 @@ 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() } @@ -442,6 +443,7 @@ 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() } @@ -502,6 +504,7 @@ 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() } @@ -543,6 +546,7 @@ 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 @@ -949,6 +953,7 @@ 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 @@ -978,6 +983,7 @@ 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() } @@ -1004,6 +1010,7 @@ 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() } @@ -1969,6 +1976,7 @@ 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() } @@ -1980,6 +1988,7 @@ 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() } @@ -2008,6 +2017,7 @@ 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 5804701892e6e..f3bfa87bbde57 100644 --- a/library/std/src/collections/hash/set.rs +++ b/library/std/src/collections/hash/set.rs @@ -185,6 +185,7 @@ 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() } @@ -244,6 +245,7 @@ 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() } @@ -282,6 +284,7 @@ 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 @@ -506,6 +509,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) -> Difference<'a, T, S> { Difference { iter: self.iter(), other } @@ -533,6 +537,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, @@ -560,6 +565,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) -> Intersection<'a, T, S> { if self.len() <= other.len() { @@ -588,6 +594,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) -> Union<'a, T, S> { if self.len() >= other.len() { @@ -922,6 +929,7 @@ 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 @@ -1403,6 +1411,7 @@ 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() } @@ -1434,6 +1443,7 @@ 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 new file mode 100644 index 0000000000000..560675b448608 --- /dev/null +++ b/src/test/ui-fulldeps/internal-lints/query_stability.rs @@ -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::::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 new file mode 100644 index 0000000000000..7e8b448f41a91 --- /dev/null +++ b/src/test/ui-fulldeps/internal-lints/query_stability.stderr @@ -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 + diff --git a/src/test/ui-fulldeps/internal-lints/query_stability_incorrect.rs b/src/test/ui-fulldeps/internal-lints/query_stability_incorrect.rs new file mode 100644 index 0000000000000..f478b73329eb7 --- /dev/null +++ b/src/test/ui-fulldeps/internal-lints/query_stability_incorrect.rs @@ -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() {} diff --git a/src/test/ui-fulldeps/internal-lints/query_stability_incorrect.stderr b/src/test/ui-fulldeps/internal-lints/query_stability_incorrect.stderr new file mode 100644 index 0000000000000..b5156f2ac5905 --- /dev/null +++ b/src/test/ui-fulldeps/internal-lints/query_stability_incorrect.stderr @@ -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 + From 00e5abe9b6f713b1d868f17694113a5d50d96c19 Mon Sep 17 00:00:00 2001 From: lcnr Date: Wed, 13 Oct 2021 14:53:49 +0200 Subject: [PATCH 03/13] allow `potential_query_instability` everywhere --- compiler/rustc_ast_lowering/src/lib.rs | 1 + compiler/rustc_ast_passes/src/lib.rs | 1 + compiler/rustc_borrowck/src/lib.rs | 1 + compiler/rustc_builtin_macros/src/lib.rs | 1 + compiler/rustc_codegen_llvm/src/lib.rs | 1 + compiler/rustc_codegen_ssa/src/lib.rs | 1 + compiler/rustc_const_eval/src/lib.rs | 1 + compiler/rustc_data_structures/src/lib.rs | 1 + compiler/rustc_driver/src/lib.rs | 3 ++- compiler/rustc_errors/src/lib.rs | 1 + compiler/rustc_expand/src/lib.rs | 1 + compiler/rustc_incremental/src/lib.rs | 1 + compiler/rustc_infer/src/lib.rs | 1 + compiler/rustc_interface/src/lib.rs | 1 + compiler/rustc_lint/src/context.rs | 7 +++++-- compiler/rustc_lint/src/lib.rs | 1 + compiler/rustc_metadata/src/lib.rs | 1 + compiler/rustc_middle/src/lib.rs | 1 + compiler/rustc_mir_build/src/lib.rs | 1 + compiler/rustc_mir_transform/src/lib.rs | 1 + compiler/rustc_monomorphize/src/lib.rs | 1 + compiler/rustc_passes/src/lib.rs | 1 + compiler/rustc_privacy/src/lib.rs | 1 + compiler/rustc_query_impl/src/lib.rs | 1 + compiler/rustc_query_system/src/lib.rs | 1 + compiler/rustc_resolve/src/lib.rs | 1 + compiler/rustc_save_analysis/src/lib.rs | 1 + compiler/rustc_session/src/lib.rs | 1 + compiler/rustc_span/src/lib.rs | 1 + compiler/rustc_symbol_mangling/src/lib.rs | 1 + compiler/rustc_trait_selection/src/lib.rs | 1 + compiler/rustc_typeck/src/lib.rs | 1 + 32 files changed, 37 insertions(+), 3 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 245199e375113..fc21c54fef4c3 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(iter_zip)] #![recursion_limit = "256"] +#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] use rustc_ast::node_id::NodeMap; use rustc_ast::token::{self, Token}; diff --git a/compiler/rustc_ast_passes/src/lib.rs b/compiler/rustc_ast_passes/src/lib.rs index 47666670b2b63..6da128a037499 100644 --- a/compiler/rustc_ast_passes/src/lib.rs +++ b/compiler/rustc_ast_passes/src/lib.rs @@ -7,6 +7,7 @@ #![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 e6260157d11a7..5dba948d984da 100644 --- a/compiler/rustc_borrowck/src/lib.rs +++ b/compiler/rustc_borrowck/src/lib.rs @@ -12,6 +12,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 d1d276930b90a..d3e2ed02c32ea 100644 --- a/compiler/rustc_builtin_macros/src/lib.rs +++ b/compiler/rustc_builtin_macros/src/lib.rs @@ -11,6 +11,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 8f4d79e7147d3..f1dacc393d53b 100644 --- a/compiler/rustc_codegen_llvm/src/lib.rs +++ b/compiler/rustc_codegen_llvm/src/lib.rs @@ -13,6 +13,7 @@ #![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 b759e3a7a7a33..de428bfedba06 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 7ce40b319a1e5..e78606c6f8f7c 100644 --- a/compiler/rustc_const_eval/src/lib.rs +++ b/compiler/rustc_const_eval/src/lib.rs @@ -23,6 +23,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 94e115ed49856..0fbcd22c5e098 100644 --- a/compiler/rustc_data_structures/src/lib.rs +++ b/compiler/rustc_data_structures/src/lib.rs @@ -28,6 +28,7 @@ #![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 9a57ec991444a..1a9f8961bd741 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; @@ -846,7 +847,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 60a48b5a2d9c1..0d4ea28878eb1 100644 --- a/compiler/rustc_errors/src/lib.rs +++ b/compiler/rustc_errors/src/lib.rs @@ -9,6 +9,7 @@ #![feature(format_args_capture)] #![feature(iter_zip)] #![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 6dfeb047ec94c..e2eaaadc9b05e 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_incremental/src/lib.rs b/compiler/rustc_incremental/src/lib.rs index f089cbcfca6e5..5331b63a6160c 100644 --- a/compiler/rustc_incremental/src/lib.rs +++ b/compiler/rustc_incremental/src/lib.rs @@ -4,6 +4,7 @@ #![feature(in_band_lifetimes)] #![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 a4cfaddeeb96f..da6cb34315e96 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 2fc3759968fd3..969df0fbf24d9 100644 --- a/compiler/rustc_interface/src/lib.rs +++ b/compiler/rustc_interface/src/lib.rs @@ -5,6 +5,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 d235b2209444e..e34a92aba25f6 100644 --- a/compiler/rustc_lint/src/context.rs +++ b/compiler/rustc_lint/src/context.rs @@ -144,7 +144,11 @@ impl LintStore { &self.lints } - pub fn get_lint_groups<'t>(&'t self) -> Vec<(&'static str, Vec, bool)> { + 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))] self.lint_groups .iter() .filter(|(_, LintGroup { depr, .. })| { @@ -154,7 +158,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/lib.rs b/compiler/rustc_lint/src/lib.rs index 7a3d99068012f..f83eaabdfefcd 100644 --- a/compiler/rustc_lint/src/lib.rs +++ b/compiler/rustc_lint/src/lib.rs @@ -38,6 +38,7 @@ #![feature(nll)] #![feature(control_flow_enum)] #![recursion_limit = "256"] +#![cfg_attr(not(bootstrap), allow(rustc::potential_query_instability))] #[macro_use] extern crate rustc_middle; diff --git a/compiler/rustc_metadata/src/lib.rs b/compiler/rustc_metadata/src/lib.rs index 644b849a9f899..cb3d4b2931eaf 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 e41f5add457fb..9401247d37c00 100644 --- a/compiler/rustc_middle/src/lib.rs +++ b/compiler/rustc_middle/src/lib.rs @@ -55,6 +55,7 @@ #![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 02023c48a6c98..d962c9afd232b 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 9b11c8f0b24c0..2c6dc138b0f25 100644 --- a/compiler/rustc_mir_transform/src/lib.rs +++ b/compiler/rustc_mir_transform/src/lib.rs @@ -12,6 +12,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 08b1d7b7fabd7..04c83abd814d5 100644 --- a/compiler/rustc_monomorphize/src/lib.rs +++ b/compiler/rustc_monomorphize/src/lib.rs @@ -4,6 +4,7 @@ #![feature(control_flow_enum)] #![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/lib.rs b/compiler/rustc_passes/src/lib.rs index 4adec3c4f608d..c698333c8e222 100644 --- a/compiler/rustc_passes/src/lib.rs +++ b/compiler/rustc_passes/src/lib.rs @@ -14,6 +14,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 ae3a9c71c5968..38ccdb79f9bd6 100644 --- a/compiler/rustc_privacy/src/lib.rs +++ b/compiler/rustc_privacy/src/lib.rs @@ -5,6 +5,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 e50a8c191ad40..2465f1cbdf918 100644 --- a/compiler/rustc_query_impl/src/lib.rs +++ b/compiler/rustc_query_impl/src/lib.rs @@ -8,6 +8,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 bc23de069b0d9..21d21ea2b4441 100644 --- a/compiler/rustc_query_system/src/lib.rs +++ b/compiler/rustc_query_system/src/lib.rs @@ -5,6 +5,7 @@ #![feature(iter_zip)] #![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 9652c483686f0..ccf033aeec600 100644 --- a/compiler/rustc_resolve/src/lib.rs +++ b/compiler/rustc_resolve/src/lib.rs @@ -19,6 +19,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 543cd0247a53d..8fd2011ac46e0 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 6c86f86ecd9bb..1a6cab7ecde81 100644 --- a/compiler/rustc_session/src/lib.rs +++ b/compiler/rustc_session/src/lib.rs @@ -2,6 +2,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 032ae73bbf3c6..4eafa7cebb327 100644 --- a/compiler/rustc_span/src/lib.rs +++ b/compiler/rustc_span/src/lib.rs @@ -21,6 +21,7 @@ #![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_symbol_mangling/src/lib.rs b/compiler/rustc_symbol_mangling/src/lib.rs index 220c9f7e2ec2b..f6517610da262 100644 --- a/compiler/rustc_symbol_mangling/src/lib.rs +++ b/compiler/rustc_symbol_mangling/src/lib.rs @@ -93,6 +93,7 @@ #![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 017a7c45bbf9d..077d83866e25a 100644 --- a/compiler/rustc_trait_selection/src/lib.rs +++ b/compiler/rustc_trait_selection/src/lib.rs @@ -21,6 +21,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 971776c882a15..4a37cebe6eaae 100644 --- a/compiler/rustc_typeck/src/lib.rs +++ b/compiler/rustc_typeck/src/lib.rs @@ -70,6 +70,7 @@ 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; From 9a3c02473b922e91ad7c37beed8bd48da0ef05db Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Wed, 20 Oct 2021 11:58:20 -0400 Subject: [PATCH 04/13] Skip documentation for tier 2 targets --- .github/workflows/ci.yml | 2 +- src/ci/github-actions/ci.yml | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d921286ba3489..3c3f5e3100d3b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -287,7 +287,7 @@ jobs: os: ubuntu-latest-xl - name: dist-x86_64-apple env: - SCRIPT: "./x.py dist" + SCRIPT: "./x.py dist --exclude src/doc --exclude extended && ./x.py dist --target=x86_64-apple-darwin src/doc && ./x.py dist extended" RUST_CONFIGURE_ARGS: "--host=x86_64-apple-darwin --target=x86_64-apple-darwin,aarch64-apple-ios,x86_64-apple-ios,aarch64-apple-ios-sim --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc --set llvm.ninja=false" RUSTC_RETRY_LINKER_ON_SEGFAULT: 1 MACOSX_DEPLOYMENT_TARGET: 10.7 diff --git a/src/ci/github-actions/ci.yml b/src/ci/github-actions/ci.yml index eb16cf3c7620a..2b37a6fde7e0b 100644 --- a/src/ci/github-actions/ci.yml +++ b/src/ci/github-actions/ci.yml @@ -448,9 +448,11 @@ jobs: # macOS Builders # #################### + # Only generate documentation for x86_64-apple-darwin, not other + # tier 2 targets produced by this builder. - name: dist-x86_64-apple env: - SCRIPT: ./x.py dist + SCRIPT: ./x.py dist --exclude src/doc --exclude extended && ./x.py dist --target=x86_64-apple-darwin src/doc && ./x.py dist extended RUST_CONFIGURE_ARGS: --host=x86_64-apple-darwin --target=x86_64-apple-darwin,aarch64-apple-ios,x86_64-apple-ios,aarch64-apple-ios-sim --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc --set llvm.ninja=false RUSTC_RETRY_LINKER_ON_SEGFAULT: 1 MACOSX_DEPLOYMENT_TARGET: 10.7 From 5503dd9b0e2bb8518147591c66090729b5bea1bd Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Wed, 20 Oct 2021 12:15:45 -0400 Subject: [PATCH 05/13] [do not merge] try build --- .github/workflows/ci.yml | 13 ++++++++++--- src/ci/github-actions/ci.yml | 12 +++++++++++- 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3c3f5e3100d3b..8484289992980 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -528,9 +528,16 @@ jobs: strategy: matrix: include: - - name: dist-x86_64-linux - os: ubuntu-latest-xl - env: {} + - name: dist-x86_64-apple + env: + SCRIPT: "./x.py dist --exclude src/doc --exclude extended && ./x.py dist --target=x86_64-apple-darwin src/doc && ./x.py dist extended" + RUST_CONFIGURE_ARGS: "--host=x86_64-apple-darwin --target=x86_64-apple-darwin,aarch64-apple-ios,x86_64-apple-ios,aarch64-apple-ios-sim --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc --set llvm.ninja=false" + RUSTC_RETRY_LINKER_ON_SEGFAULT: 1 + MACOSX_DEPLOYMENT_TARGET: 10.7 + NO_LLVM_ASSERTIONS: 1 + NO_DEBUG_ASSERTIONS: 1 + DIST_REQUIRE_ALL_TOOLS: 1 + os: macos-latest timeout-minutes: 600 runs-on: "${{ matrix.os }}" steps: diff --git a/src/ci/github-actions/ci.yml b/src/ci/github-actions/ci.yml index 2b37a6fde7e0b..9616594b5a344 100644 --- a/src/ci/github-actions/ci.yml +++ b/src/ci/github-actions/ci.yml @@ -668,7 +668,17 @@ jobs: strategy: matrix: include: - - *dist-x86_64-linux + - name: dist-x86_64-apple + env: + SCRIPT: ./x.py dist --exclude src/doc --exclude extended && ./x.py dist --target=x86_64-apple-darwin src/doc && ./x.py dist extended + RUST_CONFIGURE_ARGS: --host=x86_64-apple-darwin --target=x86_64-apple-darwin,aarch64-apple-ios,x86_64-apple-ios,aarch64-apple-ios-sim --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc --set llvm.ninja=false + RUSTC_RETRY_LINKER_ON_SEGFAULT: 1 + MACOSX_DEPLOYMENT_TARGET: 10.7 + NO_LLVM_ASSERTIONS: 1 + NO_DEBUG_ASSERTIONS: 1 + DIST_REQUIRE_ALL_TOOLS: 1 + <<: *job-macos-xl + master: name: master From 9296efe3ef5544ec0eadb594d1fcbb5d7cc47276 Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Thu, 21 Oct 2021 09:16:16 -0400 Subject: [PATCH 06/13] Print step timings for try builds --- src/ci/run.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ci/run.sh b/src/ci/run.sh index b5019d83af45b..73175b43470c9 100755 --- a/src/ci/run.sh +++ b/src/ci/run.sh @@ -43,7 +43,7 @@ else PYTHON="python2" fi -if ! isCI || isCiBranch auto || isCiBranch beta; then +if ! isCI || isCiBranch auto || isCiBranch beta || isCiBranch try; then RUST_CONFIGURE_ARGS="$RUST_CONFIGURE_ARGS --set build.print-step-timings --enable-verbose-tests" fi From 22e17989751427625f6187a0b7ec27d621ce8164 Mon Sep 17 00:00:00 2001 From: lcnr Date: Thu, 21 Oct 2021 19:48:56 +0200 Subject: [PATCH 07/13] ignore `potential_query_instability` in rustdoc --- compiler/rustc_lint/src/internal.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs index 93823aca8ec24..e9dcc120200d0 100644 --- a/compiler/rustc_lint/src/internal.rs +++ b/compiler/rustc_lint/src/internal.rs @@ -59,6 +59,21 @@ 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) From a288bf6afbf7f98fd357b971b23ef09a66aaa8c0 Mon Sep 17 00:00:00 2001 From: Maybe Waffle Date: Fri, 22 Oct 2021 11:15:56 +0300 Subject: [PATCH 08/13] Mark {array,slice}::{from_ref,from_mut} as const fn --- library/core/src/array/mod.rs | 6 ++++-- library/core/src/lib.rs | 2 ++ library/core/src/slice/raw.rs | 6 ++++-- 3 files changed, 10 insertions(+), 4 deletions(-) diff --git a/library/core/src/array/mod.rs b/library/core/src/array/mod.rs index 8d5c0510404fb..752e3fceb35e6 100644 --- a/library/core/src/array/mod.rs +++ b/library/core/src/array/mod.rs @@ -85,14 +85,16 @@ where /// Converts a reference to `T` into a reference to an array of length 1 (without copying). #[stable(feature = "array_from_ref", since = "1.53.0")] -pub fn from_ref(s: &T) -> &[T; 1] { +#[rustc_const_unstable(feature = "const_array_from_ref", issue = "none")] +pub const fn from_ref(s: &T) -> &[T; 1] { // SAFETY: Converting `&T` to `&[T; 1]` is sound. unsafe { &*(s as *const T).cast::<[T; 1]>() } } /// Converts a mutable reference to `T` into a mutable reference to an array of length 1 (without copying). #[stable(feature = "array_from_ref", since = "1.53.0")] -pub fn from_mut(s: &mut T) -> &mut [T; 1] { +#[rustc_const_unstable(feature = "const_array_from_ref", issue = "none")] +pub const fn from_mut(s: &mut T) -> &mut [T; 1] { // SAFETY: Converting `&mut T` to `&mut [T; 1]` is sound. unsafe { &mut *(s as *mut T).cast::<[T; 1]>() } } diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs index 13b80c05dbb30..06497ff053967 100644 --- a/library/core/src/lib.rs +++ b/library/core/src/lib.rs @@ -135,6 +135,8 @@ #![feature(ptr_metadata)] #![feature(slice_ptr_get)] #![feature(variant_count)] +#![feature(const_array_from_ref)] +#![feature(const_slice_from_ref)] // // Language features: #![feature(abi_unadjusted)] diff --git a/library/core/src/slice/raw.rs b/library/core/src/slice/raw.rs index eda50dc287f6c..bcf3d9ba48e36 100644 --- a/library/core/src/slice/raw.rs +++ b/library/core/src/slice/raw.rs @@ -138,12 +138,14 @@ pub unsafe fn from_raw_parts_mut<'a, T>(data: *mut T, len: usize) -> &'a mut [T] /// Converts a reference to T into a slice of length 1 (without copying). #[stable(feature = "from_ref", since = "1.28.0")] -pub fn from_ref(s: &T) -> &[T] { +#[rustc_const_unstable(feature = "const_slice_from_ref", issue = "none")] +pub const fn from_ref(s: &T) -> &[T] { array::from_ref(s) } /// Converts a reference to T into a slice of length 1 (without copying). #[stable(feature = "from_ref", since = "1.28.0")] -pub fn from_mut(s: &mut T) -> &mut [T] { +#[rustc_const_unstable(feature = "const_slice_from_ref", issue = "none")] +pub const fn from_mut(s: &mut T) -> &mut [T] { array::from_mut(s) } From 27d69611347142cc5f103df0923b46d670e75739 Mon Sep 17 00:00:00 2001 From: Maybe Waffle Date: Sat, 23 Oct 2021 20:59:15 +0300 Subject: [PATCH 09/13] Fill tracking issue for `const_slice_from_ref` and `const_array_from_ref` --- library/core/src/array/mod.rs | 4 ++-- library/core/src/slice/raw.rs | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/library/core/src/array/mod.rs b/library/core/src/array/mod.rs index 752e3fceb35e6..5286ea60e3fee 100644 --- a/library/core/src/array/mod.rs +++ b/library/core/src/array/mod.rs @@ -85,7 +85,7 @@ where /// Converts a reference to `T` into a reference to an array of length 1 (without copying). #[stable(feature = "array_from_ref", since = "1.53.0")] -#[rustc_const_unstable(feature = "const_array_from_ref", issue = "none")] +#[rustc_const_unstable(feature = "const_array_from_ref", issue = "90206")] pub const fn from_ref(s: &T) -> &[T; 1] { // SAFETY: Converting `&T` to `&[T; 1]` is sound. unsafe { &*(s as *const T).cast::<[T; 1]>() } @@ -93,7 +93,7 @@ pub const fn from_ref(s: &T) -> &[T; 1] { /// Converts a mutable reference to `T` into a mutable reference to an array of length 1 (without copying). #[stable(feature = "array_from_ref", since = "1.53.0")] -#[rustc_const_unstable(feature = "const_array_from_ref", issue = "none")] +#[rustc_const_unstable(feature = "const_array_from_ref", issue = "90206")] pub const fn from_mut(s: &mut T) -> &mut [T; 1] { // SAFETY: Converting `&mut T` to `&mut [T; 1]` is sound. unsafe { &mut *(s as *mut T).cast::<[T; 1]>() } diff --git a/library/core/src/slice/raw.rs b/library/core/src/slice/raw.rs index bcf3d9ba48e36..ad38aaf9f8300 100644 --- a/library/core/src/slice/raw.rs +++ b/library/core/src/slice/raw.rs @@ -138,14 +138,14 @@ pub unsafe fn from_raw_parts_mut<'a, T>(data: *mut T, len: usize) -> &'a mut [T] /// Converts a reference to T into a slice of length 1 (without copying). #[stable(feature = "from_ref", since = "1.28.0")] -#[rustc_const_unstable(feature = "const_slice_from_ref", issue = "none")] +#[rustc_const_unstable(feature = "const_slice_from_ref", issue = "90206")] pub const fn from_ref(s: &T) -> &[T] { array::from_ref(s) } /// Converts a reference to T into a slice of length 1 (without copying). #[stable(feature = "from_ref", since = "1.28.0")] -#[rustc_const_unstable(feature = "const_slice_from_ref", issue = "none")] +#[rustc_const_unstable(feature = "const_slice_from_ref", issue = "90206")] pub const fn from_mut(s: &mut T) -> &mut [T] { array::from_mut(s) } From 542ab2daa6eb4b05a01403114783aa323315b416 Mon Sep 17 00:00:00 2001 From: Jacob Hoffman-Andrews Date: Thu, 21 Oct 2021 18:46:47 -0700 Subject: [PATCH 10/13] Outdent method headings so they stand out The makes the heading / documentation distinction clearer. --- src/librustdoc/html/static/css/rustdoc.css | 28 ++++++++-------------- src/test/rustdoc-gui/anchor-navigable.goml | 11 +++++++++ 2 files changed, 21 insertions(+), 18 deletions(-) create mode 100644 src/test/rustdoc-gui/anchor-navigable.goml diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css index e41c993a5285d..8336f4c1859dc 100644 --- a/src/librustdoc/html/static/css/rustdoc.css +++ b/src/librustdoc/html/static/css/rustdoc.css @@ -152,10 +152,15 @@ h1.fqn > .in-band > a:hover { h2, h3, h4 { border-bottom: 1px solid; } -h3.code-header, h4.code-header { +h3.code-header { + font-size: 1.1em; +} +h4.code-header { font-size: 1em; +} +h3.code-header, h4.code-header { font-weight: 600; - border: none; + border-bottom-style: none; padding: 0; margin: 0; } @@ -174,12 +179,6 @@ h3.code-header, h4.code-header { margin-bottom: 10px; position: relative; } -.impl, .method.trait-impl, -.type.trait-impl, -.associatedconstant.trait-impl, -.associatedtype.trait-impl { - padding-left: 15px; -} div.impl-items > div { padding-left: 0; @@ -669,13 +668,6 @@ nav.sub { left: -19px; } -.content .impl-items .method, .content .impl-items > .type, .impl-items > .associatedconstant, -.impl-items > .associatedtype, .content .impl-items details > summary > .type, -.impl-items details > summary > .associatedconstant, -.impl-items details > summary > .associatedtype { - margin-left: 20px; -} - .content .impl-items .docblock, .content .impl-items .item-info { margin-bottom: .6em; } @@ -746,7 +738,7 @@ a { .anchor { display: none; position: absolute; - left: 0; + left: -0.5em; background: none !important; } .anchor.field { @@ -1579,14 +1571,14 @@ details.rustdoc-toggle > summary.hideme::before { details.rustdoc-toggle > summary:not(.hideme)::before { position: absolute; - left: -23px; + left: -24px; top: 3px; } .impl-items > details.rustdoc-toggle > summary:not(.hideme)::before, .undocumented > details.rustdoc-toggle > summary:not(.hideme)::before { position: absolute; - left: -2px; + left: -24px; } /* When a "hideme" summary is open and the "Expand description" or "Show diff --git a/src/test/rustdoc-gui/anchor-navigable.goml b/src/test/rustdoc-gui/anchor-navigable.goml new file mode 100644 index 0000000000000..424c312233b5d --- /dev/null +++ b/src/test/rustdoc-gui/anchor-navigable.goml @@ -0,0 +1,11 @@ +// The `impl Foo` heading underneath `Implementations` has a ยง +// anchor to its left (used for linking to that heading). The anchor only shows +// up when hovering the `impl Foo`. This test ensures there's no gap between the +// anchor and the `impl Foo`. If there were a gap, this would cause an annoying +// problem: you hover `impl Foo` to see the anchor, then when you move your +// mouse to the left, the anchor disappears before you reach it. +goto: file://|DOC_PATH|/test_docs/struct.Foo.html +// We check that ".item-info" is bigger than its content. +move-cursor-to: ".impl" +assert-property: (".impl > a.anchor", {"offsetWidth": "9"}) +assert-css: (".impl > a.anchor", {"left": "-8px"}) From 5f390cfb722cf95b0df81f9563bf97b1663cff9e Mon Sep 17 00:00:00 2001 From: Maybe Waffle Date: Sat, 23 Oct 2021 22:51:22 +0300 Subject: [PATCH 11/13] Add tests for `const_slice_from_ref` and `const_array_from_ref` --- library/core/tests/array.rs | 5 +++++ library/core/tests/lib.rs | 2 ++ library/core/tests/slice.rs | 8 ++++++++ 3 files changed, 15 insertions(+) diff --git a/library/core/tests/array.rs b/library/core/tests/array.rs index b3af1328c90d4..d10bb4bce3cb9 100644 --- a/library/core/tests/array.rs +++ b/library/core/tests/array.rs @@ -7,6 +7,11 @@ fn array_from_ref() { let value: String = "Hello World!".into(); let arr: &[String; 1] = array::from_ref(&value); assert_eq!(&[value.clone()], arr); + + const VALUE: &&str = &"Hello World!"; + const ARR: &[&str; 1] = array::from_ref(VALUE); + assert_eq!(&[*VALUE], ARR); + assert!(core::ptr::eq(VALUE, &ARR[0])); } #[test] diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs index cf669163d3ef2..665ec756db169 100644 --- a/library/core/tests/lib.rs +++ b/library/core/tests/lib.rs @@ -71,6 +71,8 @@ #![feature(trusted_random_access)] #![feature(unsize)] #![feature(unzip_option)] +#![feature(const_array_from_ref)] +#![feature(const_slice_from_ref)] #![deny(unsafe_op_in_unsafe_fn)] extern crate test; diff --git a/library/core/tests/slice.rs b/library/core/tests/slice.rs index b6a326f3d7368..f1691c4f05710 100644 --- a/library/core/tests/slice.rs +++ b/library/core/tests/slice.rs @@ -2146,6 +2146,14 @@ fn test_slice_run_destructors() { assert_eq!(x.get(), 1); } +#[test] +fn test_const_from_ref() { + const VALUE: &i32 = &1; + const SLICE: &[i32] = core::slice::from_ref(VALUE); + + assert!(core::ptr::eq(VALUE, &SLICE[0])) +} + #[test] fn test_slice_fill_with_uninit() { // This should not UB. See #87891 From 4b970231fd1254580fbddabab74a125404fea0de Mon Sep 17 00:00:00 2001 From: Jakob Degen Date: Sun, 24 Oct 2021 00:33:29 -0400 Subject: [PATCH 12/13] Fix ICE when forgetting to `Box` a parameter to a `Self::func` call --- .../src/check/fn_ctxt/suggestions.rs | 2 +- .../issue-90213-expected-boxfuture-self-ice.rs | 13 +++++++++++++ ...sue-90213-expected-boxfuture-self-ice.stderr | 17 +++++++++++++++++ 3 files changed, 31 insertions(+), 1 deletion(-) create mode 100644 src/test/ui/suggestions/issue-90213-expected-boxfuture-self-ice.rs create mode 100644 src/test/ui/suggestions/issue-90213-expected-boxfuture-self-ice.stderr diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs b/compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs index babc06822ac52..dcc635a1f00b1 100644 --- a/compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs +++ b/compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs @@ -420,7 +420,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { .. }, method, - )) if Some(recv_ty.def_id()) == pin_did && method.ident.name == sym::new => { + )) if recv_ty.opt_def_id() == pin_did && method.ident.name == sym::new => { err.span_suggestion( fn_name.span, "use `Box::pin` to pin and box this expression", diff --git a/src/test/ui/suggestions/issue-90213-expected-boxfuture-self-ice.rs b/src/test/ui/suggestions/issue-90213-expected-boxfuture-self-ice.rs new file mode 100644 index 0000000000000..1e36b2fabf2c0 --- /dev/null +++ b/src/test/ui/suggestions/issue-90213-expected-boxfuture-self-ice.rs @@ -0,0 +1,13 @@ +// Checks that we do not ICE when comparing `Self` to `Pin` +// edition:2021 + +struct S; + +impl S { + fn foo(_: Box>) {} + fn bar() { + Self::foo(None) //~ ERROR mismatched types + } +} + +fn main() {} diff --git a/src/test/ui/suggestions/issue-90213-expected-boxfuture-self-ice.stderr b/src/test/ui/suggestions/issue-90213-expected-boxfuture-self-ice.stderr new file mode 100644 index 0000000000000..c15b772b79ca4 --- /dev/null +++ b/src/test/ui/suggestions/issue-90213-expected-boxfuture-self-ice.stderr @@ -0,0 +1,17 @@ +error[E0308]: mismatched types + --> $DIR/issue-90213-expected-boxfuture-self-ice.rs:9:19 + | +LL | Self::foo(None) + | ^^^^ expected struct `Box`, found enum `Option` + | + = note: expected struct `Box>` + found enum `Option<_>` + = note: for more on the distinction between the stack and the heap, read https://doc.rust-lang.org/book/ch15-01-box.html, https://doc.rust-lang.org/rust-by-example/std/box.html, and https://doc.rust-lang.org/std/boxed/index.html +help: store this in the heap by calling `Box::new` + | +LL | Self::foo(Box::new(None)) + | +++++++++ + + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0308`. From aacb497c36fca0be3e9805fd0cf8d5fea665bd2f Mon Sep 17 00:00:00 2001 From: Hans Kratz Date: Sun, 24 Oct 2021 15:36:45 +0200 Subject: [PATCH 13/13] Temporarily turn overflow checks off for rustc-rayon-core --- Cargo.toml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index 8d6afd2b44837..cae48d7951783 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -77,6 +77,13 @@ overflow-checks = false # per-crate configuration isn't specifiable in the environment. codegen-units = 10000 +[profile.release.package.rustc-rayon-core] +# The rustc fork of Rayon has deadlock detection code which intermittently +# causes overflows in the CI (see https://github.com/rust-lang/rust/issues/90227) +# so we turn overflow checks off for now. +# FIXME: This workaround should be removed once #90227 is fixed. +overflow-checks = false + # These dependencies of the standard library implement symbolication for # backtraces on most platforms. Their debuginfo causes both linking to be slower # (more data to chew through) and binaries to be larger without really all that