languages/rust
languages/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust synced 2024-10-01 14:25:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #119009 - workingjubilee:rollup-ytexy6j, r=workingjubilee

Browse source 
Rollup of 6 pull requests

Successful merges:

 - #118523 (Add ASCII whitespace trimming functions to `&str`)
 - #118851 ([std] Add xcoff in object's feature list)
 - #118989 (Simplify lint decorator derive too)
 - #118993 (use `if cfg!` instead of `#[cfg]`)
 - #119003 (NFC: do not clone types that are copy)
 - #119004 (NFC don't convert types to identical types)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2023-12-16 05:35:12 +00:00
parent 5c927ab999 c5a3d98cc6
commit 1c6a06183a
37 changed files with 146 additions and 128 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
compiler/rustc_ast_lowering/src/expr.rs
View file

@ -1260,9 +1260,7 @@ fn is_ordinary(lower_ctx: &mut LoweringContext<'_, '_>, lhs: &Expr) -> bool {
);
// `a = lhs1; b = lhs2;`.
let stmts = self
.arena
.alloc_from_iter(std::iter::once(destructure_let).chain(assignments.into_iter()));
let stmts = self.arena.alloc_from_iter(std::iter::once(destructure_let).chain(assignments));
// Wrap everything in a block.
hir::ExprKind::Block(self.block_all(whole_span, stmts, None), None)

2
compiler/rustc_codegen_llvm/src/builder.rs
View file

@ -353,7 +353,7 @@ fn checked_binop(
let new_kind = match ty.kind() {
Int(t @ Isize) => Int(t.normalize(self.tcx.sess.target.pointer_width)),
Uint(t @ Usize) => Uint(t.normalize(self.tcx.sess.target.pointer_width)),
t @ (Uint(_) | Int(_)) => t.clone(),
t @ (Uint(_) | Int(_)) => *t,
_ => panic!("tried to get overflow intrinsic for op applied to non-int type"),
};

2
compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
View file

@ -607,7 +607,7 @@ fn alloc_new_file_metadata<'ll>(
if let Ok(rel_path) = abs_path.strip_prefix(working_directory) {
(
working_directory.to_string_lossy().into(),
working_directory.to_string_lossy(),
rel_path.to_string_lossy().into_owned(),
)
} else {

2
compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs
View file

@ -396,7 +396,7 @@ pub fn build_coroutine_variant_struct_type_di_node<'ll, 'tcx>(
})
.collect();
state_specific_fields.into_iter().chain(common_fields.into_iter()).collect()
state_specific_fields.into_iter().chain(common_fields).collect()
},
|cx| build_generic_type_param_di_nodes(cx, coroutine_type_and_layout.ty),
)

2
compiler/rustc_data_structures/src/sorted_map.rs
View file

@ -198,7 +198,7 @@ pub fn insert_presorted(&mut self, elements: Vec<(K, V)>) {
if index == self.data.len() || elements.last().unwrap().0 < self.data[index].0 {
// We can copy the whole range without having to mix with
// existing elements.
self.data.splice(index..index, elements.into_iter());
self.data.splice(index..index, elements);
return;
}

5
compiler/rustc_errors/src/diagnostic.rs
View file

@ -91,10 +91,7 @@ fn add_to_diagnostic_with<F>(self, diag: &mut Diagnostic, f: F)
#[rustc_diagnostic_item = "DecorateLint"]
pub trait DecorateLint<'a, G: EmissionGuarantee> {
/// Decorate and emit a lint.
fn decorate_lint<'b>(
self,
diag: &'b mut DiagnosticBuilder<'a, G>,
) -> &'b mut DiagnosticBuilder<'a, G>;
fn decorate_lint<'b>(self, diag: &'b mut DiagnosticBuilder<'a, G>);
fn msg(&self) -> DiagnosticMessage;
}

5
compiler/rustc_errors/src/emitter.rs
View file

@ -2677,10 +2677,7 @@ fn from_stderr(color: ColorConfig) -> Destination {
/// On Windows, BRIGHT_BLUE is hard to read on black. Use cyan instead.
///
/// See #36178.
#[cfg(windows)]
const BRIGHT_BLUE: Color = Color::Cyan;
#[cfg(not(windows))]
const BRIGHT_BLUE: Color = Color::Blue;
const BRIGHT_BLUE: Color = if cfg!(windows) { Color::Cyan } else { Color::Blue };
impl Style {
fn color_spec(&self, lvl: Level) -> ColorSpec {

10
compiler/rustc_hir/src/hir.rs
View file

@ -1557,7 +1557,7 @@ pub fn precedence(&self) -> ExprPrecedence {
ExprKind::Call(..) => ExprPrecedence::Call,
ExprKind::MethodCall(..) => ExprPrecedence::MethodCall,
ExprKind::Tup(_) => ExprPrecedence::Tup,
ExprKind::Binary(op, ..) => ExprPrecedence::Binary(op.node.into()),
ExprKind::Binary(op, ..) => ExprPrecedence::Binary(op.node),
ExprKind::Unary(..) => ExprPrecedence::Unary,
ExprKind::Lit(_) => ExprPrecedence::Lit,
ExprKind::Type(..) | ExprKind::Cast(..) => ExprPrecedence::Cast,
@ -1697,11 +1697,9 @@ pub fn can_have_side_effects(&self) -> bool {
// them being used only for its side-effects.
base.can_have_side_effects()
}
ExprKind::Struct(_, fields, init) => fields
.iter()
.map(|field| field.expr)
.chain(init.into_iter())
.any(|e| e.can_have_side_effects()),
ExprKind::Struct(_, fields, init) => {
fields.iter().map(|field| field.expr).chain(init).any(|e| e.can_have_side_effects())
}
ExprKind::Array(args)
| ExprKind::Tup(args)

2
compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
View file

@ -350,7 +350,7 @@ fn poly_trait_ref_binder_info(&mut self) -> (Vec<ty::BoundVariableKind>, BinderS
// Nested poly trait refs have the binders concatenated
let mut full_binders =
self.map.late_bound_vars.entry(*hir_id).or_default().clone();
full_binders.extend(supertrait_bound_vars.into_iter());
full_binders.extend(supertrait_bound_vars);
break (full_binders, BinderScopeType::Concatenating);
}
}

6
compiler/rustc_hir_typeck/src/errors.rs
View file

@ -573,13 +573,13 @@ fn add_to_diagnostic_with<F>(self, diag: &mut rustc_errors::Diagnostic, f: F)
{
match self {
CastUnknownPointerSub::To(span) => {
let msg = f(diag, crate::fluent_generated::hir_typeck_label_to.into());
let msg = f(diag, crate::fluent_generated::hir_typeck_label_to);
diag.span_label(span, msg);
let msg = f(diag, crate::fluent_generated::hir_typeck_note.into());
let msg = f(diag, crate::fluent_generated::hir_typeck_note);
diag.note(msg);
}
CastUnknownPointerSub::From(span) => {
let msg = f(diag, crate::fluent_generated::hir_typeck_label_from.into());
let msg = f(diag, crate::fluent_generated::hir_typeck_label_from);
diag.span_label(span, msg);
}
}

4
compiler/rustc_hir_typeck/src/method/probe.rs
View file

@ -1546,9 +1546,9 @@ fn consider_probe(
);
let candidate_obligations = impl_obligations
.chain(norm_obligations.into_iter())
.chain(norm_obligations)
.chain(ref_obligations.iter().cloned())
.chain(normalization_obligations.into_iter());
.chain(normalization_obligations);
// Evaluate those obligations to see if they might possibly hold.
for o in candidate_obligations {

7
compiler/rustc_infer/src/infer/outlives/verify.rs
View file

@ -130,12 +130,7 @@ pub fn alias_bound(
// see the extensive comment in projection_must_outlive
let recursive_bound = {
let mut components = smallvec![];
compute_alias_components_recursive(
self.tcx,
alias_ty_as_ty.into(),
&mut components,
visited,
);
compute_alias_components_recursive(self.tcx, alias_ty_as_ty, &mut components, visited);
self.bound_from_components(&components, visited)
};

2
compiler/rustc_infer/src/infer/relate/combine.rs
View file

@ -552,7 +552,7 @@ pub fn instantiate(
}
pub fn register_obligations(&mut self, obligations: PredicateObligations<'tcx>) {
self.obligations.extend(obligations.into_iter());
self.obligations.extend(obligations);
}
pub fn register_predicates(&mut self, obligations: impl IntoIterator<Item: ToPredicate<'tcx>>) {

56
compiler/rustc_lint/src/lints.rs
View file

@ -134,12 +134,8 @@ pub struct BuiltinMissingDebugImpl<'a> {
// Needed for def_path_str
impl<'a> DecorateLint<'a, ()> for BuiltinMissingDebugImpl<'_> {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
fn decorate_lint<'b>(self, diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>) {
diag.set_arg("debug", self.tcx.def_path_str(self.def_id));
diag
}
fn msg(&self) -> DiagnosticMessage {
@ -243,17 +239,13 @@ pub struct BuiltinUngatedAsyncFnTrackCaller<'a> {
}
impl<'a> DecorateLint<'a, ()> for BuiltinUngatedAsyncFnTrackCaller<'_> {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
fn decorate_lint<'b>(self, diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>) {
diag.span_label(self.label, fluent::lint_label);
rustc_session::parse::add_feature_diagnostics(
diag,
self.parse_sess,
sym::async_fn_track_caller,
);
diag
}
fn msg(&self) -> DiagnosticMessage {
@ -433,10 +425,7 @@ pub struct BuiltinUnpermittedTypeInit<'a> {
}
impl<'a> DecorateLint<'a, ()> for BuiltinUnpermittedTypeInit<'_> {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
fn decorate_lint<'b>(self, diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>) {
diag.set_arg("ty", self.ty);
diag.span_label(self.label, fluent::lint_builtin_unpermitted_type_init_label);
if let InhabitedPredicate::True = self.ty.inhabited_predicate(self.tcx) {
@ -447,7 +436,6 @@ fn decorate_lint<'b>(
);
}
self.sub.add_to_diagnostic(diag);
diag
}
fn msg(&self) -> rustc_errors::DiagnosticMessage {
@ -1159,10 +1147,7 @@ pub struct NonFmtPanicUnused {
// Used because of two suggestions based on one Option<Span>
impl<'a> DecorateLint<'a, ()> for NonFmtPanicUnused {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
fn decorate_lint<'b>(self, diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>) {
diag.set_arg("count", self.count);
diag.note(fluent::lint_note);
if let Some(span) = self.suggestion {
@ -1179,7 +1164,6 @@ fn decorate_lint<'b>(
Applicability::MachineApplicable,
);
}
diag
}
fn msg(&self) -> rustc_errors::DiagnosticMessage {
@ -1358,12 +1342,9 @@ pub struct DropTraitConstraintsDiag<'a> {
// Needed for def_path_str
impl<'a> DecorateLint<'a, ()> for DropTraitConstraintsDiag<'_> {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
fn decorate_lint<'b>(self, diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>) {
diag.set_arg("predicate", self.predicate);
diag.set_arg("needs_drop", self.tcx.def_path_str(self.def_id))
diag.set_arg("needs_drop", self.tcx.def_path_str(self.def_id));
}
fn msg(&self) -> rustc_errors::DiagnosticMessage {
@ -1378,11 +1359,8 @@ pub struct DropGlue<'a> {
// Needed for def_path_str
impl<'a> DecorateLint<'a, ()> for DropGlue<'_> {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
diag.set_arg("needs_drop", self.tcx.def_path_str(self.def_id))
fn decorate_lint<'b>(self, diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>) {
diag.set_arg("needs_drop", self.tcx.def_path_str(self.def_id));
}
fn msg(&self) -> rustc_errors::DiagnosticMessage {
@ -1655,10 +1633,7 @@ pub struct ImproperCTypes<'a> {
// Used because of the complexity of Option<DiagnosticMessage>, DiagnosticMessage, and Option<Span>
impl<'a> DecorateLint<'a, ()> for ImproperCTypes<'_> {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
fn decorate_lint<'b>(self, diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>) {
diag.set_arg("ty", self.ty);
diag.set_arg("desc", self.desc);
diag.span_label(self.label, fluent::lint_label);
@ -1669,7 +1644,6 @@ fn decorate_lint<'b>(
if let Some(note) = self.span_note {
diag.span_note(note, fluent::lint_note);
}
diag
}
fn msg(&self) -> rustc_errors::DiagnosticMessage {
@ -1802,10 +1776,7 @@ pub enum UnusedDefSuggestion {
// Needed because of def_path_str
impl<'a> DecorateLint<'a, ()> for UnusedDef<'_, '_> {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
fn decorate_lint<'b>(self, diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>) {
diag.set_arg("pre", self.pre);
diag.set_arg("post", self.post);
diag.set_arg("def", self.cx.tcx.def_path_str(self.def_id));
@ -1816,7 +1787,6 @@ fn decorate_lint<'b>(
if let Some(sugg) = self.suggestion {
diag.subdiagnostic(sugg);
}
diag
}
fn msg(&self) -> rustc_errors::DiagnosticMessage {
@ -1889,15 +1859,11 @@ pub struct AsyncFnInTraitDiag {
}
impl<'a> DecorateLint<'a, ()> for AsyncFnInTraitDiag {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
fn decorate_lint<'b>(self, diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>) {
diag.note(fluent::lint_note);
if let Some(sugg) = self.sugg {
diag.multipart_suggestion(fluent::lint_suggestion, sugg, Applicability::MaybeIncorrect);
}
diag
}
fn msg(&self) -> rustc_errors::DiagnosticMessage {

4
compiler/rustc_macros/src/diagnostics/diagnostic.rs
View file

@ -175,9 +175,9 @@ pub(crate) fn into_tokens(self) -> TokenStream {
fn decorate_lint<'__b>(
self,
#diag: &'__b mut rustc_errors::DiagnosticBuilder<'__a, ()>
) -> &'__b mut rustc_errors::DiagnosticBuilder<'__a, ()> {
) {
use rustc_errors::IntoDiagnosticArg;
#implementation
#implementation;
}
fn msg(&self) -> rustc_errors::DiagnosticMessage {

4
compiler/rustc_middle/src/infer/canonical.rs
View file

@ -341,13 +341,13 @@ pub fn get_or_insert(
Entry::Occupied(e) => {
let (canonical, var_values) = e.get();
state.var_values.extend_from_slice(var_values);
canonical.clone()
*canonical
}
Entry::Vacant(e) => {
let canonical = canonicalize_op(tcx, key, state);
let OriginalQueryValues { var_values, universe_map } = state;
assert_eq!(universe_map.len(), 1);
e.insert((canonical.clone(), tcx.arena.alloc_slice(var_values)));
e.insert((canonical, tcx.arena.alloc_slice(var_values)));
canonical
}
}

2
compiler/rustc_middle/src/ty/consts.rs
View file

@ -59,7 +59,7 @@ pub fn ty(self) -> Ty<'tcx> {
#[inline]
pub fn kind(self) -> ConstKind<'tcx> {
self.0.kind.clone()
self.0.kind
}
#[inline]

2
compiler/rustc_middle/src/ty/mod.rs
View file

@ -473,7 +473,7 @@ impl<'tcx> IntoKind for Ty<'tcx> {
type Kind = TyKind<'tcx>;
fn kind(self) -> TyKind<'tcx> {
self.kind().clone()
*self.kind()
}
}

6
compiler/rustc_mir_dataflow/src/value_analysis.rs
View file

@ -956,11 +956,7 @@ fn for_each_aliasing_place(
// The local is not tracked at all, so it does not alias anything.
return;
};
let elems = place
.projection
.iter()
.map(|&elem| elem.try_into())
.chain(tail_elem.map(Ok).into_iter());
let elems = place.projection.iter().map(|&elem| elem.try_into()).chain(tail_elem.map(Ok));
for elem in elems {
// A field aliases the parent place.
if let Some(vi) = self.places[index].value_index {

2
compiler/rustc_mir_transform/src/dataflow_const_prop.rs
View file

@ -496,7 +496,7 @@ fn eval_operand(
FlatSet::Elem(scalar) => {
let ty = op.ty(self.local_decls, self.tcx);
self.tcx.layout_of(self.param_env.and(ty)).map_or(FlatSet::Top, |layout| {
FlatSet::Elem(ImmTy::from_scalar(scalar.into(), layout))
FlatSet::Elem(ImmTy::from_scalar(scalar, layout))
})
}
FlatSet::Bottom => FlatSet::Bottom,

20
compiler/rustc_mir_transform/src/errors.rs
View file

@ -180,10 +180,7 @@ pub(crate) struct UnsafeOpInUnsafeFn {
impl<'a> DecorateLint<'a, ()> for UnsafeOpInUnsafeFn {
#[track_caller]
fn decorate_lint<'b>(
self,
diag: &'b mut DiagnosticBuilder<'a, ()>,
) -> &'b mut DiagnosticBuilder<'a, ()> {
fn decorate_lint<'b>(self, diag: &'b mut DiagnosticBuilder<'a, ()>) {
let handler = diag.handler().expect("lint should not yet be emitted");
let desc = handler.eagerly_translate_to_string(self.details.label(), [].into_iter());
diag.set_arg("details", desc);
@ -198,8 +195,6 @@ fn decorate_lint<'b>(
Applicability::MaybeIncorrect,
);
}
diag
}
fn msg(&self) -> DiagnosticMessage {
@ -213,10 +208,7 @@ pub(crate) enum AssertLint<P> {
}
impl<'a, P: std::fmt::Debug> DecorateLint<'a, ()> for AssertLint<P> {
fn decorate_lint<'b>(
self,
diag: &'b mut DiagnosticBuilder<'a, ()>,
) -> &'b mut DiagnosticBuilder<'a, ()> {
fn decorate_lint<'b>(self, diag: &'b mut DiagnosticBuilder<'a, ()>) {
let span = self.span();
let assert_kind = self.panic();
let message = assert_kind.diagnostic_message();
@ -224,8 +216,6 @@ fn decorate_lint<'b>(
diag.set_arg(name, value);
});
diag.span_label(span, message);
diag
}
fn msg(&self) -> DiagnosticMessage {
@ -284,10 +274,7 @@ pub(crate) struct MustNotSupend<'tcx, 'a> {
// Needed for def_path_str
impl<'a> DecorateLint<'a, ()> for MustNotSupend<'_, '_> {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
fn decorate_lint<'b>(self, diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>) {
diag.span_label(self.yield_sp, fluent::_subdiag::label);
if let Some(reason) = self.reason {
diag.subdiagnostic(reason);
@ -296,7 +283,6 @@ fn decorate_lint<'b>(
diag.set_arg("pre", self.pre);
diag.set_arg("def_path", self.tcx.def_path_str(self.def_id));
diag.set_arg("post", self.post);
diag
}
fn msg(&self) -> rustc_errors::DiagnosticMessage {

2
compiler/rustc_parse/src/parser/item.rs
View file

@ -923,7 +923,7 @@ fn parse_type_alias(&mut self, defaultness: Defaultness) -> PResult<'a, ItemInfo
);
let where_predicates_split = before_where_clause.predicates.len();
let mut predicates = before_where_clause.predicates;
predicates.extend(after_where_clause.predicates.into_iter());
predicates.extend(after_where_clause.predicates);
let where_clause = WhereClause {
has_where_token: before_where_clause.has_where_token
|| after_where_clause.has_where_token,

2
compiler/rustc_parse/src/validate_attr.rs
View file

@ -215,7 +215,7 @@ fn emit_malformed_attribute(
} else {
"the following are the possible correct uses"
},
suggestions.into_iter(),
suggestions,
Applicability::HasPlaceholders,
)
.emit();

2
compiler/rustc_pattern_analysis/src/constructor.rs
View file

@ -923,7 +923,7 @@ pub(crate) fn split<'a, 'tcx>(
}
ConstructorSet::Integers { range_1, range_2 } => {
let seen_ranges: Vec<_> =
seen.iter().map(|ctor| ctor.as_int_range().unwrap().clone()).collect();
seen.iter().map(|ctor| *ctor.as_int_range().unwrap()).collect();
for (seen, splitted_range) in range_1.split(seen_ranges.iter().cloned()) {
match seen {
Presence::Unseen => missing.push(IntRange(splitted_range)),

3
compiler/rustc_resolve/src/rustdoc.rs
View file

@ -407,8 +407,7 @@ fn parse_links<'md>(doc: &'md str) -> Vec<Box<str>> {
doc,
main_body_opts(),
Some(&mut broken_link_callback),
)
.into_iter();
);
let mut links = Vec::new();
while let Some(event) = event_iter.next() {

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

@ -1579,7 +1579,7 @@ macro_rules! ins {
pub fn build_configuration(sess: &Session, mut user_cfg: Cfg) -> Cfg {
// Combine the configuration requested by the session (command line) with
// some default and generated configuration items.
user_cfg.extend(default_configuration(sess).into_iter());
user_cfg.extend(default_configuration(sess));
user_cfg
}

1
compiler/rustc_smir/src/rustc_smir/context.rs
View file

@ -158,7 +158,6 @@ fn find_crates(&self, name: &str) -> Vec<stable_mir::Crate> {
let crate_name = tables.tcx.crate_name(*crate_num).to_string();
(name == crate_name).then(|| smir_crate(tables.tcx, *crate_num))
})
.into_iter()
.flatten()
.collect();
crates

2
compiler/rustc_trait_selection/src/traits/object_safety.rs
View file

@ -344,7 +344,7 @@ fn generics_require_sized_self(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
// Search for a predicate like `Self : Sized` amongst the trait bounds.
let predicates = tcx.predicates_of(def_id);
let predicates = predicates.instantiate_identity(tcx).predicates;
elaborate(tcx, predicates.into_iter()).any(|pred| match pred.kind().skip_binder() {
elaborate(tcx, predicates).any(|pred| match pred.kind().skip_binder() {
ty::ClauseKind::Trait(ref trait_pred) => {
trait_pred.def_id() == sized_def_id && trait_pred.self_ty().is_param(0)
}

5
compiler/rustc_trait_selection/src/traits/util.rs
View file

@ -220,9 +220,8 @@ pub fn impl_subject_and_oblig<'a, 'tcx>(
selcx.infcx.at(&ObligationCause::dummy(), param_env).normalize(predicates);
let impl_obligations = super::predicates_for_generics(cause, param_env, predicates);
let impl_obligations = impl_obligations
.chain(normalization_obligations1.into_iter())
.chain(normalization_obligations2.into_iter());
let impl_obligations =
impl_obligations.chain(normalization_obligations1).chain(normalization_obligations2);
(subject, impl_obligations)
}

3
library/core/src/slice/ascii.rs
View file

@ -125,6 +125,7 @@ pub fn escape_ascii(&self) -> EscapeAscii<'_> {
/// assert_eq!(b"".trim_ascii_start(), b"");
/// ```
#[unstable(feature = "byte_slice_trim_ascii", issue = "94035")]
#[inline]
pub const fn trim_ascii_start(&self) -> &[u8] {
let mut bytes = self;
// Note: A pattern matching based approach (instead of indexing) allows
@ -154,6 +155,7 @@ pub const fn trim_ascii_start(&self) -> &[u8] {
/// assert_eq!(b"".trim_ascii_end(), b"");
/// ```
#[unstable(feature = "byte_slice_trim_ascii", issue = "94035")]
#[inline]
pub const fn trim_ascii_end(&self) -> &[u8] {
let mut bytes = self;
// Note: A pattern matching based approach (instead of indexing) allows
@ -184,6 +186,7 @@ pub const fn trim_ascii_end(&self) -> &[u8] {
/// assert_eq!(b"".trim_ascii(), b"");
/// ```
#[unstable(feature = "byte_slice_trim_ascii", issue = "94035")]
#[inline]
pub const fn trim_ascii(&self) -> &[u8] {
self.trim_ascii_start().trim_ascii_end()
}

79
library/core/src/str/mod.rs
View file

@ -2423,6 +2423,85 @@ pub fn make_ascii_lowercase(&mut self) {
me.make_ascii_lowercase()
}
/// Returns a string slice with leading ASCII whitespace removed.
///
/// 'Whitespace' refers to the definition used by
/// [`u8::is_ascii_whitespace`].
///
/// [`u8::is_ascii_whitespace`]: u8::is_ascii_whitespace
///
/// # Examples
///
/// ```
/// #![feature(byte_slice_trim_ascii)]
///
/// assert_eq!(" \t \u{3000}hello world\n".trim_ascii_start(), "\u{3000}hello world\n");
/// assert_eq!(" ".trim_ascii_start(), "");
/// assert_eq!("".trim_ascii_start(), "");
/// ```
#[unstable(feature = "byte_slice_trim_ascii", issue = "94035")]
#[must_use = "this returns the trimmed string as a new slice, \
without modifying the original"]
#[inline]
pub const fn trim_ascii_start(&self) -> &str {
// SAFETY: Removing ASCII characters from a `&str` does not invalidate
// UTF-8.
unsafe { core::str::from_utf8_unchecked(self.as_bytes().trim_ascii_start()) }
}
/// Returns a string slice with trailing ASCII whitespace removed.
///
/// 'Whitespace' refers to the definition used by
/// [`u8::is_ascii_whitespace`].
///
/// [`u8::is_ascii_whitespace`]: u8::is_ascii_whitespace
///
/// # Examples
///
/// ```
/// #![feature(byte_slice_trim_ascii)]
///
/// assert_eq!("\r hello world\u{3000}\n ".trim_ascii_end(), "\r hello world\u{3000}");
/// assert_eq!(" ".trim_ascii_end(), "");
/// assert_eq!("".trim_ascii_end(), "");
/// ```
#[unstable(feature = "byte_slice_trim_ascii", issue = "94035")]
#[must_use = "this returns the trimmed string as a new slice, \
without modifying the original"]
#[inline]
pub const fn trim_ascii_end(&self) -> &str {
// SAFETY: Removing ASCII characters from a `&str` does not invalidate
// UTF-8.
unsafe { core::str::from_utf8_unchecked(self.as_bytes().trim_ascii_end()) }
}
/// Returns a string slice with leading and trailing ASCII whitespace
/// removed.
///
/// 'Whitespace' refers to the definition used by
/// [`u8::is_ascii_whitespace`].
///
/// [`u8::is_ascii_whitespace`]: u8::is_ascii_whitespace
///
/// # Examples
///
/// ```
/// #![feature(byte_slice_trim_ascii)]
///
/// assert_eq!("\r hello world\n ".trim_ascii(), "hello world");
/// assert_eq!(" ".trim_ascii(), "");
/// assert_eq!("".trim_ascii(), "");
/// ```
#[unstable(feature = "byte_slice_trim_ascii", issue = "94035")]
#[must_use = "this returns the trimmed string as a new slice, \
without modifying the original"]
#[inline]
pub const fn trim_ascii(&self) -> &str {
// SAFETY: Removing ASCII characters from a `&str` does not invalidate
// UTF-8.
unsafe { core::str::from_utf8_unchecked(self.as_bytes().trim_ascii()) }
}
/// Return an iterator that escapes each char in `self` with [`char::escape_debug`].
///
/// Note: only extended grapheme codepoints that begin the string will be

5
library/std/Cargo.toml
View file

@ -30,8 +30,13 @@ rustc-demangle = { version = "0.1.21", features = ['rustc-dep-of-std'] }
[target.'cfg(not(all(windows, target_env = "msvc", not(target_vendor = "uwp"))))'.dependencies]
miniz_oxide = { version = "0.7.0", optional = true, default-features = false }
addr2line = { version = "0.21.0", optional = true, default-features = false }
[target.'cfg(all(not(target_os = "aix"), not(all(windows, target_env = "msvc", not(target_vendor = "uwp")))))'.dependencies]
object = { version = "0.32.0", default-features = false, optional = true, features = ['read_core', 'elf', 'macho', 'pe', 'unaligned', 'archive'] }
[target.'cfg(target_os = "aix")'.dependencies]
object = { version = "0.32.0", default-features = false, optional = true, features = ['read_core', 'xcoff', 'unaligned', 'archive'] }
[dev-dependencies]
rand = { version = "0.8.5", default-features = false, features = ["alloc"] }
rand_xorshift = "0.3.0"

2
src/librustdoc/clean/mod.rs
View file

@ -727,7 +727,7 @@ pub(crate) fn clean_generics<'tcx>(
.into_iter()
.map(|(lifetime, bounds)| WherePredicate::RegionPredicate { lifetime, bounds }),
)
.chain(eq_predicates.into_iter())
.chain(eq_predicates)
.collect(),
}
}

2
src/librustdoc/html/markdown.rs
View file

@ -1381,7 +1381,7 @@ fn parse(
};
if custom_code_classes_in_docs {
call(&mut TagIterator::new(string, extra).into_iter())
call(&mut TagIterator::new(string, extra))
} else {
call(&mut tokens(string))
}

4
src/librustdoc/lint.rs
View file

@ -33,7 +33,7 @@ pub(crate) fn init_lints<F>(
let lints = || {
lint::builtin::HardwiredLints::get_lints()
.into_iter()
.chain(rustc_lint::SoftLints::get_lints().into_iter())
.chain(rustc_lint::SoftLints::get_lints())
};
let lint_opts = lints()
@ -46,7 +46,7 @@ pub(crate) fn init_lints<F>(
filter_call(lint)
}
})
.chain(lint_opts.into_iter())
.chain(lint_opts)
.collect::<Vec<_>>();
let lint_caps = lints()

2
src/librustdoc/passes/check_custom_code_classes.rs
View file

@ -48,7 +48,7 @@ struct TestsWithCustomClasses {
impl crate::doctest::Tester for TestsWithCustomClasses {
fn add_test(&mut self, _: String, config: LangString, _: usize) {
self.custom_classes_found.extend(config.added_classes.into_iter());
self.custom_classes_found.extend(config.added_classes);
}
}

9
src/librustdoc/visit_ast.rs
View file

@ -168,10 +168,11 @@ pub(crate) fn visit(mut self) -> Module<'tcx> {
})
.collect::<Vec<_>>()
})
.chain(
[Cfg::Cfg(sym::test, None), Cfg::Cfg(sym::doc, None), Cfg::Cfg(sym::doctest, None)]
.into_iter(),
)
.chain([
Cfg::Cfg(sym::test, None),
Cfg::Cfg(sym::doc, None),
Cfg::Cfg(sym::doctest, None),
])
.collect();
self.cx.cache.exact_paths = self.exact_paths;