From c771970b97d44c9a6680decb0087e184e35169ed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lauren=C8=9Biu=20Nicola?= Date: Tue, 14 Dec 2021 17:03:44 +0200 Subject: [PATCH 01/10] :arrow_up: rust-analyzer --- src/tools/rust-analyzer | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/rust-analyzer b/src/tools/rust-analyzer index 7d6fcbc0be215..db2a7087b994e 160000 --- a/src/tools/rust-analyzer +++ b/src/tools/rust-analyzer @@ -1 +1 @@ -Subproject commit 7d6fcbc0be2151bfa85ec146545b42d8be2fb28c +Subproject commit db2a7087b994e20f264f26ad6db75184282ad120 From c4bafafac1a0e44919cb45d93692a3e6c7f7f00b Mon Sep 17 00:00:00 2001 From: Peter Jaszkowiak Date: Mon, 13 Dec 2021 22:16:36 -0700 Subject: [PATCH 02/10] Remove `in_band_lifetimes` for `rustc_passes` --- compiler/rustc_passes/src/check_attr.rs | 10 +++++----- compiler/rustc_passes/src/check_const.rs | 8 ++++---- compiler/rustc_passes/src/dead.rs | 6 +++--- compiler/rustc_passes/src/intrinsicck.rs | 6 +++--- compiler/rustc_passes/src/lang_items.rs | 4 ++-- compiler/rustc_passes/src/layout_test.rs | 12 ++++++------ compiler/rustc_passes/src/lib.rs | 1 - compiler/rustc_passes/src/lib_features.rs | 4 ++-- compiler/rustc_passes/src/liveness.rs | 2 +- compiler/rustc_passes/src/naked_functions.rs | 2 +- compiler/rustc_passes/src/reachable.rs | 2 +- compiler/rustc_passes/src/stability.rs | 6 +++--- compiler/rustc_passes/src/upvars.rs | 4 ++-- 13 files changed, 33 insertions(+), 34 deletions(-) diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index 49e6a7df10301..38ad8283f4df0 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -58,7 +58,7 @@ struct CheckAttrVisitor<'tcx> { tcx: TyCtxt<'tcx>, } -impl CheckAttrVisitor<'tcx> { +impl CheckAttrVisitor<'_> { /// Checks any attribute. fn check_attributes( &self, @@ -382,7 +382,7 @@ impl CheckAttrVisitor<'tcx> { &self, hir_id: HirId, attr_span: &Span, - attrs: &'hir [Attribute], + attrs: &[Attribute], span: &Span, target: Target, ) -> bool { @@ -1481,7 +1481,7 @@ impl CheckAttrVisitor<'tcx> { /// Checks if the `#[repr]` attributes on `item` are valid. fn check_repr( &self, - attrs: &'hir [Attribute], + attrs: &[Attribute], span: &Span, target: Target, item: Option>, @@ -1663,7 +1663,7 @@ impl CheckAttrVisitor<'tcx> { } } - fn check_used(&self, attrs: &'hir [Attribute], target: Target) { + fn check_used(&self, attrs: &[Attribute], target: Target) { for attr in attrs { if attr.has_name(sym::used) && target != Target::Static { self.tcx @@ -1842,7 +1842,7 @@ impl CheckAttrVisitor<'tcx> { } } -impl Visitor<'tcx> for CheckAttrVisitor<'tcx> { +impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> { type Map = Map<'tcx>; fn nested_visit_map(&mut self) -> NestedVisitorMap { diff --git a/compiler/rustc_passes/src/check_const.rs b/compiler/rustc_passes/src/check_const.rs index 9ccf76b5700c2..a5a65740707e6 100644 --- a/compiler/rustc_passes/src/check_const.rs +++ b/compiler/rustc_passes/src/check_const.rs @@ -78,7 +78,7 @@ impl<'tcx> CheckConstTraitVisitor<'tcx> { impl<'tcx> hir::itemlikevisit::ItemLikeVisitor<'tcx> for CheckConstTraitVisitor<'tcx> { /// check for const trait impls, and errors if the impl uses provided/default functions /// of the trait being implemented; as those provided functions can be non-const. - fn visit_item(&mut self, item: &'hir hir::Item<'hir>) { + fn visit_item<'hir>(&mut self, item: &'hir hir::Item<'hir>) { let _: Option<_> = try { if let hir::ItemKind::Impl(ref imp) = item.kind { if let hir::Constness::Const = imp.constness { @@ -134,11 +134,11 @@ impl<'tcx> hir::itemlikevisit::ItemLikeVisitor<'tcx> for CheckConstTraitVisitor< }; } - fn visit_trait_item(&mut self, _: &'hir hir::TraitItem<'hir>) {} + fn visit_trait_item<'hir>(&mut self, _: &'hir hir::TraitItem<'hir>) {} - fn visit_impl_item(&mut self, _: &'hir hir::ImplItem<'hir>) {} + fn visit_impl_item<'hir>(&mut self, _: &'hir hir::ImplItem<'hir>) {} - fn visit_foreign_item(&mut self, _: &'hir hir::ForeignItem<'hir>) {} + fn visit_foreign_item<'hir>(&mut self, _: &'hir hir::ForeignItem<'hir>) {} } #[derive(Copy, Clone)] diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs index 772791324019a..3b15332c678fd 100644 --- a/compiler/rustc_passes/src/dead.rs +++ b/compiler/rustc_passes/src/dead.rs @@ -150,7 +150,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> { #[allow(dead_code)] // FIXME(81658): should be used + lint reinstated after #83171 relands. fn check_for_self_assign(&mut self, assign: &'tcx hir::Expr<'tcx>) { - fn check_for_self_assign_helper( + fn check_for_self_assign_helper<'tcx>( tcx: TyCtxt<'tcx>, typeck_results: &'tcx ty::TypeckResults<'tcx>, lhs: &'tcx hir::Expr<'tcx>, @@ -600,7 +600,7 @@ struct DeadVisitor<'tcx> { live_symbols: FxHashSet, } -impl DeadVisitor<'tcx> { +impl<'tcx> DeadVisitor<'tcx> { fn should_warn_about_item(&mut self, item: &hir::Item<'_>) -> bool { let should_warn = matches!( item.kind, @@ -672,7 +672,7 @@ impl DeadVisitor<'tcx> { } } -impl Visitor<'tcx> for DeadVisitor<'tcx> { +impl<'tcx> Visitor<'tcx> for DeadVisitor<'tcx> { type Map = Map<'tcx>; /// Walk nested items in place so that we don't report dead-code diff --git a/compiler/rustc_passes/src/intrinsicck.rs b/compiler/rustc_passes/src/intrinsicck.rs index 008b856ebf2fa..064c469662842 100644 --- a/compiler/rustc_passes/src/intrinsicck.rs +++ b/compiler/rustc_passes/src/intrinsicck.rs @@ -62,7 +62,7 @@ fn unpack_option_like<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { ty } -impl ExprVisitor<'tcx> { +impl<'tcx> ExprVisitor<'tcx> { fn def_id_is_transmute(&self, def_id: DefId) -> bool { self.tcx.fn_sig(def_id).abi() == RustIntrinsic && self.tcx.item_name(def_id) == sym::transmute @@ -487,7 +487,7 @@ impl ExprVisitor<'tcx> { } } -impl Visitor<'tcx> for ItemVisitor<'tcx> { +impl<'tcx> Visitor<'tcx> for ItemVisitor<'tcx> { type Map = intravisit::ErasedMap<'tcx>; fn nested_visit_map(&mut self) -> NestedVisitorMap { @@ -504,7 +504,7 @@ impl Visitor<'tcx> for ItemVisitor<'tcx> { } } -impl Visitor<'tcx> for ExprVisitor<'tcx> { +impl<'tcx> Visitor<'tcx> for ExprVisitor<'tcx> { type Map = intravisit::ErasedMap<'tcx>; fn nested_visit_map(&mut self) -> NestedVisitorMap { diff --git a/compiler/rustc_passes/src/lang_items.rs b/compiler/rustc_passes/src/lang_items.rs index 388c33917c64f..a808d6c8348a7 100644 --- a/compiler/rustc_passes/src/lang_items.rs +++ b/compiler/rustc_passes/src/lang_items.rs @@ -28,7 +28,7 @@ struct LanguageItemCollector<'tcx> { tcx: TyCtxt<'tcx>, } -impl ItemLikeVisitor<'v> for LanguageItemCollector<'tcx> { +impl<'v, 'tcx> ItemLikeVisitor<'v> for LanguageItemCollector<'tcx> { fn visit_item(&mut self, item: &hir::Item<'_>) { self.check_for_lang(Target::from_item(item), item.hir_id()); @@ -50,7 +50,7 @@ impl ItemLikeVisitor<'v> for LanguageItemCollector<'tcx> { fn visit_foreign_item(&mut self, _: &hir::ForeignItem<'_>) {} } -impl LanguageItemCollector<'tcx> { +impl<'tcx> LanguageItemCollector<'tcx> { fn new(tcx: TyCtxt<'tcx>) -> LanguageItemCollector<'tcx> { LanguageItemCollector { tcx, items: LanguageItems::new() } } diff --git a/compiler/rustc_passes/src/layout_test.rs b/compiler/rustc_passes/src/layout_test.rs index 558d8958b1358..00e8eb5eb2b38 100644 --- a/compiler/rustc_passes/src/layout_test.rs +++ b/compiler/rustc_passes/src/layout_test.rs @@ -20,7 +20,7 @@ struct LayoutTest<'tcx> { tcx: TyCtxt<'tcx>, } -impl ItemLikeVisitor<'tcx> for LayoutTest<'tcx> { +impl<'tcx> ItemLikeVisitor<'tcx> for LayoutTest<'tcx> { fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { match item.kind { ItemKind::TyAlias(..) @@ -42,7 +42,7 @@ impl ItemLikeVisitor<'tcx> for LayoutTest<'tcx> { fn visit_foreign_item(&mut self, _: &'tcx hir::ForeignItem<'tcx>) {} } -impl LayoutTest<'tcx> { +impl<'tcx> LayoutTest<'tcx> { fn dump_layout_of(&self, item_def_id: LocalDefId, item: &hir::Item<'tcx>, attr: &Attribute) { let tcx = self.tcx; let param_env = self.tcx.param_env(item_def_id); @@ -114,7 +114,7 @@ struct UnwrapLayoutCx<'tcx> { param_env: ParamEnv<'tcx>, } -impl LayoutOfHelpers<'tcx> for UnwrapLayoutCx<'tcx> { +impl<'tcx> LayoutOfHelpers<'tcx> for UnwrapLayoutCx<'tcx> { type LayoutOfResult = TyAndLayout<'tcx>; fn handle_layout_err(&self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx>) -> ! { @@ -127,19 +127,19 @@ impl LayoutOfHelpers<'tcx> for UnwrapLayoutCx<'tcx> { } } -impl HasTyCtxt<'tcx> for UnwrapLayoutCx<'tcx> { +impl<'tcx> HasTyCtxt<'tcx> for UnwrapLayoutCx<'tcx> { fn tcx(&self) -> TyCtxt<'tcx> { self.tcx } } -impl HasParamEnv<'tcx> for UnwrapLayoutCx<'tcx> { +impl<'tcx> HasParamEnv<'tcx> for UnwrapLayoutCx<'tcx> { fn param_env(&self) -> ParamEnv<'tcx> { self.param_env } } -impl HasDataLayout for UnwrapLayoutCx<'tcx> { +impl<'tcx> HasDataLayout for UnwrapLayoutCx<'tcx> { fn data_layout(&self) -> &TargetDataLayout { self.tcx.data_layout() } diff --git a/compiler/rustc_passes/src/lib.rs b/compiler/rustc_passes/src/lib.rs index d6528364e9806..8a411f01d6ee2 100644 --- a/compiler/rustc_passes/src/lib.rs +++ b/compiler/rustc_passes/src/lib.rs @@ -6,7 +6,6 @@ #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")] #![feature(crate_visibility_modifier)] -#![feature(in_band_lifetimes)] #![feature(map_try_insert)] #![feature(min_specialization)] #![feature(nll)] diff --git a/compiler/rustc_passes/src/lib_features.rs b/compiler/rustc_passes/src/lib_features.rs index 10b8c3104fcad..55ae808dc3089 100644 --- a/compiler/rustc_passes/src/lib_features.rs +++ b/compiler/rustc_passes/src/lib_features.rs @@ -23,7 +23,7 @@ pub struct LibFeatureCollector<'tcx> { lib_features: LibFeatures, } -impl LibFeatureCollector<'tcx> { +impl<'tcx> LibFeatureCollector<'tcx> { fn new(tcx: TyCtxt<'tcx>) -> LibFeatureCollector<'tcx> { LibFeatureCollector { tcx, lib_features: new_lib_features() } } @@ -110,7 +110,7 @@ impl LibFeatureCollector<'tcx> { } } -impl Visitor<'tcx> for LibFeatureCollector<'tcx> { +impl<'tcx> Visitor<'tcx> for LibFeatureCollector<'tcx> { type Map = Map<'tcx>; fn nested_visit_map(&mut self) -> NestedVisitorMap { diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs index 3d7a215754aca..8bd08913e90d4 100644 --- a/compiler/rustc_passes/src/liveness.rs +++ b/compiler/rustc_passes/src/liveness.rs @@ -198,7 +198,7 @@ struct IrMaps<'tcx> { lnks: IndexVec, } -impl IrMaps<'tcx> { +impl<'tcx> IrMaps<'tcx> { fn new(tcx: TyCtxt<'tcx>) -> IrMaps<'tcx> { IrMaps { tcx, diff --git a/compiler/rustc_passes/src/naked_functions.rs b/compiler/rustc_passes/src/naked_functions.rs index d3ecd18a93c5a..07cb165d79670 100644 --- a/compiler/rustc_passes/src/naked_functions.rs +++ b/compiler/rustc_passes/src/naked_functions.rs @@ -37,7 +37,7 @@ impl<'tcx> Visitor<'tcx> for CheckNakedFunctions<'tcx> { fn visit_fn( &mut self, - fk: FnKind<'v>, + fk: FnKind<'_>, _fd: &'tcx hir::FnDecl<'tcx>, body_id: hir::BodyId, span: Span, diff --git a/compiler/rustc_passes/src/reachable.rs b/compiler/rustc_passes/src/reachable.rs index fc56a339215be..707e6b123daa2 100644 --- a/compiler/rustc_passes/src/reachable.rs +++ b/compiler/rustc_passes/src/reachable.rs @@ -22,7 +22,7 @@ use rustc_target::spec::abi::Abi; // Returns true if the given item must be inlined because it may be // monomorphized or it was marked with `#[inline]`. This will only return // true for functions. -fn item_might_be_inlined(tcx: TyCtxt<'tcx>, item: &hir::Item<'_>, attrs: &CodegenFnAttrs) -> bool { +fn item_might_be_inlined(tcx: TyCtxt<'_>, item: &hir::Item<'_>, attrs: &CodegenFnAttrs) -> bool { if attrs.requests_inline() { return true; } diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs index 92911c3cd2455..5f19991f9c78b 100644 --- a/compiler/rustc_passes/src/stability.rs +++ b/compiler/rustc_passes/src/stability.rs @@ -655,7 +655,7 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> { // stable (assuming they have not inherited instability from their parent). } -fn stability_index(tcx: TyCtxt<'tcx>, (): ()) -> Index<'tcx> { +fn stability_index<'tcx>(tcx: TyCtxt<'tcx>, (): ()) -> Index<'tcx> { let is_staged_api = tcx.sess.opts.debugging_opts.force_unstable_if_unmarked || tcx.features().staged_api; let mut staged_api = FxHashMap::default(); @@ -737,7 +737,7 @@ struct Checker<'tcx> { tcx: TyCtxt<'tcx>, } -impl Visitor<'tcx> for Checker<'tcx> { +impl<'tcx> Visitor<'tcx> for Checker<'tcx> { type Map = Map<'tcx>; /// Because stability levels are scoped lexically, we want to walk @@ -866,7 +866,7 @@ struct CheckTraitImplStable<'tcx> { fully_stable: bool, } -impl Visitor<'tcx> for CheckTraitImplStable<'tcx> { +impl<'tcx> Visitor<'tcx> for CheckTraitImplStable<'tcx> { type Map = Map<'tcx>; fn nested_visit_map(&mut self) -> NestedVisitorMap { diff --git a/compiler/rustc_passes/src/upvars.rs b/compiler/rustc_passes/src/upvars.rs index 91b8ae07637df..2d84c8caada80 100644 --- a/compiler/rustc_passes/src/upvars.rs +++ b/compiler/rustc_passes/src/upvars.rs @@ -42,7 +42,7 @@ struct LocalCollector { locals: FxHashSet, } -impl Visitor<'tcx> for LocalCollector { +impl<'tcx> Visitor<'tcx> for LocalCollector { type Map = intravisit::ErasedMap<'tcx>; fn nested_visit_map(&mut self) -> NestedVisitorMap { @@ -71,7 +71,7 @@ impl CaptureCollector<'_, '_> { } } -impl Visitor<'tcx> for CaptureCollector<'a, 'tcx> { +impl<'tcx> Visitor<'tcx> for CaptureCollector<'_, 'tcx> { type Map = intravisit::ErasedMap<'tcx>; fn nested_visit_map(&mut self) -> NestedVisitorMap { From fed881aafc9fe4889a32a74060dc1d4294960477 Mon Sep 17 00:00:00 2001 From: LegionMammal978 Date: Tue, 14 Dec 2021 12:02:45 -0500 Subject: [PATCH 03/10] Remove `in_band_lifetimes` from `rustc_mir_dataflow` See #91867 for more information. --- .../src/framework/direction.rs | 32 +++++++++---------- .../src/framework/engine.rs | 21 ++++++------ .../src/framework/graphviz.rs | 26 +++++++-------- .../rustc_mir_dataflow/src/framework/mod.rs | 14 ++++++-- .../rustc_mir_dataflow/src/framework/tests.rs | 8 ++--- .../src/framework/visitor.rs | 2 +- .../src/impls/borrowed_locals.rs | 6 ++-- .../src/impls/init_locals.rs | 6 ++-- .../rustc_mir_dataflow/src/impls/liveness.rs | 6 ++-- compiler/rustc_mir_dataflow/src/impls/mod.rs | 2 +- .../src/impls/storage_liveness.rs | 4 +-- compiler/rustc_mir_dataflow/src/lib.rs | 1 - compiler/rustc_mir_dataflow/src/storage.rs | 2 +- 13 files changed, 70 insertions(+), 60 deletions(-) diff --git a/compiler/rustc_mir_dataflow/src/framework/direction.rs b/compiler/rustc_mir_dataflow/src/framework/direction.rs index 6131ee7981829..102e74397724a 100644 --- a/compiler/rustc_mir_dataflow/src/framework/direction.rs +++ b/compiler/rustc_mir_dataflow/src/framework/direction.rs @@ -18,7 +18,7 @@ pub trait Direction { /// Applies all effects between the given `EffectIndex`s. /// /// `effects.start()` must precede or equal `effects.end()` in this direction. - fn apply_effects_in_range( + fn apply_effects_in_range<'tcx, A>( analysis: &A, state: &mut A::Domain, block: BasicBlock, @@ -27,7 +27,7 @@ pub trait Direction { ) where A: Analysis<'tcx>; - fn apply_effects_in_block( + fn apply_effects_in_block<'tcx, A>( analysis: &A, state: &mut A::Domain, block: BasicBlock, @@ -35,7 +35,7 @@ pub trait Direction { ) where A: Analysis<'tcx>; - fn gen_kill_effects_in_block( + fn gen_kill_effects_in_block<'tcx, A>( analysis: &A, trans: &mut GenKillSet, block: BasicBlock, @@ -43,7 +43,7 @@ pub trait Direction { ) where A: GenKillAnalysis<'tcx>; - fn visit_results_in_block( + fn visit_results_in_block<'mir, 'tcx, F, R>( state: &mut F, block: BasicBlock, block_data: &'mir mir::BasicBlockData<'tcx>, @@ -52,7 +52,7 @@ pub trait Direction { ) where R: ResultsVisitable<'tcx, FlowState = F>; - fn join_state_into_successors_of( + fn join_state_into_successors_of<'tcx, A>( analysis: &A, tcx: TyCtxt<'tcx>, body: &mir::Body<'tcx>, @@ -72,7 +72,7 @@ impl Direction for Backward { false } - fn apply_effects_in_block( + fn apply_effects_in_block<'tcx, A>( analysis: &A, state: &mut A::Domain, block: BasicBlock, @@ -92,7 +92,7 @@ impl Direction for Backward { } } - fn gen_kill_effects_in_block( + fn gen_kill_effects_in_block<'tcx, A>( analysis: &A, trans: &mut GenKillSet, block: BasicBlock, @@ -112,7 +112,7 @@ impl Direction for Backward { } } - fn apply_effects_in_range( + fn apply_effects_in_range<'tcx, A>( analysis: &A, state: &mut A::Domain, block: BasicBlock, @@ -189,7 +189,7 @@ impl Direction for Backward { analysis.apply_statement_effect(state, statement, location); } - fn visit_results_in_block( + fn visit_results_in_block<'mir, 'tcx, F, R>( state: &mut F, block: BasicBlock, block_data: &'mir mir::BasicBlockData<'tcx>, @@ -221,7 +221,7 @@ impl Direction for Backward { vis.visit_block_start(state, block_data, block); } - fn join_state_into_successors_of( + fn join_state_into_successors_of<'tcx, A>( analysis: &A, _tcx: TyCtxt<'tcx>, body: &mir::Body<'tcx>, @@ -294,7 +294,7 @@ impl Direction for Forward { true } - fn apply_effects_in_block( + fn apply_effects_in_block<'tcx, A>( analysis: &A, state: &mut A::Domain, block: BasicBlock, @@ -314,7 +314,7 @@ impl Direction for Forward { analysis.apply_terminator_effect(state, terminator, location); } - fn gen_kill_effects_in_block( + fn gen_kill_effects_in_block<'tcx, A>( analysis: &A, trans: &mut GenKillSet, block: BasicBlock, @@ -334,7 +334,7 @@ impl Direction for Forward { analysis.terminator_effect(trans, terminator, location); } - fn apply_effects_in_range( + fn apply_effects_in_range<'tcx, A>( analysis: &A, state: &mut A::Domain, block: BasicBlock, @@ -407,7 +407,7 @@ impl Direction for Forward { } } - fn visit_results_in_block( + fn visit_results_in_block<'mir, 'tcx, F, R>( state: &mut F, block: BasicBlock, block_data: &'mir mir::BasicBlockData<'tcx>, @@ -438,7 +438,7 @@ impl Direction for Forward { vis.visit_block_end(state, block_data, block); } - fn join_state_into_successors_of( + fn join_state_into_successors_of<'tcx, A>( analysis: &A, _tcx: TyCtxt<'tcx>, _body: &mir::Body<'tcx>, @@ -591,7 +591,7 @@ where // // FIXME: Figure out how to express this using `Option::clone_from`, or maybe lift it into the // standard library? -fn opt_clone_from_or_clone(opt: &'a mut Option, val: &T) -> &'a mut T { +fn opt_clone_from_or_clone<'a, T: Clone>(opt: &'a mut Option, val: &T) -> &'a mut T { if opt.is_some() { let ret = opt.as_mut().unwrap(); ret.clone_from(val); diff --git a/compiler/rustc_mir_dataflow/src/framework/engine.rs b/compiler/rustc_mir_dataflow/src/framework/engine.rs index 804abc3b42b53..e8a6d8dad439e 100644 --- a/compiler/rustc_mir_dataflow/src/framework/engine.rs +++ b/compiler/rustc_mir_dataflow/src/framework/engine.rs @@ -31,12 +31,15 @@ where pub(super) entry_sets: IndexVec, } -impl Results<'tcx, A> +impl<'tcx, A> Results<'tcx, A> where A: Analysis<'tcx>, { /// Creates a `ResultsCursor` that can inspect these `Results`. - pub fn into_results_cursor(self, body: &'mir mir::Body<'tcx>) -> ResultsCursor<'mir, 'tcx, A> { + pub fn into_results_cursor<'mir>( + self, + body: &'mir mir::Body<'tcx>, + ) -> ResultsCursor<'mir, 'tcx, A> { ResultsCursor::new(body, self) } @@ -45,7 +48,7 @@ where &self.entry_sets[block] } - pub fn visit_with( + pub fn visit_with<'mir>( &self, body: &'mir mir::Body<'tcx>, blocks: impl IntoIterator, @@ -54,7 +57,7 @@ where visit_results(body, blocks, self, vis) } - pub fn visit_reachable_with( + pub fn visit_reachable_with<'mir>( &self, body: &'mir mir::Body<'tcx>, vis: &mut impl ResultsVisitor<'mir, 'tcx, FlowState = A::Domain>, @@ -85,7 +88,7 @@ where apply_trans_for_block: Option>, } -impl Engine<'a, 'tcx, A> +impl<'a, 'tcx, A, D, T> Engine<'a, 'tcx, A> where A: GenKillAnalysis<'tcx, Idx = T, Domain = D>, D: Clone + JoinSemiLattice + GenKill + BorrowMut>, @@ -119,7 +122,7 @@ where } } -impl Engine<'a, 'tcx, A> +impl<'a, 'tcx, A, D> Engine<'a, 'tcx, A> where A: Analysis<'tcx, Domain = D>, D: Clone + JoinSemiLattice, @@ -257,7 +260,7 @@ where /// Writes a DOT file containing the results of a dataflow analysis if the user requested it via /// `rustc_mir` attributes. -fn write_graphviz_results( +fn write_graphviz_results<'tcx, A>( tcx: TyCtxt<'tcx>, body: &mir::Body<'tcx>, results: &Results<'tcx, A>, @@ -330,7 +333,7 @@ struct RustcMirAttrs { } impl RustcMirAttrs { - fn parse(tcx: TyCtxt<'tcx>, def_id: DefId) -> Result { + fn parse(tcx: TyCtxt<'_>, def_id: DefId) -> Result { let attrs = tcx.get_attrs(def_id); let mut result = Ok(()); @@ -373,7 +376,7 @@ impl RustcMirAttrs { fn set_field( field: &mut Option, - tcx: TyCtxt<'tcx>, + tcx: TyCtxt<'_>, attr: &ast::NestedMetaItem, mapper: impl FnOnce(Symbol) -> Result, ) -> Result<(), ()> { diff --git a/compiler/rustc_mir_dataflow/src/framework/graphviz.rs b/compiler/rustc_mir_dataflow/src/framework/graphviz.rs index 517bc086ef683..34bc157a744a7 100644 --- a/compiler/rustc_mir_dataflow/src/framework/graphviz.rs +++ b/compiler/rustc_mir_dataflow/src/framework/graphviz.rs @@ -36,7 +36,7 @@ where style: OutputStyle, } -impl Formatter<'a, 'tcx, A> +impl<'a, 'tcx, A> Formatter<'a, 'tcx, A> where A: Analysis<'tcx>, { @@ -52,7 +52,7 @@ pub struct CfgEdge { index: usize, } -fn dataflow_successors(body: &Body<'tcx>, bb: BasicBlock) -> Vec { +fn dataflow_successors(body: &Body<'_>, bb: BasicBlock) -> Vec { body[bb] .terminator() .successors() @@ -61,7 +61,7 @@ fn dataflow_successors(body: &Body<'tcx>, bb: BasicBlock) -> Vec { .collect() } -impl dot::Labeller<'_> for Formatter<'a, 'tcx, A> +impl<'tcx, A> dot::Labeller<'_> for Formatter<'_, 'tcx, A> where A: Analysis<'tcx>, A::Domain: DebugWithContext, @@ -100,7 +100,7 @@ where } } -impl dot::GraphWalk<'a> for Formatter<'a, 'tcx, A> +impl<'a, 'tcx, A> dot::GraphWalk<'a> for Formatter<'a, 'tcx, A> where A: Analysis<'tcx>, { @@ -138,7 +138,7 @@ where style: OutputStyle, } -impl BlockFormatter<'a, 'tcx, A> +impl<'a, 'tcx, A> BlockFormatter<'a, 'tcx, A> where A: Analysis<'tcx>, A::Domain: DebugWithContext, @@ -491,7 +491,7 @@ where after: Vec, } -impl StateDiffCollector<'a, 'tcx, A> +impl<'a, 'tcx, A> StateDiffCollector<'a, 'tcx, A> where A: Analysis<'tcx>, A::Domain: DebugWithContext, @@ -514,7 +514,7 @@ where } } -impl ResultsVisitor<'a, 'tcx> for StateDiffCollector<'a, 'tcx, A> +impl<'a, 'tcx, A> ResultsVisitor<'a, 'tcx> for StateDiffCollector<'a, 'tcx, A> where A: Analysis<'tcx>, A::Domain: DebugWithContext, @@ -524,7 +524,7 @@ where fn visit_block_start( &mut self, state: &Self::FlowState, - _block_data: &'mir mir::BasicBlockData<'tcx>, + _block_data: &mir::BasicBlockData<'tcx>, _block: BasicBlock, ) { if A::Direction::is_forward() { @@ -535,7 +535,7 @@ where fn visit_block_end( &mut self, state: &Self::FlowState, - _block_data: &'mir mir::BasicBlockData<'tcx>, + _block_data: &mir::BasicBlockData<'tcx>, _block: BasicBlock, ) { if A::Direction::is_backward() { @@ -546,7 +546,7 @@ where fn visit_statement_before_primary_effect( &mut self, state: &Self::FlowState, - _statement: &'mir mir::Statement<'tcx>, + _statement: &mir::Statement<'tcx>, _location: Location, ) { if let Some(before) = self.before.as_mut() { @@ -558,7 +558,7 @@ where fn visit_statement_after_primary_effect( &mut self, state: &Self::FlowState, - _statement: &'mir mir::Statement<'tcx>, + _statement: &mir::Statement<'tcx>, _location: Location, ) { self.after.push(diff_pretty(state, &self.prev_state, self.analysis)); @@ -568,7 +568,7 @@ where fn visit_terminator_before_primary_effect( &mut self, state: &Self::FlowState, - _terminator: &'mir mir::Terminator<'tcx>, + _terminator: &mir::Terminator<'tcx>, _location: Location, ) { if let Some(before) = self.before.as_mut() { @@ -580,7 +580,7 @@ where fn visit_terminator_after_primary_effect( &mut self, state: &Self::FlowState, - _terminator: &'mir mir::Terminator<'tcx>, + _terminator: &mir::Terminator<'tcx>, _location: Location, ) { self.after.push(diff_pretty(state, &self.prev_state, self.analysis)); diff --git a/compiler/rustc_mir_dataflow/src/framework/mod.rs b/compiler/rustc_mir_dataflow/src/framework/mod.rs index 500fba8b1142c..dac6720a6e543 100644 --- a/compiler/rustc_mir_dataflow/src/framework/mod.rs +++ b/compiler/rustc_mir_dataflow/src/framework/mod.rs @@ -214,7 +214,11 @@ pub trait Analysis<'tcx>: AnalysisDomain<'tcx> { /// .iterate_to_fixpoint() /// .into_results_cursor(body); /// ``` - fn into_engine(self, tcx: TyCtxt<'tcx>, body: &'mir mir::Body<'tcx>) -> Engine<'mir, 'tcx, Self> + fn into_engine<'mir>( + self, + tcx: TyCtxt<'tcx>, + body: &'mir mir::Body<'tcx>, + ) -> Engine<'mir, 'tcx, Self> where Self: Sized, { @@ -296,7 +300,7 @@ pub trait GenKillAnalysis<'tcx>: Analysis<'tcx> { } } -impl Analysis<'tcx> for A +impl<'tcx, A> Analysis<'tcx> for A where A: GenKillAnalysis<'tcx>, A::Domain: GenKill + BorrowMut>, @@ -368,7 +372,11 @@ where /* Extension methods */ - fn into_engine(self, tcx: TyCtxt<'tcx>, body: &'mir mir::Body<'tcx>) -> Engine<'mir, 'tcx, Self> + fn into_engine<'mir>( + self, + tcx: TyCtxt<'tcx>, + body: &'mir mir::Body<'tcx>, + ) -> Engine<'mir, 'tcx, Self> where Self: Sized, { diff --git a/compiler/rustc_mir_dataflow/src/framework/tests.rs b/compiler/rustc_mir_dataflow/src/framework/tests.rs index 01ca8ca9258fb..3cc8d30259c0e 100644 --- a/compiler/rustc_mir_dataflow/src/framework/tests.rs +++ b/compiler/rustc_mir_dataflow/src/framework/tests.rs @@ -85,7 +85,7 @@ struct MockAnalysis<'tcx, D> { dir: PhantomData, } -impl MockAnalysis<'tcx, D> { +impl MockAnalysis<'_, D> { const BASIC_BLOCK_OFFSET: usize = 100; /// The entry set for each `BasicBlock` is the ID of that block offset by a fixed amount to @@ -160,7 +160,7 @@ impl MockAnalysis<'tcx, D> { } } -impl AnalysisDomain<'tcx> for MockAnalysis<'tcx, D> { +impl<'tcx, D: Direction> AnalysisDomain<'tcx> for MockAnalysis<'tcx, D> { type Domain = BitSet; type Direction = D; @@ -175,7 +175,7 @@ impl AnalysisDomain<'tcx> for MockAnalysis<'tcx, D> { } } -impl Analysis<'tcx> for MockAnalysis<'tcx, D> { +impl<'tcx, D: Direction> Analysis<'tcx> for MockAnalysis<'tcx, D> { fn apply_statement_effect( &self, state: &mut Self::Domain, @@ -260,7 +260,7 @@ impl SeekTarget { } } -fn test_cursor(analysis: MockAnalysis<'tcx, D>) { +fn test_cursor(analysis: MockAnalysis<'_, D>) { let body = analysis.body; let mut cursor = diff --git a/compiler/rustc_mir_dataflow/src/framework/visitor.rs b/compiler/rustc_mir_dataflow/src/framework/visitor.rs index 84136c4d78cf1..75b4e150a8a33 100644 --- a/compiler/rustc_mir_dataflow/src/framework/visitor.rs +++ b/compiler/rustc_mir_dataflow/src/framework/visitor.rs @@ -4,7 +4,7 @@ use super::{Analysis, Direction, Results}; /// Calls the corresponding method in `ResultsVisitor` for every location in a `mir::Body` with the /// dataflow state at that location. -pub fn visit_results( +pub fn visit_results<'mir, 'tcx, F, V>( body: &'mir mir::Body<'tcx>, blocks: impl IntoIterator, results: &V, diff --git a/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs b/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs index 6df2c8df3cea0..bb9755e4f48dd 100644 --- a/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs +++ b/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs @@ -45,7 +45,7 @@ impl MaybeBorrowedLocals { } } -impl AnalysisDomain<'tcx> for MaybeBorrowedLocals { +impl<'tcx> AnalysisDomain<'tcx> for MaybeBorrowedLocals { type Domain = BitSet; const NAME: &'static str = "maybe_borrowed_locals"; @@ -59,7 +59,7 @@ impl AnalysisDomain<'tcx> for MaybeBorrowedLocals { } } -impl GenKillAnalysis<'tcx> for MaybeBorrowedLocals { +impl<'tcx> GenKillAnalysis<'tcx> for MaybeBorrowedLocals { type Idx = Local; fn statement_effect( @@ -95,7 +95,7 @@ struct TransferFunction<'a, T> { ignore_borrow_on_drop: bool, } -impl Visitor<'tcx> for TransferFunction<'a, T> +impl<'tcx, T> Visitor<'tcx> for TransferFunction<'_, T> where T: GenKill, { diff --git a/compiler/rustc_mir_dataflow/src/impls/init_locals.rs b/compiler/rustc_mir_dataflow/src/impls/init_locals.rs index df13b5c33940a..b355871d64f6f 100644 --- a/compiler/rustc_mir_dataflow/src/impls/init_locals.rs +++ b/compiler/rustc_mir_dataflow/src/impls/init_locals.rs @@ -10,7 +10,7 @@ use rustc_middle::mir::{self, BasicBlock, Local, Location}; pub struct MaybeInitializedLocals; -impl crate::AnalysisDomain<'tcx> for MaybeInitializedLocals { +impl<'tcx> crate::AnalysisDomain<'tcx> for MaybeInitializedLocals { type Domain = BitSet; const NAME: &'static str = "maybe_init_locals"; @@ -28,7 +28,7 @@ impl crate::AnalysisDomain<'tcx> for MaybeInitializedLocals { } } -impl crate::GenKillAnalysis<'tcx> for MaybeInitializedLocals { +impl<'tcx> crate::GenKillAnalysis<'tcx> for MaybeInitializedLocals { type Idx = Local; fn statement_effect( @@ -73,7 +73,7 @@ struct TransferFunction<'a, T> { trans: &'a mut T, } -impl Visitor<'tcx> for TransferFunction<'a, T> +impl Visitor<'_> for TransferFunction<'_, T> where T: GenKill, { diff --git a/compiler/rustc_mir_dataflow/src/impls/liveness.rs b/compiler/rustc_mir_dataflow/src/impls/liveness.rs index 5be9df6c452a2..65c388f8124a3 100644 --- a/compiler/rustc_mir_dataflow/src/impls/liveness.rs +++ b/compiler/rustc_mir_dataflow/src/impls/liveness.rs @@ -48,12 +48,12 @@ use crate::{AnalysisDomain, Backward, CallReturnPlaces, GenKill, GenKillAnalysis pub struct MaybeLiveLocals; impl MaybeLiveLocals { - fn transfer_function(&self, trans: &'a mut T) -> TransferFunction<'a, T> { + fn transfer_function<'a, T>(&self, trans: &'a mut T) -> TransferFunction<'a, T> { TransferFunction(trans) } } -impl AnalysisDomain<'tcx> for MaybeLiveLocals { +impl<'tcx> AnalysisDomain<'tcx> for MaybeLiveLocals { type Domain = BitSet; type Direction = Backward; @@ -69,7 +69,7 @@ impl AnalysisDomain<'tcx> for MaybeLiveLocals { } } -impl GenKillAnalysis<'tcx> for MaybeLiveLocals { +impl<'tcx> GenKillAnalysis<'tcx> for MaybeLiveLocals { type Idx = Local; fn statement_effect( diff --git a/compiler/rustc_mir_dataflow/src/impls/mod.rs b/compiler/rustc_mir_dataflow/src/impls/mod.rs index 5659fd2dc7075..5dc8a003b4778 100644 --- a/compiler/rustc_mir_dataflow/src/impls/mod.rs +++ b/compiler/rustc_mir_dataflow/src/impls/mod.rs @@ -704,7 +704,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for EverInitializedPlaces<'_, 'tcx> { /// /// If the basic block matches this pattern, this function returns the place corresponding to the /// enum (`_1` in the example above) as well as the `AdtDef` of that enum. -fn switch_on_enum_discriminant( +fn switch_on_enum_discriminant<'mir, 'tcx>( tcx: TyCtxt<'tcx>, body: &'mir mir::Body<'tcx>, block: &'mir mir::BasicBlockData<'tcx>, diff --git a/compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs b/compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs index 108357abc0de0..896377f2bc307 100644 --- a/compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs +++ b/compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs @@ -17,7 +17,7 @@ impl MaybeStorageLive { } } -impl crate::AnalysisDomain<'tcx> for MaybeStorageLive { +impl<'tcx> crate::AnalysisDomain<'tcx> for MaybeStorageLive { type Domain = BitSet; const NAME: &'static str = "maybe_storage_live"; @@ -39,7 +39,7 @@ impl crate::AnalysisDomain<'tcx> for MaybeStorageLive { } } -impl crate::GenKillAnalysis<'tcx> for MaybeStorageLive { +impl<'tcx> crate::GenKillAnalysis<'tcx> for MaybeStorageLive { type Idx = Local; fn statement_effect( diff --git a/compiler/rustc_mir_dataflow/src/lib.rs b/compiler/rustc_mir_dataflow/src/lib.rs index 8fdd0a39f250a..6c2d1b85646b1 100644 --- a/compiler/rustc_mir_dataflow/src/lib.rs +++ b/compiler/rustc_mir_dataflow/src/lib.rs @@ -3,7 +3,6 @@ #![feature(box_patterns)] #![feature(box_syntax)] #![feature(exact_size_is_empty)] -#![feature(in_band_lifetimes)] #![feature(let_else)] #![feature(min_specialization)] #![feature(once_cell)] diff --git a/compiler/rustc_mir_dataflow/src/storage.rs b/compiler/rustc_mir_dataflow/src/storage.rs index 18b8ef557d671..218d4557215fb 100644 --- a/compiler/rustc_mir_dataflow/src/storage.rs +++ b/compiler/rustc_mir_dataflow/src/storage.rs @@ -11,7 +11,7 @@ use rustc_middle::mir::{self, Local}; pub struct AlwaysLiveLocals(BitSet); impl AlwaysLiveLocals { - pub fn new(body: &mir::Body<'tcx>) -> Self { + pub fn new(body: &mir::Body<'_>) -> Self { let mut always_live_locals = AlwaysLiveLocals(BitSet::new_filled(body.local_decls.len())); for block in body.basic_blocks() { From 78a3078c3fe6773ec955256f7eccbf688fb8b17e Mon Sep 17 00:00:00 2001 From: David CARLIER Date: Thu, 16 Dec 2021 21:32:53 +0000 Subject: [PATCH 04/10] Revert "socket ancillary data implementation for dragonflybsd." --- library/std/src/os/unix/net/ancillary.rs | 82 +----------------------- library/std/src/os/unix/net/datagram.rs | 14 ++-- library/std/src/sys/unix/net.rs | 4 +- 3 files changed, 8 insertions(+), 92 deletions(-) diff --git a/library/std/src/os/unix/net/ancillary.rs b/library/std/src/os/unix/net/ancillary.rs index a29008140f784..6e6f5212b4651 100644 --- a/library/std/src/os/unix/net/ancillary.rs +++ b/library/std/src/os/unix/net/ancillary.rs @@ -16,8 +16,6 @@ mod libc { pub use libc::c_int; pub struct ucred; pub struct cmsghdr; - #[cfg(target_os = "dragonfly")] - pub struct cmsgcred; pub type pid_t = i32; pub type gid_t = u32; pub type uid_t = u32; @@ -185,11 +183,6 @@ impl<'a, T> Iterator for AncillaryDataIter<'a, T> { #[derive(Clone)] pub struct SocketCred(libc::ucred); -#[cfg(target_os = "dragonfly")] -#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] -#[derive(Clone)] -pub struct SocketCred(libc::cmsgcred); - #[cfg(any(doc, target_os = "android", target_os = "linux",))] impl SocketCred { /// Create a Unix credential struct. @@ -241,57 +234,6 @@ impl SocketCred { } } -#[cfg(target_os = "dragonfly")] -impl SocketCred { - /// Create a Unix credential struct. - /// - /// PID, UID and GID is set to 0. - #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] - #[must_use] - pub fn new() -> SocketCred { - SocketCred(libc::cmsgcred { cmsgcred_pid: 0, cmsgcred_uid: 0, cmsgcred_gid: 0 }) - } - - /// Set the PID. - #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] - pub fn set_pid(&mut self, pid: libc::pid_t) { - self.0.cmsgcred_pid = pid; - } - - /// Get the current PID. - #[must_use] - #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] - pub fn get_pid(&self) -> libc::pid_t { - self.0.cmsgcred_pid - } - - /// Set the UID. - #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] - pub fn set_uid(&mut self, uid: libc::uid_t) { - self.0.cmsgcred_uid = uid; - } - - /// Get the current UID. - #[must_use] - #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] - pub fn get_uid(&self) -> libc::uid_t { - self.0.cmsgcred_uid - } - - /// Set the GID. - #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] - pub fn set_gid(&mut self, gid: libc::gid_t) { - self.0.cmsgcred_gid = gid; - } - - /// Get the current GID. - #[must_use] - #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] - pub fn get_gid(&self) -> libc::gid_t { - self.0.cmsgcred_gid - } -} - /// This control message contains file descriptors. /// /// The level is equal to `SOL_SOCKET` and the type is equal to `SCM_RIGHTS`. @@ -314,11 +256,7 @@ impl<'a> Iterator for ScmRights<'a> { #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] pub struct ScmCredentials<'a>(AncillaryDataIter<'a, libc::ucred>); -#[cfg(target_os = "dragonfly")] -#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] -pub struct ScmCredentials<'a>(AncillaryDataIter<'a, libc::cmsgcred>); - -#[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "dragonfly",))] +#[cfg(any(doc, target_os = "android", target_os = "linux",))] #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] impl<'a> Iterator for ScmCredentials<'a> { type Item = SocketCred; @@ -362,7 +300,7 @@ impl<'a> AncillaryData<'a> { /// # Safety /// /// `data` must contain a valid control message and the control message must be type of - /// `SOL_SOCKET` and level of `SCM_CREDENTIALS` or `SCM_CREDS`. + /// `SOL_SOCKET` and level of `SCM_CREDENTIALS` or `SCM_CREDENTIALS`. #[cfg(any(doc, target_os = "android", target_os = "linux",))] unsafe fn as_credentials(data: &'a [u8]) -> Self { let ancillary_data_iter = AncillaryDataIter::new(data); @@ -382,9 +320,6 @@ impl<'a> AncillaryData<'a> { libc::SCM_RIGHTS => Ok(AncillaryData::as_rights(data)), #[cfg(any(target_os = "android", target_os = "linux",))] libc::SCM_CREDENTIALS => Ok(AncillaryData::as_credentials(data)), - #[cfg(target_os = "dragonfly")] - libc::SCM_CREDS => Ok(AncillaryData::as_credentials(data)), - cmsg_type => { Err(AncillaryError::Unknown { cmsg_level: libc::SOL_SOCKET, cmsg_type }) } @@ -609,19 +544,6 @@ impl<'a> SocketAncillary<'a> { ) } - #[cfg(target_os = "dragonfly")] - #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] - pub fn add_creds(&mut self, creds: &[SocketCred]) -> bool { - self.truncated = false; - add_to_ancillary_data( - &mut self.buffer, - &mut self.length, - creds, - libc::SOL_SOCKET, - libc::SCM_CREDS, - ) - } - /// Clears the ancillary data, removing all values. /// /// # Example diff --git a/library/std/src/os/unix/net/datagram.rs b/library/std/src/os/unix/net/datagram.rs index f23f8f94a242f..a2caccc784917 100644 --- a/library/std/src/os/unix/net/datagram.rs +++ b/library/std/src/os/unix/net/datagram.rs @@ -854,14 +854,8 @@ impl UnixDatagram { /// /// # Examples /// - #[cfg_attr( - any(target_os = "android", target_os = "linux", target_os = "dragonfly"), - doc = "```no_run" - )] - #[cfg_attr( - not(any(target_os = "android", target_os = "linux", target_os = "dragonfly")), - doc = "```ignore" - )] + #[cfg_attr(any(target_os = "android", target_os = "linux"), doc = "```no_run")] + #[cfg_attr(not(any(target_os = "android", target_os = "linux")), doc = "```ignore")] /// #![feature(unix_socket_ancillary_data)] /// use std::os::unix::net::UnixDatagram; /// @@ -871,7 +865,7 @@ impl UnixDatagram { /// Ok(()) /// } /// ``` - #[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "dragonfly",))] + #[cfg(any(doc, target_os = "android", target_os = "linux",))] #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] pub fn set_passcred(&self, passcred: bool) -> io::Result<()> { self.0.set_passcred(passcred) @@ -883,7 +877,7 @@ impl UnixDatagram { /// Get the socket option `SO_PASSCRED`. /// /// [`set_passcred`]: UnixDatagram::set_passcred - #[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "dragonfly",))] + #[cfg(any(doc, target_os = "android", target_os = "linux",))] #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] pub fn passcred(&self) -> io::Result { self.0.passcred() diff --git a/library/std/src/sys/unix/net.rs b/library/std/src/sys/unix/net.rs index 15d0dbe07fe7e..a82a0172126d4 100644 --- a/library/std/src/sys/unix/net.rs +++ b/library/std/src/sys/unix/net.rs @@ -408,12 +408,12 @@ impl Socket { Ok(raw != 0) } - #[cfg(any(target_os = "android", target_os = "linux", target_os = "dragonfly",))] + #[cfg(any(target_os = "android", target_os = "linux",))] pub fn set_passcred(&self, passcred: bool) -> io::Result<()> { setsockopt(self, libc::SOL_SOCKET, libc::SO_PASSCRED, passcred as libc::c_int) } - #[cfg(any(target_os = "android", target_os = "linux", target_os = "dragonfly",))] + #[cfg(any(target_os = "android", target_os = "linux",))] pub fn passcred(&self) -> io::Result { let passcred: libc::c_int = getsockopt(self, libc::SOL_SOCKET, libc::SO_PASSCRED)?; Ok(passcred != 0) From 97bf7b934e740b8b94aaf0e75a17f995444e44b6 Mon Sep 17 00:00:00 2001 From: Lucas Kent Date: Sat, 4 Dec 2021 18:57:31 +1100 Subject: [PATCH 05/10] Improve suggestion to change struct field to &mut --- .../src/diagnostics/mutability_errors.rs | 39 +++++++------------ src/test/ui/did_you_mean/issue-38147-2.rs | 7 +++- src/test/ui/did_you_mean/issue-38147-2.stderr | 23 ++++++++--- src/test/ui/did_you_mean/issue-38147-3.stderr | 8 ++-- 4 files changed, 42 insertions(+), 35 deletions(-) diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs index 0434c1ba59a10..86e577fdf1dde 100644 --- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs +++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs @@ -229,15 +229,15 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { } => { err.span_label(span, format!("cannot {ACT}", ACT = act)); - if let Some((span, message)) = annotate_struct_field( + if let Some(span) = get_mut_span_in_struct_field( self.infcx.tcx, Place::ty_from(local, proj_base, self.body, self.infcx.tcx).ty, field, ) { - err.span_suggestion( + err.span_suggestion_verbose( span, "consider changing this to be mutable", - message, + "mut ".into(), Applicability::MaybeIncorrect, ); } @@ -1059,18 +1059,18 @@ fn is_closure_or_generator(ty: Ty<'_>) -> bool { ty.is_closure() || ty.is_generator() } -/// Adds a suggestion to a struct definition given a field access to a local. -/// This function expects the local to be a reference to a struct in order to produce a suggestion. +/// Given a field that needs to be mutuable, returns a span where the mut could go. +/// This function expects the local to be a reference to a struct in order to produce a span. /// /// ```text /// LL | s: &'a String -/// | ---------- use `&'a mut String` here to make mutable +/// | ^ returns a span pointing here /// ``` -fn annotate_struct_field<'tcx>( +fn get_mut_span_in_struct_field<'tcx>( tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, field: &mir::Field, -) -> Option<(Span, String)> { +) -> Option { // Expect our local to be a reference to a struct of some kind. if let ty::Ref(_, ty, _) = ty.kind() { if let ty::Adt(def, _) = ty.kind() { @@ -1081,25 +1081,12 @@ fn annotate_struct_field<'tcx>( // Now we're dealing with the actual struct that we're going to suggest a change to, // we can expect a field that is an immutable reference to a type. if let hir::Node::Field(field) = node { - if let hir::TyKind::Rptr( - lifetime, - hir::MutTy { mutbl: hir::Mutability::Not, ref ty }, - ) = field.ty.kind + if let hir::TyKind::Rptr(lifetime, hir::MutTy { mutbl: hir::Mutability::Not, .. }) = + field.ty.kind { - // Get the snippets in two parts - the named lifetime (if there is one) and - // type being referenced, that way we can reconstruct the snippet without loss - // of detail. - let type_snippet = tcx.sess.source_map().span_to_snippet(ty.span).ok()?; - let lifetime_snippet = if !lifetime.is_elided() { - format!("{} ", tcx.sess.source_map().span_to_snippet(lifetime.span).ok()?) - } else { - String::new() - }; - - return Some(( - field.ty.span, - format!("&{}mut {}", lifetime_snippet, &*type_snippet,), - )); + return Some( + lifetime.span.with_hi(lifetime.span.hi() + BytePos(1)).shrink_to_hi(), + ); } } } diff --git a/src/test/ui/did_you_mean/issue-38147-2.rs b/src/test/ui/did_you_mean/issue-38147-2.rs index fe2634d88abf4..154b149b72073 100644 --- a/src/test/ui/did_you_mean/issue-38147-2.rs +++ b/src/test/ui/did_you_mean/issue-38147-2.rs @@ -1,11 +1,16 @@ struct Bar<'a> { - s: &'a String + s: &'a String, + // use wonky spaces to ensure we are creating the span correctly + longer_name: & 'a Vec } impl<'a> Bar<'a> { fn f(&mut self) { self.s.push('x'); //~^ ERROR cannot borrow `*self.s` as mutable, as it is behind a `&` reference + + self.longer_name.push(13); + //~^ ERROR cannot borrow `*self.longer_name` as mutable, as it is behind a `&` reference } } diff --git a/src/test/ui/did_you_mean/issue-38147-2.stderr b/src/test/ui/did_you_mean/issue-38147-2.stderr index 8bf5c76977da5..5ff97eacc23e8 100644 --- a/src/test/ui/did_you_mean/issue-38147-2.stderr +++ b/src/test/ui/did_you_mean/issue-38147-2.stderr @@ -1,12 +1,25 @@ error[E0596]: cannot borrow `*self.s` as mutable, as it is behind a `&` reference - --> $DIR/issue-38147-2.rs:7:9 + --> $DIR/issue-38147-2.rs:9:9 | -LL | s: &'a String - | ---------- help: consider changing this to be mutable: `&'a mut String` -... LL | self.s.push('x'); | ^^^^^^^^^^^^^^^^ cannot borrow as mutable + | +help: consider changing this to be mutable + | +LL | s: &'a mut String, + | +++ + +error[E0596]: cannot borrow `*self.longer_name` as mutable, as it is behind a `&` reference + --> $DIR/issue-38147-2.rs:12:9 + | +LL | self.longer_name.push(13); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot borrow as mutable + | +help: consider changing this to be mutable + | +LL | longer_name: & 'a mut Vec + | +++ -error: aborting due to previous error +error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0596`. diff --git a/src/test/ui/did_you_mean/issue-38147-3.stderr b/src/test/ui/did_you_mean/issue-38147-3.stderr index 0e1e42261c42b..94ffe17f10116 100644 --- a/src/test/ui/did_you_mean/issue-38147-3.stderr +++ b/src/test/ui/did_you_mean/issue-38147-3.stderr @@ -1,11 +1,13 @@ error[E0596]: cannot borrow `*self.s` as mutable, as it is behind a `&` reference --> $DIR/issue-38147-3.rs:7:9 | -LL | s: &'a String - | ---------- help: consider changing this to be mutable: `&'a mut String` -... LL | self.s.push('x'); | ^^^^^^^^^^^^^^^^ cannot borrow as mutable + | +help: consider changing this to be mutable + | +LL | s: &'a mut String + | +++ error: aborting due to previous error From 9c83b56056860fe6efcb2dc8b731c8532f1e57b7 Mon Sep 17 00:00:00 2001 From: Dylan MacKenzie Date: Mon, 29 Nov 2021 19:06:44 -0800 Subject: [PATCH 06/10] Mark defaulted `PartialEq`/`PartialOrd` methods as const --- library/core/src/cmp.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs index 7456f886ea5d8..deed9901cc9e4 100644 --- a/library/core/src/cmp.rs +++ b/library/core/src/cmp.rs @@ -215,6 +215,7 @@ pub trait PartialEq { #[inline] #[must_use] #[stable(feature = "rust1", since = "1.0.0")] + #[default_method_body_is_const] fn ne(&self, other: &Rhs) -> bool { !self.eq(other) } @@ -1031,6 +1032,7 @@ pub trait PartialOrd: PartialEq { #[inline] #[must_use] #[stable(feature = "rust1", since = "1.0.0")] + #[default_method_body_is_const] fn lt(&self, other: &Rhs) -> bool { matches!(self.partial_cmp(other), Some(Less)) } @@ -1050,6 +1052,7 @@ pub trait PartialOrd: PartialEq { #[inline] #[must_use] #[stable(feature = "rust1", since = "1.0.0")] + #[default_method_body_is_const] fn le(&self, other: &Rhs) -> bool { // Pattern `Some(Less | Eq)` optimizes worse than negating `None | Some(Greater)`. // FIXME: The root cause was fixed upstream in LLVM with: @@ -1072,6 +1075,7 @@ pub trait PartialOrd: PartialEq { #[inline] #[must_use] #[stable(feature = "rust1", since = "1.0.0")] + #[default_method_body_is_const] fn gt(&self, other: &Rhs) -> bool { matches!(self.partial_cmp(other), Some(Greater)) } @@ -1091,6 +1095,7 @@ pub trait PartialOrd: PartialEq { #[inline] #[must_use] #[stable(feature = "rust1", since = "1.0.0")] + #[default_method_body_is_const] fn ge(&self, other: &Rhs) -> bool { matches!(self.partial_cmp(other), Some(Greater | Equal)) } From 1606335a93a2c0ab218ffc1c776ed7ddd9515520 Mon Sep 17 00:00:00 2001 From: Dylan MacKenzie Date: Wed, 1 Dec 2021 14:37:51 -0800 Subject: [PATCH 07/10] Test const impl of `cmp` traits --- library/core/tests/cmp.rs | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/library/core/tests/cmp.rs b/library/core/tests/cmp.rs index 11cf7add07ada..c9d29ed3a83f4 100644 --- a/library/core/tests/cmp.rs +++ b/library/core/tests/cmp.rs @@ -203,3 +203,31 @@ fn cmp_default() { assert!(Fool(false) != Fool(false)); assert_eq!(Fool(false), Fool(true)); } + +struct S(i32); + +impl const PartialEq for S { + fn eq(&self, other: &Self) -> bool { + self.0 == other.0 + } +} + +impl const PartialOrd for S { + fn partial_cmp(&self, other: &Self) -> Option { + let ret = match (self.0, other.0) { + (a, b) if a > b => Ordering::Greater, + (a, b) if a < b => Ordering::Less, + _ => Ordering::Equal, + }; + + Some(ret) + } +} + +const _: () = assert!(S(1) == S(1)); +const _: () = assert!(S(0) != S(1)); + +const _: () = assert!(S(1) <= S(1)); +const _: () = assert!(S(1) >= S(1)); +const _: () = assert!(S(0) < S(1)); +const _: () = assert!(S(1) > S(0)); From 20492870307feae4ca57acdca75bcc8ea06fe175 Mon Sep 17 00:00:00 2001 From: Dylan MacKenzie Date: Thu, 16 Dec 2021 22:11:17 -0800 Subject: [PATCH 08/10] Disable test on bootstrap compiler --- library/core/tests/cmp.rs | 45 ++++++++++++++++++++++----------------- 1 file changed, 25 insertions(+), 20 deletions(-) diff --git a/library/core/tests/cmp.rs b/library/core/tests/cmp.rs index c9d29ed3a83f4..58fee19ca7490 100644 --- a/library/core/tests/cmp.rs +++ b/library/core/tests/cmp.rs @@ -204,30 +204,35 @@ fn cmp_default() { assert_eq!(Fool(false), Fool(true)); } -struct S(i32); +#[cfg(not(bootstrap))] +mod const_cmp { + use super::*; -impl const PartialEq for S { - fn eq(&self, other: &Self) -> bool { - self.0 == other.0 + struct S(i32); + + impl const PartialEq for S { + fn eq(&self, other: &Self) -> bool { + self.0 == other.0 + } } -} -impl const PartialOrd for S { - fn partial_cmp(&self, other: &Self) -> Option { - let ret = match (self.0, other.0) { - (a, b) if a > b => Ordering::Greater, - (a, b) if a < b => Ordering::Less, - _ => Ordering::Equal, - }; + impl const PartialOrd for S { + fn partial_cmp(&self, other: &Self) -> Option { + let ret = match (self.0, other.0) { + (a, b) if a > b => Ordering::Greater, + (a, b) if a < b => Ordering::Less, + _ => Ordering::Equal, + }; - Some(ret) + Some(ret) + } } -} -const _: () = assert!(S(1) == S(1)); -const _: () = assert!(S(0) != S(1)); + const _: () = assert!(S(1) == S(1)); + const _: () = assert!(S(0) != S(1)); -const _: () = assert!(S(1) <= S(1)); -const _: () = assert!(S(1) >= S(1)); -const _: () = assert!(S(0) < S(1)); -const _: () = assert!(S(1) > S(0)); + const _: () = assert!(S(1) <= S(1)); + const _: () = assert!(S(1) >= S(1)); + const _: () = assert!(S(0) < S(1)); + const _: () = assert!(S(1) > S(0)); +} From b656384d8398ec03ce5c40056252f818d6c44761 Mon Sep 17 00:00:00 2001 From: Lucas Kent Date: Fri, 17 Dec 2021 20:08:36 +1100 Subject: [PATCH 09/10] Update stdlib to the 2021 edition --- library/std/Cargo.toml | 2 +- library/std/src/fs/tests.rs | 9 ++++----- library/std/src/process.rs | 1 - library/std/src/thread/tests.rs | 15 ++++++++------- src/tools/tidy/src/edition.rs | 6 ++++-- 5 files changed, 17 insertions(+), 16 deletions(-) diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml index b7a4512152521..232ccdf39d456 100644 --- a/library/std/Cargo.toml +++ b/library/std/Cargo.toml @@ -4,7 +4,7 @@ version = "0.0.0" license = "MIT OR Apache-2.0" repository = "https://github.com/rust-lang/rust.git" description = "The Rust Standard Library" -edition = "2018" +edition = "2021" [lib] crate-type = ["dylib", "rlib"] diff --git a/library/std/src/fs/tests.rs b/library/std/src/fs/tests.rs index 2293fb6b55812..749d51d4981c3 100644 --- a/library/std/src/fs/tests.rs +++ b/library/std/src/fs/tests.rs @@ -38,10 +38,9 @@ macro_rules! error { ($e:expr, $s:expr) => { match $e { Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s), - Err(ref err) => assert!( - err.raw_os_error() == Some($s), - format!("`{}` did not have a code of `{}`", err, $s) - ), + Err(ref err) => { + assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s) + } } }; } @@ -58,7 +57,7 @@ macro_rules! error_contains { match $e { Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s), Err(ref err) => { - assert!(err.to_string().contains($s), format!("`{}` did not contain `{}`", err, $s)) + assert!(err.to_string().contains($s), "`{}` did not contain `{}`", err, $s) } } }; diff --git a/library/std/src/process.rs b/library/std/src/process.rs index bf35d71bc4f05..e012594dd4648 100644 --- a/library/std/src/process.rs +++ b/library/std/src/process.rs @@ -1600,7 +1600,6 @@ impl ExitStatusError { /// ``` /// #![feature(exit_status_error)] /// # if cfg!(unix) { - /// use std::convert::TryFrom; /// use std::num::NonZeroI32; /// use std::process::Command; /// diff --git a/library/std/src/thread/tests.rs b/library/std/src/thread/tests.rs index ca0d88135a5d8..4f2c81731a335 100644 --- a/library/std/src/thread/tests.rs +++ b/library/std/src/thread/tests.rs @@ -1,6 +1,7 @@ use super::Builder; use crate::any::Any; use crate::mem; +use crate::panic::panic_any; use crate::result; use crate::sync::{ mpsc::{channel, Sender}, @@ -183,7 +184,7 @@ fn test_simple_newsched_spawn() { } #[test] -fn test_try_panic_message_static_str() { +fn test_try_panic_message_string_literal() { match thread::spawn(move || { panic!("static string"); }) @@ -199,9 +200,9 @@ fn test_try_panic_message_static_str() { } #[test] -fn test_try_panic_message_owned_str() { +fn test_try_panic_any_message_owned_str() { match thread::spawn(move || { - panic!("owned string".to_string()); + panic_any("owned string".to_string()); }) .join() { @@ -215,9 +216,9 @@ fn test_try_panic_message_owned_str() { } #[test] -fn test_try_panic_message_any() { +fn test_try_panic_any_message_any() { match thread::spawn(move || { - panic!(box 413u16 as Box); + panic_any(box 413u16 as Box); }) .join() { @@ -233,10 +234,10 @@ fn test_try_panic_message_any() { } #[test] -fn test_try_panic_message_unit_struct() { +fn test_try_panic_any_message_unit_struct() { struct Juju; - match thread::spawn(move || panic!(Juju)).join() { + match thread::spawn(move || panic_any(Juju)).join() { Err(ref e) if e.is::() => {} Err(_) | Ok(()) => panic!(), } diff --git a/src/tools/tidy/src/edition.rs b/src/tools/tidy/src/edition.rs index 3f59fefd041eb..f610dbd806aea 100644 --- a/src/tools/tidy/src/edition.rs +++ b/src/tools/tidy/src/edition.rs @@ -23,8 +23,10 @@ pub fn check(path: &Path, bad: &mut bool) { return; } - // Library crates are not yet ready to migrate to 2021. - if path.components().any(|c| c.as_os_str() == "library") { + // Not all library crates are ready to migrate to 2021. + if file.components().any(|c| c.as_os_str() == "library") + && file.components().all(|c| c.as_os_str() != "std") + { let has = contents.lines().any(is_edition_2018); if !has { tidy_error!( From e57307560e7ac522b18f79fc7e98a808664f4059 Mon Sep 17 00:00:00 2001 From: Lucas Kent Date: Sat, 18 Dec 2021 12:57:55 +1100 Subject: [PATCH 10/10] get_mut_span_in_struct_field uses span.between --- .../src/diagnostics/mutability_errors.rs | 14 ++++++-------- src/test/ui/did_you_mean/issue-38147-2.stderr | 2 +- 2 files changed, 7 insertions(+), 9 deletions(-) diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs index 86e577fdf1dde..b5dad5ccdea8e 100644 --- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs +++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs @@ -237,7 +237,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { err.span_suggestion_verbose( span, "consider changing this to be mutable", - "mut ".into(), + " mut ".into(), Applicability::MaybeIncorrect, ); } @@ -1059,12 +1059,12 @@ fn is_closure_or_generator(ty: Ty<'_>) -> bool { ty.is_closure() || ty.is_generator() } -/// Given a field that needs to be mutuable, returns a span where the mut could go. +/// Given a field that needs to be mutable, returns a span where the " mut " could go. /// This function expects the local to be a reference to a struct in order to produce a span. /// /// ```text -/// LL | s: &'a String -/// | ^ returns a span pointing here +/// LL | s: &'a String +/// | ^^^ returns a span taking up the space here /// ``` fn get_mut_span_in_struct_field<'tcx>( tcx: TyCtxt<'tcx>, @@ -1081,12 +1081,10 @@ fn get_mut_span_in_struct_field<'tcx>( // Now we're dealing with the actual struct that we're going to suggest a change to, // we can expect a field that is an immutable reference to a type. if let hir::Node::Field(field) = node { - if let hir::TyKind::Rptr(lifetime, hir::MutTy { mutbl: hir::Mutability::Not, .. }) = + if let hir::TyKind::Rptr(lifetime, hir::MutTy { mutbl: hir::Mutability::Not, ty }) = field.ty.kind { - return Some( - lifetime.span.with_hi(lifetime.span.hi() + BytePos(1)).shrink_to_hi(), - ); + return Some(lifetime.span.between(ty.span)); } } } diff --git a/src/test/ui/did_you_mean/issue-38147-2.stderr b/src/test/ui/did_you_mean/issue-38147-2.stderr index 5ff97eacc23e8..7c287a7dbfa0d 100644 --- a/src/test/ui/did_you_mean/issue-38147-2.stderr +++ b/src/test/ui/did_you_mean/issue-38147-2.stderr @@ -17,7 +17,7 @@ LL | self.longer_name.push(13); | help: consider changing this to be mutable | -LL | longer_name: & 'a mut Vec +LL | longer_name: & 'a mut Vec | +++ error: aborting due to 2 previous errors