nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 06:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #92099 - matthiaskrgr:rollup-4gwv67m, r=matthiaskrgr

Browse Source 
Rollup of 7 pull requests

Successful merges:

 - #91141 (Revert "Temporarily rename int_roundings functions to avoid conflicts")
 - #91984 (Remove `in_band_lifetimes` from `rustc_middle`)
 - #92028 (Sync portable-simd to fix libcore build for AVX-512 enabled targets)
 - #92042 (Enable `#[thread_local]` for all windows-msvc targets)
 - #92071 (Update example code for Vec::splice to change the length)
 - #92077 (rustdoc: Remove unused `collapsed` field)
 - #92081 (rustdoc: Remove unnecessary `need_backline` function)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2021-12-19 12:36:56 +00:00
commit 41c3017c82
77 changed files with 228 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
compiler/rustc_macros/src/type_foldable.rs
View File

@ -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! {

4
compiler/rustc_middle/src/dep_graph/dep_node.rs
View File

@ -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<DefId> {
fn extract_def_id<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Option<DefId> {
if self.kind.fingerprint_style(tcx) == FingerprintStyle::DefPathHash {
Some(tcx.def_path_hash_to_def_id(DefPathHash(self.hash.into())))
} else {

2
compiler/rustc_middle/src/infer/canonical.rs
View File

@ -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);

2
compiler/rustc_middle/src/infer/unify_key.rs
View File

@ -164,7 +164,7 @@ impl<'tcx> UnifyValue for ConstVarValue<'tcx> {
impl<'tcx> EqUnifyValue for &'tcx ty::Const<'tcx> {}
pub fn replace_if_possible<V, L>(
pub fn replace_if_possible<'tcx, V, L>(
table: &mut UnificationTable<InPlace<ty::ConstVid<'tcx>, V, L>>,
c: &'tcx ty::Const<'tcx>,
) -> &'tcx ty::Const<'tcx>

1
compiler/rustc_middle/src/lib.rs
View File

@ -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)]

2
compiler/rustc_middle/src/lint.rs
View File

@ -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,

2
compiler/rustc_middle/src/middle/stability.rs
View File

@ -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<Symbol>,

2
compiler/rustc_middle/src/mir/interpret/error.rs
View File

@ -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);

6
compiler/rustc_middle/src/mir/interpret/mod.rs
View File

@ -145,7 +145,7 @@ pub struct GlobalId<'tcx> {
pub promoted: Option<mir::Promoted>,
}
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<D>(&self, decoder: &mut D) -> Result<AllocId, D::Error>
pub fn decode_alloc_id<'tcx, D>(&self, decoder: &mut D) -> Result<AllocId, D::Error>
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]

16
compiler/rustc_middle/src/mir/mod.rs
View File

@ -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<SourceScope, SourceScopeData<'tcx>>,
) -> Option<HirId> {
@ -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<DefId> {
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<Successors<'b>>;
}
impl graph::GraphPredecessors<'graph> for Body<'tcx> {
impl<'tcx, 'graph> graph::GraphPredecessors<'graph> for Body<'tcx> {
type Item = BasicBlock;
type Iter = std::iter::Copied<std::slice::Iter<'graph, BasicBlock>>;
}
impl graph::WithPredecessors for Body<'tcx> {
impl<'tcx> graph::WithPredecessors for Body<'tcx> {
#[inline]
fn predecessors(&self, node: Self::Node) -> <Self as graph::GraphPredecessors<'_>>::Iter {
self.predecessors()[node].iter().copied()

2
compiler/rustc_middle/src/mir/mono.rs
View File

@ -431,7 +431,7 @@ pub struct CodegenUnitNameBuilder<'tcx> {
cache: FxHashMap<CrateNum, String>,
}
impl CodegenUnitNameBuilder<'tcx> {
impl<'tcx> CodegenUnitNameBuilder<'tcx> {
pub fn new(tcx: TyCtxt<'tcx>) -> Self {
CodegenUnitNameBuilder { tcx, cache: Default::default() }
}

22
compiler/rustc_middle/src/mir/pretty.rs
View File

@ -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<String>,
}
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<Tag, Extra>(
pub fn display_allocation<'a, 'tcx, Tag, Extra>(
tcx: TyCtxt<'tcx>,
alloc: &'a Allocation<Tag, Extra>,
) -> RenderAllocation<'a, 'tcx, Tag, Extra> {
@ -775,7 +775,9 @@ pub struct RenderAllocation<'a, 'tcx, Tag, Extra> {
alloc: &'a Allocation<Tag, Extra>,
}
impl<Tag: Provenance, Extra> 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<Tag: Provenance, Extra>(
fn write_allocation_bytes<'tcx, Tag: Provenance, Extra>(
tcx: TyCtxt<'tcx>,
alloc: &Allocation<Tag, Extra>,
w: &mut dyn std::fmt::Write,

2
compiler/rustc_middle/src/mir/traversal.rs
View File

@ -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<BasicBlock> {
pub fn reachable_as_bitset<'tcx>(body: &Body<'tcx>) -> BitSet<BasicBlock> {
let mut iter = preorder(body);
(&mut iter).for_each(drop);
iter.visited

2
compiler/rustc_middle/src/mir/visit.rs
View File

@ -965,7 +965,7 @@ macro_rules! visit_place_fns {
}
}
fn process_projection(
fn process_projection<'a>(
&mut self,
projection: &'a [PlaceElem<'tcx>],
location: Location,

2
compiler/rustc_middle/src/traits/mod.rs
View File

@ -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)]

2
compiler/rustc_middle/src/traits/specialization_graph.rs
View File

@ -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,

2
compiler/rustc_middle/src/traits/structural_impls.rs
View File

@ -74,7 +74,7 @@ impl<N: fmt::Debug> fmt::Debug for traits::ImplSourceBuiltinData<N> {
}
}
impl<N: fmt::Debug> 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,

4
compiler/rustc_middle/src/ty/_match.rs
View File

@ -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"
}

2
compiler/rustc_middle/src/ty/adjustment.rs
View File

@ -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(..)))
}

2
compiler/rustc_middle/src/ty/assoc.rs
View File

@ -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,

4
compiler/rustc_middle/src/ty/closure.rs
View File

@ -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"),

6
compiler/rustc_middle/src/ty/codec.rs
View File

@ -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<E, T, M>(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<T, usize>,

2
compiler/rustc_middle/src/ty/consts/int.rs
View File

@ -234,7 +234,7 @@ impl ScalarInt {
}
#[inline]
pub fn try_to_machine_usize(&self, tcx: TyCtxt<'tcx>) -> Result<u64, Size> {
pub fn try_to_machine_usize<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Result<u64, Size> {
Ok(self.to_bits(tcx.data_layout.pointer_size)? as u64)
}
}

2
compiler/rustc_middle/src/ty/consts/valtree.rs
View File

@ -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(&[])
}

6
compiler/rustc_middle/src/ty/context.rs
View File

@ -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> {

2
compiler/rustc_middle/src/ty/erase_regions.rs
View File

@ -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
}

6
compiler/rustc_middle/src/ty/flags.rs
View File

@ -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<P>(&mut self, ct: ty::Unevaluated<'tcx, P>) {
fn add_unevaluated_const<P>(&mut self, ct: ty::Unevaluated<'_, P>) {
// The generic arguments of unevaluated consts are a bit special,
// see the `rustc-dev-guide` for more information.
//

10
compiler/rustc_middle/src/ty/fold.rs
View File

@ -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<F: TypeFolder<'tcx>>(self, _: &mut F) -> Result<Self, F::Error> {
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,

2
compiler/rustc_middle/src/ty/inhabitedness/def_id_forest.rs
View File

@ -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))
}

2
compiler/rustc_middle/src/ty/instance.rs
View File

@ -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
}

16
compiler/rustc_middle/src/ty/layout.rs
View File

@ -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<C: LayoutOfHelpers<'tcx>> 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<TyAndLayout<'tcx>, 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<TyAndLayout<'tcx>, 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<LayoutError<'tcx>> for FnAbiError<'tcx> {
impl<'tcx> From<LayoutError<'tcx>> for FnAbiError<'tcx> {
fn from(err: LayoutError<'tcx>) -> Self {
Self::Layout(err)
}
@ -2942,7 +2942,7 @@ pub trait FnAbiOf<'tcx>: FnAbiOfHelpers<'tcx> {
}
}
impl<C: FnAbiOfHelpers<'tcx>> FnAbiOf<'tcx> for C {}
impl<'tcx, C: FnAbiOfHelpers<'tcx>> FnAbiOf<'tcx> for C {}
fn fn_abi_of_fn_ptr<'tcx>(
tcx: TyCtxt<'tcx>,

4
compiler/rustc_middle/src/ty/mod.rs
View File

@ -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 {

6
compiler/rustc_middle/src/ty/normalize_erasing_regions.rs
View File

@ -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<Ty<'tcx>, Self::Error> {
match self.try_normalize_generic_arg_after_erasing_regions(ty.into()) {
Ok(t) => Ok(t.expect_ty()),

2
compiler/rustc_middle/src/ty/print/mod.rs
View File

@ -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,

25
compiler/rustc_middle/src/ty/print/pretty.rs
View File

@ -1513,7 +1513,7 @@ pub struct FmtPrinterData<'a, 'tcx, F> {
pub name_resolver: Option<Box<&'a dyn Fn(ty::TyVid) -> Option<String>>>,
}
impl<F> 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<F> DerefMut for FmtPrinter<'_, '_, F> {
}
}
impl<F> 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<F: fmt::Write> fmt::Write for FmtPrinter<'_, '_, F> {
}
}
impl<F: fmt::Write> 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<F: fmt::Write> 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<F: fmt::Write> Printer<'tcx> for FmtPrinter<'_, 'tcx, F> {
}
}
impl<F: fmt::Write> 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<String> {
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<F: fmt::Write> FmtPrinter<'_, 'tcx, F> {
impl<'tcx, F: fmt::Write> FmtPrinter<'_, 'tcx, F> {
pub fn name_all_regions<T>(
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())
}

14
compiler/rustc_middle/src/ty/query.rs
View File

@ -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<query_storage::$name<$tcx>>,)*
}
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<DefId>) -> 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<DefId>) -> DefKind {
let def_id = def_id.into_query_param();
self.opt_def_kind(def_id)

10
compiler/rustc_middle/src/ty/relate.rs
View File

@ -132,7 +132,7 @@ pub fn relate_type_and_mut<'tcx, R: TypeRelation<'tcx>>(
}
}
pub fn relate_substs<R: TypeRelation<'tcx>>(
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<R: TypeRelation<'tcx>>(
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<R: TypeRelation<'tcx>>(
/// 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<R: TypeRelation<'tcx>>(
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<R: TypeRelation<'tcx>>(
if is_match { Ok(a) } else { Err(TypeError::ConstMismatch(expected_found(relation, a, b))) }
}
fn check_const_value_eq<R: TypeRelation<'tcx>>(
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<R, T>(relation: &mut R, a: T, b: T) -> ExpectedFound<T>
pub fn expected_found<'tcx, R, T>(relation: &mut R, a: T, b: T) -> ExpectedFound<T>
where
R: TypeRelation<'tcx>,
{

20
compiler/rustc_middle/src/ty/structural_impls.rs
View File

@ -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),

2
compiler/rustc_middle/src/ty/sty.rs
View File

@ -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(_))

2
compiler/rustc_middle/src/ty/subst.rs
View File

@ -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),

4
compiler/rustc_middle/src/ty/util.rs
View File

@ -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<SmallVec<[Ty<'tcx>; 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<ty::Predicate<'tcx>>,
) -> &'tcx List<ty::Predicate<'tcx>> {

2
compiler/rustc_middle/src/ty/walk.rs
View File

@ -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

2
compiler/rustc_session/src/config.rs
View File

@ -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 [

1
compiler/rustc_target/src/spec/aarch64_pc_windows_msvc.rs
View File

@ -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 {

1
compiler/rustc_target/src/spec/aarch64_uwp_windows_msvc.rs
View File

@ -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(),

2
compiler/rustc_target/src/spec/android_base.rs
View File

@ -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`).

4
compiler/rustc_target/src/spec/apple_base.rs
View File

@ -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,

2
compiler/rustc_target/src/spec/apple_sdk_base.rs
View File

@ -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)
}
}

2
compiler/rustc_target/src/spec/fuchsia_base.rs
View File

@ -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()
}
}

2
compiler/rustc_target/src/spec/hermit_base.rs
View File

@ -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,

1
compiler/rustc_target/src/spec/i686_uwp_windows_msvc.rs
View File

@ -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(),

2
compiler/rustc_target/src/spec/illumos_base.rs
View File

@ -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

2
compiler/rustc_target/src/spec/linux_base.rs
View File

@ -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()
}

11
compiler/rustc_target/src/spec/mod.rs
View File

@ -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);

2
compiler/rustc_target/src/spec/redox_base.rs
View File

@ -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()

2
compiler/rustc_target/src/spec/solid_base.rs
View File

@ -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()
}
}

1
compiler/rustc_target/src/spec/thumbv7a_uwp_windows_msvc.rs
View File

@ -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,

2
compiler/rustc_target/src/spec/vxworks_base.rs
View File

@ -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,

4
compiler/rustc_target/src/spec/wasm_base.rs
View File

@ -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

1
compiler/rustc_target/src/spec/windows_msvc_base.rs
View File

@ -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
}

1
compiler/rustc_target/src/spec/x86_64_pc_windows_msvc.rs
View File

@ -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(),

2
compiler/rustc_target/src/spec/x86_64_unknown_linux_gnux32.rs
View File

@ -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;

1
compiler/rustc_target/src/spec/x86_64_uwp_windows_msvc.rs
View File

@ -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(),

10
library/alloc/src/vec/mod.rs
View File

@ -2683,11 +2683,11 @@ impl<T, A: Allocator> Vec<T, A> {
/// # 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]

38
library/core/src/num/int_macros.rs
View File

@ -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;

14
library/core/src/num/uint_macros.rs
View File

@ -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)

34
library/core/tests/num/int_macros.rs
View File

@ -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]

10
library/core/tests/num/uint_macros.rs
View File

@ -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]

8
library/portable-simd/crates/core_simd/src/masks/bitmask.rs
View File

@ -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<T, LANES> {
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<T, LANES>) -> Self {
unsafe { Self(crate::intrinsics::simd_bitmask(value), PhantomData) }
unsafe { Self(intrinsics::simd_bitmask(value), PhantomData) }
}
#[cfg(feature = "generic_const_exprs")]

4
library/portable-simd/crates/core_simd/src/masks/full_masks.rs
View File

@ -115,7 +115,7 @@ where
pub fn to_bitmask(self) -> [u8; LaneCount::<LANES>::BITMASK_LEN] {
unsafe {
let mut bitmask: [u8; LaneCount::<LANES>::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(),

1
library/portable-simd/crates/core_simd/src/mod.rs
View File

@ -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::*;
}

74
library/portable-simd/crates/core_simd/src/select.rs
View File

@ -1,54 +1,6 @@
use crate::simd::intrinsics;
use crate::simd::{LaneCount, Mask, MaskElement, Simd, SimdElement, SupportedLaneCount};
mod sealed {
pub trait Sealed<Mask> {
fn select(mask: Mask, true_values: Self, false_values: Self) -> Self;
}
}
use sealed::Sealed;
/// Supporting trait for vector `select` function
pub trait Select<Mask>: Sealed<Mask> {}
impl<T, const LANES: usize> Sealed<Mask<T::Mask, LANES>> for Simd<T, LANES>
where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
{
#[inline]
#[must_use = "method returns a new vector and does not mutate the original inputs"]
fn select(mask: Mask<T::Mask, LANES>, true_values: Self, false_values: Self) -> Self {
unsafe { intrinsics::simd_select(mask.to_int(), true_values, false_values) }
}
}
impl<T, const LANES: usize> Select<Mask<T::Mask, LANES>> for Simd<T, LANES>
where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
{
}
impl<T, const LANES: usize> Sealed<Self> for Mask<T, LANES>
where
T: MaskElement,
LaneCount<LANES>: 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<T, const LANES: usize> Select<Self> for Mask<T, LANES>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
{
}
impl<T, const LANES: usize> Mask<T, LANES>
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<U>(
self,
true_values: Simd<U, LANES>,
false_values: Simd<U, LANES>,
) -> Simd<U, LANES>
where
U: SimdElement<Mask = T>,
{
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::<i32, 4>::from_array([true, true, false, false]);
/// let b = Mask::<i32, 4>::from_array([false, false, true, true]);
/// let mask = Mask::<i32, 4>::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<S: Select<Self>>(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
}
}

13
src/librustdoc/clean/types.rs
View File

@ -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<RefCell<FxHashMap<DefId, TraitWithExtraInfo>>>,
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<DocFragment> = vec![];
fn update_need_backline(doc_strings: &mut Vec<DocFragment>) {
if let Some(prev) = doc_strings.last_mut() {
prev.need_backline = true;
}
}
let clean_attr = |(attr, parent_module): (&ast::Attribute, Option<DefId>)| {
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);

2
src/librustdoc/clean/utils.rs
View File

@ -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(

3
src/librustdoc/core.rs
View File

@ -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)
}

9
src/librustdoc/html/render/context.rs
View File

@ -88,8 +88,6 @@ crate struct SharedContext<'tcx> {
crate local_sources: FxHashMap<PathBuf, String>,
/// 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<String>,
@ -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<String> {
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,

4
src/librustdoc/html/render/mod.rs
View File

@ -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, "</summary>")
}
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,