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

Re-format code with new rustfmt

Browse Source
This commit is contained in:
Mark Rousskov 2023-11-13 08:24:55 -05:00
parent db3e2bacb6
commit 917f6540ed
70 changed files with 652 additions and 490 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
compiler/rustc_ast_passes/src/ast_validation.rs
View File

@ -1213,8 +1213,12 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
DisallowTildeConstContext::Fn(FnKind::Fn(_, ident, ..)) => {
errors::TildeConstReason::Function { ident: ident.span }
}
&DisallowTildeConstContext::Trait(span) => errors::TildeConstReason::Trait { span },
&DisallowTildeConstContext::Impl(span) => errors::TildeConstReason::Impl { span },
&DisallowTildeConstContext::Trait(span) => {
errors::TildeConstReason::Trait { span }
}
&DisallowTildeConstContext::Impl(span) => {
errors::TildeConstReason::Impl { span }
}
DisallowTildeConstContext::TraitObject => {
errors::TildeConstReason::TraitObject
}
@ -1446,9 +1450,7 @@ fn deny_equality_constraints(
id: rustc_ast::node_id::DUMMY_NODE_ID,
ident: *ident,
gen_args,
kind: AssocConstraintKind::Equality {
term: predicate.rhs_ty.clone().into(),
},
kind: AssocConstraintKind::Equality { term: predicate.rhs_ty.clone().into() },
span: ident.span,
});
// Add `<Bar = RhsTy>` to `Foo`.
@ -1461,11 +1463,7 @@ fn deny_equality_constraints(
},
empty_args => {
*empty_args = Some(
AngleBracketedArgs {
span: ident.span,
args: thin_vec![arg],
}
.into(),
AngleBracketedArgs { span: ident.span, args: thin_vec![arg] }.into(),
);
}
}

3
compiler/rustc_borrowck/src/diagnostics/move_errors.rs
View File

@ -607,7 +607,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
if let Some(adt) = local_ty.ty_adt_def()
&& adt.repr().packed()
&& let ExpnKind::Macro(MacroKind::Derive, name) = self.body.span.ctxt().outer_expn_data().kind
&& let ExpnKind::Macro(MacroKind::Derive, name) =
self.body.span.ctxt().outer_expn_data().kind
{
err.note(format!("`#[derive({name})]` triggers a move because taking references to the fields of a packed struct is undefined behaviour"));
}

13
compiler/rustc_builtin_macros/src/format.rs
View File

@ -617,10 +617,17 @@ fn report_missing_placeholders(
let placeholders = pieces
.iter()
.filter_map(|piece| {
if let parse::Piece::NextArgument(argument) = piece && let ArgumentNamed(binding) = argument.position {
let span = fmt_span.from_inner(InnerSpan::new(argument.position_span.start, argument.position_span.end));
if let parse::Piece::NextArgument(argument) = piece
&& let ArgumentNamed(binding) = argument.position
{
let span = fmt_span.from_inner(InnerSpan::new(
argument.position_span.start,
argument.position_span.end,
));
Some((span, binding))
} else { None }
} else {
None
}
})
.collect::<Vec<_>>();

5
compiler/rustc_const_eval/src/interpret/operator.rs
View File

@ -114,9 +114,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
use rustc_middle::mir::BinOp::*;
// Performs appropriate non-deterministic adjustments of NaN results.
let adjust_nan = |f: F| -> F {
if f.is_nan() { M::generate_nan(self, &[l, r]) } else { f }
};
let adjust_nan =
|f: F| -> F { if f.is_nan() { M::generate_nan(self, &[l, r]) } else { f } };
let val = match bin_op {
Eq => ImmTy::from_bool(l == r, *self.tcx),

8
compiler/rustc_expand/src/config.rs
View File

@ -74,7 +74,9 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
// - E.g. enable `test_2018_feature` if `features_edition` is 2018 or higher
let mut edition_enabled_features = FxHashSet::default();
for f in UNSTABLE_FEATURES {
if let Some(edition) = f.feature.edition && edition <= features_edition {
if let Some(edition) = f.feature.edition
&& edition <= features_edition
{
// FIXME(Manishearth) there is currently no way to set lib features by
// edition.
edition_enabled_features.insert(f.feature.name);
@ -251,8 +253,7 @@ impl<'a> StripUnconfigured<'a> {
let trees: Vec<_> = stream
.0
.iter()
.flat_map(|tree| {
match tree.clone() {
.flat_map(|tree| match tree.clone() {
AttrTokenTree::Attributes(mut data) => {
data.attrs.flat_map_in_place(|attr| self.process_cfg_attr(&attr));
@ -277,7 +278,6 @@ impl<'a> StripUnconfigured<'a> {
AttrTokenTree::Token(token, spacing) => {
Some(AttrTokenTree::Token(token, spacing)).into_iter()
}
}
})
.collect();
AttrTokenStream::new(trees)

4
compiler/rustc_hir_analysis/src/astconv/bounds.rs
View File

@ -194,8 +194,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
self.add_bounds(
param_ty,
ast_bounds.iter().filter(|bound| {
match filter {
ast_bounds.iter().filter(|bound| match filter {
PredicateFilter::All
| PredicateFilter::SelfOnly
| PredicateFilter::SelfAndAssociatedTypeBounds => true,
@ -209,7 +208,6 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
false
}
}
}
}),
&mut bounds,
ty::List::empty(),

26
compiler/rustc_hir_analysis/src/astconv/errors.rs
View File

@ -206,15 +206,14 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
&& let parent = hir.get_parent_item(hir.local_def_id_to_hir_id(def_id))
&& let Some(generics) = hir.get_generics(parent.def_id)
{
if generics.bounds_for_param(def_id)
.flat_map(|pred| pred.bounds.iter())
.any(|b| match b {
if generics.bounds_for_param(def_id).flat_map(|pred| pred.bounds.iter()).any(
|b| match b {
hir::GenericBound::Trait(t, ..) => {
t.trait_ref.trait_def_id().as_ref() == Some(best_trait)
}
_ => false,
})
{
},
) {
// The type param already has a bound for `trait_name`, we just need to
// change the associated type.
err.span_suggestion_verbose(
@ -227,15 +226,14 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
Applicability::MaybeIncorrect,
);
} else if suggest_constraining_type_param(
self.tcx(),
generics,
&mut err,
&ty_param_name,
&trait_name,
None,
None,
)
&& suggested_name != assoc_name.name
self.tcx(),
generics,
&mut err,
&ty_param_name,
&trait_name,
None,
None,
) && suggested_name != assoc_name.name
{
// We suggested constraining a type parameter, but the associated type on it
// was also not an exact match, so we also suggest changing it.

21
compiler/rustc_hir_typeck/src/expr.rs
View File

@ -3185,19 +3185,22 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
sym::offset_of_enum,
ident.span,
"using enums in offset_of is experimental",
).emit();
)
.emit();
}
let Some((index, variant)) = container_def.variants()
let Some((index, variant)) = container_def
.variants()
.iter_enumerated()
.find(|(_, v)| v.ident(self.tcx).normalize_to_macros_2_0() == ident) else {
.find(|(_, v)| v.ident(self.tcx).normalize_to_macros_2_0() == ident)
else {
let mut err = type_error_struct!(
self.tcx().sess,
ident.span,
container,
E0599,
"no variant named `{ident}` found for enum `{container}`",
);
);
err.span_label(field.span, "variant not found");
err.emit();
break;
@ -3209,7 +3212,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
container,
E0795,
"`{ident}` is an enum variant; expected field at end of `offset_of`",
);
);
err.span_label(field.span, "enum variant");
err.emit();
break;
@ -3217,16 +3220,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let (subident, sub_def_scope) =
self.tcx.adjust_ident_and_get_scope(subfield, variant.def_id, block);
let Some((subindex, field)) = variant.fields
let Some((subindex, field)) = variant
.fields
.iter_enumerated()
.find(|(_, f)| f.ident(self.tcx).normalize_to_macros_2_0() == subident) else {
.find(|(_, f)| f.ident(self.tcx).normalize_to_macros_2_0() == subident)
else {
let mut err = type_error_struct!(
self.tcx().sess,
ident.span,
container,
E0609,
"no field named `{subfield}` on enum variant `{container}::{ident}`",
);
);
err.span_label(field.span, "this enum variant...");
err.span_label(subident.span, "...does not have this field");
err.emit();

45
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
View File

@ -1864,35 +1864,42 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
&& let ExprBindingObligation(_, _, hir_id, ..) = code
&& !fn_sig.output().is_unit()
{
let mut block_num = 0;
let mut found_semi = false;
for (_, node) in self.tcx.hir().parent_iter(hir_id) {
match node {
hir::Node::Stmt(stmt) => if let hir::StmtKind::Semi(ref expr) = stmt.kind {
let mut block_num = 0;
let mut found_semi = false;
for (_, node) in self.tcx.hir().parent_iter(hir_id) {
match node {
hir::Node::Stmt(stmt) => {
if let hir::StmtKind::Semi(ref expr) = stmt.kind {
let expr_ty = self.typeck_results.borrow().expr_ty(expr);
let return_ty = fn_sig.output();
if !matches!(expr.kind, hir::ExprKind::Ret(..)) &&
self.can_coerce(expr_ty, return_ty) {
if !matches!(expr.kind, hir::ExprKind::Ret(..))
&& self.can_coerce(expr_ty, return_ty)
{
found_semi = true;
}
},
hir::Node::Block(_block) => if found_semi {
}
}
hir::Node::Block(_block) => {
if found_semi {
block_num += 1;
}
hir::Node::Item(item) => if let hir::ItemKind::Fn(..) = item.kind {
}
hir::Node::Item(item) => {
if let hir::ItemKind::Fn(..) = item.kind {
break;
}
_ => {}
}
_ => {}
}
if block_num > 1 && found_semi {
diag.span_suggestion_verbose(
span.shrink_to_lo(),
"you might have meant to return this to infer its type parameters",
"return ",
Applicability::MaybeIncorrect,
);
}
}
if block_num > 1 && found_semi {
diag.span_suggestion_verbose(
span.shrink_to_lo(),
"you might have meant to return this to infer its type parameters",
"return ",
Applicability::MaybeIncorrect,
);
}
}
diag.emit();
}

153
compiler/rustc_hir_typeck/src/method/suggest.rs
View File

@ -1,6 +1,8 @@
//! Give useful errors and suggestions to users when an item can't be
//! found or is otherwise invalid.
// ignore-tidy-filelength
use crate::errors;
use crate::errors::{CandidateTraitNote, NoAssociatedItem};
use crate::Expectation;
@ -369,25 +371,23 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
tcx.is_diagnostic_item(sym::write_macro, def_id)
|| tcx.is_diagnostic_item(sym::writeln_macro, def_id)
}) && item_name.name == Symbol::intern("write_fmt");
let mut err =
if is_write && let SelfSource::MethodCall(rcvr_expr) = source
{
self.suggest_missing_writer(rcvr_ty, rcvr_expr)
} else {
tcx.sess.create_err(NoAssociatedItem {
span,
item_kind,
item_name,
ty_prefix: if trait_missing_method {
// FIXME(mu001999) E0599 maybe not suitable here because it is for types
Cow::from("trait")
} else {
rcvr_ty.prefix_string(self.tcx)
},
ty_str: ty_str_reported,
trait_missing_method,
})
};
let mut err = if is_write && let SelfSource::MethodCall(rcvr_expr) = source {
self.suggest_missing_writer(rcvr_ty, rcvr_expr)
} else {
tcx.sess.create_err(NoAssociatedItem {
span,
item_kind,
item_name,
ty_prefix: if trait_missing_method {
// FIXME(mu001999) E0599 maybe not suitable here because it is for types
Cow::from("trait")
} else {
rcvr_ty.prefix_string(self.tcx)
},
ty_str: ty_str_reported,
trait_missing_method,
})
};
if tcx.sess.source_map().is_multiline(sugg_span) {
err.span_label(sugg_span.with_hi(span.lo()), "");
}
@ -1240,20 +1240,27 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
}
// If an appropriate error source is not found, check method chain for possible candiates
if unsatisfied_predicates.is_empty() && let Mode::MethodCall = mode && let SelfSource::MethodCall(mut source_expr) = source {
if unsatisfied_predicates.is_empty()
&& let Mode::MethodCall = mode
&& let SelfSource::MethodCall(mut source_expr) = source
{
let mut stack_methods = vec![];
while let hir::ExprKind::MethodCall(_path_segment, rcvr_expr, _args, method_span) =
source_expr.kind
source_expr.kind
{
// Pop the matching receiver, to align on it's notional span
if let Some(prev_match) = stack_methods.pop() {
err.span_label(method_span, format!("{item_kind} `{item_name}` is available on `{prev_match}`"));
// Pop the matching receiver, to align on it's notional span
if let Some(prev_match) = stack_methods.pop() {
err.span_label(
method_span,
format!("{item_kind} `{item_name}` is available on `{prev_match}`"),
);
}
let rcvr_ty = self.resolve_vars_if_possible(
self.typeck_results
.borrow()
.expr_ty_adjusted_opt(rcvr_expr)
.unwrap_or(Ty::new_misc_error(self.tcx)),);
.unwrap_or(Ty::new_misc_error(self.tcx)),
);
for _matched_method in self.probe_for_name_many(
Mode::MethodCall,
@ -1262,15 +1269,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
IsSuggestion(true),
rcvr_ty,
source_expr.hir_id,
ProbeScope::TraitsInScope,) {
// found a match, push to stack
stack_methods.push(rcvr_ty);
ProbeScope::TraitsInScope,
) {
// found a match, push to stack
stack_methods.push(rcvr_ty);
}
source_expr = rcvr_expr;
}
// If there is a match at the start of the chain, add a label for it too!
if let Some(prev_match) = stack_methods.pop() {
err.span_label(source_expr.span, format!("{item_kind} `{item_name}` is available on `{prev_match}`"));
err.span_label(
source_expr.span,
format!("{item_kind} `{item_name}` is available on `{prev_match}`"),
);
}
}
self.note_derefed_ty_has_method(&mut err, source, rcvr_ty, item_name, expected);
@ -1357,10 +1368,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
err,
self_source,
args,
trait_ref.instantiate(
self.tcx,
self.fresh_args_for_item(sugg_span, impl_did)
).with_self_ty(self.tcx, rcvr_ty),
trait_ref
.instantiate(
self.tcx,
self.fresh_args_for_item(sugg_span, impl_did),
)
.with_self_ty(self.tcx, rcvr_ty),
idx,
sugg_span,
item,
@ -1397,8 +1410,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
ty::TraitRef::new(
self.tcx,
trait_did,
self.fresh_args_for_item(sugg_span, trait_did)
).with_self_ty(self.tcx, rcvr_ty),
self.fresh_args_for_item(sugg_span, trait_did),
)
.with_self_ty(self.tcx, rcvr_ty),
idx,
sugg_span,
item,
@ -1409,7 +1423,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
}
}
if !suggs.is_empty() && let Some(span) = sugg_span {
if !suggs.is_empty()
&& let Some(span) = sugg_span
{
err.span_suggestions(
span.with_hi(item_name.span.lo()),
"use fully-qualified syntax to disambiguate",
@ -1585,39 +1601,39 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
};
let mut applicability = Applicability::MachineApplicable;
let args = if let SelfSource::MethodCall(receiver) = source
&& let Some(args) = args
{
// The first arg is the same kind as the receiver
let explicit_args = if first_arg.is_some() {
std::iter::once(receiver).chain(args.iter()).collect::<Vec<_>>()
} else {
// There is no `Self` kind to infer the arguments from
if has_unsuggestable_args {
applicability = Applicability::HasPlaceholders;
}
args.iter().collect()
};
format!(
"({}{})",
first_arg.unwrap_or(""),
explicit_args
.iter()
.map(|arg| self
.tcx
.sess
.source_map()
.span_to_snippet(arg.span)
.unwrap_or_else(|_| {
applicability = Applicability::HasPlaceholders;
"_".to_owned()
}))
.collect::<Vec<_>>()
.join(", "),
)
&& let Some(args) = args
{
// The first arg is the same kind as the receiver
let explicit_args = if first_arg.is_some() {
std::iter::once(receiver).chain(args.iter()).collect::<Vec<_>>()
} else {
applicability = Applicability::HasPlaceholders;
"(...)".to_owned()
// There is no `Self` kind to infer the arguments from
if has_unsuggestable_args {
applicability = Applicability::HasPlaceholders;
}
args.iter().collect()
};
format!(
"({}{})",
first_arg.unwrap_or(""),
explicit_args
.iter()
.map(|arg| self
.tcx
.sess
.source_map()
.span_to_snippet(arg.span)
.unwrap_or_else(|_| {
applicability = Applicability::HasPlaceholders;
"_".to_owned()
}))
.collect::<Vec<_>>()
.join(", "),
)
} else {
applicability = Applicability::HasPlaceholders;
"(...)".to_owned()
};
err.span_suggestion(
sugg_span,
"use associated function syntax instead",
@ -3296,7 +3312,8 @@ fn print_disambiguation_help<'tcx>(
{
let def_kind_descr = tcx.def_kind_descr(item.kind.as_def_kind(), item.def_id);
let item_name = item.ident(tcx);
let rcvr_ref = tcx.fn_sig(item.def_id)
let rcvr_ref = tcx
.fn_sig(item.def_id)
.skip_binder()
.skip_binder()
.inputs()

3
compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs
View File

@ -87,7 +87,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
| (ty::Alias(ty::Projection, proj), ty::Param(p))
if !tcx.is_impl_trait_in_trait(proj.def_id) =>
{
let parent = tcx.generics_of(body_owner_def_id)
let parent = tcx
.generics_of(body_owner_def_id)
.opt_type_param(p, tcx)
.and_then(|param| {
let p_def_id = param.def_id;

4
compiler/rustc_infer/src/infer/outlives/for_liveness.rs
View File

@ -112,7 +112,9 @@ where
};
for (idx, s) in args.iter().enumerate() {
if variances.map(|variances| variances[idx]) != Some(ty::Variance::Bivariant) {
if variances.map(|variances| variances[idx])
!= Some(ty::Variance::Bivariant)
{
s.visit_with(self)?;
}
}

24
compiler/rustc_interface/src/interface.rs
View File

@ -178,7 +178,9 @@ pub(crate) fn parse_check_cfg(handler: &EarlyErrorHandler, specs: Vec<String>) -
check_cfg.exhaustive_names = true;
for arg in args {
if arg.is_word() && let Some(ident) = arg.ident() {
if arg.is_word()
&& let Some(ident) = arg.ident()
{
check_cfg.expecteds.entry(ident.name).or_insert(ExpectedValues::Any);
} else {
error!("`names()` arguments must be simple identifiers");
@ -188,7 +190,9 @@ pub(crate) fn parse_check_cfg(handler: &EarlyErrorHandler, specs: Vec<String>) -
set_old_syntax();
if let Some((name, values)) = args.split_first() {
if name.is_word() && let Some(ident) = name.ident() {
if name.is_word()
&& let Some(ident) = name.ident()
{
let expected_values = check_cfg
.expecteds
.entry(ident.name)
@ -236,12 +240,16 @@ pub(crate) fn parse_check_cfg(handler: &EarlyErrorHandler, specs: Vec<String>) -
let mut values_any_specified = false;
for arg in args {
if arg.is_word() && let Some(ident) = arg.ident() {
if arg.is_word()
&& let Some(ident) = arg.ident()
{
if values_specified {
error!("`cfg()` names cannot be after values");
}
names.push(ident);
} else if arg.has_name(sym::any) && let Some(args) = arg.meta_item_list() {
} else if arg.has_name(sym::any)
&& let Some(args) = arg.meta_item_list()
{
if any_specified {
error!("`any()` cannot be specified multiple times");
}
@ -249,7 +257,9 @@ pub(crate) fn parse_check_cfg(handler: &EarlyErrorHandler, specs: Vec<String>) -
if !args.is_empty() {
error!("`any()` must be empty");
}
} else if arg.has_name(sym::values) && let Some(args) = arg.meta_item_list() {
} else if arg.has_name(sym::values)
&& let Some(args) = arg.meta_item_list()
{
if names.is_empty() {
error!("`values()` cannot be specified before the names");
} else if values_specified {
@ -260,7 +270,9 @@ pub(crate) fn parse_check_cfg(handler: &EarlyErrorHandler, specs: Vec<String>) -
for arg in args {
if let Some(LitKind::Str(s, _)) = arg.lit().map(|lit| &lit.kind) {
values.insert(Some(*s));
} else if arg.has_name(sym::any) && let Some(args) = arg.meta_item_list() {
} else if arg.has_name(sym::any)
&& let Some(args) = arg.meta_item_list()
{
if values_any_specified {
error!("`any()` in `values()` cannot be specified multiple times");
}

4
compiler/rustc_interface/src/util.rs
View File

@ -415,7 +415,9 @@ pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<C
let mut base = session.opts.crate_types.clone();
if base.is_empty() {
let attr_types = attrs.iter().filter_map(|a| {
if a.has_name(sym::crate_type) && let Some(s) = a.value_str() {
if a.has_name(sym::crate_type)
&& let Some(s) = a.value_str()
{
categorize_crate_type(s)
} else {
None

4
compiler/rustc_macros/src/symbols.rs
View File

@ -85,7 +85,9 @@ impl Parse for Value {
}
}
Expr::Macro(expr) => {
if expr.mac.path.is_ident("env") && let Ok(lit) = expr.mac.parse_body() {
if expr.mac.path.is_ident("env")
&& let Ok(lit) = expr.mac.parse_body()
{
return Ok(Value::Env(lit, expr.mac.clone()));
}
}

16
compiler/rustc_metadata/src/rmeta/encoder.rs
View File

@ -2396,8 +2396,10 @@ pub fn rendered_const<'tcx>(tcx: TyCtxt<'tcx>, body: hir::BodyId) -> String {
// * character escapes
//
// FIXME: This passes through `-/*spacer*/0` verbatim.
Literal if !value.span.from_expansion()
&& let Ok(snippet) = tcx.sess.source_map().span_to_snippet(value.span) => {
Literal
if !value.span.from_expansion()
&& let Ok(snippet) = tcx.sess.source_map().span_to_snippet(value.span) =>
{
snippet
}
@ -2408,10 +2410,12 @@ pub fn rendered_const<'tcx>(tcx: TyCtxt<'tcx>, body: hir::BodyId) -> String {
// FIXME: Omit the curly braces if the enclosing expression is an array literal
// with a repeated element (an `ExprKind::Repeat`) as in such case it
// would not actually need any disambiguation.
Complex => if tcx.def_kind(hir.body_owner_def_id(body).to_def_id()) == DefKind::AnonConst {
"{ _ }".to_owned()
} else {
"_".to_owned()
Complex => {
if tcx.def_kind(hir.body_owner_def_id(body).to_def_id()) == DefKind::AnonConst {
"{ _ }".to_owned()
} else {
"_".to_owned()
}
}
}
}

6
compiler/rustc_middle/src/mir/spanview.rs
View File

@ -507,11 +507,7 @@ fn write_span<W>(
where
W: Write,
{
let maybe_alt_class = if layer > 0 {
if alt { " odd" } else { " even" }
} else {
""
};
let maybe_alt_class = if layer > 0 { if alt { " odd" } else { " even" } } else { "" };
let maybe_title_attr = if !tooltip.is_empty() {
format!(" title=\"{}\"", escape_attr(tooltip))
} else {

4
compiler/rustc_middle/src/mir/terminator.rs
View File

@ -28,7 +28,9 @@ impl SwitchTargets {
/// Inverse of `SwitchTargets::static_if`.
pub fn as_static_if(&self) -> Option<(u128, BasicBlock, BasicBlock)> {
if let &[value] = &self.values[..] && let &[then, else_] = &self.targets[..] {
if let &[value] = &self.values[..]
&& let &[then, else_] = &self.targets[..]
{
Some((value, then, else_))
} else {
None

4
compiler/rustc_middle/src/thir.rs
View File

@ -655,7 +655,9 @@ impl<'tcx> Pat<'tcx> {
pub fn pat_error_reported(&self) -> Result<(), ErrorGuaranteed> {
let mut error = None;
self.walk(|pat| {
if let PatKind::Error(e) = pat.kind && error.is_none() {
if let PatKind::Error(e) = pat.kind
&& error.is_none()
{
error = Some(e);
}
error.is_none()

8
compiler/rustc_mir_build/src/thir/cx/expr.rs
View File

@ -192,10 +192,10 @@ impl<'tcx> Cx<'tcx> {
cast: PointerCoercion::ArrayToPointer,
}
} else if let hir::ExprKind::Path(ref qpath) = source.kind
&& let res = self.typeck_results().qpath_res(qpath, source.hir_id)
&& let ty = self.typeck_results().node_type(source.hir_id)
&& let ty::Adt(adt_def, args) = ty.kind()
&& let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), variant_ctor_id) = res
&& let res = self.typeck_results().qpath_res(qpath, source.hir_id)
&& let ty = self.typeck_results().node_type(source.hir_id)
&& let ty::Adt(adt_def, args) = ty.kind()
&& let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), variant_ctor_id) = res
{
// Check whether this is casting an enum variant discriminant.
// To prevent cycles, we refer to the discriminant initializer,

4
compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
View File

@ -200,7 +200,9 @@ impl<'tcx> ConstToPat<'tcx> {
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
let kind = PatKind::Error(e);
return Box::new(Pat { span: self.span, ty: cv.ty(), kind });
} else if let ty::Adt(..) = cv.ty().kind() && matches!(cv, mir::Const::Val(..)) {
} else if let ty::Adt(..) = cv.ty().kind()
&& matches!(cv, mir::Const::Val(..))
{
// This branch is only entered when the current `cv` is `mir::Const::Val`.
// This is because `mir::Const::ty` has already been handled by `Self::recur`
// and the invalid types may be ignored.

4
compiler/rustc_mir_transform/src/cost_checker.rs
View File

@ -69,7 +69,9 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {
}
TerminatorKind::Call { func: Operand::Constant(ref f), unwind, .. } => {
let fn_ty = self.instantiate_ty(f.const_.ty());
self.cost += if let ty::FnDef(def_id, _) = *fn_ty.kind() && tcx.is_intrinsic(def_id) {
self.cost += if let ty::FnDef(def_id, _) = *fn_ty.kind()
&& tcx.is_intrinsic(def_id)
{
// Don't give intrinsics the extra penalty for calls
INSTR_COST
} else {

4
compiler/rustc_mir_transform/src/coverage/counters.rs
View File

@ -138,7 +138,9 @@ impl CoverageCounters {
// If the BCB has an edge counter (to be injected into a new `BasicBlock`), it can also
// have an expression (to be injected into an existing `BasicBlock` represented by this
// `BasicCoverageBlock`).
if let Some(node_counter) = self.bcb_counter(to_bcb) && !node_counter.is_expression() {
if let Some(node_counter) = self.bcb_counter(to_bcb)
&& !node_counter.is_expression()
{
bug!(
"attempt to add an incoming edge counter from {from_bcb:?} \
when the target BCB already has {node_counter:?}"

4
compiler/rustc_mir_transform/src/coverage/spans.rs
View File

@ -475,7 +475,9 @@ impl<'a> CoverageSpansGenerator<'a> {
}
while let Some(curr) = self.sorted_spans_iter.next() {
debug!("FOR curr={:?}", curr);
if let Some(prev) = &self.some_prev && prev.span.lo() > curr.span.lo() {
if let Some(prev) = &self.some_prev
&& prev.span.lo() > curr.span.lo()
{
// Skip curr because prev has already advanced beyond the end of curr.
// This can only happen if a prior iteration updated `prev` to skip past
// a region of code, such as skipping past a closure.

7
compiler/rustc_mir_transform/src/dataflow_const_prop.rs
View File

@ -597,7 +597,9 @@ fn propagatable_scalar(
state: &State<FlatSet<Scalar>>,
map: &Map,
) -> Option<Scalar> {
if let FlatSet::Elem(value) = state.get_idx(place, map) && value.try_to_int().is_ok() {
if let FlatSet::Elem(value) = state.get_idx(place, map)
&& value.try_to_int().is_ok()
{
// Do not attempt to propagate pointers, as we may fail to preserve their identity.
Some(value)
} else {
@ -836,7 +838,8 @@ impl<'tcx> Visitor<'tcx> for OperandCollector<'tcx, '_, '_, '_> {
location: Location,
) {
if let PlaceElem::Index(local) = elem
&& let Some(value) = self.visitor.try_make_constant(self.ecx, local.into(), self.state, self.map)
&& let Some(value) =
self.visitor.try_make_constant(self.ecx, local.into(), self.state, self.map)
{
self.visitor.patch.before_effect.insert((location, local.into()), value);
}

11
compiler/rustc_mir_transform/src/gvn.rs
View File

@ -461,7 +461,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
}
NullaryOp(null_op, ty) => {
let layout = self.ecx.layout_of(ty).ok()?;
if let NullOp::SizeOf | NullOp::AlignOf = null_op && layout.is_unsized() {
if let NullOp::SizeOf | NullOp::AlignOf = null_op
&& layout.is_unsized()
{
return None;
}
let val = match null_op {
@ -865,7 +867,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
.collect();
let fields = fields?;
if let AggregateTy::Array = ty && fields.len() > 4 {
if let AggregateTy::Array = ty
&& fields.len() > 4
{
let first = fields[0];
if fields.iter().all(|&v| v == first) {
let len = ty::Const::from_target_usize(self.tcx, fields.len().try_into().unwrap());
@ -1008,8 +1012,7 @@ impl<'tcx> MutVisitor<'tcx> for VnState<'_, 'tcx> {
// Do not try to simplify a constant, it's already in canonical shape.
&& !matches!(rvalue, Rvalue::Use(Operand::Constant(_)))
{
if let Some(value) = self.simplify_rvalue(rvalue, location)
{
if let Some(value) = self.simplify_rvalue(rvalue, location) {
if let Some(const_) = self.try_as_constant(value) {
*rvalue = Rvalue::Use(Operand::Constant(Box::new(const_)));
} else if let Some(local) = self.try_as_local(value, location)

10
compiler/rustc_mir_transform/src/jump_threading.rs
View File

@ -247,7 +247,9 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
let last_non_rec = self.opportunities.len();
let predecessors = &self.body.basic_blocks.predecessors()[bb];
if let &[pred] = &predecessors[..] && bb != START_BLOCK {
if let &[pred] = &predecessors[..]
&& bb != START_BLOCK
{
let term = self.body.basic_blocks[pred].terminator();
match term.kind {
TerminatorKind::SwitchInt { ref discr, ref targets } => {
@ -419,8 +421,10 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
// Do not support unions.
AggregateKind::Adt(.., Some(_)) => return None,
AggregateKind::Adt(_, variant_index, ..) if agg_ty.is_enum() => {
if let Some(discr_target) = self.map.apply(lhs, TrackElem::Discriminant)
&& let Some(discr_value) = discriminant_for_variant(agg_ty, *variant_index)
if let Some(discr_target) =
self.map.apply(lhs, TrackElem::Discriminant)
&& let Some(discr_value) =
discriminant_for_variant(agg_ty, *variant_index)
{
self.process_operand(bb, discr_target, &discr_value, state);
}

4
compiler/rustc_parse/src/parser/diagnostics.rs
View File

@ -506,7 +506,9 @@ impl<'a> Parser<'a> {
if expected.contains(&TokenType::Token(token::Semi)) {
// If the user is trying to write a ternary expression, recover it and
// return an Err to prevent a cascade of irrelevant diagnostics
if self.prev_token == token::Question && let Err(e) = self.maybe_recover_from_ternary_operator() {
if self.prev_token == token::Question
&& let Err(e) = self.maybe_recover_from_ternary_operator()
{
return Err(e);
}

18
compiler/rustc_parse/src/parser/mod.rs
View File

@ -107,15 +107,15 @@ macro_rules! maybe_whole {
macro_rules! maybe_recover_from_interpolated_ty_qpath {
($self: expr, $allow_qpath_recovery: expr) => {
if $allow_qpath_recovery
&& $self.may_recover()
&& $self.look_ahead(1, |t| t == &token::ModSep)
&& let token::Interpolated(nt) = &$self.token.kind
&& let token::NtTy(ty) = &**nt
{
let ty = ty.clone();
$self.bump();
return $self.maybe_recover_from_bad_qpath_stage_2($self.prev_token.span, ty);
}
&& $self.may_recover()
&& $self.look_ahead(1, |t| t == &token::ModSep)
&& let token::Interpolated(nt) = &$self.token.kind
&& let token::NtTy(ty) = &**nt
{
let ty = ty.clone();
$self.bump();
return $self.maybe_recover_from_bad_qpath_stage_2($self.prev_token.span, ty);
}
};
}

5
compiler/rustc_passes/src/stability.rs
View File

@ -196,7 +196,10 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
}
}
if let Some((depr, span)) = &depr && depr.is_since_rustc_version() && stab.is_none() {
if let Some((depr, span)) = &depr
&& depr.is_since_rustc_version()
&& stab.is_none()
{
self.tcx.sess.emit_err(errors::DeprecatedAttribute { span: *span });
}

10
compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs
View File

@ -187,11 +187,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
if let Some(kind) = self.tcx.fn_trait_kind_from_def_id(trait_ref.def_id)
&& let ty::Tuple(args) = trait_ref.args.type_at(1).kind()
{
let args = args
.iter()
.map(|ty| ty.to_string())
.collect::<Vec<_>>()
.join(", ");
let args = args.iter().map(|ty| ty.to_string()).collect::<Vec<_>>().join(", ");
flags.push((sym::Trait, Some(format!("{}({args})", kind.as_str()))));
} else {
flags.push((sym::Trait, Some(trait_ref.print_only_trait_path().to_string())));
@ -636,7 +632,9 @@ impl<'tcx> OnUnimplementedDirective {
let value = cfg.value.map(|v| {
// `with_no_visible_paths` is also used when generating the options,
// so we need to match it here.
ty::print::with_no_visible_paths!(OnUnimplementedFormatString(v).format(tcx, trait_ref, &options_map))
ty::print::with_no_visible_paths!(
OnUnimplementedFormatString(v).format(tcx, trait_ref, &options_map)
)
});
options.contains(&(cfg.name, value))

70
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View File

@ -2723,11 +2723,14 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
.collect::<Vec<_>>();
if !impls.is_empty() {
let len = impls.len();
let mut types = impls.iter()
.map(|t| with_no_trimmed_paths!(format!(
" {}",
tcx.type_of(*t).instantiate_identity(),
)))
let mut types = impls
.iter()
.map(|t| {
with_no_trimmed_paths!(format!(
" {}",
tcx.type_of(*t).instantiate_identity(),
))
})
.collect::<Vec<_>>();
let post = if types.len() > 9 {
types.truncate(8);
@ -2769,30 +2772,47 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
));
}
}
ObligationCauseCode::RepeatElementCopy { is_constable, elt_type, elt_span, elt_stmt_span } => {
ObligationCauseCode::RepeatElementCopy {
is_constable,
elt_type,
elt_span,
elt_stmt_span,
} => {
err.note(
"the `Copy` trait is required because this value will be copied for each element of the array",
);
let value_kind = match is_constable {
IsConstable::Fn => Some("the result of the function call"),
IsConstable::Ctor => Some("the result of the constructor"),
_ => None
_ => None,
};
let sm = tcx.sess.source_map();
if let Some(value_kind) = value_kind &&
let Ok(snip) = sm.span_to_snippet(elt_span)
if let Some(value_kind) = value_kind
&& let Ok(snip) = sm.span_to_snippet(elt_span)
{
let help_msg = format!(
"consider creating a new `const` item and initializing it with {value_kind} \
to be used in the repeat position");
to be used in the repeat position"
);
let indentation = sm.indentation_before(elt_stmt_span).unwrap_or_default();
err.multipart_suggestion(help_msg, vec![
(elt_stmt_span.shrink_to_lo(), format!("const ARRAY_REPEAT_VALUE: {elt_type} = {snip};\n{indentation}")),
(elt_span, "ARRAY_REPEAT_VALUE".to_string())
], Applicability::MachineApplicable);
err.multipart_suggestion(
help_msg,
vec![
(
elt_stmt_span.shrink_to_lo(),
format!(
"const ARRAY_REPEAT_VALUE: {elt_type} = {snip};\n{indentation}"
),
),
(elt_span, "ARRAY_REPEAT_VALUE".to_string()),
],
Applicability::MachineApplicable,
);
}
if self.tcx.sess.is_nightly_build() && matches!(is_constable, IsConstable::Fn|IsConstable::Ctor) {
if self.tcx.sess.is_nightly_build()
&& matches!(is_constable, IsConstable::Fn | IsConstable::Ctor)
{
err.help(
"create an inline `const` block, see RFC #2920 \
<https://github.com/rust-lang/rfcs/pull/2920> for more information",
@ -2957,7 +2977,9 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
}
ObligationCauseCode::SizedCoroutineInterior(coroutine_def_id) => {
let what = match self.tcx.coroutine_kind(coroutine_def_id) {
None | Some(hir::CoroutineKind::Coroutine) | Some(hir::CoroutineKind::Gen(_)) => "yield",
None
| Some(hir::CoroutineKind::Coroutine)
| Some(hir::CoroutineKind::Gen(_)) => "yield",
Some(hir::CoroutineKind::Async(..)) => "await",
};
err.note(format!(
@ -3519,7 +3541,8 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
{
if let hir::Expr { kind: hir::ExprKind::Block(block, _), .. } = expr {
let inner_expr = expr.peel_blocks();
let ty = typeck_results.expr_ty_adjusted_opt(inner_expr)
let ty = typeck_results
.expr_ty_adjusted_opt(inner_expr)
.unwrap_or(Ty::new_misc_error(tcx));
let span = inner_expr.span;
if Some(span) != err.span.primary_span() {
@ -3538,14 +3561,13 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
tcx.lang_items().fn_once_trait(),
tcx.lang_items().fn_mut_trait(),
tcx.lang_items().fn_trait(),
].contains(&Some(pred.def_id()))
]
.contains(&Some(pred.def_id()))
{
if let [stmt, ..] = block.stmts
&& let hir::StmtKind::Semi(value) = stmt.kind
&& let hir::ExprKind::Closure(hir::Closure {
body,
fn_decl_span,
..
body, fn_decl_span, ..
}) = value.kind
&& let body = hir.body(*body)
&& !matches!(body.value.kind, hir::ExprKind::Block(..))
@ -3568,9 +3590,11 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
"you might have meant to create the closure instead of a block",
format!(
"|{}| ",
(0..pred.trait_ref.args.len() - 1).map(|_| "_")
(0..pred.trait_ref.args.len() - 1)
.map(|_| "_")
.collect::<Vec<_>>()
.join(", ")),
.join(", ")
),
Applicability::MaybeIncorrect,
);
}

6
compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
View File

@ -928,10 +928,8 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
}
fn fn_arg_obligation(&self, obligation: &PredicateObligation<'tcx>) -> bool {
if let ObligationCauseCode::FunctionArgumentObligation {
arg_hir_id,
..
} = obligation.cause.code()
if let ObligationCauseCode::FunctionArgumentObligation { arg_hir_id, .. } =
obligation.cause.code()
&& let Some(Node::Expr(arg)) = self.tcx.hir().find(*arg_hir_id)
&& let arg = arg.peel_borrows()
&& let hir::ExprKind::Path(hir::QPath::Resolved(

6
compiler/rustc_ty_utils/src/ty.rs
View File

@ -203,11 +203,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ImplTraitInTraitFinder<'_, 'tcx> {
"we shouldn't walk non-predicate binders with `impl Trait`...",
);
}
ty::Region::new_bound(
self.tcx,
index.shifted_out_to_binder(self.depth),
bv,
)
ty::Region::new_bound(self.tcx, index.shifted_out_to_binder(self.depth), bv)
} else {
re
}

4
library/alloc/src/vec/into_iter.rs
View File

@ -285,9 +285,7 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> {
// Also note the implementation of `Self: TrustedRandomAccess` requires
// that `T: Copy` so reading elements from the buffer doesn't invalidate
// them for `Drop`.
unsafe {
if T::IS_ZST { mem::zeroed() } else { ptr::read(self.ptr.add(i)) }
}
unsafe { if T::IS_ZST { mem::zeroed() } else { ptr::read(self.ptr.add(i)) } }
}
}

16
library/core/src/escape.rs
View File

@ -21,12 +21,16 @@ pub(crate) fn escape_ascii_into(output: &mut [ascii::Char; 4], byte: u8) -> Rang
b'\\' => backslash(ascii::Char::ReverseSolidus),
b'\'' => backslash(ascii::Char::Apostrophe),
b'\"' => backslash(ascii::Char::QuotationMark),
_ => if let Some(a) = byte.as_ascii() && !byte.is_ascii_control() {
([a, ascii::Char::Null, ascii::Char::Null, ascii::Char::Null], 1)
} else {
let hi = HEX_DIGITS[usize::from(byte >> 4)];
let lo = HEX_DIGITS[usize::from(byte & 0xf)];
([ascii::Char::ReverseSolidus, ascii::Char::SmallX, hi, lo], 4)
_ => {
if let Some(a) = byte.as_ascii()
&& !byte.is_ascii_control()
{
([a, ascii::Char::Null, ascii::Char::Null, ascii::Char::Null], 1)
} else {
let hi = HEX_DIGITS[usize::from(byte >> 4)];
let lo = HEX_DIGITS[usize::from(byte & 0xf)];
([ascii::Char::ReverseSolidus, ascii::Char::SmallX, hi, lo], 4)
}
}
};
*output = data;

6
library/core/src/iter/adapters/step_by.rs
View File

@ -83,11 +83,7 @@ where
// last element. Used in the `DoubleEndedIterator` implementation.
fn next_back_index(&self) -> usize {
let rem = self.iter.len() % (self.step + 1);
if self.first_take {
if rem == 0 { self.step } else { rem - 1 }
} else {
rem
}
if self.first_take { if rem == 0 { self.step } else { rem - 1 } } else { rem }
}
}

5
library/core/src/mem/maybe_uninit.rs
View File

@ -691,10 +691,7 @@ impl<T> MaybeUninit<T> {
/// // they both get dropped!
/// ```
#[stable(feature = "maybe_uninit_extra", since = "1.60.0")]
#[rustc_const_stable(
feature = "const_maybe_uninit_assume_init_read",
since = "1.75.0"
)]
#[rustc_const_stable(feature = "const_maybe_uninit_assume_init_read", since = "1.75.0")]
#[inline(always)]
#[track_caller]
pub const unsafe fn assume_init_read(&self) -> T {

18
library/std/src/sys/unix/fs.rs
View File

@ -1300,13 +1300,17 @@ impl File {
pub fn set_times(&self, times: FileTimes) -> io::Result<()> {
#[cfg(not(any(target_os = "redox", target_os = "espidf", target_os = "horizon")))]
let to_timespec = |time: Option<SystemTime>| {
match time {
Some(time) if let Some(ts) = time.t.to_timespec() => Ok(ts),
Some(time) if time > crate::sys::time::UNIX_EPOCH => Err(io::const_io_error!(io::ErrorKind::InvalidInput, "timestamp is too large to set as a file time")),
Some(_) => Err(io::const_io_error!(io::ErrorKind::InvalidInput, "timestamp is too small to set as a file time")),
None => Ok(libc::timespec { tv_sec: 0, tv_nsec: libc::UTIME_OMIT as _ }),
}
let to_timespec = |time: Option<SystemTime>| match time {
Some(time) if let Some(ts) = time.t.to_timespec() => Ok(ts),
Some(time) if time > crate::sys::time::UNIX_EPOCH => Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"timestamp is too large to set as a file time"
)),
Some(_) => Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"timestamp is too small to set as a file time"
)),
None => Ok(libc::timespec { tv_sec: 0, tv_nsec: libc::UTIME_OMIT as _ }),
};
cfg_if::cfg_if! {
if #[cfg(any(target_os = "redox", target_os = "espidf", target_os = "horizon"))] {

10
library/std/src/sys/unix/os.rs
View File

@ -274,15 +274,19 @@ pub fn current_exe() -> io::Result<PathBuf> {
return path.canonicalize();
}
// Search PWD to infer current_exe.
if let Some(pstr) = path.to_str() && pstr.contains("/") {
if let Some(pstr) = path.to_str()
&& pstr.contains("/")
{
return getcwd().map(|cwd| cwd.join(path))?.canonicalize();
}
// Search PATH to infer current_exe.
if let Some(p) = getenv(OsStr::from_bytes("PATH".as_bytes())) {
for search_path in split_paths(&p) {
let pb = search_path.join(&path);
if pb.is_file() && let Ok(metadata) = crate::fs::metadata(&pb) &&
metadata.permissions().mode() & 0o111 != 0 {
if pb.is_file()
&& let Ok(metadata) = crate::fs::metadata(&pb)
&& metadata.permissions().mode() & 0o111 != 0
{
return pb.canonicalize();
}
}

13
library/std/src/sys/wasi/fs.rs
View File

@ -477,12 +477,13 @@ impl File {
}
pub fn set_times(&self, times: FileTimes) -> io::Result<()> {
let to_timestamp = |time: Option<SystemTime>| {
match time {
Some(time) if let Some(ts) = time.to_wasi_timestamp() => Ok(ts),
Some(_) => Err(io::const_io_error!(io::ErrorKind::InvalidInput, "timestamp is too large to set as a file time")),
None => Ok(0),
}
let to_timestamp = |time: Option<SystemTime>| match time {
Some(time) if let Some(ts) = time.to_wasi_timestamp() => Ok(ts),
Some(_) => Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"timestamp is too large to set as a file time"
)),
None => Ok(0),
};
self.fd.filestat_set_times(
to_timestamp(times.accessed)?,

4
library/std/src/sys/windows/path.rs
View File

@ -104,7 +104,9 @@ pub fn parse_prefix(path: &OsStr) -> Option<Prefix<'_>> {
// The meaning of verbatim paths can change when they use a different
// separator.
if let Some(parser) = parser.strip_prefix(r"?\") && !parser.prefix_bytes().iter().any(|&x| x == b'/') {
if let Some(parser) = parser.strip_prefix(r"?\")
&& !parser.prefix_bytes().iter().any(|&x| x == b'/')
{
// \\?\
if let Some(parser) = parser.strip_prefix(r"UNC\") {
// \\?\UNC\server\share

3
library/std/src/sys_common/once/futex.rs
View File

@ -128,7 +128,8 @@ impl Once {
RUNNING | QUEUED => {
// Set the state to QUEUED if it is not already.
if state == RUNNING
&& let Err(new) = self.state.compare_exchange_weak(RUNNING, QUEUED, Relaxed, Acquire)
&& let Err(new) =
self.state.compare_exchange_weak(RUNNING, QUEUED, Relaxed, Acquire)
{
state = new;
continue;

4
src/librustdoc/clean/cfg.rs
View File

@ -164,8 +164,8 @@ impl Cfg {
/// Renders the configuration for human display, as a short HTML description.
pub(crate) fn render_short_html(&self) -> String {
let mut msg = Display(self, Format::ShortHtml).to_string();
if self.should_capitalize_first_letter() &&
let Some(i) = msg.find(|c: char| c.is_ascii_alphanumeric())
if self.should_capitalize_first_letter()
&& let Some(i) = msg.find(|c: char| c.is_ascii_alphanumeric())
{
msg[i..i + 1].make_ascii_uppercase();
}

18
src/librustdoc/clean/inline.rs
View File

@ -374,15 +374,17 @@ pub(crate) fn build_impl(
// Only inline impl if the implemented trait is
// reachable in rustdoc generated documentation
if !did.is_local() && let Some(traitref) = associated_trait {
if !did.is_local()
&& let Some(traitref) = associated_trait
{
let did = traitref.def_id;
if !cx.cache.effective_visibilities.is_directly_public(tcx, did) {
return;
}
if let Some(stab) = tcx.lookup_stability(did) &&
stab.is_unstable() &&
stab.feature == sym::rustc_private
if let Some(stab) = tcx.lookup_stability(did)
&& stab.is_unstable()
&& stab.feature == sym::rustc_private
{
return;
}
@ -514,7 +516,10 @@ pub(crate) fn build_impl(
}
while let Some(ty) = stack.pop() {
if let Some(did) = ty.def_id(&cx.cache) && !document_hidden && tcx.is_doc_hidden(did) {
if let Some(did) = ty.def_id(&cx.cache)
&& !document_hidden
&& tcx.is_doc_hidden(did)
{
return;
}
if let Some(generics) = ty.generics() {
@ -580,7 +585,8 @@ fn build_module_items(
let res = item.res.expect_non_local();
if let Some(def_id) = res.opt_def_id()
&& let Some(allowed_def_ids) = allowed_def_ids
&& !allowed_def_ids.contains(&def_id) {
&& !allowed_def_ids.contains(&def_id)
{
continue;
}
if let Some(def_id) = res.mod_def_id() {

90
src/librustdoc/clean/mod.rs
View File

@ -54,7 +54,9 @@ pub(crate) fn clean_doc_module<'tcx>(doc: &DocModule<'tcx>, cx: &mut DocContext<
let mut inserted = FxHashSet::default();
items.extend(doc.foreigns.iter().map(|(item, renamed)| {
let item = clean_maybe_renamed_foreign_item(cx, item, *renamed);
if let Some(name) = item.name && (cx.render_options.document_hidden || !item.is_doc_hidden()) {
if let Some(name) = item.name
&& (cx.render_options.document_hidden || !item.is_doc_hidden())
{
inserted.insert((item.type_(), name));
}
item
@ -85,7 +87,9 @@ pub(crate) fn clean_doc_module<'tcx>(doc: &DocModule<'tcx>, cx: &mut DocContext<
}
let v = clean_maybe_renamed_item(cx, item, *renamed, *import_id);
for item in &v {
if let Some(name) = item.name && (cx.render_options.document_hidden || !item.is_doc_hidden()) {
if let Some(name) = item.name
&& (cx.render_options.document_hidden || !item.is_doc_hidden())
{
inserted.insert((item.type_(), name));
}
}
@ -817,12 +821,7 @@ fn clean_ty_generics<'tcx>(
{
let pred = clean_predicate(*pred, cx)?;
bounds.extend(
pred.get_bounds()
.into_iter()
.flatten()
.cloned()
);
bounds.extend(pred.get_bounds().into_iter().flatten().cloned());
if let Some(proj) = projection
&& let lhs = clean_projection(proj.map_bound(|p| p.projection_ty), cx, None)
@ -989,10 +988,8 @@ fn clean_proc_macro<'tcx>(
cx: &mut DocContext<'tcx>,
) -> ItemKind {
let attrs = cx.tcx.hir().attrs(item.hir_id());
if kind == MacroKind::Derive &&
let Some(derive_name) = attrs
.lists(sym::proc_macro_derive)
.find_map(|mi| mi.ident())
if kind == MacroKind::Derive
&& let Some(derive_name) = attrs.lists(sym::proc_macro_derive).find_map(|mi| mi.ident())
{
*name = derive_name.name;
}
@ -1154,7 +1151,9 @@ fn clean_fn_decl_with_args<'tcx>(
hir::FnRetTy::Return(typ) => clean_ty(typ, cx),
hir::FnRetTy::DefaultReturn(..) => Type::Tuple(Vec::new()),
};
if let Some(header) = header && header.is_async() {
if let Some(header) = header
&& header.is_async()
{
output = output.sugared_async_return_type();
}
FnDecl { inputs: args, output, c_variadic: decl.c_variadic }
@ -1606,14 +1605,16 @@ fn first_non_private<'tcx>(
continue;
}
if let Some(def_id) = child.res.opt_def_id() && target_def_id == def_id {
if let Some(def_id) = child.res.opt_def_id()
&& target_def_id == def_id
{
let mut last_path_res = None;
'reexps: for reexp in child.reexport_chain.iter() {
if let Some(use_def_id) = reexp.id() &&
let Some(local_use_def_id) = use_def_id.as_local() &&
let Some(hir::Node::Item(item)) = hir.find_by_def_id(local_use_def_id) &&
!item.ident.name.is_empty() &&
let hir::ItemKind::Use(path, _) = item.kind
if let Some(use_def_id) = reexp.id()
&& let Some(local_use_def_id) = use_def_id.as_local()
&& let Some(hir::Node::Item(item)) = hir.find_by_def_id(local_use_def_id)
&& !item.ident.name.is_empty()
&& let hir::ItemKind::Use(path, _) = item.kind
{
for res in &path.res {
if let Res::Def(DefKind::Ctor(..), _) | Res::SelfCtor(..) = res {
@ -1624,7 +1625,8 @@ fn first_non_private<'tcx>(
// We never check for "cx.render_options.document_private"
// because if a re-export is not fully public, it's never
// documented.
cx.tcx.local_visibility(local_use_def_id).is_public() {
cx.tcx.local_visibility(local_use_def_id).is_public()
{
break 'reexps;
}
last_path_res = Some((path, res));
@ -1639,7 +1641,12 @@ fn first_non_private<'tcx>(
// 1. We found a public reexport.
// 2. We didn't find a public reexport so it's the "end type" path.
if let Some((new_path, _)) = last_path_res {
return Some(first_non_private_clean_path(cx, path, new_path.segments, new_path.span));
return Some(first_non_private_clean_path(
cx,
path,
new_path.segments,
new_path.span,
));
}
// If `last_path_res` is `None`, it can mean two things:
//
@ -2304,7 +2311,9 @@ fn clean_middle_opaque_bounds<'tcx>(
_ => return None,
};
if let Some(sized) = cx.tcx.lang_items().sized_trait() && trait_ref.def_id() == sized {
if let Some(sized) = cx.tcx.lang_items().sized_trait()
&& trait_ref.def_id() == sized
{
has_sized = true;
return None;
}
@ -2680,28 +2689,27 @@ fn add_without_unwanted_attributes<'hir>(
let mut attr = attr.clone();
match attr.kind {
ast::AttrKind::Normal(ref mut normal) => {
if let [ident] = &*normal.item.path.segments &&
let ident = ident.ident.name &&
ident == sym::doc
if let [ident] = &*normal.item.path.segments
&& let ident = ident.ident.name
&& ident == sym::doc
{
match normal.item.args {
ast::AttrArgs::Delimited(ref mut args) => {
let tokens =
filter_tokens_from_list(&args.tokens, |token| {
!matches!(
token,
TokenTree::Token(
Token {
kind: TokenKind::Ident(
sym::hidden | sym::inline | sym::no_inline,
_,
),
..
},
_,
),
)
});
let tokens = filter_tokens_from_list(&args.tokens, |token| {
!matches!(
token,
TokenTree::Token(
Token {
kind: TokenKind::Ident(
sym::hidden | sym::inline | sym::no_inline,
_,
),
..
},
_,
),
)
});
args.tokens = TokenStream::new(tokens);
attrs.push((Cow::Owned(attr), import_parent));
}

3
src/librustdoc/clean/simplify.rs
View File

@ -146,7 +146,8 @@ pub(crate) fn move_bounds_to_generic_parameters(generics: &mut clean::Generics)
}) = generics.params.iter_mut().find(|param| &param.name == arg)
{
param_bounds.extend(bounds.drain(..));
} else if let WherePredicate::RegionPredicate { lifetime: Lifetime(arg), bounds } = &mut pred
} else if let WherePredicate::RegionPredicate { lifetime: Lifetime(arg), bounds } =
&mut pred
&& let Some(GenericParamDef {
kind: GenericParamDefKind::Lifetime { outlives: param_bounds },
..

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

@ -1269,8 +1269,8 @@ impl GenericBound {
pub(crate) fn is_sized_bound(&self, cx: &DocContext<'_>) -> bool {
use rustc_hir::TraitBoundModifier as TBM;
if let GenericBound::TraitBound(PolyTrait { ref trait_, .. }, TBM::None) = *self &&
Some(trait_.def_id()) == cx.tcx.lang_items().sized_trait()
if let GenericBound::TraitBound(PolyTrait { ref trait_, .. }, TBM::None) = *self
&& Some(trait_.def_id()) == cx.tcx.lang_items().sized_trait()
{
return true;
}
@ -1623,7 +1623,7 @@ impl Type {
/// functions.
pub(crate) fn sugared_async_return_type(self) -> Type {
if let Type::ImplTrait(mut v) = self
&& let Some(GenericBound::TraitBound(PolyTrait { mut trait_, .. }, _ )) = v.pop()
&& let Some(GenericBound::TraitBound(PolyTrait { mut trait_, .. }, _)) = v.pop()
&& let Some(segment) = trait_.segments.pop()
&& let GenericArgs::AngleBracketed { mut bindings, .. } = segment.args
&& let Some(binding) = bindings.pop()

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

@ -443,8 +443,8 @@ pub(crate) fn is_literal_expr(tcx: TyCtxt<'_>, hir_id: hir::HirId) -> bool {
return true;
}
if let hir::ExprKind::Unary(hir::UnOp::Neg, expr) = &expr.kind &&
let hir::ExprKind::Lit(_) = &expr.kind
if let hir::ExprKind::Unary(hir::UnOp::Neg, expr) = &expr.kind
&& let hir::ExprKind::Lit(_) = &expr.kind
{
return true;
}
@ -643,17 +643,16 @@ pub(crate) fn inherits_doc_hidden(
) -> bool {
let hir = tcx.hir();
while let Some(id) = tcx.opt_local_parent(def_id) {
if let Some(stop_at) = stop_at && id == stop_at {
if let Some(stop_at) = stop_at
&& id == stop_at
{
return false;
}
def_id = id;
if tcx.is_doc_hidden(def_id.to_def_id()) {
return true;
} else if let Some(node) = hir.find_by_def_id(def_id) &&
matches!(
node,
hir::Node::Item(hir::Item { kind: hir::ItemKind::Impl(_), .. }),
)
} else if let Some(node) = hir.find_by_def_id(def_id)
&& matches!(node, hir::Node::Item(hir::Item { kind: hir::ItemKind::Impl(_), .. }),)
{
// `impl` blocks stand a bit on their own: unless they have `#[doc(hidden)]` directly
// on them, they don't inherit it from the parent context.

18
src/librustdoc/doctest.rs
View File

@ -597,15 +597,15 @@ pub(crate) fn make_test(
loop {
match parser.parse_item(ForceCollect::No) {
Ok(Some(item)) => {
if !found_main &&
let ast::ItemKind::Fn(..) = item.kind &&
item.ident.name == sym::main
if !found_main
&& let ast::ItemKind::Fn(..) = item.kind
&& item.ident.name == sym::main
{
found_main = true;
}
if !found_extern_crate &&
let ast::ItemKind::ExternCrate(original) = item.kind
if !found_extern_crate
&& let ast::ItemKind::ExternCrate(original) = item.kind
{
// This code will never be reached if `crate_name` is none because
// `found_extern_crate` is initialized to `true` if it is none.
@ -957,10 +957,10 @@ impl Collector {
fn get_filename(&self) -> FileName {
if let Some(ref source_map) = self.source_map {
let filename = source_map.span_to_filename(self.position);
if let FileName::Real(ref filename) = filename &&
let Ok(cur_dir) = env::current_dir() &&
let Some(local_path) = filename.local_path() &&
let Ok(path) = local_path.strip_prefix(&cur_dir)
if let FileName::Real(ref filename) = filename
&& let Ok(cur_dir) = env::current_dir()
&& let Some(local_path) = filename.local_path()
&& let Ok(path) = local_path.strip_prefix(&cur_dir)
{
return path.to_owned().into();
}

27
src/librustdoc/formats/cache.rs
View File

@ -230,8 +230,8 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
// If the impl is from a masked crate or references something from a
// masked crate then remove it completely.
if let clean::ImplItem(ref i) = *item.kind &&
(self.cache.masked_crates.contains(&item.item_id.krate())
if let clean::ImplItem(ref i) = *item.kind
&& (self.cache.masked_crates.contains(&item.item_id.krate())
|| i.trait_
.as_ref()
.map_or(false, |t| is_from_private_dep(self.tcx, self.cache, t.def_id()))
@ -249,9 +249,9 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
}
// Collect all the implementors of traits.
if let clean::ImplItem(ref i) = *item.kind &&
let Some(trait_) = &i.trait_ &&
!i.kind.is_blanket()
if let clean::ImplItem(ref i) = *item.kind
&& let Some(trait_) = &i.trait_
&& !i.kind.is_blanket()
{
self.cache
.implementors
@ -264,8 +264,9 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
if let Some(s) = item.name.or_else(|| {
if item.is_stripped() {
None
} else if let clean::ImportItem(ref i) = *item.kind &&
let clean::ImportKind::Simple(s) = i.kind {
} else if let clean::ImportItem(ref i) = *item.kind
&& let clean::ImportKind::Simple(s) = i.kind
{
Some(s)
} else {
None
@ -357,7 +358,9 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
desc,
parent,
parent_idx: None,
impl_id: if let Some(ParentStackItem::Impl { item_id, .. }) = self.cache.parent_stack.last() {
impl_id: if let Some(ParentStackItem::Impl { item_id, .. }) =
self.cache.parent_stack.last()
{
item_id.as_def_id()
} else {
None
@ -493,9 +496,11 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
clean::Type::Path { ref path }
| clean::BorrowedRef { type_: box clean::Type::Path { ref path }, .. } => {
dids.insert(path.def_id());
if let Some(generics) = path.generics() &&
let ty::Adt(adt, _) = self.tcx.type_of(path.def_id()).instantiate_identity().kind() &&
adt.is_fundamental() {
if let Some(generics) = path.generics()
&& let ty::Adt(adt, _) =
self.tcx.type_of(path.def_id()).instantiate_identity().kind()
&& adt.is_fundamental()
{
for ty in generics {
if let Some(did) = ty.def_id(self.cache) {
dids.insert(did);

57
src/librustdoc/html/format.rs
View File

@ -1166,13 +1166,17 @@ fn fmt_type<'cx>(
// we need to surround them with angle brackets in some cases (e.g. `<dyn …>::P`).
if f.alternate() {
if let Some(trait_) = trait_ && should_show_cast {
if let Some(trait_) = trait_
&& should_show_cast
{
write!(f, "<{:#} as {:#}>::", self_type.print(cx), trait_.print(cx))?
} else {
write!(f, "{:#}::", self_type.print(cx))?
}
} else {
if let Some(trait_) = trait_ && should_show_cast {
if let Some(trait_) = trait_
&& should_show_cast
{
write!(f, "&lt;{} as {}&gt;::", self_type.print(cx), trait_.print(cx))?
} else {
write!(f, "{}::", self_type.print(cx))?
@ -1268,16 +1272,23 @@ impl clean::Impl {
write!(f, " for ")?;
}
if let clean::Type::Tuple(types) = &self.for_ &&
let [clean::Type::Generic(name)] = &types[..] &&
(self.kind.is_fake_variadic() || self.kind.is_auto())
if let clean::Type::Tuple(types) = &self.for_
&& let [clean::Type::Generic(name)] = &types[..]
&& (self.kind.is_fake_variadic() || self.kind.is_auto())
{
// Hardcoded anchor library/core/src/primitive_docs.rs
// Link should match `# Trait implementations`
primitive_link_fragment(f, PrimitiveType::Tuple, format_args!("({name}₁, {name}₂, …, {name}ₙ)"), "#trait-implementations-1", cx)?;
} else if let clean::BareFunction(bare_fn) = &self.for_ &&
let [clean::Argument { type_: clean::Type::Generic(name), .. }] = &bare_fn.decl.inputs.values[..] &&
(self.kind.is_fake_variadic() || self.kind.is_auto())
primitive_link_fragment(
f,
PrimitiveType::Tuple,
format_args!("({name}₁, {name}₂, …, {name}ₙ)"),
"#trait-implementations-1",
cx,
)?;
} else if let clean::BareFunction(bare_fn) = &self.for_
&& let [clean::Argument { type_: clean::Type::Generic(name), .. }] =
&bare_fn.decl.inputs.values[..]
&& (self.kind.is_fake_variadic() || self.kind.is_auto())
{
// Hardcoded anchor library/core/src/primitive_docs.rs
// Link should match `# Trait implementations`
@ -1286,22 +1297,18 @@ impl clean::Impl {
let unsafety = bare_fn.unsafety.print_with_space();
let abi = print_abi_with_space(bare_fn.abi);
if f.alternate() {
write!(
f,
"{hrtb:#}{unsafety}{abi:#}",
)?;
write!(f, "{hrtb:#}{unsafety}{abi:#}",)?;
} else {
write!(
f,
"{hrtb}{unsafety}{abi}",
)?;
write!(f, "{hrtb}{unsafety}{abi}",)?;
}
let ellipsis = if bare_fn.decl.c_variadic {
", ..."
} else {
""
};
primitive_link_fragment(f, PrimitiveType::Tuple, format_args!("fn ({name}₁, {name}₂, …, {name}ₙ{ellipsis})"), "#trait-implementations-1", cx)?;
let ellipsis = if bare_fn.decl.c_variadic { ", ..." } else { "" };
primitive_link_fragment(
f,
PrimitiveType::Tuple,
format_args!("fn ({name}₁, {name}₂, …, {name}ₙ{ellipsis})"),
"#trait-implementations-1",
cx,
)?;
// Write output.
if !bare_fn.decl.output.is_unit() {
write!(f, " -> ")?;
@ -1447,7 +1454,9 @@ impl clean::FnDecl {
let amp = if f.alternate() { "&" } else { "&amp;" };
write!(f, "(")?;
if let Some(n) = line_wrapping_indent && !self.inputs.values.is_empty() {
if let Some(n) = line_wrapping_indent
&& !self.inputs.values.is_empty()
{
write!(f, "\n{}", Indent(n + 4))?;
}
for (i, input) in self.inputs.values.iter().enumerate() {

35
src/librustdoc/html/highlight.rs
View File

@ -185,8 +185,8 @@ impl<'a, 'tcx, F: Write> TokenHandler<'a, 'tcx, F> {
if self.pending_elems.is_empty() {
return false;
}
if let Some((_, parent_class)) = self.closing_tags.last() &&
can_merge(current_class, Some(*parent_class), "")
if let Some((_, parent_class)) = self.closing_tags.last()
&& can_merge(current_class, Some(*parent_class), "")
{
for (text, class) in self.pending_elems.iter() {
string(self.out, Escape(text), *class, &self.href_context, false);
@ -194,7 +194,9 @@ impl<'a, 'tcx, F: Write> TokenHandler<'a, 'tcx, F> {
} else {
// We only want to "open" the tag ourselves if we have more than one pending and if the
// current parent tag is not the same as our pending content.
let close_tag = if self.pending_elems.len() > 1 && let Some(current_class) = current_class {
let close_tag = if self.pending_elems.len() > 1
&& let Some(current_class) = current_class
{
Some(enter_span(self.out, current_class, &self.href_context))
} else {
None
@ -260,10 +262,12 @@ pub(super) fn write_code(
Highlight::Token { text, class } => {
// If we received a `ExitSpan` event and then have a non-compatible `Class`, we
// need to close the `<span>`.
let need_current_class_update = if let Some(pending) = token_handler.pending_exit_span &&
!can_merge(Some(pending), class, text) {
token_handler.handle_exit_span();
true
let need_current_class_update = if let Some(pending) =
token_handler.pending_exit_span
&& !can_merge(Some(pending), class, text)
{
token_handler.handle_exit_span();
true
// If the two `Class` are different, time to flush the current content and start
// a new one.
} else if !can_merge(token_handler.current_class, class, text) {
@ -293,7 +297,8 @@ pub(super) fn write_code(
}
}
if should_add {
let closing_tag = enter_span(token_handler.out, class, &token_handler.href_context);
let closing_tag =
enter_span(token_handler.out, class, &token_handler.href_context);
token_handler.closing_tags.push((closing_tag, class));
}
@ -302,8 +307,14 @@ pub(super) fn write_code(
}
Highlight::ExitSpan => {
token_handler.current_class = None;
token_handler.pending_exit_span =
Some(token_handler.closing_tags.last().as_ref().expect("ExitSpan without EnterSpan").1);
token_handler.pending_exit_span = Some(
token_handler
.closing_tags
.last()
.as_ref()
.expect("ExitSpan without EnterSpan")
.1,
);
}
};
});
@ -466,7 +477,9 @@ impl<'a> PeekIter<'a> {
}
/// Returns the next item after the current one. It doesn't interfere with `peek_next` output.
fn peek(&mut self) -> Option<&(TokenKind, &'a str)> {
if self.stored.is_empty() && let Some(next) = self.iter.next() {
if self.stored.is_empty()
&& let Some(next) = self.iter.next()
{
self.stored.push_back(next);
}
self.stored.front()

8
src/librustdoc/html/markdown.rs
View File

@ -1119,10 +1119,10 @@ impl<'a, 'tcx> TagIterator<'a, 'tcx> {
return None;
}
let indices = self.parse_string(pos)?;
if let Some((_, c)) = self.inner.peek().copied() &&
c != '{' &&
!is_separator(c) &&
c != '('
if let Some((_, c)) = self.inner.peek().copied()
&& c != '{'
&& !is_separator(c)
&& c != '('
{
self.emit_error(format!("expected ` `, `{{` or `,` after `\"`, found `{c}`"));
return None;

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

@ -176,9 +176,9 @@ impl<'tcx> Context<'tcx> {
let mut render_redirect_pages = self.render_redirect_pages;
// If the item is stripped but inlined, links won't point to the item so no need to generate
// a file for it.
if it.is_stripped() &&
let Some(def_id) = it.def_id() &&
def_id.is_local()
if it.is_stripped()
&& let Some(def_id) = it.def_id()
&& def_id.is_local()
{
if self.is_inside_inlined_module || self.shared.cache.inlined_items.contains(&def_id) {
// For now we're forced to generate a redirect page for stripped items until
@ -371,7 +371,9 @@ impl<'tcx> Context<'tcx> {
path = href.into_inner().to_string_lossy().into_owned();
if let Some(c) = path.as_bytes().last() && *c != b'/' {
if let Some(c) = path.as_bytes().last()
&& *c != b'/'
{
path.push('/');
}
@ -741,9 +743,10 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
shared.fs.write(scrape_examples_help_file, v)?;
}
if let Some(ref redirections) = shared.redirections && !redirections.borrow().is_empty() {
let redirect_map_path =
self.dst.join(crate_name.as_str()).join("redirect-map.json");
if let Some(ref redirections) = shared.redirections
&& !redirections.borrow().is_empty()
{
let redirect_map_path = self.dst.join(crate_name.as_str()).join("redirect-map.json");
let paths = serde_json::to_string(&*redirections.borrow()).unwrap();
shared.ensure_dir(&self.dst.join(crate_name.as_str()))?;
shared.fs.write(redirect_map_path, paths)?;
@ -790,7 +793,9 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
}
}
if !self.is_inside_inlined_module {
if let Some(def_id) = item.def_id() && self.cache().inlined_items.contains(&def_id) {
if let Some(def_id) = item.def_id()
&& self.cache().inlined_items.contains(&def_id)
{
self.is_inside_inlined_module = true;
}
} else if !self.cache().document_hidden && item.is_doc_hidden() {

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

@ -180,7 +180,9 @@ impl Serialize for IndexItemFunctionType {
_ => seq.serialize_element(&self.output)?,
}
for constraint in &self.where_clause {
if let [one] = &constraint[..] && one.generics.is_none() {
if let [one] = &constraint[..]
&& one.generics.is_none()
{
seq.serialize_element(one)?;
} else {
seq.serialize_element(constraint)?;
@ -915,7 +917,9 @@ fn render_stability_since_raw_with_extra(
containing_const_ver: Option<StableSince>,
extra_class: &str,
) -> bool {
let stable_version = if ver != containing_ver && let Some(ver) = &ver {
let stable_version = if ver != containing_ver
&& let Some(ver) = &ver
{
since_to_string(ver)
} else {
None

20
src/librustdoc/html/render/print_item.rs
View File

@ -974,8 +974,9 @@ fn item_trait(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, t: &clean:
// if any Types with the same name but different DefId have been found.
let mut implementor_dups: FxHashMap<Symbol, (DefId, bool)> = FxHashMap::default();
for implementor in implementors {
if let Some(did) = implementor.inner_impl().for_.without_borrowed_ref().def_id(cache) &&
!did.is_local() {
if let Some(did) = implementor.inner_impl().for_.without_borrowed_ref().def_id(cache)
&& !did.is_local()
{
extern_crates.insert(did.krate);
}
match implementor.inner_impl().for_.without_borrowed_ref() {
@ -1152,9 +1153,10 @@ fn item_trait(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, t: &clean:
.take(cx.current.len())
.chain(std::iter::once("trait.impl"))
.collect();
if let Some(did) = it.item_id.as_def_id() &&
let get_extern = { || cache.external_paths.get(&did).map(|s| &s.0) } &&
let Some(fqp) = cache.exact_paths.get(&did).or_else(get_extern) {
if let Some(did) = it.item_id.as_def_id()
&& let get_extern = { || cache.external_paths.get(&did).map(|s| &s.0) }
&& let Some(fqp) = cache.exact_paths.get(&did).or_else(get_extern)
{
js_src_path.extend(fqp[..fqp.len() - 1].iter().copied());
js_src_path.push_fmt(format_args!("{}.{}.js", it.type_(), fqp.last().unwrap()));
} else {
@ -1564,8 +1566,8 @@ fn should_show_enum_discriminant(
) -> bool {
let mut has_variants_with_value = false;
for variant in variants {
if let clean::VariantItem(ref var) = *variant.kind &&
matches!(var.kind, clean::VariantKind::CLike)
if let clean::VariantItem(ref var) = *variant.kind
&& matches!(var.kind, clean::VariantKind::CLike)
{
has_variants_with_value |= var.discriminant.is_some();
} else {
@ -1706,8 +1708,8 @@ fn item_variants(
" rightside",
);
w.write_str("<h3 class=\"code-header\">");
if let clean::VariantItem(ref var) = *variant.kind &&
let clean::VariantKind::CLike = var.kind
if let clean::VariantItem(ref var) = *variant.kind
&& let clean::VariantKind::CLike = var.kind
{
display_c_like_variant(
w,

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

@ -228,10 +228,11 @@ pub(crate) fn build_index<'tcx>(
let mut associated_item_duplicates = FxHashMap::<(isize, ItemType, Symbol), usize>::default();
for &item in &crate_items {
if item.impl_id.is_some() && let Some(parent_idx) = item.parent_idx {
let count = associated_item_duplicates
.entry((parent_idx, item.ty, item.name))
.or_insert(0);
if item.impl_id.is_some()
&& let Some(parent_idx) = item.parent_idx
{
let count =
associated_item_duplicates.entry((parent_idx, item.ty, item.name)).or_insert(0);
*count += 1;
}
}

24
src/librustdoc/html/render/sidebar.rs
View File

@ -435,9 +435,9 @@ fn sidebar_deref_methods<'a>(
}
// Recurse into any further impls that might exist for `target`
if let Some(target_did) = target.def_id(c) &&
let Some(target_impls) = c.impls.get(&target_did) &&
let Some(target_deref_impl) = target_impls.iter().find(|i| {
if let Some(target_did) = target.def_id(c)
&& let Some(target_impls) = c.impls.get(&target_did)
&& let Some(target_deref_impl) = target_impls.iter().find(|i| {
i.inner_impl()
.trait_
.as_ref()
@ -445,14 +445,7 @@ fn sidebar_deref_methods<'a>(
.unwrap_or(false)
})
{
sidebar_deref_methods(
cx,
out,
target_deref_impl,
target_impls,
derefs,
used_links,
);
sidebar_deref_methods(cx, out, target_deref_impl, target_impls, derefs, used_links);
}
}
}
@ -494,8 +487,13 @@ fn sidebar_module(items: &[clean::Item]) -> LinkBlock<'static> {
&& it
.name
.or_else(|| {
if let clean::ImportItem(ref i) = *it.kind &&
let clean::ImportKind::Simple(s) = i.kind { Some(s) } else { None }
if let clean::ImportItem(ref i) = *it.kind
&& let clean::ImportKind::Simple(s) = i.kind
{
Some(s)
} else {
None
}
})
.is_some()
})

56
src/librustdoc/html/render/type_layout.rs
View File

@ -42,37 +42,35 @@ pub(crate) fn document_type_layout<'a, 'cx: 'a>(
let ty = tcx.type_of(ty_def_id).instantiate_identity();
let type_layout = tcx.layout_of(param_env.and(ty));
let variants =
if let Ok(type_layout) = type_layout &&
let Variants::Multiple { variants, tag, tag_encoding, .. } =
type_layout.layout.variants() &&
!variants.is_empty()
{
let tag_size =
if let TagEncoding::Niche { .. } = tag_encoding {
0
} else if let Primitive::Int(i, _) = tag.primitive() {
i.size().bytes()
} else {
span_bug!(tcx.def_span(ty_def_id), "tag is neither niche nor int")
};
variants
.iter_enumerated()
.map(|(variant_idx, variant_layout)| {
let Adt(adt, _) = type_layout.ty.kind() else {
span_bug!(tcx.def_span(ty_def_id), "not an adt")
};
let name = adt.variant(variant_idx).name;
let is_unsized = variant_layout.abi.is_unsized();
let is_uninhabited = variant_layout.abi.is_uninhabited();
let size = variant_layout.size.bytes() - tag_size;
let type_layout_size = TypeLayoutSize { is_unsized, is_uninhabited, size };
(name, type_layout_size)
})
.collect()
let variants = if let Ok(type_layout) = type_layout
&& let Variants::Multiple { variants, tag, tag_encoding, .. } =
type_layout.layout.variants()
&& !variants.is_empty()
{
let tag_size = if let TagEncoding::Niche { .. } = tag_encoding {
0
} else if let Primitive::Int(i, _) = tag.primitive() {
i.size().bytes()
} else {
Vec::new()
span_bug!(tcx.def_span(ty_def_id), "tag is neither niche nor int")
};
variants
.iter_enumerated()
.map(|(variant_idx, variant_layout)| {
let Adt(adt, _) = type_layout.ty.kind() else {
span_bug!(tcx.def_span(ty_def_id), "not an adt")
};
let name = adt.variant(variant_idx).name;
let is_unsized = variant_layout.abi.is_unsized();
let is_uninhabited = variant_layout.abi.is_uninhabited();
let size = variant_layout.size.bytes() - tag_size;
let type_layout_size = TypeLayoutSize { is_unsized, is_uninhabited, size };
(name, type_layout_size)
})
.collect()
} else {
Vec::new()
};
let type_layout_size = tcx.layout_of(param_env.and(ty)).map(|layout| {
let is_unsized = layout.abi.is_unsized();

8
src/librustdoc/html/sources.rs
View File

@ -90,7 +90,9 @@ impl LocalSourcesCollector<'_, '_> {
);
let mut href = href.into_inner().to_string_lossy().into_owned();
if let Some(c) = href.as_bytes().last() && *c != b'/' {
if let Some(c) = href.as_bytes().last()
&& *c != b'/'
{
href.push('/');
}
let mut src_fname = p.file_name().expect("source has no filename").to_os_string();
@ -212,7 +214,9 @@ impl SourceCollector<'_, '_> {
let root_path = PathBuf::from("../../").join(root_path.into_inner());
let mut root_path = root_path.to_string_lossy();
if let Some(c) = root_path.as_bytes().last() && *c != b'/' {
if let Some(c) = root_path.as_bytes().last()
&& *c != b'/'
{
root_path += "/";
}
let mut cur = self.dst.join(cur.into_inner());

15
src/librustdoc/json/conversions.rs
View File

@ -250,15 +250,16 @@ pub(crate) fn id_from_item_inner(
// their parent module, which isn't present in the output JSON items. So
// instead, we directly get the primitive symbol and convert it to u32 to
// generate the ID.
if matches!(tcx.def_kind(def_id), DefKind::Mod) &&
let Some(prim) = tcx.get_attrs(*def_id, sym::rustc_doc_primitive)
.find_map(|attr| attr.value_str()) {
if matches!(tcx.def_kind(def_id), DefKind::Mod)
&& let Some(prim) = tcx
.get_attrs(*def_id, sym::rustc_doc_primitive)
.find_map(|attr| attr.value_str())
{
format!(":{}", prim.as_u32())
} else {
tcx
.opt_item_name(*def_id)
.map(|n| format!(":{}", n.as_u32()))
.unwrap_or_default()
tcx.opt_item_name(*def_id)
.map(|n| format!(":{}", n.as_u32()))
.unwrap_or_default()
}
}
};

6
src/librustdoc/json/mod.rs
View File

@ -80,9 +80,9 @@ impl<'tcx> JsonRenderer<'tcx> {
// document primitive items in an arbitrary crate by using
// `rustc_doc_primitive`.
let mut is_primitive_impl = false;
if let clean::types::ItemKind::ImplItem(ref impl_) = *item.kind &&
impl_.trait_.is_none() &&
let clean::types::Type::Primitive(_) = impl_.for_
if let clean::types::ItemKind::ImplItem(ref impl_) = *item.kind
&& impl_.trait_.is_none()
&& let clean::types::Type::Primitive(_) = impl_.for_
{
is_primitive_impl = true;
}

6
src/librustdoc/passes/check_doc_test_visibility.rs
View File

@ -79,9 +79,9 @@ pub(crate) fn should_have_doc_example(cx: &DocContext<'_>, item: &clean::Item) -
let def_id = item.item_id.expect_def_id().expect_local();
// check if parent is trait impl
if let Some(parent_def_id) = cx.tcx.opt_local_parent(def_id) &&
let Some(parent_node) = cx.tcx.hir().find_by_def_id(parent_def_id) &&
matches!(
if let Some(parent_def_id) = cx.tcx.opt_local_parent(def_id)
&& let Some(parent_node) = cx.tcx.hir().find_by_def_id(parent_def_id)
&& matches!(
parent_node,
hir::Node::Item(hir::Item {
kind: hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }),

24
src/librustdoc/passes/collect_intra_doc_links.rs
View File

@ -303,7 +303,9 @@ impl<'a, 'tcx> LinkCollector<'a, 'tcx> {
Res::Def(DefKind::Enum, did) => match tcx.type_of(did).instantiate_identity().kind() {
ty::Adt(def, _) if def.is_enum() => {
if let Some(variant) = def.variants().iter().find(|v| v.name == variant_name)
&& let Some(field) = variant.fields.iter().find(|f| f.name == variant_field_name) {
&& let Some(field) =
variant.fields.iter().find(|f| f.name == variant_field_name)
{
Ok((ty_res, field.did))
} else {
Err(UnresolvedPath {
@ -973,7 +975,8 @@ impl LinkCollector<'_, '_> {
&& let Some(def_id) = item.item_id.as_def_id()
&& let Some(def_id) = def_id.as_local()
&& !self.cx.tcx.effective_visibilities(()).is_exported(def_id)
&& !has_primitive_or_keyword_docs(&item.attrs.other_attrs) {
&& !has_primitive_or_keyword_docs(&item.attrs.other_attrs)
{
// Skip link resolution for non-exported items.
return;
}
@ -1250,9 +1253,10 @@ impl LinkCollector<'_, '_> {
// FIXME: it would be nice to check that the feature gate was enabled in the original crate, not just ignore it altogether.
// However I'm not sure how to check that across crates.
if let Some(candidate) = candidates.get(0) &&
candidate.0 == Res::Primitive(PrimitiveType::RawPointer) &&
key.path_str.contains("::") // We only want to check this if this is an associated item.
if let Some(candidate) = candidates.get(0)
&& candidate.0 == Res::Primitive(PrimitiveType::RawPointer)
&& key.path_str.contains("::")
// We only want to check this if this is an associated item.
{
if key.item_id.is_local() && !self.cx.tcx.features().intra_doc_pointers {
self.report_rawptr_assoc_feature_gate(diag.dox, &diag.link_range, diag.item);
@ -1318,8 +1322,8 @@ impl LinkCollector<'_, '_> {
for other_ns in [TypeNS, ValueNS, MacroNS] {
if other_ns != expected_ns {
if let Ok(res) =
self.resolve(path_str, other_ns, item_id, module_id) &&
!res.is_empty()
self.resolve(path_str, other_ns, item_id, module_id)
&& !res.is_empty()
{
err = ResolutionFailure::WrongNamespace {
res: full_res(self.cx.tcx, res[0]),
@ -1892,8 +1896,10 @@ fn resolution_failure(
};
let is_struct_variant = |did| {
if let ty::Adt(def, _) = tcx.type_of(did).instantiate_identity().kind()
&& def.is_enum()
&& let Some(variant) = def.variants().iter().find(|v| v.name == res.name(tcx)) {
&& def.is_enum()
&& let Some(variant) =
def.variants().iter().find(|v| v.name == res.name(tcx))
{
// ctor is `None` if variant is a struct
variant.ctor.is_none()
} else {

10
src/librustdoc/passes/collect_trait_impls.rs
View File

@ -154,9 +154,9 @@ pub(crate) fn collect_trait_impls(mut krate: Crate, cx: &mut DocContext<'_>) ->
// scan through included items ahead of time to splice in Deref targets to the "valid" sets
for it in new_items_external.iter().chain(new_items_local.iter()) {
if let ImplItem(box Impl { ref for_, ref trait_, ref items, .. }) = *it.kind &&
trait_.as_ref().map(|t| t.def_id()) == tcx.lang_items().deref_trait() &&
cleaner.keep_impl(for_, true)
if let ImplItem(box Impl { ref for_, ref trait_, ref items, .. }) = *it.kind
&& trait_.as_ref().map(|t| t.def_id()) == tcx.lang_items().deref_trait()
&& cleaner.keep_impl(for_, true)
{
let target = items
.iter()
@ -250,8 +250,8 @@ impl<'cache> DocVisitor for ItemAndAliasCollector<'cache> {
fn visit_item(&mut self, i: &Item) {
self.items.insert(i.item_id);
if let TypeAliasItem(alias) = &*i.kind &&
let Some(did) = alias.type_.def_id(self.cache)
if let TypeAliasItem(alias) = &*i.kind
&& let Some(did) = alias.type_.def_id(self.cache)
{
self.items.insert(ItemId::DefId(did));
}

4
src/librustdoc/passes/lint/html_tags.rs
View File

@ -213,7 +213,9 @@ fn extract_path_backwards(text: &str, end_pos: usize) -> Option<usize> {
.take_while(|(_, c)| is_id_start(*c) || is_id_continue(*c))
.reduce(|_accum, item| item)
.and_then(|(new_pos, c)| is_id_start(c).then_some(new_pos));
if let Some(new_pos) = new_pos && current_pos != new_pos {
if let Some(new_pos) = new_pos
&& current_pos != new_pos
{
current_pos = new_pos;
continue;
}

17
src/librustdoc/passes/stripper.rs
View File

@ -208,24 +208,25 @@ impl<'a> DocFolder for ImplStripper<'a, '_> {
// Because we don't inline in `maybe_inline_local` if the output format is JSON,
// we need to make a special check for JSON output: we want to keep it unless it has
// a `#[doc(hidden)]` attribute if the `for_` type is exported.
if let Some(did) = imp.for_.def_id(self.cache) &&
!imp.for_.is_assoc_ty() && !self.should_keep_impl(&i, did)
if let Some(did) = imp.for_.def_id(self.cache)
&& !imp.for_.is_assoc_ty()
&& !self.should_keep_impl(&i, did)
{
debug!("ImplStripper: impl item for stripped type; removing");
return None;
}
if let Some(did) = imp.trait_.as_ref().map(|t| t.def_id()) &&
!self.should_keep_impl(&i, did) {
if let Some(did) = imp.trait_.as_ref().map(|t| t.def_id())
&& !self.should_keep_impl(&i, did)
{
debug!("ImplStripper: impl item for stripped trait; removing");
return None;
}
if let Some(generics) = imp.trait_.as_ref().and_then(|t| t.generics()) {
for typaram in generics {
if let Some(did) = typaram.def_id(self.cache) && !self.should_keep_impl(&i, did)
if let Some(did) = typaram.def_id(self.cache)
&& !self.should_keep_impl(&i, did)
{
debug!(
"ImplStripper: stripped item in trait's generics; removing impl"
);
debug!("ImplStripper: stripped item in trait's generics; removing impl");
return None;
}
}

14
src/librustdoc/visit_ast.rs
View File

@ -135,14 +135,16 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
// macro in the same module.
let mut inserted = FxHashSet::default();
for child in self.cx.tcx.module_children_local(CRATE_DEF_ID) {
if !child.reexport_chain.is_empty() &&
let Res::Def(DefKind::Macro(_), def_id) = child.res &&
let Some(local_def_id) = def_id.as_local() &&
self.cx.tcx.has_attr(def_id, sym::macro_export) &&
inserted.insert(def_id)
if !child.reexport_chain.is_empty()
&& let Res::Def(DefKind::Macro(_), def_id) = child.res
&& let Some(local_def_id) = def_id.as_local()
&& self.cx.tcx.has_attr(def_id, sym::macro_export)
&& inserted.insert(def_id)
{
let item = self.cx.tcx.hir().expect_item(local_def_id);
top_level_module.items.insert((local_def_id, Some(item.ident.name)), (item, None, None));
top_level_module
.items
.insert((local_def_id, Some(item.ident.name)), (item, None, None));
}
}

4
src/tools/compiletest/src/runtest.rs
View File

@ -3701,9 +3701,7 @@ impl<'test> TestCx<'test> {
let stderr_bits = format!("{}bit.stderr", self.config.get_pointer_width());
let (stderr_kind, stdout_kind) = match output_kind {
TestOutput::Compile => (
{
if self.props.stderr_per_bitwidth { &stderr_bits } else { UI_STDERR }
},
{ if self.props.stderr_per_bitwidth { &stderr_bits } else { UI_STDERR } },
UI_STDOUT,
),
TestOutput::Run => (UI_RUN_STDERR, UI_RUN_STDOUT),