diff --git a/compiler/rustc_macros/src/type_foldable.rs b/compiler/rustc_macros/src/type_foldable.rs index 9f448a593da50..bc8213a18eacc 100644 --- a/compiler/rustc_macros/src/type_foldable.rs +++ b/compiler/rustc_macros/src/type_foldable.rs @@ -1,10 +1,15 @@ use quote::quote; +use syn::parse_quote; pub fn type_foldable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream { if let syn::Data::Union(_) = s.ast().data { panic!("cannot derive on union") } + if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") { + s.add_impl_generic(parse_quote! { 'tcx }); + } + s.add_bounds(synstructure::AddBounds::Generics); let body_visit = s.each(|bind| { quote! { diff --git a/compiler/rustc_middle/src/dep_graph/dep_node.rs b/compiler/rustc_middle/src/dep_graph/dep_node.rs index f310001077030..5c7cdbe4c2bdb 100644 --- a/compiler/rustc_middle/src/dep_graph/dep_node.rs +++ b/compiler/rustc_middle/src/dep_graph/dep_node.rs @@ -201,7 +201,7 @@ crate fn make_compile_codegen_unit(tcx: TyCtxt<'_>, name: Symbol) -> DepNode { // WARNING: `construct` is generic and does not know that `CompileMonoItem` takes `MonoItem`s as keys. // Be very careful changing this type signature! -crate fn make_compile_mono_item(tcx: TyCtxt<'tcx>, mono_item: &MonoItem<'tcx>) -> DepNode { +crate fn make_compile_mono_item<'tcx>(tcx: TyCtxt<'tcx>, mono_item: &MonoItem<'tcx>) -> DepNode { DepNode::construct(tcx, DepKind::CompileMonoItem, mono_item) } @@ -264,7 +264,7 @@ impl DepNodeExt for DepNode { /// DepNode. Condition (2) might not be fulfilled if a DepNode /// refers to something from the previous compilation session that /// has been removed. - fn extract_def_id(&self, tcx: TyCtxt<'tcx>) -> Option { + fn extract_def_id<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Option { if self.kind.fingerprint_style(tcx) == FingerprintStyle::DefPathHash { Some(tcx.def_path_hash_to_def_id(DefPathHash(self.hash.into()))) } else { diff --git a/compiler/rustc_middle/src/infer/canonical.rs b/compiler/rustc_middle/src/infer/canonical.rs index 14cff60475aa2..605fff671db06 100644 --- a/compiler/rustc_middle/src/infer/canonical.rs +++ b/compiler/rustc_middle/src/infer/canonical.rs @@ -75,7 +75,7 @@ pub struct OriginalQueryValues<'tcx> { pub var_values: SmallVec<[GenericArg<'tcx>; 8]>, } -impl Default for OriginalQueryValues<'tcx> { +impl<'tcx> Default for OriginalQueryValues<'tcx> { fn default() -> Self { let mut universe_map = SmallVec::default(); universe_map.push(ty::UniverseIndex::ROOT); diff --git a/compiler/rustc_middle/src/infer/unify_key.rs b/compiler/rustc_middle/src/infer/unify_key.rs index 0b05dd5c0ba6f..dcc49a5357248 100644 --- a/compiler/rustc_middle/src/infer/unify_key.rs +++ b/compiler/rustc_middle/src/infer/unify_key.rs @@ -164,7 +164,7 @@ impl<'tcx> UnifyValue for ConstVarValue<'tcx> { impl<'tcx> EqUnifyValue for &'tcx ty::Const<'tcx> {} -pub fn replace_if_possible( +pub fn replace_if_possible<'tcx, V, L>( table: &mut UnificationTable, V, L>>, c: &'tcx ty::Const<'tcx>, ) -> &'tcx ty::Const<'tcx> diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs index 8590a5c2e2d9e..e6dd4e484cc9c 100644 --- a/compiler/rustc_middle/src/lib.rs +++ b/compiler/rustc_middle/src/lib.rs @@ -44,7 +44,6 @@ #![feature(let_else)] #![feature(min_specialization)] #![feature(trusted_len)] -#![feature(in_band_lifetimes)] #![feature(crate_visibility_modifier)] #![feature(associated_type_bounds)] #![feature(rustc_attrs)] diff --git a/compiler/rustc_middle/src/lint.rs b/compiler/rustc_middle/src/lint.rs index 66857625e88af..eef10356ed25e 100644 --- a/compiler/rustc_middle/src/lint.rs +++ b/compiler/rustc_middle/src/lint.rs @@ -212,7 +212,7 @@ pub fn struct_lint_level<'s, 'd>( ) { // Avoid codegen bloat from monomorphization by immediately doing dyn dispatch of `decorate` to // the "real" work. - fn struct_lint_level_impl( + fn struct_lint_level_impl<'s, 'd>( sess: &'s Session, lint: &'static Lint, level: Level, diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs index acc8b92b97ac0..175d31d69d916 100644 --- a/compiler/rustc_middle/src/middle/stability.rs +++ b/compiler/rustc_middle/src/middle/stability.rs @@ -228,7 +228,7 @@ pub fn deprecation_message_and_lint( ) } -pub fn early_report_deprecation( +pub fn early_report_deprecation<'a>( lint_buffer: &'a mut LintBuffer, message: &str, suggestion: Option, diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs index 8e4a17bfa65cb..37ec2006172b6 100644 --- a/compiler/rustc_middle/src/mir/interpret/error.rs +++ b/compiler/rustc_middle/src/mir/interpret/error.rs @@ -63,7 +63,7 @@ impl fmt::Display for InterpErrorInfo<'_> { } } -impl InterpErrorInfo<'tcx> { +impl<'tcx> InterpErrorInfo<'tcx> { pub fn print_backtrace(&self) { if let Some(backtrace) = self.0.backtrace.as_ref() { print_backtrace(backtrace); diff --git a/compiler/rustc_middle/src/mir/interpret/mod.rs b/compiler/rustc_middle/src/mir/interpret/mod.rs index 4628c24292f02..b762a10da847a 100644 --- a/compiler/rustc_middle/src/mir/interpret/mod.rs +++ b/compiler/rustc_middle/src/mir/interpret/mod.rs @@ -145,7 +145,7 @@ pub struct GlobalId<'tcx> { pub promoted: Option, } -impl GlobalId<'tcx> { +impl<'tcx> GlobalId<'tcx> { pub fn display(self, tcx: TyCtxt<'tcx>) -> String { let instance_name = with_no_trimmed_paths(|| tcx.def_path_str(self.instance.def.def_id())); if let Some(promoted) = self.promoted { @@ -273,7 +273,7 @@ pub struct AllocDecodingSession<'s> { impl<'s> AllocDecodingSession<'s> { /// Decodes an `AllocId` in a thread-safe way. - pub fn decode_alloc_id(&self, decoder: &mut D) -> Result + pub fn decode_alloc_id<'tcx, D>(&self, decoder: &mut D) -> Result where D: TyDecoder<'tcx>, { @@ -390,7 +390,7 @@ pub enum GlobalAlloc<'tcx> { Memory(&'tcx Allocation), } -impl GlobalAlloc<'tcx> { +impl<'tcx> GlobalAlloc<'tcx> { /// Panics if the `GlobalAlloc` does not refer to an `GlobalAlloc::Memory` #[track_caller] #[inline] diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs index 0028f8a79466e..d2dd15aad1276 100644 --- a/compiler/rustc_middle/src/mir/mod.rs +++ b/compiler/rustc_middle/src/mir/mod.rs @@ -2033,7 +2033,7 @@ impl SourceScope { /// Finds the original HirId this MIR item came from. /// This is necessary after MIR optimizations, as otherwise we get a HirId /// from the function that was inlined instead of the function call site. - pub fn lint_root( + pub fn lint_root<'tcx>( self, source_scopes: &IndexVec>, ) -> Option { @@ -2543,7 +2543,7 @@ pub enum ConstantKind<'tcx> { Val(interpret::ConstValue<'tcx>, Ty<'tcx>), } -impl Constant<'tcx> { +impl<'tcx> Constant<'tcx> { pub fn check_static_ptr(&self, tcx: TyCtxt<'_>) -> Option { match self.literal.const_for_ty()?.val.try_to_scalar() { Some(Scalar::Ptr(ptr, _size)) => match tcx.global_alloc(ptr.provenance) { @@ -2562,14 +2562,14 @@ impl Constant<'tcx> { } } -impl From<&'tcx ty::Const<'tcx>> for ConstantKind<'tcx> { +impl<'tcx> From<&'tcx ty::Const<'tcx>> for ConstantKind<'tcx> { #[inline] fn from(ct: &'tcx ty::Const<'tcx>) -> Self { Self::Ty(ct) } } -impl ConstantKind<'tcx> { +impl<'tcx> ConstantKind<'tcx> { /// Returns `None` if the constant is not trivially safe for use in the type system. pub fn const_for_ty(&self) -> Option<&'tcx ty::Const<'tcx>> { match self { @@ -2851,7 +2851,7 @@ impl<'tcx> Display for ConstantKind<'tcx> { } } -fn pretty_print_const( +fn pretty_print_const<'tcx>( c: &ty::Const<'tcx>, fmt: &mut Formatter<'_>, print_types: bool, @@ -2866,7 +2866,7 @@ fn pretty_print_const( }) } -fn pretty_print_const_value( +fn pretty_print_const_value<'tcx>( val: interpret::ConstValue<'tcx>, ty: Ty<'tcx>, fmt: &mut Formatter<'_>, @@ -2913,12 +2913,12 @@ impl<'a, 'b> graph::GraphSuccessors<'b> for Body<'a> { type Iter = iter::Cloned>; } -impl graph::GraphPredecessors<'graph> for Body<'tcx> { +impl<'tcx, 'graph> graph::GraphPredecessors<'graph> for Body<'tcx> { type Item = BasicBlock; type Iter = std::iter::Copied>; } -impl graph::WithPredecessors for Body<'tcx> { +impl<'tcx> graph::WithPredecessors for Body<'tcx> { #[inline] fn predecessors(&self, node: Self::Node) -> >::Iter { self.predecessors()[node].iter().copied() diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs index facd7abbc9da1..fd8606e6929e2 100644 --- a/compiler/rustc_middle/src/mir/mono.rs +++ b/compiler/rustc_middle/src/mir/mono.rs @@ -431,7 +431,7 @@ pub struct CodegenUnitNameBuilder<'tcx> { cache: FxHashMap, } -impl CodegenUnitNameBuilder<'tcx> { +impl<'tcx> CodegenUnitNameBuilder<'tcx> { pub fn new(tcx: TyCtxt<'tcx>) -> Self { CodegenUnitNameBuilder { tcx, cache: Default::default() } } diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs index 8e1b887f87da7..8cc705384b03e 100644 --- a/compiler/rustc_middle/src/mir/pretty.rs +++ b/compiler/rustc_middle/src/mir/pretty.rs @@ -167,8 +167,8 @@ fn dump_matched_mir_node<'tcx, F>( /// Returns the file basename portion (without extension) of a filename path /// where we should dump a MIR representation output files. -fn dump_file_basename( - tcx: TyCtxt<'_>, +fn dump_file_basename<'tcx>( + tcx: TyCtxt<'tcx>, pass_num: Option<&dyn Display>, pass_name: &str, disambiguator: &dyn Display, @@ -251,8 +251,8 @@ fn create_dump_file_with_basename( /// bit of MIR-related data. Used by `mir-dump`, but also by other /// bits of code (e.g., NLL inference) that dump graphviz data or /// other things, and hence takes the extension as an argument. -pub fn create_dump_file( - tcx: TyCtxt<'_>, +pub fn create_dump_file<'tcx>( + tcx: TyCtxt<'tcx>, extension: &str, pass_num: Option<&dyn Display>, pass_name: &str, @@ -419,7 +419,7 @@ struct ExtraComments<'tcx> { comments: Vec, } -impl ExtraComments<'tcx> { +impl<'tcx> ExtraComments<'tcx> { fn push(&mut self, lines: &str) { for line in lines.split('\n') { self.comments.push(line.to_string()); @@ -427,7 +427,7 @@ impl ExtraComments<'tcx> { } } -fn use_verbose(ty: &&TyS<'tcx>, fn_def: bool) -> bool { +fn use_verbose<'tcx>(ty: &&TyS<'tcx>, fn_def: bool) -> bool { match ty.kind() { ty::Int(_) | ty::Uint(_) | ty::Bool | ty::Char | ty::Float(_) => false, // Unit type @@ -439,7 +439,7 @@ fn use_verbose(ty: &&TyS<'tcx>, fn_def: bool) -> bool { } } -impl Visitor<'tcx> for ExtraComments<'tcx> { +impl<'tcx> Visitor<'tcx> for ExtraComments<'tcx> { fn visit_constant(&mut self, constant: &Constant<'tcx>, location: Location) { self.super_constant(constant, location); let Constant { span, user_ty, literal } = constant; @@ -762,7 +762,7 @@ pub fn write_allocations<'tcx>( /// After the hex dump, an ascii dump follows, replacing all unprintable characters (control /// characters or characters whose value is larger than 127) with a `.` /// This also prints relocations adequately. -pub fn display_allocation( +pub fn display_allocation<'a, 'tcx, Tag, Extra>( tcx: TyCtxt<'tcx>, alloc: &'a Allocation, ) -> RenderAllocation<'a, 'tcx, Tag, Extra> { @@ -775,7 +775,9 @@ pub struct RenderAllocation<'a, 'tcx, Tag, Extra> { alloc: &'a Allocation, } -impl std::fmt::Display for RenderAllocation<'a, 'tcx, Tag, Extra> { +impl<'a, 'tcx, Tag: Provenance, Extra> std::fmt::Display + for RenderAllocation<'a, 'tcx, Tag, Extra> +{ fn fmt(&self, w: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let RenderAllocation { tcx, alloc } = *self; write!(w, "size: {}, align: {})", alloc.size().bytes(), alloc.align.bytes())?; @@ -818,7 +820,7 @@ fn write_allocation_newline( /// The `prefix` argument allows callers to add an arbitrary prefix before each line (even if there /// is only one line). Note that your prefix should contain a trailing space as the lines are /// printed directly after it. -fn write_allocation_bytes( +fn write_allocation_bytes<'tcx, Tag: Provenance, Extra>( tcx: TyCtxt<'tcx>, alloc: &Allocation, w: &mut dyn std::fmt::Write, diff --git a/compiler/rustc_middle/src/mir/traversal.rs b/compiler/rustc_middle/src/mir/traversal.rs index 725448584dd29..8c930fd161efb 100644 --- a/compiler/rustc_middle/src/mir/traversal.rs +++ b/compiler/rustc_middle/src/mir/traversal.rs @@ -300,7 +300,7 @@ pub fn reachable<'a, 'tcx>( } /// Returns a `BitSet` containing all basic blocks reachable from the `START_BLOCK`. -pub fn reachable_as_bitset(body: &Body<'tcx>) -> BitSet { +pub fn reachable_as_bitset<'tcx>(body: &Body<'tcx>) -> BitSet { let mut iter = preorder(body); (&mut iter).for_each(drop); iter.visited diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs index d783b6330e8e5..f301c68a7c091 100644 --- a/compiler/rustc_middle/src/mir/visit.rs +++ b/compiler/rustc_middle/src/mir/visit.rs @@ -965,7 +965,7 @@ macro_rules! visit_place_fns { } } - fn process_projection( + fn process_projection<'a>( &mut self, projection: &'a [PlaceElem<'tcx>], location: Location, diff --git a/compiler/rustc_middle/src/traits/mod.rs b/compiler/rustc_middle/src/traits/mod.rs index a5bd246712b8e..3e6a6b3ba4222 100644 --- a/compiler/rustc_middle/src/traits/mod.rs +++ b/compiler/rustc_middle/src/traits/mod.rs @@ -101,7 +101,7 @@ impl<'tcx> fmt::Debug for ObligationCause<'tcx> { } } -impl Deref for ObligationCause<'tcx> { +impl<'tcx> Deref for ObligationCause<'tcx> { type Target = ObligationCauseData<'tcx>; #[inline(always)] diff --git a/compiler/rustc_middle/src/traits/specialization_graph.rs b/compiler/rustc_middle/src/traits/specialization_graph.rs index ab47c2a7636f9..3e9cd6b46b211 100644 --- a/compiler/rustc_middle/src/traits/specialization_graph.rs +++ b/compiler/rustc_middle/src/traits/specialization_graph.rs @@ -216,7 +216,7 @@ impl<'tcx> Ancestors<'tcx> { /// /// Returns `Err` if an error was reported while building the specialization /// graph. -pub fn ancestors( +pub fn ancestors<'tcx>( tcx: TyCtxt<'tcx>, trait_def_id: DefId, start_from_impl: DefId, diff --git a/compiler/rustc_middle/src/traits/structural_impls.rs b/compiler/rustc_middle/src/traits/structural_impls.rs index 6032004e60776..aa2f37bd81ad8 100644 --- a/compiler/rustc_middle/src/traits/structural_impls.rs +++ b/compiler/rustc_middle/src/traits/structural_impls.rs @@ -74,7 +74,7 @@ impl fmt::Debug for traits::ImplSourceBuiltinData { } } -impl fmt::Debug for traits::ImplSourceTraitUpcastingData<'tcx, N> { +impl<'tcx, N: fmt::Debug> fmt::Debug for traits::ImplSourceTraitUpcastingData<'tcx, N> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!( f, diff --git a/compiler/rustc_middle/src/ty/_match.rs b/compiler/rustc_middle/src/ty/_match.rs index 02ff1b9f4d655..e0e3febe6b310 100644 --- a/compiler/rustc_middle/src/ty/_match.rs +++ b/compiler/rustc_middle/src/ty/_match.rs @@ -23,13 +23,13 @@ pub struct Match<'tcx> { param_env: ty::ParamEnv<'tcx>, } -impl Match<'tcx> { +impl<'tcx> Match<'tcx> { pub fn new(tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> Match<'tcx> { Match { tcx, param_env } } } -impl TypeRelation<'tcx> for Match<'tcx> { +impl<'tcx> TypeRelation<'tcx> for Match<'tcx> { fn tag(&self) -> &'static str { "Match" } diff --git a/compiler/rustc_middle/src/ty/adjustment.rs b/compiler/rustc_middle/src/ty/adjustment.rs index 8f648b2113145..2676b7ab521d8 100644 --- a/compiler/rustc_middle/src/ty/adjustment.rs +++ b/compiler/rustc_middle/src/ty/adjustment.rs @@ -83,7 +83,7 @@ pub struct Adjustment<'tcx> { pub target: Ty<'tcx>, } -impl Adjustment<'tcx> { +impl<'tcx> Adjustment<'tcx> { pub fn is_region_borrow(&self) -> bool { matches!(self.kind, Adjust::Borrow(AutoBorrow::Ref(..))) } diff --git a/compiler/rustc_middle/src/ty/assoc.rs b/compiler/rustc_middle/src/ty/assoc.rs index 5cb2b90fe1116..bf5a3e68250a0 100644 --- a/compiler/rustc_middle/src/ty/assoc.rs +++ b/compiler/rustc_middle/src/ty/assoc.rs @@ -139,7 +139,7 @@ impl<'tcx> AssocItems<'tcx> { /// Multiple items may have the same name if they are in different `Namespace`s. For example, /// an associated type can have the same name as a method. Use one of the `find_by_name_and_*` /// methods below if you know which item you are looking for. - pub fn filter_by_name( + pub fn filter_by_name<'a>( &'a self, tcx: TyCtxt<'a>, ident: Ident, diff --git a/compiler/rustc_middle/src/ty/closure.rs b/compiler/rustc_middle/src/ty/closure.rs index 4eacb3c4176c9..771acc2964913 100644 --- a/compiler/rustc_middle/src/ty/closure.rs +++ b/compiler/rustc_middle/src/ty/closure.rs @@ -156,7 +156,7 @@ pub struct CapturedPlace<'tcx> { pub mutability: hir::Mutability, } -impl CapturedPlace<'tcx> { +impl<'tcx> CapturedPlace<'tcx> { pub fn to_string(&self, tcx: TyCtxt<'tcx>) -> String { place_to_string_for_capture(tcx, &self.place) } @@ -328,7 +328,7 @@ pub struct CaptureInfo<'tcx> { pub capture_kind: UpvarCapture<'tcx>, } -pub fn place_to_string_for_capture(tcx: TyCtxt<'tcx>, place: &HirPlace<'tcx>) -> String { +pub fn place_to_string_for_capture<'tcx>(tcx: TyCtxt<'tcx>, place: &HirPlace<'tcx>) -> String { let mut curr_string: String = match place.base { HirPlaceBase::Upvar(upvar_id) => tcx.hir().name(upvar_id.var_path.hir_id).to_string(), _ => bug!("Capture_information should only contain upvars"), diff --git a/compiler/rustc_middle/src/ty/codec.rs b/compiler/rustc_middle/src/ty/codec.rs index 3f2b987b1e630..f7601a18790b2 100644 --- a/compiler/rustc_middle/src/ty/codec.rs +++ b/compiler/rustc_middle/src/ty/codec.rs @@ -76,7 +76,11 @@ pub trait RefDecodable<'tcx, D: TyDecoder<'tcx>> { } /// Encode the given value or a previously cached shorthand. -pub fn encode_with_shorthand(encoder: &mut E, value: &T, cache: M) -> Result<(), E::Error> +pub fn encode_with_shorthand<'tcx, E, T, M>( + encoder: &mut E, + value: &T, + cache: M, +) -> Result<(), E::Error> where E: TyEncoder<'tcx>, M: for<'b> Fn(&'b mut E) -> &'b mut FxHashMap, diff --git a/compiler/rustc_middle/src/ty/consts/int.rs b/compiler/rustc_middle/src/ty/consts/int.rs index 8262bc261996a..1f4ebd036766f 100644 --- a/compiler/rustc_middle/src/ty/consts/int.rs +++ b/compiler/rustc_middle/src/ty/consts/int.rs @@ -234,7 +234,7 @@ impl ScalarInt { } #[inline] - pub fn try_to_machine_usize(&self, tcx: TyCtxt<'tcx>) -> Result { + pub fn try_to_machine_usize<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Result { Ok(self.to_bits(tcx.data_layout.pointer_size)? as u64) } } diff --git a/compiler/rustc_middle/src/ty/consts/valtree.rs b/compiler/rustc_middle/src/ty/consts/valtree.rs index f1b78c876328d..fae22c28628f8 100644 --- a/compiler/rustc_middle/src/ty/consts/valtree.rs +++ b/compiler/rustc_middle/src/ty/consts/valtree.rs @@ -27,7 +27,7 @@ pub enum ValTree<'tcx> { Branch(&'tcx [ValTree<'tcx>]), } -impl ValTree<'tcx> { +impl<'tcx> ValTree<'tcx> { pub fn zst() -> Self { Self::Branch(&[]) } diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs index 0c31adebda092..e220003e445d6 100644 --- a/compiler/rustc_middle/src/ty/context.rs +++ b/compiler/rustc_middle/src/ty/context.rs @@ -824,7 +824,7 @@ pub struct CanonicalUserTypeAnnotation<'tcx> { /// Canonicalized user type annotation. pub type CanonicalUserType<'tcx> = Canonical<'tcx, UserType<'tcx>>; -impl CanonicalUserType<'tcx> { +impl<'tcx> CanonicalUserType<'tcx> { /// Returns `true` if this represents a substitution of the form `[?0, ?1, ?2]`, /// i.e., each thing is mapped to a canonical variable with the same index. pub fn is_identity(&self) -> bool { @@ -1893,7 +1893,7 @@ impl<'tcx> TyCtxt<'tcx> { pub fn debug_stats(self) -> impl std::fmt::Debug + 'tcx { struct DebugStats<'tcx>(TyCtxt<'tcx>); - impl std::fmt::Debug for DebugStats<'tcx> { + impl<'tcx> std::fmt::Debug for DebugStats<'tcx> { fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { sty_debug_print!( fmt, @@ -2711,7 +2711,7 @@ impl<'tcx> TyCtxt<'tcx> { } } -impl TyCtxtAt<'tcx> { +impl<'tcx> TyCtxtAt<'tcx> { /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` to ensure it gets used. #[track_caller] pub fn ty_error(self) -> Ty<'tcx> { diff --git a/compiler/rustc_middle/src/ty/erase_regions.rs b/compiler/rustc_middle/src/ty/erase_regions.rs index 63eb55ed1a620..0d290752e8fd8 100644 --- a/compiler/rustc_middle/src/ty/erase_regions.rs +++ b/compiler/rustc_middle/src/ty/erase_regions.rs @@ -37,7 +37,7 @@ struct RegionEraserVisitor<'tcx> { tcx: TyCtxt<'tcx>, } -impl TypeFolder<'tcx> for RegionEraserVisitor<'tcx> { +impl<'tcx> TypeFolder<'tcx> for RegionEraserVisitor<'tcx> { fn tcx<'b>(&'b self) -> TyCtxt<'tcx> { self.tcx } diff --git a/compiler/rustc_middle/src/ty/flags.rs b/compiler/rustc_middle/src/ty/flags.rs index a078b6fb742a7..617c522ac8197 100644 --- a/compiler/rustc_middle/src/ty/flags.rs +++ b/compiler/rustc_middle/src/ty/flags.rs @@ -22,7 +22,7 @@ impl FlagComputation { result } - pub fn for_predicate(binder: ty::Binder<'tcx, ty::PredicateKind<'_>>) -> FlagComputation { + pub fn for_predicate<'tcx>(binder: ty::Binder<'tcx, ty::PredicateKind<'_>>) -> FlagComputation { let mut result = FlagComputation::new(); result.add_predicate(binder); result @@ -216,7 +216,7 @@ impl FlagComputation { } } - fn add_predicate(&mut self, binder: ty::Binder<'tcx, ty::PredicateKind<'_>>) { + fn add_predicate(&mut self, binder: ty::Binder<'_, ty::PredicateKind<'_>>) { self.bound_computation(binder, |computation, atom| computation.add_predicate_atom(atom)); } @@ -310,7 +310,7 @@ impl FlagComputation { } } - fn add_unevaluated_const

(&mut self, ct: ty::Unevaluated<'tcx, P>) { + fn add_unevaluated_const

(&mut self, ct: ty::Unevaluated<'_, P>) { // The generic arguments of unevaluated consts are a bit special, // see the `rustc-dev-guide` for more information. // diff --git a/compiler/rustc_middle/src/ty/fold.rs b/compiler/rustc_middle/src/ty/fold.rs index aff485a413226..f5be8b21e8aca 100644 --- a/compiler/rustc_middle/src/ty/fold.rs +++ b/compiler/rustc_middle/src/ty/fold.rs @@ -199,7 +199,7 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone { } } -impl TypeFoldable<'tcx> for hir::Constness { +impl<'tcx> TypeFoldable<'tcx> for hir::Constness { fn try_super_fold_with>(self, _: &mut F) -> Result { Ok(self) } @@ -1060,13 +1060,13 @@ struct Shifter<'tcx> { amount: u32, } -impl Shifter<'tcx> { +impl<'tcx> Shifter<'tcx> { pub fn new(tcx: TyCtxt<'tcx>, amount: u32) -> Self { Shifter { tcx, current_index: ty::INNERMOST, amount } } } -impl TypeFolder<'tcx> for Shifter<'tcx> { +impl<'tcx> TypeFolder<'tcx> for Shifter<'tcx> { fn tcx<'b>(&'b self) -> TyCtxt<'tcx> { self.tcx } @@ -1257,7 +1257,7 @@ struct HasTypeFlagsVisitor<'tcx> { flags: ty::TypeFlags, } -impl std::fmt::Debug for HasTypeFlagsVisitor<'tcx> { +impl<'tcx> std::fmt::Debug for HasTypeFlagsVisitor<'tcx> { fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { self.flags.fmt(fmt) } @@ -1454,7 +1454,7 @@ struct LateBoundRegionsCollector<'tcx> { just_constrained: bool, } -impl LateBoundRegionsCollector<'tcx> { +impl<'tcx> LateBoundRegionsCollector<'tcx> { fn new(tcx: TyCtxt<'tcx>, just_constrained: bool) -> Self { LateBoundRegionsCollector { tcx, diff --git a/compiler/rustc_middle/src/ty/inhabitedness/def_id_forest.rs b/compiler/rustc_middle/src/ty/inhabitedness/def_id_forest.rs index 275384e227a90..f31c7dd743d82 100644 --- a/compiler/rustc_middle/src/ty/inhabitedness/def_id_forest.rs +++ b/compiler/rustc_middle/src/ty/inhabitedness/def_id_forest.rs @@ -30,7 +30,7 @@ pub enum DefIdForest { /// Tests whether a slice of roots contains a given DefId. #[inline] -fn slice_contains(tcx: TyCtxt<'tcx>, slice: &[DefId], id: DefId) -> bool { +fn slice_contains<'tcx>(tcx: TyCtxt<'tcx>, slice: &[DefId], id: DefId) -> bool { slice.iter().any(|root_id| tcx.is_descendant_of(id, *root_id)) } diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs index 2d30126273064..eaa7ee84b7b8d 100644 --- a/compiler/rustc_middle/src/ty/instance.rs +++ b/compiler/rustc_middle/src/ty/instance.rs @@ -635,7 +635,7 @@ fn polymorphize<'tcx>( tcx: TyCtxt<'tcx>, } - impl ty::TypeFolder<'tcx> for PolymorphizationFolder<'tcx> { + impl<'tcx> ty::TypeFolder<'tcx> for PolymorphizationFolder<'tcx> { fn tcx<'a>(&'a self) -> TyCtxt<'tcx> { self.tcx } diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs index 727c0ba63cbb6..7ec6d3f3b2b2d 100644 --- a/compiler/rustc_middle/src/ty/layout.rs +++ b/compiler/rustc_middle/src/ty/layout.rs @@ -168,7 +168,7 @@ impl PrimitiveExt for Primitive { /// Return an *integer* type matching this primitive. /// Useful in particular when dealing with enum discriminants. #[inline] - fn to_int_ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> { + fn to_int_ty<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> { match *self { Int(i, signed) => i.to_ty(tcx, signed), Pointer => tcx.types.usize, @@ -2195,9 +2195,9 @@ pub trait LayoutOf<'tcx>: LayoutOfHelpers<'tcx> { } } -impl> LayoutOf<'tcx> for C {} +impl<'tcx, C: LayoutOfHelpers<'tcx>> LayoutOf<'tcx> for C {} -impl LayoutOfHelpers<'tcx> for LayoutCx<'tcx, TyCtxt<'tcx>> { +impl<'tcx> LayoutOfHelpers<'tcx> for LayoutCx<'tcx, TyCtxt<'tcx>> { type LayoutOfResult = Result, LayoutError<'tcx>>; #[inline] @@ -2206,7 +2206,7 @@ impl LayoutOfHelpers<'tcx> for LayoutCx<'tcx, TyCtxt<'tcx>> { } } -impl LayoutOfHelpers<'tcx> for LayoutCx<'tcx, ty::query::TyCtxtAt<'tcx>> { +impl<'tcx> LayoutOfHelpers<'tcx> for LayoutCx<'tcx, ty::query::TyCtxtAt<'tcx>> { type LayoutOfResult = Result, LayoutError<'tcx>>; #[inline] @@ -2282,7 +2282,7 @@ where TyAndLayout(TyAndLayout<'tcx>), } - fn field_ty_or_layout( + fn field_ty_or_layout<'tcx>( this: TyAndLayout<'tcx>, cx: &(impl HasTyCtxt<'tcx> + HasParamEnv<'tcx>), i: usize, @@ -2724,7 +2724,7 @@ impl<'tcx> ty::Instance<'tcx> { /// with `-Cpanic=abort` will look like they can't unwind when in fact they /// might (from a foreign exception or similar). #[inline] -pub fn fn_can_unwind( +pub fn fn_can_unwind<'tcx>( tcx: TyCtxt<'tcx>, codegen_fn_attr_flags: CodegenFnAttrFlags, abi: SpecAbi, @@ -2842,7 +2842,7 @@ pub enum FnAbiError<'tcx> { AdjustForForeignAbi(call::AdjustForForeignAbiError), } -impl From> for FnAbiError<'tcx> { +impl<'tcx> From> for FnAbiError<'tcx> { fn from(err: LayoutError<'tcx>) -> Self { Self::Layout(err) } @@ -2942,7 +2942,7 @@ pub trait FnAbiOf<'tcx>: FnAbiOfHelpers<'tcx> { } } -impl> FnAbiOf<'tcx> for C {} +impl<'tcx, C: FnAbiOfHelpers<'tcx>> FnAbiOf<'tcx> for C {} fn fn_abi_of_fn_ptr<'tcx>( tcx: TyCtxt<'tcx>, diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs index 10232dc9cb60e..70203ff2fb4c2 100644 --- a/compiler/rustc_middle/src/ty/mod.rs +++ b/compiler/rustc_middle/src/ty/mod.rs @@ -852,7 +852,7 @@ pub trait ToPredicate<'tcx> { fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx>; } -impl ToPredicate<'tcx> for Binder<'tcx, PredicateKind<'tcx>> { +impl<'tcx> ToPredicate<'tcx> for Binder<'tcx, PredicateKind<'tcx>> { #[inline(always)] fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { tcx.mk_predicate(self) @@ -1418,7 +1418,7 @@ impl<'tcx> ParamEnv<'tcx> { // FIXME(ecstaticmorse): Audit all occurrences of `without_const().to_predicate(tcx)` to ensure that // the constness of trait bounds is being propagated correctly. -impl PolyTraitRef<'tcx> { +impl<'tcx> PolyTraitRef<'tcx> { #[inline] pub fn with_constness(self, constness: BoundConstness) -> PolyTraitPredicate<'tcx> { self.map_bound(|trait_ref| ty::TraitPredicate { diff --git a/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs b/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs index 312093b4f8859..84ab42a760b93 100644 --- a/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs +++ b/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs @@ -183,7 +183,7 @@ impl<'tcx> NormalizeAfterErasingRegionsFolder<'tcx> { } } -impl TypeFolder<'tcx> for NormalizeAfterErasingRegionsFolder<'tcx> { +impl<'tcx> TypeFolder<'tcx> for NormalizeAfterErasingRegionsFolder<'tcx> { fn tcx(&self) -> TyCtxt<'tcx> { self.tcx } @@ -228,7 +228,7 @@ impl<'tcx> TryNormalizeAfterErasingRegionsFolder<'tcx> { } } -impl TypeFolder<'tcx> for TryNormalizeAfterErasingRegionsFolder<'tcx> { +impl<'tcx> TypeFolder<'tcx> for TryNormalizeAfterErasingRegionsFolder<'tcx> { type Error = NormalizationError<'tcx>; fn tcx(&self) -> TyCtxt<'tcx> { @@ -236,7 +236,7 @@ impl TypeFolder<'tcx> for TryNormalizeAfterErasingRegionsFolder<'tcx> { } } -impl FallibleTypeFolder<'tcx> for TryNormalizeAfterErasingRegionsFolder<'tcx> { +impl<'tcx> FallibleTypeFolder<'tcx> for TryNormalizeAfterErasingRegionsFolder<'tcx> { fn try_fold_ty(&mut self, ty: Ty<'tcx>) -> Result, Self::Error> { match self.try_normalize_generic_arg_after_erasing_regions(ty.into()) { Ok(t) => Ok(t.expect_ty()), diff --git a/compiler/rustc_middle/src/ty/print/mod.rs b/compiler/rustc_middle/src/ty/print/mod.rs index 308b4d2fefc71..94127a144dfef 100644 --- a/compiler/rustc_middle/src/ty/print/mod.rs +++ b/compiler/rustc_middle/src/ty/print/mod.rs @@ -37,7 +37,7 @@ pub trait Printer<'tcx>: Sized { type DynExistential; type Const; - fn tcx(&'a self) -> TyCtxt<'tcx>; + fn tcx<'a>(&'a self) -> TyCtxt<'tcx>; fn print_def_path( self, diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs index dfb73e99d461a..3faedf242860e 100644 --- a/compiler/rustc_middle/src/ty/print/pretty.rs +++ b/compiler/rustc_middle/src/ty/print/pretty.rs @@ -1513,7 +1513,7 @@ pub struct FmtPrinterData<'a, 'tcx, F> { pub name_resolver: Option Option>>, } -impl Deref for FmtPrinter<'a, 'tcx, F> { +impl<'a, 'tcx, F> Deref for FmtPrinter<'a, 'tcx, F> { type Target = FmtPrinterData<'a, 'tcx, F>; fn deref(&self) -> &Self::Target { &self.0 @@ -1526,7 +1526,7 @@ impl DerefMut for FmtPrinter<'_, '_, F> { } } -impl FmtPrinter<'a, 'tcx, F> { +impl<'a, 'tcx, F> FmtPrinter<'a, 'tcx, F> { pub fn new(tcx: TyCtxt<'tcx>, fmt: F, ns: Namespace) -> Self { FmtPrinter(Box::new(FmtPrinterData { tcx, @@ -1563,7 +1563,7 @@ fn guess_def_namespace(tcx: TyCtxt<'_>, def_id: DefId) -> Namespace { } } -impl TyCtxt<'t> { +impl<'t> TyCtxt<'t> { /// Returns a string identifying this `DefId`. This string is /// suitable for user output. pub fn def_path_str(self, def_id: DefId) -> String { @@ -1585,7 +1585,7 @@ impl fmt::Write for FmtPrinter<'_, '_, F> { } } -impl Printer<'tcx> for FmtPrinter<'_, 'tcx, F> { +impl<'tcx, F: fmt::Write> Printer<'tcx> for FmtPrinter<'_, 'tcx, F> { type Error = fmt::Error; type Path = Self; @@ -1594,7 +1594,7 @@ impl Printer<'tcx> for FmtPrinter<'_, 'tcx, F> { type DynExistential = Self; type Const = Self; - fn tcx(&'a self) -> TyCtxt<'tcx> { + fn tcx<'a>(&'a self) -> TyCtxt<'tcx> { self.tcx } @@ -1792,7 +1792,7 @@ impl Printer<'tcx> for FmtPrinter<'_, 'tcx, F> { } } -impl PrettyPrinter<'tcx> for FmtPrinter<'_, 'tcx, F> { +impl<'tcx, F: fmt::Write> PrettyPrinter<'tcx> for FmtPrinter<'_, 'tcx, F> { fn infer_ty_name(&self, id: ty::TyVid) -> Option { self.0.name_resolver.as_ref().and_then(|func| func(id)) } @@ -2058,7 +2058,7 @@ impl<'a, 'tcx> ty::TypeFolder<'tcx> for RegionFolder<'a, 'tcx> { // HACK(eddyb) limited to `FmtPrinter` because of `binder_depth`, // `region_index` and `used_region_names`. -impl FmtPrinter<'_, 'tcx, F> { +impl<'tcx, F: fmt::Write> FmtPrinter<'_, 'tcx, F> { pub fn name_all_regions( mut self, value: &ty::Binder<'tcx, T>, @@ -2312,7 +2312,8 @@ where macro_rules! forward_display_to_print { ($($ty:ty),+) => { - $(impl fmt::Display for $ty { + // Some of the $ty arguments may not actually use 'tcx + $(#[allow(unused_lifetimes)] impl<'tcx> fmt::Display for $ty { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { ty::tls::with(|tcx| { tcx.lift(*self) @@ -2360,7 +2361,7 @@ impl fmt::Display for ty::RegionKind { #[derive(Copy, Clone, TypeFoldable, Lift)] pub struct TraitRefPrintOnlyTraitPath<'tcx>(ty::TraitRef<'tcx>); -impl fmt::Debug for TraitRefPrintOnlyTraitPath<'tcx> { +impl<'tcx> fmt::Debug for TraitRefPrintOnlyTraitPath<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(self, f) } @@ -2372,13 +2373,13 @@ impl fmt::Debug for TraitRefPrintOnlyTraitPath<'tcx> { #[derive(Copy, Clone, TypeFoldable, Lift)] pub struct TraitRefPrintOnlyTraitName<'tcx>(ty::TraitRef<'tcx>); -impl fmt::Debug for TraitRefPrintOnlyTraitName<'tcx> { +impl<'tcx> fmt::Debug for TraitRefPrintOnlyTraitName<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(self, f) } } -impl ty::TraitRef<'tcx> { +impl<'tcx> ty::TraitRef<'tcx> { pub fn print_only_trait_path(self) -> TraitRefPrintOnlyTraitPath<'tcx> { TraitRefPrintOnlyTraitPath(self) } @@ -2388,7 +2389,7 @@ impl ty::TraitRef<'tcx> { } } -impl ty::Binder<'tcx, ty::TraitRef<'tcx>> { +impl<'tcx> ty::Binder<'tcx, ty::TraitRef<'tcx>> { pub fn print_only_trait_path(self) -> ty::Binder<'tcx, TraitRefPrintOnlyTraitPath<'tcx>> { self.map_bound(|tr| tr.print_only_trait_path()) } diff --git a/compiler/rustc_middle/src/ty/query.rs b/compiler/rustc_middle/src/ty/query.rs index f18517eee04c0..2f91503afdfaf 100644 --- a/compiler/rustc_middle/src/ty/query.rs +++ b/compiler/rustc_middle/src/ty/query.rs @@ -69,7 +69,7 @@ pub struct TyCtxtAt<'tcx> { pub span: Span, } -impl Deref for TyCtxtAt<'tcx> { +impl<'tcx> Deref for TyCtxtAt<'tcx> { type Target = TyCtxt<'tcx>; #[inline(always)] fn deref(&self) -> &Self::Target { @@ -82,7 +82,7 @@ pub struct TyCtxtEnsure<'tcx> { pub tcx: TyCtxt<'tcx>, } -impl TyCtxt<'tcx> { +impl<'tcx> TyCtxt<'tcx> { /// Returns a transparent wrapper for `TyCtxt`, which ensures queries /// are executed instead of just returning their results. #[inline(always)] @@ -207,7 +207,7 @@ macro_rules! define_callbacks { $($(#[$attr])* pub $name: QueryCacheStore>,)* } - impl TyCtxtEnsure<$tcx> { + impl<$tcx> TyCtxtEnsure<$tcx> { $($(#[$attr])* #[inline(always)] pub fn $name(self, key: query_helper_param_ty!($($K)*)) { @@ -225,7 +225,7 @@ macro_rules! define_callbacks { })* } - impl TyCtxt<$tcx> { + impl<$tcx> TyCtxt<$tcx> { $($(#[$attr])* #[inline(always)] #[must_use] @@ -235,7 +235,7 @@ macro_rules! define_callbacks { })* } - impl TyCtxtAt<$tcx> { + impl<$tcx> TyCtxtAt<$tcx> { $($(#[$attr])* #[inline(always)] pub fn $name(self, key: query_helper_param_ty!($($K)*)) -> query_stored::$name<$tcx> @@ -357,7 +357,7 @@ mod sealed { use sealed::IntoQueryParam; -impl TyCtxt<'tcx> { +impl<'tcx> TyCtxt<'tcx> { pub fn def_kind(self, def_id: impl IntoQueryParam) -> DefKind { let def_id = def_id.into_query_param(); self.opt_def_kind(def_id) @@ -365,7 +365,7 @@ impl TyCtxt<'tcx> { } } -impl TyCtxtAt<'tcx> { +impl<'tcx> TyCtxtAt<'tcx> { pub fn def_kind(self, def_id: impl IntoQueryParam) -> DefKind { let def_id = def_id.into_query_param(); self.opt_def_kind(def_id) diff --git a/compiler/rustc_middle/src/ty/relate.rs b/compiler/rustc_middle/src/ty/relate.rs index aaef137c7e0f8..905a5c47d2b3d 100644 --- a/compiler/rustc_middle/src/ty/relate.rs +++ b/compiler/rustc_middle/src/ty/relate.rs @@ -132,7 +132,7 @@ pub fn relate_type_and_mut<'tcx, R: TypeRelation<'tcx>>( } } -pub fn relate_substs>( +pub fn relate_substs<'tcx, R: TypeRelation<'tcx>>( relation: &mut R, variances: Option<&[ty::Variance]>, a_subst: SubstsRef<'tcx>, @@ -353,7 +353,7 @@ impl<'tcx> Relate<'tcx> for Ty<'tcx> { /// The main "type relation" routine. Note that this does not handle /// inference artifacts, so you should filter those out before calling /// it. -pub fn super_relate_tys>( +pub fn super_relate_tys<'tcx, R: TypeRelation<'tcx>>( relation: &mut R, a: Ty<'tcx>, b: Ty<'tcx>, @@ -526,7 +526,7 @@ pub fn super_relate_tys>( /// The main "const relation" routine. Note that this does not handle /// inference artifacts, so you should filter those out before calling /// it. -pub fn super_relate_consts>( +pub fn super_relate_consts<'tcx, R: TypeRelation<'tcx>>( relation: &mut R, a: &'tcx ty::Const<'tcx>, b: &'tcx ty::Const<'tcx>, @@ -599,7 +599,7 @@ pub fn super_relate_consts>( if is_match { Ok(a) } else { Err(TypeError::ConstMismatch(expected_found(relation, a, b))) } } -fn check_const_value_eq>( +fn check_const_value_eq<'tcx, R: TypeRelation<'tcx>>( relation: &mut R, a_val: ConstValue<'tcx>, b_val: ConstValue<'tcx>, @@ -832,7 +832,7 @@ impl<'tcx> Relate<'tcx> for ty::ProjectionPredicate<'tcx> { /////////////////////////////////////////////////////////////////////////// // Error handling -pub fn expected_found(relation: &mut R, a: T, b: T) -> ExpectedFound +pub fn expected_found<'tcx, R, T>(relation: &mut R, a: T, b: T) -> ExpectedFound where R: TypeRelation<'tcx>, { diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs index 28dc9767b782e..98b1a8b4d7631 100644 --- a/compiler/rustc_middle/src/ty/structural_impls.rs +++ b/compiler/rustc_middle/src/ty/structural_impls.rs @@ -47,19 +47,19 @@ impl fmt::Debug for ty::UpvarId { } } -impl fmt::Debug for ty::UpvarBorrow<'tcx> { +impl<'tcx> fmt::Debug for ty::UpvarBorrow<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "UpvarBorrow({:?}, {:?})", self.kind, self.region) } } -impl fmt::Debug for ty::ExistentialTraitRef<'tcx> { +impl<'tcx> fmt::Debug for ty::ExistentialTraitRef<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { with_no_trimmed_paths(|| fmt::Display::fmt(self, f)) } } -impl fmt::Debug for ty::adjustment::Adjustment<'tcx> { +impl<'tcx> fmt::Debug for ty::adjustment::Adjustment<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{:?} -> {}", self.kind, self.target) } @@ -111,7 +111,7 @@ impl fmt::Debug for ty::FreeRegion { } } -impl fmt::Debug for ty::FnSig<'tcx> { +impl<'tcx> fmt::Debug for ty::FnSig<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "({:?}; c_variadic: {})->{:?}", self.inputs(), self.c_variadic, self.output()) } @@ -129,13 +129,13 @@ impl fmt::Debug for ty::RegionVid { } } -impl fmt::Debug for ty::TraitRef<'tcx> { +impl<'tcx> fmt::Debug for ty::TraitRef<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { with_no_trimmed_paths(|| fmt::Display::fmt(self, f)) } } -impl fmt::Debug for Ty<'tcx> { +impl<'tcx> fmt::Debug for Ty<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { with_no_trimmed_paths(|| fmt::Display::fmt(self, f)) } @@ -153,7 +153,7 @@ impl fmt::Debug for ty::ParamConst { } } -impl fmt::Debug for ty::TraitPredicate<'tcx> { +impl<'tcx> fmt::Debug for ty::TraitPredicate<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if let ty::BoundConstness::ConstIfConst = self.constness { write!(f, "~const ")?; @@ -162,19 +162,19 @@ impl fmt::Debug for ty::TraitPredicate<'tcx> { } } -impl fmt::Debug for ty::ProjectionPredicate<'tcx> { +impl<'tcx> fmt::Debug for ty::ProjectionPredicate<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "ProjectionPredicate({:?}, {:?})", self.projection_ty, self.ty) } } -impl fmt::Debug for ty::Predicate<'tcx> { +impl<'tcx> fmt::Debug for ty::Predicate<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{:?}", self.kind()) } } -impl fmt::Debug for ty::PredicateKind<'tcx> { +impl<'tcx> fmt::Debug for ty::PredicateKind<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match *self { ty::PredicateKind::Trait(ref a) => a.fmt(f), diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs index 1c525fb55e1b5..8706661b25021 100644 --- a/compiler/rustc_middle/src/ty/sty.rs +++ b/compiler/rustc_middle/src/ty/sty.rs @@ -198,7 +198,7 @@ pub enum TyKind<'tcx> { Error(DelaySpanBugEmitted), } -impl TyKind<'tcx> { +impl<'tcx> TyKind<'tcx> { #[inline] pub fn is_primitive(&self) -> bool { matches!(self, Bool | Char | Int(_) | Uint(_) | Float(_)) diff --git a/compiler/rustc_middle/src/ty/subst.rs b/compiler/rustc_middle/src/ty/subst.rs index 8fddafaf6206a..a71181149149d 100644 --- a/compiler/rustc_middle/src/ty/subst.rs +++ b/compiler/rustc_middle/src/ty/subst.rs @@ -67,7 +67,7 @@ impl<'tcx> GenericArgKind<'tcx> { } } -impl fmt::Debug for GenericArg<'tcx> { +impl<'tcx> fmt::Debug for GenericArg<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self.unpack() { GenericArgKind::Lifetime(lt) => lt.fmt(f), diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs index ba9b2eae2c830..669065598f149 100644 --- a/compiler/rustc_middle/src/ty/util.rs +++ b/compiler/rustc_middle/src/ty/util.rs @@ -981,7 +981,7 @@ impl<'tcx> ExplicitSelf<'tcx> { /// Returns a list of types such that the given type needs drop if and only if /// *any* of the returned types need drop. Returns `Err(AlwaysRequiresDrop)` if /// this type always needs drop. -pub fn needs_drop_components( +pub fn needs_drop_components<'tcx>( ty: Ty<'tcx>, target_layout: &TargetDataLayout, ) -> Result; 2]>, AlwaysRequiresDrop> { @@ -1083,7 +1083,7 @@ pub struct AlwaysRequiresDrop; /// Normalizes all opaque types in the given value, replacing them /// with their underlying types. -pub fn normalize_opaque_types( +pub fn normalize_opaque_types<'tcx>( tcx: TyCtxt<'tcx>, val: &'tcx List>, ) -> &'tcx List> { diff --git a/compiler/rustc_middle/src/ty/walk.rs b/compiler/rustc_middle/src/ty/walk.rs index 73985cf31e0f9..ba5775fd77376 100644 --- a/compiler/rustc_middle/src/ty/walk.rs +++ b/compiler/rustc_middle/src/ty/walk.rs @@ -69,7 +69,7 @@ impl<'tcx> Iterator for TypeWalker<'tcx> { } } -impl GenericArg<'tcx> { +impl<'tcx> GenericArg<'tcx> { /// Iterator that walks `self` and any types reachable from /// `self`, in depth-first order. Note that just walks the types /// that appear in `self`, it does not descend into the fields of diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs index 50a8f0336728e..de5ff231d6171 100644 --- a/compiler/rustc_session/src/config.rs +++ b/compiler/rustc_session/src/config.rs @@ -880,7 +880,7 @@ fn default_configuration(sess: &Session) -> CrateConfig { ret.insert((sym::target_env, Some(Symbol::intern(env)))); ret.insert((sym::target_abi, Some(Symbol::intern(abi)))); ret.insert((sym::target_vendor, Some(Symbol::intern(vendor)))); - if sess.target.has_elf_tls { + if sess.target.has_thread_local { ret.insert((sym::target_thread_local, None)); } for (i, align) in [ diff --git a/compiler/rustc_target/src/spec/aarch64_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/aarch64_pc_windows_msvc.rs index 1369d9d079856..a9a0977e70285 100644 --- a/compiler/rustc_target/src/spec/aarch64_pc_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/aarch64_pc_windows_msvc.rs @@ -3,7 +3,6 @@ use crate::spec::Target; pub fn target() -> Target { let mut base = super::windows_msvc_base::opts(); base.max_atomic_width = Some(64); - base.has_elf_tls = true; base.features = "+neon,+fp-armv8".to_string(); Target { diff --git a/compiler/rustc_target/src/spec/aarch64_uwp_windows_msvc.rs b/compiler/rustc_target/src/spec/aarch64_uwp_windows_msvc.rs index e0a81df2b0dec..db4eb204e0b12 100644 --- a/compiler/rustc_target/src/spec/aarch64_uwp_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/aarch64_uwp_windows_msvc.rs @@ -3,7 +3,6 @@ use crate::spec::Target; pub fn target() -> Target { let mut base = super::windows_uwp_msvc_base::opts(); base.max_atomic_width = Some(64); - base.has_elf_tls = true; Target { llvm_target: "aarch64-pc-windows-msvc".to_string(), diff --git a/compiler/rustc_target/src/spec/android_base.rs b/compiler/rustc_target/src/spec/android_base.rs index 0f01a78c8c592..e982b3565b56c 100644 --- a/compiler/rustc_target/src/spec/android_base.rs +++ b/compiler/rustc_target/src/spec/android_base.rs @@ -11,7 +11,7 @@ pub fn opts() -> TargetOptions { .push("-Wl,--allow-multiple-definition".to_string()); base.dwarf_version = Some(2); base.position_independent_executables = true; - base.has_elf_tls = false; + base.has_thread_local = false; // This is for backward compatibility, see https://github.com/rust-lang/rust/issues/49867 // for context. (At that time, there was no `-C force-unwind-tables`, so the only solution // was to always emit `uwtable`). diff --git a/compiler/rustc_target/src/spec/apple_base.rs b/compiler/rustc_target/src/spec/apple_base.rs index db6aee59a5dd3..a4488f695f210 100644 --- a/compiler/rustc_target/src/spec/apple_base.rs +++ b/compiler/rustc_target/src/spec/apple_base.rs @@ -16,7 +16,7 @@ pub fn opts(os: &str) -> TargetOptions { // TLS is flagged as enabled if it looks to be supported. The architecture // only matters for default deployment target which is 11.0 for ARM64 and // 10.7 for everything else. - let has_elf_tls = macos_deployment_target("x86_64") >= (10, 7); + let has_thread_local = macos_deployment_target("x86_64") >= (10, 7); TargetOptions { os: os.to_string(), @@ -33,7 +33,7 @@ pub fn opts(os: &str) -> TargetOptions { has_rpath: true, dll_suffix: ".dylib".to_string(), archive_format: "darwin".to_string(), - has_elf_tls, + has_thread_local, abi_return_struct_as_int: true, emit_debug_gdb_scripts: false, eh_frame_header: false, diff --git a/compiler/rustc_target/src/spec/apple_sdk_base.rs b/compiler/rustc_target/src/spec/apple_sdk_base.rs index 39bc699eef04a..874e9b56aaa1e 100644 --- a/compiler/rustc_target/src/spec/apple_sdk_base.rs +++ b/compiler/rustc_target/src/spec/apple_sdk_base.rs @@ -53,7 +53,7 @@ pub fn opts(os: &str, arch: Arch) -> TargetOptions { dynamic_linking: false, executables: true, link_env_remove: link_env_remove(arch), - has_elf_tls: false, + has_thread_local: false, ..super::apple_base::opts(os) } } diff --git a/compiler/rustc_target/src/spec/fuchsia_base.rs b/compiler/rustc_target/src/spec/fuchsia_base.rs index 23a2e65749e11..4a7686ae1a1e4 100644 --- a/compiler/rustc_target/src/spec/fuchsia_base.rs +++ b/compiler/rustc_target/src/spec/fuchsia_base.rs @@ -35,7 +35,7 @@ pub fn opts() -> TargetOptions { (LinkOutputKind::StaticPicExe, &["Scrt1.o"]), ]), position_independent_executables: true, - has_elf_tls: true, + has_thread_local: true, ..Default::default() } } diff --git a/compiler/rustc_target/src/spec/hermit_base.rs b/compiler/rustc_target/src/spec/hermit_base.rs index 75ca1f79b12cc..b0b1d80ab37fc 100644 --- a/compiler/rustc_target/src/spec/hermit_base.rs +++ b/compiler/rustc_target/src/spec/hermit_base.rs @@ -12,7 +12,7 @@ pub fn opts() -> TargetOptions { linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld), linker: Some("rust-lld".to_owned()), executables: true, - has_elf_tls: true, + has_thread_local: true, pre_link_args, panic_strategy: PanicStrategy::Abort, position_independent_executables: true, diff --git a/compiler/rustc_target/src/spec/i686_uwp_windows_msvc.rs b/compiler/rustc_target/src/spec/i686_uwp_windows_msvc.rs index ce6200be81fd4..05f204c560446 100644 --- a/compiler/rustc_target/src/spec/i686_uwp_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/i686_uwp_windows_msvc.rs @@ -4,7 +4,6 @@ pub fn target() -> Target { let mut base = super::windows_uwp_msvc_base::opts(); base.cpu = "pentium4".to_string(); base.max_atomic_width = Some(64); - base.has_elf_tls = true; Target { llvm_target: "i686-pc-windows-msvc".to_string(), diff --git a/compiler/rustc_target/src/spec/illumos_base.rs b/compiler/rustc_target/src/spec/illumos_base.rs index f598f0f38f305..aeb40f7712ee3 100644 --- a/compiler/rustc_target/src/spec/illumos_base.rs +++ b/compiler/rustc_target/src/spec/illumos_base.rs @@ -45,7 +45,7 @@ pub fn opts() -> TargetOptions { // (see src/libstd/sys/unix/fast_thread_local.rs) that is currently // missing in illumos. For now at least, we must fallback to using // pthread_{get,set}specific. - //has_elf_tls: true, + //has_thread_local: true, // FIXME: Currently, rust is invoking cc to link, which ends up // causing these to get included twice. We should eventually transition diff --git a/compiler/rustc_target/src/spec/linux_base.rs b/compiler/rustc_target/src/spec/linux_base.rs index af81bc714c743..e53d465e20dfd 100644 --- a/compiler/rustc_target/src/spec/linux_base.rs +++ b/compiler/rustc_target/src/spec/linux_base.rs @@ -9,7 +9,7 @@ pub fn opts() -> TargetOptions { has_rpath: true, position_independent_executables: true, relro_level: RelroLevel::Full, - has_elf_tls: true, + has_thread_local: true, crt_static_respected: true, ..Default::default() } diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs index ece704d770003..43913183694e0 100644 --- a/compiler/rustc_target/src/spec/mod.rs +++ b/compiler/rustc_target/src/spec/mod.rs @@ -1279,9 +1279,8 @@ pub struct TargetOptions { /// `argc` and `argv` values. pub main_needs_argc_argv: bool, - /// Flag indicating whether ELF TLS (e.g., #[thread_local]) is available for - /// this target. - pub has_elf_tls: bool, + /// Flag indicating whether #[thread_local] is available for this target. + pub has_thread_local: bool, // This is mainly for easy compatibility with emscripten. // If we give emcc .o files that are actually .bc files it // will 'just work'. @@ -1487,7 +1486,7 @@ impl Default for TargetOptions { archive_format: "gnu".to_string(), main_needs_argc_argv: true, allow_asm: true, - has_elf_tls: false, + has_thread_local: false, obj_is_bitcode: false, forces_embed_bitcode: false, bitcode_llvm_cmdline: String::new(), @@ -2074,7 +2073,7 @@ impl Target { key!(archive_format); key!(allow_asm, bool); key!(main_needs_argc_argv, bool); - key!(has_elf_tls, bool); + key!(has_thread_local, bool); key!(obj_is_bitcode, bool); key!(forces_embed_bitcode, bool); key!(bitcode_llvm_cmdline); @@ -2315,7 +2314,7 @@ impl ToJson for Target { target_option_val!(archive_format); target_option_val!(allow_asm); target_option_val!(main_needs_argc_argv); - target_option_val!(has_elf_tls); + target_option_val!(has_thread_local); target_option_val!(obj_is_bitcode); target_option_val!(forces_embed_bitcode); target_option_val!(bitcode_llvm_cmdline); diff --git a/compiler/rustc_target/src/spec/redox_base.rs b/compiler/rustc_target/src/spec/redox_base.rs index fcf5db3746d24..bcb536b37a17e 100644 --- a/compiler/rustc_target/src/spec/redox_base.rs +++ b/compiler/rustc_target/src/spec/redox_base.rs @@ -10,7 +10,7 @@ pub fn opts() -> TargetOptions { has_rpath: true, position_independent_executables: true, relro_level: RelroLevel::Full, - has_elf_tls: true, + has_thread_local: true, crt_static_default: true, crt_static_respected: true, ..Default::default() diff --git a/compiler/rustc_target/src/spec/solid_base.rs b/compiler/rustc_target/src/spec/solid_base.rs index c6a279d92e839..421cfc401127d 100644 --- a/compiler/rustc_target/src/spec/solid_base.rs +++ b/compiler/rustc_target/src/spec/solid_base.rs @@ -6,7 +6,7 @@ pub fn opts(kernel: &str) -> TargetOptions { os: format!("solid_{}", kernel), vendor: "kmc".to_string(), frame_pointer: FramePointer::NonLeaf, - has_elf_tls: true, + has_thread_local: true, ..Default::default() } } diff --git a/compiler/rustc_target/src/spec/thumbv7a_uwp_windows_msvc.rs b/compiler/rustc_target/src/spec/thumbv7a_uwp_windows_msvc.rs index b44c008500521..72d39ef9a95ac 100644 --- a/compiler/rustc_target/src/spec/thumbv7a_uwp_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/thumbv7a_uwp_windows_msvc.rs @@ -9,7 +9,6 @@ pub fn target() -> Target { options: TargetOptions { features: "+vfp3,+neon".to_string(), max_atomic_width: Some(64), - has_elf_tls: true, // FIXME(jordanrh): use PanicStrategy::Unwind when SEH is // implemented for windows/arm in LLVM panic_strategy: PanicStrategy::Abort, diff --git a/compiler/rustc_target/src/spec/vxworks_base.rs b/compiler/rustc_target/src/spec/vxworks_base.rs index a91e771786554..3f709e7023469 100644 --- a/compiler/rustc_target/src/spec/vxworks_base.rs +++ b/compiler/rustc_target/src/spec/vxworks_base.rs @@ -11,7 +11,7 @@ pub fn opts() -> TargetOptions { executables: true, families: vec!["unix".to_string()], has_rpath: true, - has_elf_tls: true, + has_thread_local: true, crt_static_default: true, crt_static_respected: true, crt_static_allows_dylibs: true, diff --git a/compiler/rustc_target/src/spec/wasm_base.rs b/compiler/rustc_target/src/spec/wasm_base.rs index 24e9c62516999..71aa279144bb9 100644 --- a/compiler/rustc_target/src/spec/wasm_base.rs +++ b/compiler/rustc_target/src/spec/wasm_base.rs @@ -120,9 +120,9 @@ pub fn options() -> TargetOptions { // When the atomics feature is activated then these two keys matter, // otherwise they're basically ignored by the standard library. In this // mode, however, the `#[thread_local]` attribute works (i.e. - // `has_elf_tls`) and we need to get it to work by specifying + // `has_thread_local`) and we need to get it to work by specifying // `local-exec` as that's all that's implemented in LLVM today for wasm. - has_elf_tls: true, + has_thread_local: true, tls_model: TlsModel::LocalExec, // gdb scripts don't work on wasm blobs diff --git a/compiler/rustc_target/src/spec/windows_msvc_base.rs b/compiler/rustc_target/src/spec/windows_msvc_base.rs index 0d58618a449a9..063b6538d95ee 100644 --- a/compiler/rustc_target/src/spec/windows_msvc_base.rs +++ b/compiler/rustc_target/src/spec/windows_msvc_base.rs @@ -27,6 +27,7 @@ pub fn opts() -> TargetOptions { // linking some libraries which require a specific agreement, so it may // not ever be possible for us to pass this flag. no_default_libraries: false, + has_thread_local: true, ..base } diff --git a/compiler/rustc_target/src/spec/x86_64_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/x86_64_pc_windows_msvc.rs index 72bbb10323c31..1c4ccebb488c5 100644 --- a/compiler/rustc_target/src/spec/x86_64_pc_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/x86_64_pc_windows_msvc.rs @@ -4,7 +4,6 @@ pub fn target() -> Target { let mut base = super::windows_msvc_base::opts(); base.cpu = "x86-64".to_string(); base.max_atomic_width = Some(64); - base.has_elf_tls = true; Target { llvm_target: "x86_64-pc-windows-msvc".to_string(), diff --git a/compiler/rustc_target/src/spec/x86_64_unknown_linux_gnux32.rs b/compiler/rustc_target/src/spec/x86_64_unknown_linux_gnux32.rs index 1ffaa9b78c85e..109f86d3a410a 100644 --- a/compiler/rustc_target/src/spec/x86_64_unknown_linux_gnux32.rs +++ b/compiler/rustc_target/src/spec/x86_64_unknown_linux_gnux32.rs @@ -8,7 +8,7 @@ pub fn target() -> Target { base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-mx32".to_string()); // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved base.stack_probes = StackProbeType::Call; - base.has_elf_tls = false; + base.has_thread_local = false; // BUG(GabrielMajeri): disabling the PLT on x86_64 Linux with x32 ABI // breaks code gen. See LLVM bug 36743 base.needs_plt = true; diff --git a/compiler/rustc_target/src/spec/x86_64_uwp_windows_msvc.rs b/compiler/rustc_target/src/spec/x86_64_uwp_windows_msvc.rs index 27c579ed5bc67..06ccc272300d6 100644 --- a/compiler/rustc_target/src/spec/x86_64_uwp_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/x86_64_uwp_windows_msvc.rs @@ -4,7 +4,6 @@ pub fn target() -> Target { let mut base = super::windows_uwp_msvc_base::opts(); base.cpu = "x86-64".to_string(); base.max_atomic_width = Some(64); - base.has_elf_tls = true; Target { llvm_target: "x86_64-pc-windows-msvc".to_string(), diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index d24b4bdffdefc..7185f3de18ade 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -2683,11 +2683,11 @@ impl Vec { /// # Examples /// /// ``` - /// let mut v = vec![1, 2, 3]; - /// let new = [7, 8]; - /// let u: Vec<_> = v.splice(..2, new).collect(); - /// assert_eq!(v, &[7, 8, 3]); - /// assert_eq!(u, &[1, 2]); + /// let mut v = vec![1, 2, 3, 4]; + /// let new = [7, 8, 9]; + /// let u: Vec<_> = v.splice(1..3, new).collect(); + /// assert_eq!(v, &[1, 7, 8, 9, 4]); + /// assert_eq!(u, &[2, 3]); /// ``` #[cfg(not(no_global_oom_handling))] #[inline] diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs index 9a668d34b6278..e6ae4afd7c192 100644 --- a/library/core/src/num/int_macros.rs +++ b/library/core/src/num/int_macros.rs @@ -2025,17 +2025,17 @@ macro_rules! int_impl { #[doc = concat!("let a: ", stringify!($SelfT)," = 8;")] /// let b = 3; /// - /// assert_eq!(a.unstable_div_floor(b), 2); - /// assert_eq!(a.unstable_div_floor(-b), -3); - /// assert_eq!((-a).unstable_div_floor(b), -3); - /// assert_eq!((-a).unstable_div_floor(-b), 2); + /// assert_eq!(a.div_floor(b), 2); + /// assert_eq!(a.div_floor(-b), -3); + /// assert_eq!((-a).div_floor(b), -3); + /// assert_eq!((-a).div_floor(-b), 2); /// ``` #[unstable(feature = "int_roundings", issue = "88581")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] #[rustc_inherit_overflow_checks] - pub const fn unstable_div_floor(self, rhs: Self) -> Self { + pub const fn div_floor(self, rhs: Self) -> Self { let d = self / rhs; let r = self % rhs; if (r > 0 && rhs < 0) || (r < 0 && rhs > 0) { @@ -2060,17 +2060,17 @@ macro_rules! int_impl { #[doc = concat!("let a: ", stringify!($SelfT)," = 8;")] /// let b = 3; /// - /// assert_eq!(a.unstable_div_ceil(b), 3); - /// assert_eq!(a.unstable_div_ceil(-b), -2); - /// assert_eq!((-a).unstable_div_ceil(b), -2); - /// assert_eq!((-a).unstable_div_ceil(-b), 3); + /// assert_eq!(a.div_ceil(b), 3); + /// assert_eq!(a.div_ceil(-b), -2); + /// assert_eq!((-a).div_ceil(b), -2); + /// assert_eq!((-a).div_ceil(-b), 3); /// ``` #[unstable(feature = "int_roundings", issue = "88581")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] #[rustc_inherit_overflow_checks] - pub const fn unstable_div_ceil(self, rhs: Self) -> Self { + pub const fn div_ceil(self, rhs: Self) -> Self { let d = self / rhs; let r = self % rhs; if (r > 0 && rhs > 0) || (r < 0 && rhs < 0) { @@ -2095,21 +2095,21 @@ macro_rules! int_impl { /// /// ``` /// #![feature(int_roundings)] - #[doc = concat!("assert_eq!(16_", stringify!($SelfT), ".unstable_next_multiple_of(8), 16);")] - #[doc = concat!("assert_eq!(23_", stringify!($SelfT), ".unstable_next_multiple_of(8), 24);")] - #[doc = concat!("assert_eq!(16_", stringify!($SelfT), ".unstable_next_multiple_of(-8), 16);")] - #[doc = concat!("assert_eq!(23_", stringify!($SelfT), ".unstable_next_multiple_of(-8), 16);")] - #[doc = concat!("assert_eq!((-16_", stringify!($SelfT), ").unstable_next_multiple_of(8), -16);")] - #[doc = concat!("assert_eq!((-23_", stringify!($SelfT), ").unstable_next_multiple_of(8), -16);")] - #[doc = concat!("assert_eq!((-16_", stringify!($SelfT), ").unstable_next_multiple_of(-8), -16);")] - #[doc = concat!("assert_eq!((-23_", stringify!($SelfT), ").unstable_next_multiple_of(-8), -24);")] + #[doc = concat!("assert_eq!(16_", stringify!($SelfT), ".next_multiple_of(8), 16);")] + #[doc = concat!("assert_eq!(23_", stringify!($SelfT), ".next_multiple_of(8), 24);")] + #[doc = concat!("assert_eq!(16_", stringify!($SelfT), ".next_multiple_of(-8), 16);")] + #[doc = concat!("assert_eq!(23_", stringify!($SelfT), ".next_multiple_of(-8), 16);")] + #[doc = concat!("assert_eq!((-16_", stringify!($SelfT), ").next_multiple_of(8), -16);")] + #[doc = concat!("assert_eq!((-23_", stringify!($SelfT), ").next_multiple_of(8), -16);")] + #[doc = concat!("assert_eq!((-16_", stringify!($SelfT), ").next_multiple_of(-8), -16);")] + #[doc = concat!("assert_eq!((-23_", stringify!($SelfT), ").next_multiple_of(-8), -24);")] /// ``` #[unstable(feature = "int_roundings", issue = "88581")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] #[rustc_inherit_overflow_checks] - pub const fn unstable_next_multiple_of(self, rhs: Self) -> Self { + pub const fn next_multiple_of(self, rhs: Self) -> Self { // This would otherwise fail when calculating `r` when self == T::MIN. if rhs == -1 { return self; diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs index 054b814b7e08e..3cc454baf35d7 100644 --- a/library/core/src/num/uint_macros.rs +++ b/library/core/src/num/uint_macros.rs @@ -2024,14 +2024,14 @@ macro_rules! uint_impl { /// /// ``` /// #![feature(int_roundings)] - #[doc = concat!("assert_eq!(7_", stringify!($SelfT), ".unstable_div_floor(4), 1);")] + #[doc = concat!("assert_eq!(7_", stringify!($SelfT), ".div_floor(4), 1);")] /// ``` #[unstable(feature = "int_roundings", issue = "88581")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline(always)] #[rustc_inherit_overflow_checks] - pub const fn unstable_div_floor(self, rhs: Self) -> Self { + pub const fn div_floor(self, rhs: Self) -> Self { self / rhs } @@ -2047,14 +2047,14 @@ macro_rules! uint_impl { /// /// ``` /// #![feature(int_roundings)] - #[doc = concat!("assert_eq!(7_", stringify!($SelfT), ".unstable_div_ceil(4), 2);")] + #[doc = concat!("assert_eq!(7_", stringify!($SelfT), ".div_ceil(4), 2);")] /// ``` #[unstable(feature = "int_roundings", issue = "88581")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] #[rustc_inherit_overflow_checks] - pub const fn unstable_div_ceil(self, rhs: Self) -> Self { + pub const fn div_ceil(self, rhs: Self) -> Self { let d = self / rhs; let r = self % rhs; if r > 0 && rhs > 0 { @@ -2077,15 +2077,15 @@ macro_rules! uint_impl { /// /// ``` /// #![feature(int_roundings)] - #[doc = concat!("assert_eq!(16_", stringify!($SelfT), ".unstable_next_multiple_of(8), 16);")] - #[doc = concat!("assert_eq!(23_", stringify!($SelfT), ".unstable_next_multiple_of(8), 24);")] + #[doc = concat!("assert_eq!(16_", stringify!($SelfT), ".next_multiple_of(8), 16);")] + #[doc = concat!("assert_eq!(23_", stringify!($SelfT), ".next_multiple_of(8), 24);")] /// ``` #[unstable(feature = "int_roundings", issue = "88581")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] #[rustc_inherit_overflow_checks] - pub const fn unstable_next_multiple_of(self, rhs: Self) -> Self { + pub const fn next_multiple_of(self, rhs: Self) -> Self { match self % rhs { 0 => self, r => self + (rhs - r) diff --git a/library/core/tests/num/int_macros.rs b/library/core/tests/num/int_macros.rs index 0ad85bf6d943d..d2d655ea2c750 100644 --- a/library/core/tests/num/int_macros.rs +++ b/library/core/tests/num/int_macros.rs @@ -294,33 +294,33 @@ macro_rules! int_module { fn test_div_floor() { let a: $T = 8; let b = 3; - assert_eq!(a.unstable_div_floor(b), 2); - assert_eq!(a.unstable_div_floor(-b), -3); - assert_eq!((-a).unstable_div_floor(b), -3); - assert_eq!((-a).unstable_div_floor(-b), 2); + assert_eq!(a.div_floor(b), 2); + assert_eq!(a.div_floor(-b), -3); + assert_eq!((-a).div_floor(b), -3); + assert_eq!((-a).div_floor(-b), 2); } #[test] fn test_div_ceil() { let a: $T = 8; let b = 3; - assert_eq!(a.unstable_div_ceil(b), 3); - assert_eq!(a.unstable_div_ceil(-b), -2); - assert_eq!((-a).unstable_div_ceil(b), -2); - assert_eq!((-a).unstable_div_ceil(-b), 3); + assert_eq!(a.div_ceil(b), 3); + assert_eq!(a.div_ceil(-b), -2); + assert_eq!((-a).div_ceil(b), -2); + assert_eq!((-a).div_ceil(-b), 3); } #[test] fn test_next_multiple_of() { - assert_eq!((16 as $T).unstable_next_multiple_of(8), 16); - assert_eq!((23 as $T).unstable_next_multiple_of(8), 24); - assert_eq!((16 as $T).unstable_next_multiple_of(-8), 16); - assert_eq!((23 as $T).unstable_next_multiple_of(-8), 16); - assert_eq!((-16 as $T).unstable_next_multiple_of(8), -16); - assert_eq!((-23 as $T).unstable_next_multiple_of(8), -16); - assert_eq!((-16 as $T).unstable_next_multiple_of(-8), -16); - assert_eq!((-23 as $T).unstable_next_multiple_of(-8), -24); - assert_eq!(MIN.unstable_next_multiple_of(-1), MIN); + assert_eq!((16 as $T).next_multiple_of(8), 16); + assert_eq!((23 as $T).next_multiple_of(8), 24); + assert_eq!((16 as $T).next_multiple_of(-8), 16); + assert_eq!((23 as $T).next_multiple_of(-8), 16); + assert_eq!((-16 as $T).next_multiple_of(8), -16); + assert_eq!((-23 as $T).next_multiple_of(8), -16); + assert_eq!((-16 as $T).next_multiple_of(-8), -16); + assert_eq!((-23 as $T).next_multiple_of(-8), -24); + assert_eq!(MIN.next_multiple_of(-1), MIN); } #[test] diff --git a/library/core/tests/num/uint_macros.rs b/library/core/tests/num/uint_macros.rs index 35ec88c6af7d6..49f8f1f13fad4 100644 --- a/library/core/tests/num/uint_macros.rs +++ b/library/core/tests/num/uint_macros.rs @@ -208,19 +208,19 @@ macro_rules! uint_module { #[test] fn test_div_floor() { - assert_eq!((8 as $T).unstable_div_floor(3), 2); + assert_eq!((8 as $T).div_floor(3), 2); } #[test] fn test_div_ceil() { - assert_eq!((8 as $T).unstable_div_ceil(3), 3); + assert_eq!((8 as $T).div_ceil(3), 3); } #[test] fn test_next_multiple_of() { - assert_eq!((16 as $T).unstable_next_multiple_of(8), 16); - assert_eq!((23 as $T).unstable_next_multiple_of(8), 24); - assert_eq!(MAX.unstable_next_multiple_of(1), MAX); + assert_eq!((16 as $T).next_multiple_of(8), 16); + assert_eq!((23 as $T).next_multiple_of(8), 24); + assert_eq!(MAX.next_multiple_of(1), MAX); } #[test] diff --git a/library/portable-simd/crates/core_simd/src/masks/bitmask.rs b/library/portable-simd/crates/core_simd/src/masks/bitmask.rs index 4c964cb52e196..b4217dc87ba9c 100644 --- a/library/portable-simd/crates/core_simd/src/masks/bitmask.rs +++ b/library/portable-simd/crates/core_simd/src/masks/bitmask.rs @@ -105,18 +105,14 @@ where #[must_use = "method returns a new vector and does not mutate the original value"] pub fn to_int(self) -> Simd { unsafe { - crate::intrinsics::simd_select_bitmask( - self.0, - Simd::splat(T::TRUE), - Simd::splat(T::FALSE), - ) + intrinsics::simd_select_bitmask(self.0, Simd::splat(T::TRUE), Simd::splat(T::FALSE)) } } #[inline] #[must_use = "method returns a new mask and does not mutate the original value"] pub unsafe fn from_int_unchecked(value: Simd) -> Self { - unsafe { Self(crate::intrinsics::simd_bitmask(value), PhantomData) } + unsafe { Self(intrinsics::simd_bitmask(value), PhantomData) } } #[cfg(feature = "generic_const_exprs")] diff --git a/library/portable-simd/crates/core_simd/src/masks/full_masks.rs b/library/portable-simd/crates/core_simd/src/masks/full_masks.rs index 5421ccbe3d8f5..e5bb784bb910f 100644 --- a/library/portable-simd/crates/core_simd/src/masks/full_masks.rs +++ b/library/portable-simd/crates/core_simd/src/masks/full_masks.rs @@ -115,7 +115,7 @@ where pub fn to_bitmask(self) -> [u8; LaneCount::::BITMASK_LEN] { unsafe { let mut bitmask: [u8; LaneCount::::BITMASK_LEN] = - crate::intrinsics::simd_bitmask(self.0); + intrinsics::simd_bitmask(self.0); // There is a bug where LLVM appears to implement this operation with the wrong // bit order. @@ -144,7 +144,7 @@ where } } - Self::from_int_unchecked(crate::intrinsics::simd_select_bitmask( + Self::from_int_unchecked(intrinsics::simd_select_bitmask( bitmask, Self::splat(true).to_int(), Self::splat(false).to_int(), diff --git a/library/portable-simd/crates/core_simd/src/mod.rs b/library/portable-simd/crates/core_simd/src/mod.rs index ec874a22389d4..85026265956a2 100644 --- a/library/portable-simd/crates/core_simd/src/mod.rs +++ b/library/portable-simd/crates/core_simd/src/mod.rs @@ -27,7 +27,6 @@ pub mod simd { pub use crate::core_simd::lane_count::{LaneCount, SupportedLaneCount}; pub use crate::core_simd::masks::*; - pub use crate::core_simd::select::Select; pub use crate::core_simd::swizzle::*; pub use crate::core_simd::vector::*; } diff --git a/library/portable-simd/crates/core_simd/src/select.rs b/library/portable-simd/crates/core_simd/src/select.rs index 5d696ebf76ec2..8d521057fbd3e 100644 --- a/library/portable-simd/crates/core_simd/src/select.rs +++ b/library/portable-simd/crates/core_simd/src/select.rs @@ -1,54 +1,6 @@ use crate::simd::intrinsics; use crate::simd::{LaneCount, Mask, MaskElement, Simd, SimdElement, SupportedLaneCount}; -mod sealed { - pub trait Sealed { - fn select(mask: Mask, true_values: Self, false_values: Self) -> Self; - } -} -use sealed::Sealed; - -/// Supporting trait for vector `select` function -pub trait Select: Sealed {} - -impl Sealed> for Simd -where - T: SimdElement, - LaneCount: SupportedLaneCount, -{ - #[inline] - #[must_use = "method returns a new vector and does not mutate the original inputs"] - fn select(mask: Mask, true_values: Self, false_values: Self) -> Self { - unsafe { intrinsics::simd_select(mask.to_int(), true_values, false_values) } - } -} - -impl Select> for Simd -where - T: SimdElement, - LaneCount: SupportedLaneCount, -{ -} - -impl Sealed for Mask -where - T: MaskElement, - LaneCount: SupportedLaneCount, -{ - #[inline] - #[must_use = "method returns a new vector and does not mutate the original inputs"] - fn select(mask: Self, true_values: Self, false_values: Self) -> Self { - mask & true_values | !mask & false_values - } -} - -impl Select for Mask -where - T: MaskElement, - LaneCount: SupportedLaneCount, -{ -} - impl Mask where T: MaskElement, @@ -69,8 +21,24 @@ where /// let c = mask.select(a, b); /// assert_eq!(c.to_array(), [0, 5, 6, 3]); /// ``` + #[inline] + #[must_use = "method returns a new vector and does not mutate the original inputs"] + pub fn select( + self, + true_values: Simd, + false_values: Simd, + ) -> Simd + where + U: SimdElement, + { + unsafe { intrinsics::simd_select(self.to_int(), true_values, false_values) } + } + + /// Choose lanes from two masks. + /// + /// For each lane in the mask, choose the corresponding lane from `true_values` if + /// that lane mask is true, and `false_values` if that lane mask is false. /// - /// `select` can also be used on masks: /// ``` /// # #![feature(portable_simd)] /// # #[cfg(feature = "std")] use core_simd::Mask; @@ -78,12 +46,12 @@ where /// let a = Mask::::from_array([true, true, false, false]); /// let b = Mask::::from_array([false, false, true, true]); /// let mask = Mask::::from_array([true, false, false, true]); - /// let c = mask.select(a, b); + /// let c = mask.select_mask(a, b); /// assert_eq!(c.to_array(), [true, false, true, false]); /// ``` #[inline] - #[must_use = "method returns a new vector and does not mutate the original inputs"] - pub fn select>(self, true_values: S, false_values: S) -> S { - S::select(self, true_values, false_values) + #[must_use = "method returns a new mask and does not mutate the original inputs"] + pub fn select_mask(self, true_values: Self, false_values: Self) -> Self { + self & true_values | !self & false_values } } diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs index c41617665a859..24e18bb3a51f4 100644 --- a/src/librustdoc/clean/types.rs +++ b/src/librustdoc/clean/types.rs @@ -122,12 +122,11 @@ crate struct Crate { crate primitives: ThinVec<(DefId, PrimitiveType)>, /// Only here so that they can be filtered through the rustdoc passes. crate external_traits: Rc>>, - crate collapsed: bool, } // `Crate` is frequently moved by-value. Make sure it doesn't unintentionally get bigger. #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(Crate, 80); +rustc_data_structures::static_assert_size!(Crate, 72); impl Crate { crate fn name(&self, tcx: TyCtxt<'_>) -> Symbol { @@ -1030,12 +1029,6 @@ impl Attributes { ) -> Attributes { let mut doc_strings: Vec = vec![]; - fn update_need_backline(doc_strings: &mut Vec) { - if let Some(prev) = doc_strings.last_mut() { - prev.need_backline = true; - } - } - let clean_attr = |(attr, parent_module): (&ast::Attribute, Option)| { if let Some(value) = attr.doc_str() { trace!("got doc_str={:?}", value); @@ -1055,7 +1048,9 @@ impl Attributes { indent: 0, }; - update_need_backline(&mut doc_strings); + if let Some(prev) = doc_strings.last_mut() { + prev.need_backline = true; + } doc_strings.push(frag); diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs index 4d80abc98c7d5..7d5e2e36bd190 100644 --- a/src/librustdoc/clean/utils.rs +++ b/src/librustdoc/clean/utils.rs @@ -72,7 +72,7 @@ crate fn krate(cx: &mut DocContext<'_>) -> Crate { })); } - Crate { module, primitives, external_traits: cx.external_traits.clone(), collapsed: false } + Crate { module, primitives, external_traits: cx.external_traits.clone() } } fn external_generic_args( diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index c58310947d282..1b67a4c144c1e 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -510,9 +510,6 @@ crate fn run_global_ctxt( krate = tcx.sess.time("create_format_cache", || Cache::populate(&mut ctxt, krate)); - // The main crate doc comments are always collapsed. - krate.collapsed = true; - (krate, ctxt.render_options, ctxt.cache) } diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs index c4d326e7711a3..9c849b7789af7 100644 --- a/src/librustdoc/html/render/context.rs +++ b/src/librustdoc/html/render/context.rs @@ -88,8 +88,6 @@ crate struct SharedContext<'tcx> { crate local_sources: FxHashMap, /// Show the memory layout of types in the docs. pub(super) show_type_layout: bool, - /// Whether the collapsed pass ran - collapsed: bool, /// The base-URL of the issue tracker for when an item has been tagged with /// an issue number. pub(super) issue_tracker_base_url: Option, @@ -142,12 +140,6 @@ impl SharedContext<'_> { Ok(()) } - /// Returns the `collapsed_doc_value` of the given item if this is the main crate, otherwise - /// returns the `doc_value`. - crate fn maybe_collapsed_doc_value<'a>(&self, item: &'a clean::Item) -> Option { - if self.collapsed { item.collapsed_doc_value() } else { item.doc_value() } - } - crate fn edition(&self) -> Edition { self.tcx.sess.edition() } @@ -472,7 +464,6 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> { let (sender, receiver) = channel(); let mut scx = SharedContext { tcx, - collapsed: krate.collapsed, src_root, local_sources, issue_tracker_base_url, diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs index cd89164a25470..eb606178d244d 100644 --- a/src/librustdoc/html/render/mod.rs +++ b/src/librustdoc/html/render/mod.rs @@ -567,7 +567,7 @@ fn document_full_inner( is_collapsible: bool, heading_offset: HeadingOffset, ) { - if let Some(s) = cx.shared.maybe_collapsed_doc_value(item) { + if let Some(s) = item.collapsed_doc_value() { debug!("Doc block: =====\n{}\n=====", s); if is_collapsible { w.write_str( @@ -1612,7 +1612,7 @@ fn render_impl( write!(w, "") } - if let Some(ref dox) = cx.shared.maybe_collapsed_doc_value(&i.impl_item) { + if let Some(ref dox) = i.impl_item.collapsed_doc_value() { let mut ids = cx.id_map.borrow_mut(); write!( w,