From e1f073692781c832b4880158515efda8b9e6f48b Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 5 Jun 2022 10:53:35 -0400 Subject: [PATCH 1/8] Allow ptr_from_addr_cast to fail --- compiler/rustc_const_eval/src/interpret/cast.rs | 2 +- compiler/rustc_const_eval/src/interpret/machine.rs | 11 ++++++----- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs index 73cc59ad1e674..fb484fba9fd06 100644 --- a/compiler/rustc_const_eval/src/interpret/cast.rs +++ b/compiler/rustc_const_eval/src/interpret/cast.rs @@ -221,7 +221,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { let addr = addr.to_machine_usize(self)?; // Then turn address into pointer. - let ptr = M::ptr_from_addr_cast(&self, addr); + let ptr = M::ptr_from_addr_cast(&self, addr)?; Ok(Scalar::from_maybe_pointer(ptr, self).into()) } diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs index 3572a9cc68174..5377535b9fa08 100644 --- a/compiler/rustc_const_eval/src/interpret/machine.rs +++ b/compiler/rustc_const_eval/src/interpret/machine.rs @@ -294,11 +294,10 @@ pub trait Machine<'mir, 'tcx>: Sized { fn ptr_from_addr_cast( ecx: &InterpCx<'mir, 'tcx, Self>, addr: u64, - ) -> Pointer>; + ) -> InterpResult<'tcx, Pointer>>; - // FIXME: Transmuting an integer to a pointer should just always return a `None` - // provenance, but that causes problems with function pointers in Miri. /// Hook for returning a pointer from a transmute-like operation on an addr. + /// This is only needed to support Miri's (unsound) "allow-ptr-int-transmute" flag. fn ptr_from_addr_transmute( ecx: &InterpCx<'mir, 'tcx, Self>, addr: u64, @@ -519,8 +518,10 @@ pub macro compile_time_machine(<$mir: lifetime, $tcx: lifetime>) { fn ptr_from_addr_cast( _ecx: &InterpCx<$mir, $tcx, Self>, addr: u64, - ) -> Pointer> { - Pointer::new(None, Size::from_bytes(addr)) + ) -> InterpResult<$tcx, Pointer>> { + // Allow these casts, but make the pointer not dereferenceable. + // (I.e., they behave like transmutation.) + Ok(Pointer::new(None, Size::from_bytes(addr))) } #[inline(always)] From fe533e862cd2d2d65e14970d327365dfe593aa27 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Tue, 7 Jun 2022 13:38:35 -0700 Subject: [PATCH 2/8] Specify DWARF alignment in bits, not bytes. In DWARF, alignment of types is specified in bits, as is made clear by the parameter name `AlignInBits`. However, `rustc` was incorrectly passing a byte alignment. This commit fixes that. This was noticed in upstream LLVM when I tried to check in a test consisting of LLVM IR generated from `rustc` and it triggered assertions [1]. [1]: https://reviews.llvm.org/D126835 --- compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs | 2 +- src/test/codegen/debug-alignment.rs | 8 ++++++++ 2 files changed, 9 insertions(+), 1 deletion(-) create mode 100644 src/test/codegen/debug-alignment.rs diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs index dd3adbf70a62f..f5cbbc7ca9198 100644 --- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs +++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs @@ -1365,7 +1365,7 @@ pub fn build_global_var_di_node<'ll>(cx: &CodegenCx<'ll, '_>, def_id: DefId, glo is_local_to_unit, global, None, - global_align.bytes() as u32, + global_align.bits() as u32, ); } } diff --git a/src/test/codegen/debug-alignment.rs b/src/test/codegen/debug-alignment.rs new file mode 100644 index 0000000000000..f6c1062e0fc6c --- /dev/null +++ b/src/test/codegen/debug-alignment.rs @@ -0,0 +1,8 @@ +// Verifies that DWARF alignment is specified properly. +// +// compile-flags: -C debuginfo=2 +#![crate_type = "lib"] + +// CHECK: !DIGlobalVariable +// CHECK: align: 32 +pub static A: u32 = 1; From a22aad32eb5999fbf77ad3ca1797db7bd1eaaf2d Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Fri, 20 May 2022 15:52:56 -0300 Subject: [PATCH 3/8] Instrument important fns in AST lowering --- compiler/rustc_ast_lowering/src/item.rs | 7 ++++--- compiler/rustc_ast_lowering/src/lib.rs | 15 +++++++++++++-- compiler/rustc_ast_lowering/src/path.rs | 2 +- 3 files changed, 18 insertions(+), 6 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index dab4d76857a50..d5ed9aa380f45 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -19,7 +19,6 @@ use rustc_span::symbol::{kw, sym, Ident}; use rustc_span::Span; use rustc_target::spec::abi; use smallvec::{smallvec, SmallVec}; -use tracing::debug; use std::iter; @@ -117,6 +116,7 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> { self.owners[def_id] } + #[instrument(level = "debug", skip(self, c))] fn lower_crate(&mut self, c: &Crate) { debug_assert_eq!(self.resolver.local_def_id(CRATE_NODE_ID), CRATE_DEF_ID); @@ -127,6 +127,7 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> { }) } + #[instrument(level = "debug", skip(self))] fn lower_item(&mut self, item: &Item) { self.with_lctx(item.id, |lctx| hir::OwnerNode::Item(lctx.lower_item(item))) } @@ -485,6 +486,7 @@ impl<'hir> LoweringContext<'_, 'hir> { (ty, self.lower_const_body(span, body)) } + #[instrument(level = "debug", skip(self))] fn lower_use_tree( &mut self, tree: &UseTree, @@ -494,8 +496,6 @@ impl<'hir> LoweringContext<'_, 'hir> { ident: &mut Ident, attrs: Option<&'hir [Attribute]>, ) -> hir::ItemKind<'hir> { - debug!("lower_use_tree(tree={:?})", tree); - let path = &tree.prefix; let segments = prefix.segments.iter().chain(path.segments.iter()).cloned().collect(); @@ -1298,6 +1298,7 @@ impl<'hir> LoweringContext<'_, 'hir> { /// Return the pair of the lowered `generics` as `hir::Generics` and the evaluation of `f` with /// the carried impl trait definitions and bounds. + #[instrument(level = "debug", skip(self, f))] fn lower_generics( &mut self, generics: &Generics, diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 51e5c3384a791..a8a115fe38f29 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -37,6 +37,9 @@ #![recursion_limit = "256"] #![allow(rustc::potential_query_instability)] +#[macro_use] +extern crate tracing; + use rustc_ast::visit; use rustc_ast::{self as ast, *}; use rustc_ast_pretty::pprust; @@ -63,7 +66,6 @@ use rustc_span::{Span, DUMMY_SP}; use smallvec::SmallVec; use std::collections::hash_map::Entry; -use tracing::{debug, trace}; macro_rules! arena_vec { ($this:expr; $($x:expr),*) => ( @@ -439,7 +441,7 @@ pub fn lower_crate<'a, 'hir>( arena.alloc(krate) } -#[derive(Copy, Clone, PartialEq)] +#[derive(Copy, Clone, PartialEq, Debug)] enum ParamMode { /// Any path in a type context. Explicit, @@ -455,6 +457,7 @@ enum ParenthesizedGenericArgs { } impl<'a, 'hir> LoweringContext<'a, 'hir> { + #[instrument(level = "debug", skip(self, f))] fn with_hir_id_owner( &mut self, owner: NodeId, @@ -599,12 +602,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { self.lower_node_id(node_id) } + #[instrument(level = "trace", skip(self))] fn lower_res(&mut self, res: Res) -> Res { let res: Result = res.apply_id(|id| { let owner = self.current_hir_id_owner; let local_id = self.node_id_to_local_id.get(&id).copied().ok_or(())?; Ok(hir::HirId { owner, local_id }) }); + trace!(?res); + // We may fail to find a HirId when the Res points to a Local from an enclosing HIR owner. // This can happen when trying to lower the return type `x` in erroneous code like // async fn foo(x: u8) -> x {} @@ -851,6 +857,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { /// ``` /// /// returns a `hir::TypeBinding` representing `Item`. + #[instrument(level = "debug", skip(self))] fn lower_assoc_ty_constraint( &mut self, constraint: &AssocConstraint, @@ -1011,6 +1018,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { err.emit(); } + #[instrument(level = "debug", skip(self))] fn lower_generic_arg( &mut self, arg: &ast::GenericArg, @@ -1081,6 +1089,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { } } + #[instrument(level = "debug", skip(self))] fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext) -> &'hir hir::Ty<'hir> { self.arena.alloc(self.lower_ty_direct(t, itctx)) } @@ -1737,6 +1746,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { ) } + #[instrument(level = "trace", skip(self))] fn lower_param_bound( &mut self, tpb: &GenericBound, @@ -1862,6 +1872,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { self.arena.alloc_from_iter(self.lower_generic_params_mut(params)) } + #[instrument(level = "trace", skip(self))] fn lower_generic_param(&mut self, param: &GenericParam) -> hir::GenericParam<'hir> { let (name, kind) = match param.kind { GenericParamKind::Lifetime => { diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs index d56974b773de6..ac63a075ac65f 100644 --- a/compiler/rustc_ast_lowering/src/path.rs +++ b/compiler/rustc_ast_lowering/src/path.rs @@ -15,6 +15,7 @@ use smallvec::smallvec; use tracing::debug; impl<'a, 'hir> LoweringContext<'a, 'hir> { + #[instrument(level = "trace", skip(self))] pub(crate) fn lower_qpath( &mut self, id: NodeId, @@ -23,7 +24,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { param_mode: ParamMode, itctx: ImplTraitContext, ) -> hir::QPath<'hir> { - debug!("lower_qpath(id: {:?}, qself: {:?}, p: {:?})", id, qself, p); let qself_position = qself.as_ref().map(|q| q.position); let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx)); From 1e6ed67d373f2bbf3c78e9fef8f9b6eed1edeb14 Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Fri, 20 May 2022 17:32:48 -0300 Subject: [PATCH 4/8] Extract lower_generic_param_kind --- compiler/rustc_ast_lowering/src/lib.rs | 31 ++++++++++++++++---------- 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index a8a115fe38f29..387eca51b57c8 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -1874,7 +1874,25 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { #[instrument(level = "trace", skip(self))] fn lower_generic_param(&mut self, param: &GenericParam) -> hir::GenericParam<'hir> { - let (name, kind) = match param.kind { + let (name, kind) = self.lower_generic_param_kind(param); + + let hir_id = self.lower_node_id(param.id); + self.lower_attrs(hir_id, ¶m.attrs); + hir::GenericParam { + hir_id, + name, + span: self.lower_span(param.span()), + pure_wrt_drop: self.sess.contains_name(¶m.attrs, sym::may_dangle), + kind, + colon_span: param.colon_span.map(|s| self.lower_span(s)), + } + } + + fn lower_generic_param_kind( + &mut self, + param: &GenericParam, + ) -> (hir::ParamName, hir::GenericParamKind<'hir>) { + match param.kind { GenericParamKind::Lifetime => { // AST resolution emitted an error on those parameters, so we lower them using // `ParamName::Error`. @@ -1908,17 +1926,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { hir::GenericParamKind::Const { ty, default }, ) } - }; - - let hir_id = self.lower_node_id(param.id); - self.lower_attrs(hir_id, ¶m.attrs); - hir::GenericParam { - hir_id, - name, - span: self.lower_span(param.span()), - pure_wrt_drop: self.sess.contains_name(¶m.attrs, sym::may_dangle), - kind, - colon_span: param.colon_span.map(|s| self.lower_span(s)), } } From b239611451e024f0323a7057e622564e72470f91 Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Fri, 20 May 2022 15:29:45 -0300 Subject: [PATCH 5/8] Pass origin down to impl_trait_ty_to_ty --- compiler/rustc_typeck/src/astconv/mod.rs | 24 +++++++++++------------- 1 file changed, 11 insertions(+), 13 deletions(-) diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs index b83fdd02da915..c766b217c461b 100644 --- a/compiler/rustc_typeck/src/astconv/mod.rs +++ b/compiler/rustc_typeck/src/astconv/mod.rs @@ -23,7 +23,7 @@ use rustc_hir::def::{CtorOf, DefKind, Namespace, Res}; use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::intravisit::{walk_generics, Visitor as _}; use rustc_hir::lang_items::LangItem; -use rustc_hir::{GenericArg, GenericArgs}; +use rustc_hir::{GenericArg, GenericArgs, OpaqueTyOrigin}; use rustc_middle::middle::stability::AllowUnstable; use rustc_middle::ty::subst::{self, GenericArgKind, InternalSubsts, Subst, SubstsRef}; use rustc_middle::ty::GenericParamDefKind; @@ -2628,16 +2628,9 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { let def_id = item_id.def_id.to_def_id(); match opaque_ty.kind { - hir::ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => self - .impl_trait_ty_to_ty( - def_id, - lifetimes, - matches!( - origin, - hir::OpaqueTyOrigin::FnReturn(..) - | hir::OpaqueTyOrigin::AsyncFn(..) - ), - ), + hir::ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => { + self.impl_trait_ty_to_ty(def_id, lifetimes, origin) + } ref i => bug!("`impl Trait` pointed to non-opaque type?? {:#?}", i), } } @@ -2706,7 +2699,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { &self, def_id: DefId, lifetimes: &[hir::GenericArg<'_>], - replace_parent_lifetimes: bool, + origin: OpaqueTyOrigin, ) -> Ty<'tcx> { debug!("impl_trait_ty_to_ty(def_id={:?}, lifetimes={:?})", def_id, lifetimes); let tcx = self.tcx(); @@ -2736,7 +2729,12 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { // For `impl Trait` in the types of statics, constants, // locals and type aliases. These capture all parent // lifetimes, so they can use their identity subst. - GenericParamDefKind::Lifetime if replace_parent_lifetimes => { + GenericParamDefKind::Lifetime + if matches!( + origin, + hir::OpaqueTyOrigin::FnReturn(..) | hir::OpaqueTyOrigin::AsyncFn(..) + ) => + { tcx.lifetimes.re_static.into() } _ => tcx.mk_param_from_def(param), From 4ae69f86179cb263b61621b8c4b9e90e861acb10 Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Tue, 7 Jun 2022 18:17:41 -0300 Subject: [PATCH 6/8] Extract lower_generic_and_bounds function --- compiler/rustc_ast_lowering/src/lib.rs | 79 +++++++++++++++----------- 1 file changed, 47 insertions(+), 32 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 387eca51b57c8..6d780b8448cc0 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -1221,41 +1221,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { ) } ImplTraitContext::Universal => { - // Add a definition for the in-band `Param`. - let def_id = self.resolver.local_def_id(def_node_id); - - let hir_bounds = - self.lower_param_bounds(bounds, ImplTraitContext::Universal); - // Set the name to `impl Bound1 + Bound2`. + let span = t.span; let ident = Ident::from_str_and_span(&pprust::ty_to_string(t), span); - let param = hir::GenericParam { - hir_id: self.lower_node_id(def_node_id), - name: ParamName::Plain(self.lower_ident(ident)), - pure_wrt_drop: false, - span: self.lower_span(span), - kind: hir::GenericParamKind::Type { default: None, synthetic: true }, - colon_span: None, - }; + let (param, bounds, path) = + self.lower_generic_and_bounds(def_node_id, span, ident, bounds); self.impl_trait_defs.push(param); - - if let Some(preds) = self.lower_generic_bound_predicate( - ident, - def_node_id, - &GenericParamKind::Type { default: None }, - hir_bounds, - hir::PredicateOrigin::ImplTrait, - ) { - self.impl_trait_bounds.push(preds) + if let Some(bounds) = bounds { + self.impl_trait_bounds.push(bounds); } - - hir::TyKind::Path(hir::QPath::Resolved( - None, - self.arena.alloc(hir::Path { - span: self.lower_span(span), - res: Res::Def(DefKind::TyParam, def_id.to_def_id()), - segments: arena_vec![self; hir::PathSegment::from_ident(self.lower_ident(ident))], - }), - )) + path } ImplTraitContext::Disallowed(position) => { let mut err = struct_span_err!( @@ -1972,6 +1946,47 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { bounds.iter().map(move |bound| self.lower_param_bound(bound, itctx)) } + fn lower_generic_and_bounds( + &mut self, + node_id: NodeId, + span: Span, + ident: Ident, + bounds: &[GenericBound], + ) -> (hir::GenericParam<'hir>, Option>, hir::TyKind<'hir>) { + // Add a definition for the in-band `Param`. + let def_id = self.resolver.local_def_id(node_id); + + let hir_bounds = self.lower_param_bounds(bounds, ImplTraitContext::Universal); + // Set the name to `impl Bound1 + Bound2`. + let param = hir::GenericParam { + hir_id: self.lower_node_id(node_id), + name: ParamName::Plain(self.lower_ident(ident)), + pure_wrt_drop: false, + span: self.lower_span(span), + kind: hir::GenericParamKind::Type { default: None, synthetic: true }, + colon_span: None, + }; + + let preds = self.lower_generic_bound_predicate( + ident, + node_id, + &GenericParamKind::Type { default: None }, + hir_bounds, + hir::PredicateOrigin::ImplTrait, + ); + + let ty = hir::TyKind::Path(hir::QPath::Resolved( + None, + self.arena.alloc(hir::Path { + span: self.lower_span(span), + res: Res::Def(DefKind::TyParam, def_id.to_def_id()), + segments: arena_vec![self; hir::PathSegment::from_ident(self.lower_ident(ident))], + }), + )); + + (param, preds, ty) + } + /// Lowers a block directly to an expression, presuming that it /// has no attributes and is not targeted by a `break`. fn lower_block_expr(&mut self, b: &Block) -> hir::Expr<'hir> { From 6ee7e35287e106b1ee9d276111692ebfc050ca81 Mon Sep 17 00:00:00 2001 From: lcnr Date: Wed, 8 Jun 2022 10:46:52 +0200 Subject: [PATCH 7/8] bye `BorrowckMode` --- compiler/rustc_session/src/config.rs | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs index 5190cd4493661..cabaf321f80c3 100644 --- a/compiler/rustc_session/src/config.rs +++ b/compiler/rustc_session/src/config.rs @@ -547,23 +547,6 @@ pub enum PrintRequest { LinkArgs, } -#[derive(Copy, Clone)] -pub enum BorrowckMode { - Mir, - Migrate, -} - -impl BorrowckMode { - /// Returns whether we should run the MIR-based borrow check, but also fall back - /// on the AST borrow check if the MIR-based one errors. - pub fn migrate(self) -> bool { - match self { - BorrowckMode::Mir => false, - BorrowckMode::Migrate => true, - } - } -} - pub enum Input { /// Load source code from a file. File(PathBuf), From 2b58e6314a85d2cb484122eee2a2ed73e3003221 Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Sun, 22 May 2022 21:29:54 +0900 Subject: [PATCH 8/8] Stabilize `const_intrinsic_copy` --- library/alloc/tests/lib.rs | 1 - library/core/src/intrinsics.rs | 8 ++++---- library/core/src/lib.rs | 1 - library/core/src/ptr/const_ptr.rs | 4 ++-- library/core/src/ptr/mod.rs | 4 ++-- library/core/src/ptr/mut_ptr.rs | 8 ++++---- library/core/tests/lib.rs | 1 - src/test/ui/consts/copy-intrinsic.rs | 6 +++--- src/test/ui/consts/intrinsic_without_const_stab.rs | 4 ++-- src/test/ui/consts/intrinsic_without_const_stab_fail.rs | 4 ++-- 10 files changed, 19 insertions(+), 22 deletions(-) diff --git a/library/alloc/tests/lib.rs b/library/alloc/tests/lib.rs index ffc7944ec7e1b..367cdcdcc061c 100644 --- a/library/alloc/tests/lib.rs +++ b/library/alloc/tests/lib.rs @@ -7,7 +7,6 @@ #![feature(const_convert)] #![feature(const_cow_is_borrowed)] #![feature(const_heap)] -#![feature(const_intrinsic_copy)] #![feature(const_mut_refs)] #![feature(const_nonnull_slice_from_raw_parts)] #![feature(const_ptr_write)] diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs index 0b76790c0097e..7c10ed65c4c4c 100644 --- a/library/core/src/intrinsics.rs +++ b/library/core/src/intrinsics.rs @@ -2118,11 +2118,11 @@ pub(crate) fn is_nonoverlapping(src: *const T, dst: *const T, count: usize) - /// [`Vec::append`]: ../../std/vec/struct.Vec.html#method.append #[doc(alias = "memcpy")] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] +#[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] #[inline] pub const unsafe fn copy_nonoverlapping(src: *const T, dst: *mut T, count: usize) { extern "rust-intrinsic" { - #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] + #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] pub fn copy_nonoverlapping(src: *const T, dst: *mut T, count: usize); } @@ -2200,11 +2200,11 @@ pub const unsafe fn copy_nonoverlapping(src: *const T, dst: *mut T, count: us /// ``` #[doc(alias = "memmove")] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] +#[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] #[inline] pub const unsafe fn copy(src: *const T, dst: *mut T, count: usize) { extern "rust-intrinsic" { - #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] + #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] fn copy(src: *const T, dst: *mut T, count: usize); } diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs index cfcc3ffb9c092..093c7d298734a 100644 --- a/library/core/src/lib.rs +++ b/library/core/src/lib.rs @@ -114,7 +114,6 @@ #![feature(const_convert)] #![feature(const_inherent_unchecked_arith)] #![feature(const_int_unchecked_arith)] -#![feature(const_intrinsic_copy)] #![feature(const_intrinsic_forget)] #![feature(const_likely)] #![feature(const_maybe_uninit_uninit_array)] diff --git a/library/core/src/ptr/const_ptr.rs b/library/core/src/ptr/const_ptr.rs index 490d7594bb82f..74aa0d9c7bcb2 100644 --- a/library/core/src/ptr/const_ptr.rs +++ b/library/core/src/ptr/const_ptr.rs @@ -1199,7 +1199,7 @@ impl *const T { /// See [`ptr::copy`] for safety concerns and examples. /// /// [`ptr::copy`]: crate::ptr::copy() - #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] + #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] #[stable(feature = "pointer_methods", since = "1.26.0")] #[inline] pub const unsafe fn copy_to(self, dest: *mut T, count: usize) @@ -1218,7 +1218,7 @@ impl *const T { /// See [`ptr::copy_nonoverlapping`] for safety concerns and examples. /// /// [`ptr::copy_nonoverlapping`]: crate::ptr::copy_nonoverlapping() - #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] + #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] #[stable(feature = "pointer_methods", since = "1.26.0")] #[inline] pub const unsafe fn copy_to_nonoverlapping(self, dest: *mut T, count: usize) diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs index a3b4e5886ef68..8fb0bfbe2e31b 100644 --- a/library/core/src/ptr/mod.rs +++ b/library/core/src/ptr/mod.rs @@ -1136,7 +1136,7 @@ pub const unsafe fn read(src: *const T) -> T { // We are calling the intrinsics directly to avoid function calls in the generated code // as `intrinsics::copy_nonoverlapping` is a wrapper function. extern "rust-intrinsic" { - #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] + #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] fn copy_nonoverlapping(src: *const T, dst: *mut T, count: usize); } @@ -1331,7 +1331,7 @@ pub const unsafe fn write(dst: *mut T, src: T) { // We are calling the intrinsics directly to avoid function calls in the generated code // as `intrinsics::copy_nonoverlapping` is a wrapper function. extern "rust-intrinsic" { - #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] + #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] fn copy_nonoverlapping(src: *const T, dst: *mut T, count: usize); } diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs index 5846c855e8f64..b988090f4bc4c 100644 --- a/library/core/src/ptr/mut_ptr.rs +++ b/library/core/src/ptr/mut_ptr.rs @@ -1311,7 +1311,7 @@ impl *mut T { /// See [`ptr::copy`] for safety concerns and examples. /// /// [`ptr::copy`]: crate::ptr::copy() - #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] + #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] #[stable(feature = "pointer_methods", since = "1.26.0")] #[inline(always)] pub const unsafe fn copy_to(self, dest: *mut T, count: usize) @@ -1330,7 +1330,7 @@ impl *mut T { /// See [`ptr::copy_nonoverlapping`] for safety concerns and examples. /// /// [`ptr::copy_nonoverlapping`]: crate::ptr::copy_nonoverlapping() - #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] + #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] #[stable(feature = "pointer_methods", since = "1.26.0")] #[inline(always)] pub const unsafe fn copy_to_nonoverlapping(self, dest: *mut T, count: usize) @@ -1349,7 +1349,7 @@ impl *mut T { /// See [`ptr::copy`] for safety concerns and examples. /// /// [`ptr::copy`]: crate::ptr::copy() - #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] + #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] #[stable(feature = "pointer_methods", since = "1.26.0")] #[inline(always)] pub const unsafe fn copy_from(self, src: *const T, count: usize) @@ -1368,7 +1368,7 @@ impl *mut T { /// See [`ptr::copy_nonoverlapping`] for safety concerns and examples. /// /// [`ptr::copy_nonoverlapping`]: crate::ptr::copy_nonoverlapping() - #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] + #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] #[stable(feature = "pointer_methods", since = "1.26.0")] #[inline(always)] pub const unsafe fn copy_from_nonoverlapping(self, src: *const T, count: usize) diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs index 9505ec31609f5..7e9d7d2710180 100644 --- a/library/core/tests/lib.rs +++ b/library/core/tests/lib.rs @@ -84,7 +84,6 @@ #![feature(const_option)] #![feature(const_option_ext)] #![feature(const_result)] -#![feature(const_intrinsic_copy)] #![feature(integer_atomics)] #![feature(int_roundings)] #![feature(slice_group_by)] diff --git a/src/test/ui/consts/copy-intrinsic.rs b/src/test/ui/consts/copy-intrinsic.rs index 5ab90324b8f86..249bbb5991cc9 100644 --- a/src/test/ui/consts/copy-intrinsic.rs +++ b/src/test/ui/consts/copy-intrinsic.rs @@ -2,14 +2,14 @@ // ignore-tidy-linelength #![feature(intrinsics, staged_api)] -#![feature(const_mut_refs, const_intrinsic_copy)] +#![feature(const_mut_refs)] use std::mem; extern "rust-intrinsic" { - #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] + #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] fn copy_nonoverlapping(src: *const T, dst: *mut T, count: usize); - #[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] + #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] fn copy(src: *const T, dst: *mut T, count: usize); } diff --git a/src/test/ui/consts/intrinsic_without_const_stab.rs b/src/test/ui/consts/intrinsic_without_const_stab.rs index d5f694986fc89..40ec65d51beec 100644 --- a/src/test/ui/consts/intrinsic_without_const_stab.rs +++ b/src/test/ui/consts/intrinsic_without_const_stab.rs @@ -1,8 +1,8 @@ -#![feature(intrinsics, staged_api, const_intrinsic_copy)] +#![feature(intrinsics, staged_api)] #![stable(feature = "core", since = "1.6.0")] #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] +#[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] #[inline] pub const unsafe fn copy(src: *const T, dst: *mut T, count: usize) { // Const stability attributes are not inherited from parent items. diff --git a/src/test/ui/consts/intrinsic_without_const_stab_fail.rs b/src/test/ui/consts/intrinsic_without_const_stab_fail.rs index 8b37268b0b205..2b0745b3c110c 100644 --- a/src/test/ui/consts/intrinsic_without_const_stab_fail.rs +++ b/src/test/ui/consts/intrinsic_without_const_stab_fail.rs @@ -1,4 +1,4 @@ -#![feature(intrinsics, staged_api, const_intrinsic_copy)] +#![feature(intrinsics, staged_api)] #![stable(feature = "core", since = "1.6.0")] extern "rust-intrinsic" { @@ -6,7 +6,7 @@ extern "rust-intrinsic" { } #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_const_unstable(feature = "const_intrinsic_copy", issue = "80697")] +#[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] #[inline] pub const unsafe fn stuff(src: *const T, dst: *mut T, count: usize) { unsafe { copy(src, dst, count) } //~ ERROR cannot call non-const fn