bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Auto merge of #110405 - fee1-dead-contrib:rollup-9rkree6, r=fee1-dead

Browse source 
Rollup of 4 pull requests

Successful merges:

 - #110397 (Move some utils out of `rustc_const_eval`)
 - #110398 (use matches! macro in more places)
 - #110400 (more clippy fixes: clippy::{iter_cloned_collect, unwarp_or_else_defau…)
 - #110402 (Remove the loop in `Align::from_bytes`)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2023-04-16 13:12:53 +00:00
commit 8a778ca1e3
33 changed files with 91 additions and 114 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Cargo.lock
View file

@ -4421,7 +4421,6 @@ dependencies = [
"either",
"itertools",
"polonius-engine",
"rustc_const_eval",
"rustc_data_structures",
"rustc_errors",
"rustc_graphviz",

11
compiler/rustc_abi/src/lib.rs
View file

@ -665,15 +665,12 @@ impl Align {
format!("`{}` is too large", align)
}
let mut bytes = align;
let mut pow2: u8 = 0;
while (bytes & 1) == 0 {
pow2 += 1;
bytes >>= 1;
}
if bytes != 1 {
let tz = align.trailing_zeros();
if align != (1 << tz) {
return Err(not_power_of_2(align));
}
let pow2 = tz as u8;
if pow2 > Self::MAX.pow2 {
return Err(too_large(align));
}

20
compiler/rustc_ast/src/ast.rs
View file

@ -1298,17 +1298,17 @@ impl Expr {
/// To a first-order approximation, is this a pattern?
pub fn is_approximately_pattern(&self) -> bool {
match &self.peel_parens().kind {
matches!(
&self.peel_parens().kind,
ExprKind::Array(_)
| ExprKind::Call(_, _)
| ExprKind::Tup(_)
| ExprKind::Lit(_)
| ExprKind::Range(_, _, _)
| ExprKind::Underscore
| ExprKind::Path(_, _)
| ExprKind::Struct(_) => true,
_ => false,
}
| ExprKind::Call(_, _)
| ExprKind::Tup(_)
| ExprKind::Lit(_)
| ExprKind::Range(_, _, _)
| ExprKind::Underscore
| ExprKind::Path(_, _)
| ExprKind::Struct(_)
)
}
}

5
compiler/rustc_ast_lowering/src/lib.rs
View file

@ -332,10 +332,7 @@ enum FnDeclKind {
impl FnDeclKind {
fn param_impl_trait_allowed(&self) -> bool {
match self {
FnDeclKind::Fn | FnDeclKind::Inherent | FnDeclKind::Impl | FnDeclKind::Trait => true,
_ => false,
}
matches!(self, FnDeclKind::Fn | FnDeclKind::Inherent | FnDeclKind::Impl | FnDeclKind::Trait)
}
fn return_impl_trait_allowed(&self, tcx: TyCtxt<'_>) -> bool {

1
compiler/rustc_borrowck/Cargo.toml
View file

@ -20,7 +20,6 @@ rustc_infer = { path = "../rustc_infer" }
rustc_lexer = { path = "../rustc_lexer" }
rustc_macros = { path = "../rustc_macros" }
rustc_middle = { path = "../rustc_middle" }
rustc_const_eval = { path = "../rustc_const_eval" }
rustc_mir_dataflow = { path = "../rustc_mir_dataflow" }
rustc_serialize = { path = "../rustc_serialize" }
rustc_session = { path = "../rustc_session" }

4
compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
View file

@ -1,5 +1,4 @@
use either::Either;
use rustc_const_eval::util::CallKind;
use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::FxIndexSet;
use rustc_errors::{
@ -18,6 +17,7 @@ use rustc_middle::mir::{
ProjectionElem, Rvalue, Statement, StatementKind, Terminator, TerminatorKind, VarBindingForm,
};
use rustc_middle::ty::{self, suggest_constraining_type_params, PredicateKind, Ty};
use rustc_middle::util::CallKind;
use rustc_mir_dataflow::move_paths::{InitKind, MoveOutIndex, MovePathIndex};
use rustc_span::def_id::LocalDefId;
use rustc_span::hygiene::DesugaringKind;
@ -2424,7 +2424,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
Some((method_did, method_substs)),
) = (
&self.body[loan.reserve_location.block].terminator,
rustc_const_eval::util::find_self_call(
rustc_middle::util::find_self_call(
tcx,
self.body,
loan.assigned_place.local,

6
compiler/rustc_borrowck/src/diagnostics/mod.rs
View file

@ -1,7 +1,6 @@
//! Borrow checker diagnostics.
use itertools::Itertools;
use rustc_const_eval::util::{call_kind, CallDesugaringKind};
use rustc_errors::{Applicability, Diagnostic};
use rustc_hir as hir;
use rustc_hir::def::{CtorKind, Namespace};
@ -15,6 +14,7 @@ use rustc_middle::mir::{
};
use rustc_middle::ty::print::Print;
use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
use rustc_middle::util::{call_kind, CallDesugaringKind};
use rustc_mir_dataflow::move_paths::{InitLocation, LookupResult};
use rustc_span::def_id::LocalDefId;
use rustc_span::{symbol::sym, Span, Symbol, DUMMY_SP};
@ -45,7 +45,7 @@ pub(crate) use mutability_errors::AccessKind;
pub(crate) use outlives_suggestion::OutlivesSuggestionBuilder;
pub(crate) use region_errors::{ErrorConstraintInfo, RegionErrorKind, RegionErrors};
pub(crate) use region_name::{RegionName, RegionNameSource};
pub(crate) use rustc_const_eval::util::CallKind;
pub(crate) use rustc_middle::util::CallKind;
pub(super) struct DescribePlaceOpt {
pub including_downcast: bool,
@ -874,7 +874,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
}) = &self.body[location.block].terminator
{
let Some((method_did, method_substs)) =
rustc_const_eval::util::find_self_call(
rustc_middle::util::find_self_call(
self.infcx.tcx,
&self.body,
target_temp,

2
compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
View file

@ -15,8 +15,8 @@ use rustc_span::{sym, BytePos, Span};
use rustc_target::abi::FieldIdx;
use crate::diagnostics::BorrowedContentSource;
use crate::util::FindAssignments;
use crate::MirBorrowckCtxt;
use rustc_const_eval::util::collect_writes::FindAssignments;
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub(crate) enum AccessKind {

1
compiler/rustc_borrowck/src/lib.rs
View file

@ -88,6 +88,7 @@ mod session_diagnostics;
mod type_check;
mod universal_regions;
mod used_muts;
mod util;
/// A public API provided for the Rust compiler consumers.
pub mod consumers;

0
compiler/rustc_const_eval/src/util/collect_writes.rs → compiler/rustc_borrowck/src/util/collect_writes.rs
View file

3
compiler/rustc_borrowck/src/util/mod.rs Normal file
View file

@ -0,0 +1,3 @@
mod collect_writes;
pub use collect_writes::FindAssignments;

2
compiler/rustc_const_eval/src/transform/check_consts/ops.rs
View file

@ -14,6 +14,7 @@ use rustc_middle::ty::print::with_no_trimmed_paths;
use rustc_middle::ty::subst::{GenericArgKind, SubstsRef};
use rustc_middle::ty::{suggest_constraining_type_param, Adt, Closure, FnDef, FnPtr, Param, Ty};
use rustc_middle::ty::{Binder, TraitRef};
use rustc_middle::util::{call_kind, CallDesugaringKind, CallKind};
use rustc_session::parse::feature_err;
use rustc_span::symbol::sym;
use rustc_span::{BytePos, Pos, Span, Symbol};
@ -21,7 +22,6 @@ use rustc_trait_selection::traits::SelectionContext;
use super::ConstCx;
use crate::errors;
use crate::util::{call_kind, CallDesugaringKind, CallKind};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Status {

5
compiler/rustc_const_eval/src/util/mod.rs
View file

@ -1,14 +1,9 @@
mod alignment;
mod call_kind;
mod check_validity_requirement;
pub mod collect_writes;
mod compare_types;
mod find_self_call;
mod type_name;
pub use self::alignment::is_disaligned;
pub use self::call_kind::{call_kind, CallDesugaringKind, CallKind};
pub use self::check_validity_requirement::check_validity_requirement;
pub use self::compare_types::{is_equal_up_to_subtyping, is_subtype};
pub use self::find_self_call::find_self_call;
pub use self::type_name::type_name;

5
compiler/rustc_hir/src/def.rs
View file

@ -234,10 +234,7 @@ impl DefKind {
#[inline]
pub fn is_fn_like(self) -> bool {
match self {
DefKind::Fn | DefKind::AssocFn | DefKind::Closure | DefKind::Generator => true,
_ => false,
}
matches!(self, DefKind::Fn | DefKind::AssocFn | DefKind::Closure | DefKind::Generator)
}
/// Whether `query get_codegen_attrs` should be used with this definition.

2
compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
View file

@ -1317,7 +1317,7 @@ fn compare_number_of_generics<'tcx>(
impl_count,
kind,
pluralize!(impl_count),
suffix.unwrap_or_else(String::new),
suffix.unwrap_or_default(),
),
);
}

5
compiler/rustc_hir_analysis/src/collect.rs
View file

@ -1457,10 +1457,7 @@ fn compute_sig_of_foreign_fn_decl<'tcx>(
}
fn is_foreign_item(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
match tcx.hir().get_by_def_id(def_id) {
Node::ForeignItem(..) => true,
_ => false,
}
matches!(tcx.hir().get_by_def_id(def_id), Node::ForeignItem(..))
}
fn generator_kind(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<hir::GeneratorKind> {

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

@ -1735,10 +1735,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
} else {
self.check_expr_has_type_or_error(base_expr, adt_ty, |_| {
let base_ty = self.typeck_results.borrow().expr_ty(*base_expr);
let same_adt = match (adt_ty.kind(), base_ty.kind()) {
(ty::Adt(adt, _), ty::Adt(base_adt, _)) if adt == base_adt => true,
_ => false,
};
let same_adt = matches!((adt_ty.kind(), base_ty.kind()),
(ty::Adt(adt, _), ty::Adt(base_adt, _)) if adt == base_adt);
if self.tcx.sess.is_nightly_build() && same_adt {
feature_err(
&self.tcx.sess.parse_sess,

11
compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs
View file

@ -312,13 +312,10 @@ pub fn suggest_new_region_bound(
Applicability::MaybeIncorrect,
);
}
} else if opaque.bounds.iter().any(|arg| match arg {
GenericBound::Outlives(Lifetime { ident, .. })
if ident.name.to_string() == lifetime_name =>
{
true
}
_ => false,
} else if opaque.bounds.iter().any(|arg| {
matches!(arg,
GenericBound::Outlives(Lifetime { ident, .. })
if ident.name.to_string() == lifetime_name )
}) {
} else {
// get a lifetime name of existing named lifetimes if any

8
compiler/rustc_infer/src/infer/mod.rs
View file

@ -1577,10 +1577,10 @@ impl<'tcx> InferCtxt<'tcx> {
(TyOrConstInferVar::Ty(ty_var), Ok(inner)) => {
use self::type_variable::TypeVariableValue;
match inner.try_type_variables_probe_ref(ty_var) {
Some(TypeVariableValue::Unknown { .. }) => true,
_ => false,
}
matches!(
inner.try_type_variables_probe_ref(ty_var),
Some(TypeVariableValue::Unknown { .. })
)
}
_ => false,
};

8
compiler/rustc_infer/src/traits/mod.rs
View file

@ -89,10 +89,10 @@ impl<'tcx> PredicateObligation<'tcx> {
impl<'tcx> TraitObligation<'tcx> {
/// Returns `true` if the trait predicate is considered `const` in its ParamEnv.
pub fn is_const(&self) -> bool {
match (self.predicate.skip_binder().constness, self.param_env.constness()) {
(ty::BoundConstness::ConstIfConst, hir::Constness::Const) => true,
_ => false,
}
matches!(
(self.predicate.skip_binder().constness, self.param_env.constness()),
(ty::BoundConstness::ConstIfConst, hir::Constness::Const)
)
}
pub fn derived_cause(

6
compiler/rustc_middle/src/lib.rs
View file

@ -99,13 +99,9 @@ pub mod mir;
pub mod thir;
pub mod traits;
pub mod ty;
pub mod util;
mod values;
pub mod util {
pub mod bug;
pub mod common;
}
// Allows macros to refer to this crate as `::rustc_middle`
extern crate self as rustc_middle;

4
compiler/rustc_const_eval/src/util/call_kind.rs → compiler/rustc_middle/src/util/call_kind.rs
View file

@ -2,10 +2,10 @@
//! as well as errors when attempting to call a non-const function in a const
//! context.
use crate::ty::subst::SubstsRef;
use crate::ty::{AssocItemContainer, Instance, ParamEnv, Ty, TyCtxt};
use rustc_hir::def_id::DefId;
use rustc_hir::{lang_items, LangItem};
use rustc_middle::ty::subst::SubstsRef;
use rustc_middle::ty::{AssocItemContainer, Instance, ParamEnv, Ty, TyCtxt};
use rustc_span::symbol::Ident;
use rustc_span::{sym, DesugaringKind, Span};

6
compiler/rustc_const_eval/src/util/find_self_call.rs → compiler/rustc_middle/src/util/find_self_call.rs
View file

@ -1,6 +1,6 @@
use rustc_middle::mir::*;
use rustc_middle::ty::subst::SubstsRef;
use rustc_middle::ty::{self, TyCtxt};
use crate::mir::*;
use crate::ty::subst::SubstsRef;
use crate::ty::{self, TyCtxt};
use rustc_span::def_id::DefId;
/// Checks if the specified `local` is used as the `self` parameter of a method call

7
compiler/rustc_middle/src/util/mod.rs Normal file
View file

@ -0,0 +1,7 @@
pub mod bug;
pub mod call_kind;
pub mod common;
pub mod find_self_call;
pub use call_kind::{call_kind, CallDesugaringKind, CallKind};
pub use find_self_call::find_self_call;

9
compiler/rustc_mir_build/src/errors.rs
View file

@ -384,13 +384,8 @@ impl<'a> IntoDiagnostic<'a> for NonExhaustivePatternsTypeNotEmpty<'_, '_, '_> {
diag.span_note(span, fluent::mir_build_def_note);
}
let is_variant_list_non_exhaustive = match self.ty.kind() {
ty::Adt(def, _) if def.is_variant_list_non_exhaustive() && !def.did().is_local() => {
true
}
_ => false,
};
let is_variant_list_non_exhaustive = matches!(self.ty.kind(),
ty::Adt(def, _) if def.is_variant_list_non_exhaustive() && !def.did().is_local());
if is_variant_list_non_exhaustive {
diag.note(fluent::mir_build_non_exhaustive_type_note);
} else {

6
compiler/rustc_mir_build/src/thir/pattern/check_match.rs
View file

@ -671,10 +671,8 @@ fn non_exhaustive_match<'p, 'tcx>(
};
};
let is_variant_list_non_exhaustive = match scrut_ty.kind() {
ty::Adt(def, _) if def.is_variant_list_non_exhaustive() && !def.did().is_local() => true,
_ => false,
};
let is_variant_list_non_exhaustive = matches!(scrut_ty.kind(),
ty::Adt(def, _) if def.is_variant_list_non_exhaustive() && !def.did().is_local());
adt_defined_here(cx, &mut err, scrut_ty, &witnesses);
err.note(&format!(

7
compiler/rustc_mir_transform/src/check_const_item_mutation.rs
View file

@ -134,7 +134,12 @@ impl<'tcx> Visitor<'tcx> for ConstMutationChecker<'_, 'tcx> {
// the `self` parameter of a method call (as the terminator of our current
// BasicBlock). If so, we emit a more specific lint.
let method_did = self.target_local.and_then(|target_local| {
crate::util::find_self_call(self.tcx, &self.body, target_local, loc.block)
rustc_middle::util::find_self_call(
self.tcx,
&self.body,
target_local,
loc.block,
)
});
let lint_loc =
if method_did.is_some() { self.body.terminator_loc(loc.block) } else { loc };

6
compiler/rustc_mir_transform/src/coverage/debug.rs
View file

@ -292,10 +292,8 @@ impl DebugCounters {
}
pub fn some_block_label(&self, operand: ExpressionOperandId) -> Option<&String> {
self.some_counters.as_ref().map_or(None, |counters| {
counters
.get(&operand)
.map_or(None, |debug_counter| debug_counter.some_block_label.as_ref())
self.some_counters.as_ref().and_then(|counters| {
counters.get(&operand).and_then(|debug_counter| debug_counter.some_block_label.as_ref())
})
}

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

@ -2577,14 +2577,12 @@ impl<'a> Parser<'a> {
}
fn recover_self_param(&mut self) -> bool {
match self
.parse_outer_attributes()
.and_then(|_| self.parse_self_param())
.map_err(|e| e.cancel())
{
Ok(Some(_)) => true,
_ => false,
}
matches!(
self.parse_outer_attributes()
.and_then(|_| self.parse_self_param())
.map_err(|e| e.cancel()),
Ok(Some(_))
)
}
}

10
compiler/rustc_parse/src/parser/nonterminal.rs
View file

@ -20,12 +20,10 @@ impl<'a> Parser<'a> {
pub fn nonterminal_may_begin_with(kind: NonterminalKind, token: &Token) -> bool {
/// Checks whether the non-terminal may contain a single (non-keyword) identifier.
fn may_be_ident(nt: &token::Nonterminal) -> bool {
match *nt {
token::NtItem(_) | token::NtBlock(_) | token::NtVis(_) | token::NtLifetime(_) => {
false
}
_ => true,
}
!matches!(
*nt,
token::NtItem(_) | token::NtBlock(_) | token::NtVis(_) | token::NtLifetime(_)
)
}
match kind {

20
compiler/rustc_resolve/src/diagnostics.rs
View file

@ -663,15 +663,17 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
Ident::with_dummy_span(name),
Namespace::ValueNS,
&parent_scope,
&|res: Res| match res {
Res::Def(
DefKind::Ctor(CtorOf::Variant, CtorKind::Const)
| DefKind::Ctor(CtorOf::Struct, CtorKind::Const)
| DefKind::Const
| DefKind::AssocConst,
_,
) => true,
_ => false,
&|res: Res| {
matches!(
res,
Res::Def(
DefKind::Ctor(CtorOf::Variant, CtorKind::Const)
| DefKind::Ctor(CtorOf::Struct, CtorKind::Const)
| DefKind::Const
| DefKind::AssocConst,
_,
)
)
},
);

2
compiler/rustc_transmute/src/layout/tree.rs
View file

@ -196,7 +196,7 @@ pub(crate) mod rustc {
fn from(err: LayoutError<'tcx>) -> Self {
match err {
LayoutError::Unknown(..) => Self::Unknown,
err @ _ => unimplemented!("{:?}", err),
err => unimplemented!("{:?}", err),
}
}
}

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

@ -141,7 +141,7 @@ where
let f = auto_trait::AutoTraitFinder::new(tcx);
debug!("get_auto_trait_impls({:?})", ty);
let auto_traits: Vec<_> = self.cx.auto_traits.iter().copied().collect();
let auto_traits: Vec<_> = self.cx.auto_traits.to_vec();
let mut auto_traits: Vec<Item> = auto_traits
.into_iter()
.filter_map(|trait_def_id| {