mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #98802 - Dylan-DPC:rollup-u6mwx27, r=Dylan-DPC

Browse Source 
Rollup of 5 pull requests

Successful merges:

 - #98639 (Factor out `hir::Node::Binding`)
 - #98653 (Add regression test for #79494)
 - #98763 (bootstrap: illumos platform flags for split-debuginfo)
 - #98766 (cleanup mir visitor for `rustc::pass_by_value`)
 - #98783 (interpret: make a comment less scary)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2022-07-02 08:39:20 +00:00
commit aedf78e56b
45 changed files with 235 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compiler/rustc_ast_lowering/src/index.rs
View File

@ -192,9 +192,7 @@ fn visit_impl_item(&mut self, ii: &'hir ImplItem<'hir>) {
}
fn visit_pat(&mut self, pat: &'hir Pat<'hir>) {
let node =
if let PatKind::Binding(..) = pat.kind { Node::Binding(pat) } else { Node::Pat(pat) };
self.insert(pat.span, pat.hir_id, node);
self.insert(pat.span, pat.hir_id, Node::Pat(pat));
self.with_parent(pat.hir_id, |this| {
intravisit::walk_pat(this, pat);

8
compiler/rustc_borrowck/src/borrow_set.rs
View File

@ -92,9 +92,9 @@ fn build<'tcx>(
struct HasStorageDead(BitSet<Local>);
impl<'tcx> Visitor<'tcx> for HasStorageDead {
fn visit_local(&mut self, local: &Local, ctx: PlaceContext, _: Location) {
fn visit_local(&mut self, local: Local, ctx: PlaceContext, _: Location) {
if ctx == PlaceContext::NonUse(NonUseContext::StorageDead) {
self.0.insert(*local);
self.0.insert(local);
}
}
}
@ -223,7 +223,7 @@ fn visit_assign(
self.super_assign(assigned_place, rvalue, location)
}
fn visit_local(&mut self, temp: &Local, context: PlaceContext, location: Location) {
fn visit_local(&mut self, temp: Local, context: PlaceContext, location: Location) {
if !context.is_use() {
return;
}
@ -232,7 +232,7 @@ fn visit_local(&mut self, temp: &Local, context: PlaceContext, location: Locatio
// check whether we (earlier) saw a 2-phase borrow like
//
// TMP = &mut place
if let Some(&borrow_index) = self.pending_activations.get(temp) {
if let Some(&borrow_index) = self.pending_activations.get(&temp) {
let borrow_data = &mut self.location_map[borrow_index.as_usize()];
// Watch out: the use of TMP in the borrow itself

4
compiler/rustc_borrowck/src/diagnostics/find_all_local_uses.rs
View File

@ -18,8 +18,8 @@ struct AllLocalUsesVisitor {
}
impl<'tcx> Visitor<'tcx> for AllLocalUsesVisitor {
fn visit_local(&mut self, local: &Local, _context: PlaceContext, location: Location) {
if *local == self.for_local {
fn visit_local(&mut self, local: Local, _context: PlaceContext, location: Location) {
if local == self.for_local {
self.uses.insert(location);
}
}

2
compiler/rustc_borrowck/src/diagnostics/find_use.rs
View File

@ -106,7 +106,7 @@ enum DefUseResult {
}
impl<'cx, 'tcx> Visitor<'tcx> for DefUseVisitor<'cx, 'tcx> {
fn visit_local(&mut self, &local: &Local, context: PlaceContext, _: Location) {
fn visit_local(&mut self, local: Local, context: PlaceContext, _: Location) {
let local_ty = self.body.local_decls[local].ty;
let mut found_it = false;

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

@ -362,7 +362,7 @@ pub(crate) fn report_mutability_error(
let upvar_hir_id = captured_place.get_root_variable();
if let Some(Node::Binding(pat)) = self.infcx.tcx.hir().find(upvar_hir_id)
if let Some(Node::Pat(pat)) = self.infcx.tcx.hir().find(upvar_hir_id)
&& let hir::PatKind::Binding(
hir::BindingAnnotation::Unannotated,
_,

2
compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs
View File

@ -157,7 +157,7 @@ fn insert(
}
impl Visitor<'_> for LocalUseMapBuild<'_> {
fn visit_local(&mut self, &local: &Local, context: PlaceContext, location: Location) {
fn visit_local(&mut self, local: Local, context: PlaceContext, location: Location) {
if self.locals_with_use_data[local] {
match def_use::categorize(context) {
Some(DefUse::Def) => self.insert_def(local, location),

2
compiler/rustc_borrowck/src/type_check/liveness/polonius.rs
View File

@ -54,7 +54,7 @@ fn place_to_mpi(&self, place: &Place<'_>) -> Option<MovePathIndex> {
}
impl<'a, 'tcx> Visitor<'tcx> for UseFactsExtractor<'a, 'tcx> {
fn visit_local(&mut self, &local: &Local, context: PlaceContext, location: Location) {
fn visit_local(&mut self, local: Local, context: PlaceContext, location: Location) {
match def_use::categorize(context) {
Some(DefUse::Def) => self.insert_def(local, location),
Some(DefUse::Use) => self.insert_use(local, location),

4
compiler/rustc_borrowck/src/type_check/mod.rs
View File

@ -333,9 +333,9 @@ struct TypeVerifier<'a, 'b, 'tcx> {
}
impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
fn visit_span(&mut self, span: &Span) {
fn visit_span(&mut self, span: Span) {
if !span.is_dummy() {
self.last_span = *span;
self.last_span = span;
}
}

4
compiler/rustc_borrowck/src/used_muts.rs
View File

@ -91,8 +91,8 @@ fn visit_statement(&mut self, statement: &Statement<'tcx>, location: Location) {
self.super_statement(statement, location);
}
fn visit_local(&mut self, local: &Local, place_context: PlaceContext, location: Location) {
if place_context.is_place_assignment() && self.temporary_used_locals.contains(local) {
fn visit_local(&mut self, local: Local, place_context: PlaceContext, location: Location) {
if place_context.is_place_assignment() && self.temporary_used_locals.contains(&local) {
// Propagate the Local assigned at this Location as a used mutable local variable
for moi in &self.mbcx.move_data.loc_map[location] {
let mpi = &self.mbcx.move_data.moves[*moi].path;

6
compiler/rustc_codegen_ssa/src/mir/analyze.rs
View File

@ -143,13 +143,13 @@ fn process_place(
// now that we have moved to the "slice of projections" representation.
if let mir::ProjectionElem::Index(local) = elem {
self.visit_local(
&local,
local,
PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
location,
);
}
} else {
self.visit_local(&place_ref.local, context, location);
self.visit_local(place_ref.local, context, location);
}
}
}
@ -185,7 +185,7 @@ fn visit_place(&mut self, place: &mir::Place<'tcx>, context: PlaceContext, locat
self.process_place(&place.as_ref(), context, location);
}
fn visit_local(&mut self, &local: &mir::Local, context: PlaceContext, location: Location) {
fn visit_local(&mut self, local: mir::Local, context: PlaceContext, location: Location) {
match context {
PlaceContext::MutatingUse(MutatingUseContext::Call)
| PlaceContext::MutatingUse(MutatingUseContext::Yield) => {

2
compiler/rustc_const_eval/src/interpret/cast.rs
View File

@ -202,7 +202,7 @@ pub fn pointer_expose_address_cast(
let ptr = self.scalar_to_ptr(scalar)?;
match ptr.into_pointer_or_addr() {
Ok(ptr) => M::expose_ptr(self, ptr)?,
Err(_) => {} // do nothing, exposing an invalid pointer has no meaning
Err(_) => {} // Do nothing, exposing an invalid pointer (`None` provenance) is a NOP.
};
Ok(self.cast_from_int_like(scalar, src.layout, cast_ty)?.into())
}

2
compiler/rustc_const_eval/src/interpret/validity.rs
View File

@ -244,7 +244,7 @@ fn aggregate_field_path_elem(&mut self, layout: TyAndLayout<'tcx>, field: usize)
// for a generator).
let var_hir_id = captured_place.get_root_variable();
let node = self.ecx.tcx.hir().get(var_hir_id);
if let hir::Node::Binding(pat) = node {
if let hir::Node::Pat(pat) = node {
if let hir::PatKind::Binding(_, _, ident, _) = pat.kind {
name = Some(ident.name);
}

4
compiler/rustc_const_eval/src/transform/check_consts/check.rs
View File

@ -418,7 +418,7 @@ fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
PlaceContext::MutatingUse(MutatingUseContext::Borrow)
}
};
self.visit_local(&reborrowed_place_ref.local, ctx, location);
self.visit_local(reborrowed_place_ref.local, ctx, location);
self.visit_projection(reborrowed_place_ref, ctx, location);
return;
}
@ -431,7 +431,7 @@ fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
}
Mutability::Mut => PlaceContext::MutatingUse(MutatingUseContext::AddressOf),
};
self.visit_local(&reborrowed_place_ref.local, ctx, location);
self.visit_local(reborrowed_place_ref.local, ctx, location);
self.visit_projection(reborrowed_place_ref, ctx, location);
return;
}

2
compiler/rustc_const_eval/src/transform/promote_consts.rs
View File

@ -106,7 +106,7 @@ struct Collector<'a, 'tcx> {
}
impl<'tcx> Visitor<'tcx> for Collector<'_, 'tcx> {
fn visit_local(&mut self, &index: &Local, context: PlaceContext, location: Location) {
fn visit_local(&mut self, index: Local, context: PlaceContext, location: Location) {
debug!("visit_local: index={:?} context={:?} location={:?}", index, context, location);
// We're only interested in temporaries and the return place
match self.ccx.body.local_kind(index) {

10
compiler/rustc_const_eval/src/transform/validate.rs
View File

@ -196,8 +196,8 @@ fn mir_assign_valid_types(&self, src: Ty<'tcx>, dest: Ty<'tcx>) -> bool {
}
impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
fn visit_local(&mut self, local: &Local, context: PlaceContext, location: Location) {
if self.body.local_decls.get(*local).is_none() {
fn visit_local(&mut self, local: Local, context: PlaceContext, location: Location) {
if self.body.local_decls.get(local).is_none() {
self.fail(
location,
format!("local {:?} has no corresponding declaration in `body.local_decls`", local),
@ -208,7 +208,7 @@ fn visit_local(&mut self, local: &Local, context: PlaceContext, location: Locati
// Uses of locals must occur while the local's storage is allocated.
self.storage_liveness.seek_after_primary_effect(location);
let locals_with_storage = self.storage_liveness.get();
if !locals_with_storage.contains(*local) {
if !locals_with_storage.contains(local) {
self.fail(location, format!("use of local {:?}, which has no storage here", local));
}
}
@ -823,8 +823,8 @@ fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location
self.super_terminator(terminator, location);
}
fn visit_source_scope(&mut self, scope: &SourceScope) {
if self.body.source_scopes.get(*scope).is_none() {
fn visit_source_scope(&mut self, scope: SourceScope) {
if self.body.source_scopes.get(scope).is_none() {
self.tcx.sess.diagnostic().delay_span_bug(
self.body.span,
&format!(

4
compiler/rustc_const_eval/src/util/collect_writes.rs
View File

@ -24,8 +24,8 @@ struct FindLocalAssignmentVisitor {
}
impl<'tcx> Visitor<'tcx> for FindLocalAssignmentVisitor {
fn visit_local(&mut self, local: &Local, place_context: PlaceContext, location: Location) {
if self.needle != *local {
fn visit_local(&mut self, local: Local, place_context: PlaceContext, location: Location) {
if self.needle != local {
return;
}

2
compiler/rustc_hir/src/hir.rs
View File

@ -3326,7 +3326,6 @@ pub enum Node<'hir> {
Ty(&'hir Ty<'hir>),
TypeBinding(&'hir TypeBinding<'hir>),
TraitRef(&'hir TraitRef<'hir>),
Binding(&'hir Pat<'hir>),
Pat(&'hir Pat<'hir>),
Arm(&'hir Arm<'hir>),
Block(&'hir Block<'hir>),
@ -3378,7 +3377,6 @@ pub fn ident(&self) -> Option<Ident> {
| Node::Block(..)
| Node::Ctor(..)
| Node::Pat(..)
| Node::Binding(..)
| Node::Arm(..)
| Node::Local(..)
| Node::Crate(..)

2
compiler/rustc_hir_pretty/src/lib.rs
View File

@ -87,7 +87,7 @@ pub fn print_node(&mut self, node: Node<'_>) {
Node::Ty(a) => self.print_type(&a),
Node::TypeBinding(a) => self.print_type_binding(&a),
Node::TraitRef(a) => self.print_trait_ref(&a),
Node::Binding(a) | Node::Pat(a) => self.print_pat(&a),
Node::Pat(a) => self.print_pat(&a),
Node::Arm(a) => self.print_arm(&a),
Node::Infer(_) => self.word("_"),
Node::Block(a) => {

5
compiler/rustc_middle/src/hir/map/mod.rs
View File

@ -302,7 +302,6 @@ pub fn opt_def_kind(self, local_def_id: LocalDefId) -> Option<DefKind> {
| Node::Infer(_)
| Node::TraitRef(_)
| Node::Pat(_)
| Node::Binding(_)
| Node::Local(_)
| Node::Param(_)
| Node::Arm(_)
@ -901,7 +900,7 @@ pub fn expect_expr(self, id: HirId) -> &'hir Expr<'hir> {
#[inline]
fn opt_ident(self, id: HirId) -> Option<Ident> {
match self.get(id) {
Node::Binding(&Pat { kind: PatKind::Binding(_, _, ident, _), .. }) => Some(ident),
Node::Pat(&Pat { kind: PatKind::Binding(_, _, ident, _), .. }) => Some(ident),
// A `Ctor` doesn't have an identifier itself, but its parent
// struct/variant does. Compare with `hir::Map::opt_span`.
Node::Ctor(..) => match self.find(self.get_parent_node(id))? {
@ -1046,7 +1045,6 @@ pub fn span_with_body(self, hir_id: HirId) -> Span {
Node::Ty(ty) => ty.span,
Node::TypeBinding(tb) => tb.span,
Node::TraitRef(tr) => tr.path.span,
Node::Binding(pat) => pat.span,
Node::Pat(pat) => pat.span,
Node::Arm(arm) => arm.span,
Node::Block(block) => block.span,
@ -1263,7 +1261,6 @@ fn hir_id_to_string(map: Map<'_>, id: HirId) -> String {
Some(Node::Ty(_)) => node_str("type"),
Some(Node::TypeBinding(_)) => node_str("type binding"),
Some(Node::TraitRef(_)) => node_str("trait ref"),
Some(Node::Binding(_)) => node_str("local"),
Some(Node::Pat(_)) => node_str("pat"),
Some(Node::Param(_)) => node_str("param"),
Some(Node::Arm(_)) => node_str("arm"),

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

@ -30,9 +30,11 @@
//! For example, the `super_basic_block_data` method begins like this:
//!
//! ```ignore (pseudo-rust)
//! fn super_basic_block_data(&mut self,
//! block: BasicBlock,
//! data: & $($mutability)? BasicBlockData<'tcx>) {
//! fn super_basic_block_data(
//! &mut self,
//! block: BasicBlock,
//! data: & $($mutability)? BasicBlockData<'tcx>
//! ) {
//! let BasicBlockData {
//! statements,
//! terminator,
@ -78,106 +80,135 @@ fn visit_body(
self.super_body(body);
}
fn visit_basic_block_data(&mut self,
block: BasicBlock,
data: & $($mutability)? BasicBlockData<'tcx>) {
fn visit_basic_block_data(
&mut self,
block: BasicBlock,
data: & $($mutability)? BasicBlockData<'tcx>,
) {
self.super_basic_block_data(block, data);
}
fn visit_source_scope_data(&mut self,
scope_data: & $($mutability)? SourceScopeData<'tcx>) {
fn visit_source_scope_data(
&mut self,
scope_data: & $($mutability)? SourceScopeData<'tcx>,
) {
self.super_source_scope_data(scope_data);
}
fn visit_statement(&mut self,
statement: & $($mutability)? Statement<'tcx>,
location: Location) {
fn visit_statement(
&mut self,
statement: & $($mutability)? Statement<'tcx>,
location: Location,
) {
self.super_statement(statement, location);
}
fn visit_assign(&mut self,
place: & $($mutability)? Place<'tcx>,
rvalue: & $($mutability)? Rvalue<'tcx>,
location: Location) {
fn visit_assign(
&mut self,
place: & $($mutability)? Place<'tcx>,
rvalue: & $($mutability)? Rvalue<'tcx>,
location: Location,
) {
self.super_assign(place, rvalue, location);
}
fn visit_terminator(&mut self,
terminator: & $($mutability)? Terminator<'tcx>,
location: Location) {
fn visit_terminator(
&mut self,
terminator: & $($mutability)? Terminator<'tcx>,
location: Location,
) {
self.super_terminator(terminator, location);
}
fn visit_assert_message(&mut self,
msg: & $($mutability)? AssertMessage<'tcx>,
location: Location) {
fn visit_assert_message(
&mut self,
msg: & $($mutability)? AssertMessage<'tcx>,
location: Location,
) {
self.super_assert_message(msg, location);
}
fn visit_rvalue(&mut self,
rvalue: & $($mutability)? Rvalue<'tcx>,
location: Location) {
fn visit_rvalue(
&mut self,
rvalue: & $($mutability)? Rvalue<'tcx>,
location: Location,
) {
self.super_rvalue(rvalue, location);
}
fn visit_operand(&mut self,
operand: & $($mutability)? Operand<'tcx>,
location: Location) {
fn visit_operand(
&mut self,
operand: & $($mutability)? Operand<'tcx>,
location: Location,
) {
self.super_operand(operand, location);
}
fn visit_ascribe_user_ty(&mut self,
place: & $($mutability)? Place<'tcx>,
variance: & $($mutability)? ty::Variance,
user_ty: & $($mutability)? UserTypeProjection,
location: Location) {
fn visit_ascribe_user_ty(
&mut self,
place: & $($mutability)? Place<'tcx>,
variance: & $($mutability)? ty::Variance,
user_ty: & $($mutability)? UserTypeProjection,
location: Location,
) {
self.super_ascribe_user_ty(place, variance, user_ty, location);
}
fn visit_coverage(&mut self,
coverage: & $($mutability)? Coverage,
location: Location) {
fn visit_coverage(
&mut self,
coverage: & $($mutability)? Coverage,
location: Location,
) {
self.super_coverage(coverage, location);
}
fn visit_retag(&mut self,
kind: & $($mutability)? RetagKind,
place: & $($mutability)? Place<'tcx>,
location: Location) {
fn visit_retag(
&mut self,
kind: & $($mutability)? RetagKind,
place: & $($mutability)? Place<'tcx>,
location: Location,
) {
self.super_retag(kind, place, location);
}
fn visit_place(&mut self,
place: & $($mutability)? Place<'tcx>,
context: PlaceContext,
location: Location) {
fn visit_place(
&mut self,
place: & $($mutability)? Place<'tcx>,
context: PlaceContext,
location: Location,
) {
self.super_place(place, context, location);
}
visit_place_fns!($($mutability)?);
fn visit_constant(&mut self,
constant: & $($mutability)? Constant<'tcx>,
location: Location) {
fn visit_constant(
&mut self,
constant: & $($mutability)? Constant<'tcx>,
location: Location,
) {
self.super_constant(constant, location);
}
// The macro results in a false positive of sorts, where &mut Span
// is fine, but &Span is not; just allow the lint.
#[allow(rustc::pass_by_value)]
fn visit_span(&mut self,
span: & $($mutability)? Span) {
fn visit_span(
&mut self,
span: $(& $mutability)? Span,
) {
self.super_span(span);
}
fn visit_source_info(&mut self,
source_info: & $($mutability)? SourceInfo) {
fn visit_source_info(
&mut self,
source_info: & $($mutability)? SourceInfo,
) {
self.super_source_info(source_info);
}
fn visit_ty(&mut self,
ty: $(& $mutability)? Ty<'tcx>,
_: TyContext) {
fn visit_ty(
&mut self,
ty: $(& $mutability)? Ty<'tcx>,
_: TyContext,
) {
self.super_ty(ty);
}
@ -196,45 +227,56 @@ fn visit_user_type_annotation(
self.super_user_type_annotation(index, ty);
}
fn visit_region(&mut self,
region: $(& $mutability)? ty::Region<'tcx>,
_: Location) {
fn visit_region(
&mut self,
region: $(& $mutability)? ty::Region<'tcx>,
_: Location,
) {
self.super_region(region);
}
fn visit_const(&mut self,
constant: $(& $mutability)? ty::Const<'tcx>,
_: Location) {
fn visit_const(
&mut self,
constant: $(& $mutability)? ty::Const<'tcx>,
_: Location,
) {
self.super_const(constant);
}
fn visit_substs(&mut self,
substs: & $($mutability)? SubstsRef<'tcx>,
_: Location) {
fn visit_substs(
&mut self,
substs: & $($mutability)? SubstsRef<'tcx>,
_: Location,
) {
self.super_substs(substs);
}
fn visit_local_decl(&mut self,
local: Local,
local_decl: & $($mutability)? LocalDecl<'tcx>) {
fn visit_local_decl(
&mut self,
local: Local,
local_decl: & $($mutability)? LocalDecl<'tcx>,
) {
self.super_local_decl(local, local_decl);
}
fn visit_var_debug_info(&mut self,
var_debug_info: & $($mutability)* VarDebugInfo<'tcx>) {
fn visit_var_debug_info(
&mut self,
var_debug_info: & $($mutability)* VarDebugInfo<'tcx>,
) {
self.super_var_debug_info(var_debug_info);
}
#[allow(rustc::pass_by_value)]
fn visit_local(&mut self,
_local: & $($mutability)? Local,
_context: PlaceContext,
_location: Location) {
}
fn visit_local(
&mut self,
_local: $(& $mutability)? Local,
_context: PlaceContext,
_location: Location,
) {}
#[allow(rustc::pass_by_value)]
fn visit_source_scope(&mut self,
scope: & $($mutability)? SourceScope) {
fn visit_source_scope(
&mut self,
scope: $(& $mutability)? SourceScope,
) {
self.super_source_scope(scope);
}
@ -296,7 +338,7 @@ macro_rules! type_annotations {
self.visit_var_debug_info(var_debug_info);
}
self.visit_span(&$($mutability)? body.span);
self.visit_span($(& $mutability)? body.span);
for const_ in &$($mutability)? body.required_consts {
let location = START_BLOCK.start_location();
@ -338,14 +380,14 @@ fn super_source_scope_data(
local_data: _,
} = scope_data;
self.visit_span(span);
self.visit_span($(& $mutability)? *span);
if let Some(parent_scope) = parent_scope {
self.visit_source_scope(parent_scope);
self.visit_source_scope($(& $mutability)? *parent_scope);
}
if let Some((callee, callsite_span)) = inlined {
let location = START_BLOCK.start_location();
self.visit_span(callsite_span);
self.visit_span($(& $mutability)? *callsite_span);
let ty::Instance { def: callee_def, substs: callee_substs } = callee;
match callee_def {
@ -368,7 +410,7 @@ fn super_source_scope_data(
self.visit_substs(callee_substs, location);
}
if let Some(inlined_parent_scope) = inlined_parent_scope {
self.visit_source_scope(inlined_parent_scope);
self.visit_source_scope($(& $mutability)? *inlined_parent_scope);
}
}
@ -410,14 +452,14 @@ fn super_statement(&mut self,
}
StatementKind::StorageLive(local) => {
self.visit_local(
local,
$(& $mutability)? *local,
PlaceContext::NonUse(NonUseContext::StorageLive),
location
);
}
StatementKind::StorageDead(local) => {
self.visit_local(
local,
$(& $mutability)? *local,
PlaceContext::NonUse(NonUseContext::StorageDead),
location
);
@ -483,7 +525,7 @@ fn super_terminator(&mut self,
// cannot be changed by any visitor, though.
let $($mutability)? local = RETURN_PLACE;
self.visit_local(
& $($mutability)? local,
$(& $mutability)? local,
PlaceContext::NonMutatingUse(NonMutatingUseContext::Move),
location,
);
@ -840,8 +882,10 @@ fn super_local_decl(&mut self,
self.visit_source_info(source_info);
}
fn super_var_debug_info(&mut self,
var_debug_info: & $($mutability)? VarDebugInfo<'tcx>) {
fn super_var_debug_info(
&mut self,
var_debug_info: & $($mutability)? VarDebugInfo<'tcx>
) {
let VarDebugInfo {
name: _,
source_info,
@ -861,21 +905,23 @@ fn super_var_debug_info(&mut self,
}
}
#[allow(rustc::pass_by_value)]
fn super_source_scope(&mut self,
_scope: & $($mutability)? SourceScope) {
}
fn super_source_scope(
&mut self,
_scope: $(& $mutability)? SourceScope
) {}
fn super_constant(&mut self,
constant: & $($mutability)? Constant<'tcx>,
location: Location) {
fn super_constant(
&mut self,
constant: & $($mutability)? Constant<'tcx>,
location: Location
) {
let Constant {
span,
user_ty,
literal,
} = constant;
self.visit_span(span);
self.visit_span($(& $mutability)? *span);
drop(user_ty); // no visit method for this
match literal {
ConstantKind::Ty(ct) => self.visit_const($(& $mutability)? *ct, location),
@ -883,10 +929,7 @@ fn super_constant(&mut self,
}
}
// The macro results in a false positive of sorts, where &mut Span
// is fine, but &Span is not; just allow the lint.
#[allow(rustc::pass_by_value)]
fn super_span(&mut self, _span: & $($mutability)? Span) {
fn super_span(&mut self, _span: $(& $mutability)? Span) {
}
fn super_source_info(&mut self, source_info: & $($mutability)? SourceInfo) {
@ -895,8 +938,8 @@ fn super_source_info(&mut self, source_info: & $($mutability)? SourceInfo) {
scope,
} = source_info;
self.visit_span(span);
self.visit_source_scope(scope);
self.visit_span($(& $mutability)? *span);
self.visit_source_scope($(& $mutability)? *scope);
}
fn super_user_type_projection(
@ -910,7 +953,7 @@ fn super_user_type_annotation(
_index: UserTypeAnnotationIndex,
ty: & $($mutability)? CanonicalUserTypeAnnotation<'tcx>,
) {
self.visit_span(& $($mutability)? ty.span);
self.visit_span($(& $mutability)? ty.span);
self.visit_ty($(& $mutability)? ty.inferred_ty, TyContext::UserTy(ty.span));
}
@ -1058,7 +1101,7 @@ fn super_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location:
}
}
self.visit_local(&place.local, context, location);
self.visit_local(place.local, context, location);
self.visit_projection(place.as_ref(), context, location);
}
@ -1091,7 +1134,7 @@ fn super_projection_elem(
}
ProjectionElem::Index(local) => {
self.visit_local(
&local,
local,
PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
location,
);

2
compiler/rustc_mir_build/src/build/mod.rs
View File

@ -997,7 +997,7 @@ fn args_and_body(
continue;
};
let pat = match tcx.hir().get(arg.pat.hir_id) {
Node::Pat(pat) | Node::Binding(pat) => pat,
Node::Pat(pat) => pat,
node => bug!("pattern became {:?}", node),
};
let pattern = pat_from_hir(tcx, self.param_env, self.typeck_results, pat);

2
compiler/rustc_mir_build/src/thir/cx/mod.rs
View File

@ -80,7 +80,7 @@ fn new(tcx: TyCtxt<'tcx>, def: ty::WithOptConstParam<LocalDefId>) -> Cx<'tcx> {
#[tracing::instrument(level = "debug", skip(self))]
pub(crate) fn pattern_from_hir(&mut self, p: &hir::Pat<'_>) -> Pat<'tcx> {
let p = match self.tcx.hir().get(p.hir_id) {
Node::Pat(p) | Node::Binding(p) => p,
Node::Pat(p) => p,
node => bug!("pattern became {:?}", node),
};
pat_from_hir(self.tcx, self.param_env, self.typeck_results(), p)

2
compiler/rustc_mir_dataflow/src/impls/init_locals.rs
View File

@ -81,7 +81,7 @@ impl<T> Visitor<'_> for TransferFunction<'_, T>
// deinitialized, although clearly it is only partially deinitialized. This analysis is not
// actually used anywhere at the moment, so this is not critical, but this does need to be fixed
// before it starts being used again.
fn visit_local(&mut self, &local: &Local, context: PlaceContext, _: Location) {
fn visit_local(&mut self, local: Local, context: PlaceContext, _: Location) {
use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, NonUseContext};
match context {
// These are handled specially in `call_return_effect` and `yield_resume_effect`.

2
compiler/rustc_mir_dataflow/src/impls/liveness.rs
View File

@ -111,7 +111,7 @@ fn visit_place(&mut self, place: &mir::Place<'tcx>, context: PlaceContext, locat
}
}
fn visit_local(&mut self, &local: &Local, context: PlaceContext, _: Location) {
fn visit_local(&mut self, local: Local, context: PlaceContext, _: Location) {
// Because we do not call `super_place` above, `visit_local` is only called for locals that
// do not appear as part of a `Place` in the MIR. This handles cases like the implicit use
// of the return place in a `Return` terminator or the index in an `Index` projection.

6
compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs
View File

@ -288,12 +288,12 @@ impl<'a, 'mir, 'tcx, T> Visitor<'tcx> for MoveVisitor<'a, 'mir, 'tcx, T>
where
T: GenKill<Local>,
{
fn visit_local(&mut self, local: &Local, context: PlaceContext, loc: Location) {
fn visit_local(&mut self, local: Local, context: PlaceContext, loc: Location) {
if PlaceContext::NonMutatingUse(NonMutatingUseContext::Move) == context {
let mut borrowed_locals = self.borrowed_locals.borrow_mut();
borrowed_locals.seek_before_primary_effect(loc);
if !borrowed_locals.contains(*local) {
self.trans.kill(*local);
if !borrowed_locals.contains(local) {
self.trans.kill(local);
}
}
}

6
compiler/rustc_mir_transform/src/const_debuginfo.rs
View File

@ -88,12 +88,12 @@ fn find_optimization_oportunities<'tcx>(body: &Body<'tcx>) -> Vec<(Local, Consta
}
impl Visitor<'_> for LocalUseVisitor {
fn visit_local(&mut self, local: &Local, context: PlaceContext, location: Location) {
fn visit_local(&mut self, local: Local, context: PlaceContext, location: Location) {
if context.is_mutating_use() {
self.local_mutating_uses[*local] = self.local_mutating_uses[*local].saturating_add(1);
self.local_mutating_uses[local] = self.local_mutating_uses[local].saturating_add(1);
if context.is_place_assignment() {
self.local_assignment_locations[*local] = Some(location);
self.local_assignment_locations[local] = Some(location);
}
}
}

2
compiler/rustc_mir_transform/src/const_prop.rs
View File

@ -882,7 +882,7 @@ fn check<'tcx>(
}
impl Visitor<'_> for CanConstProp {
fn visit_local(&mut self, &local: &Local, context: PlaceContext, _: Location) {
fn visit_local(&mut self, local: Local, context: PlaceContext, _: Location) {
use rustc_middle::mir::visit::PlaceContext::*;
match context {
// Projections are fine, because `&mut foo.x` will be caught by

2
compiler/rustc_mir_transform/src/const_prop_lint.rs
View File

@ -773,7 +773,7 @@ fn check<'tcx>(
}
impl Visitor<'_> for CanConstProp {
fn visit_local(&mut self, &local: &Local, context: PlaceContext, _: Location) {
fn visit_local(&mut self, local: Local, context: PlaceContext, _: Location) {
use rustc_middle::mir::visit::PlaceContext::*;
match context {
// Projections are fine, because `&mut foo.x` will be caught by

2
compiler/rustc_mir_transform/src/nrvo.rs
View File

@ -219,7 +219,7 @@ fn run(body: &mir::Body<'_>) -> bool {
}
impl<'tcx> Visitor<'tcx> for IsReturnPlaceRead {
fn visit_local(&mut self, &l: &Local, ctxt: PlaceContext, _: Location) {
fn visit_local(&mut self, l: Local, ctxt: PlaceContext, _: Location) {
if l == mir::RETURN_PLACE && ctxt.is_use() && !ctxt.is_place_assignment() {
self.0 = true;
}

8
compiler/rustc_mir_transform/src/simplify.rs
View File

@ -509,12 +509,12 @@ fn visit_statement(&mut self, statement: &Statement<'tcx>, location: Location) {
}
}
fn visit_local(&mut self, local: &Local, _ctx: PlaceContext, _location: Location) {
fn visit_local(&mut self, local: Local, _ctx: PlaceContext, _location: Location) {
if self.increment {
self.use_count[*local] += 1;
self.use_count[local] += 1;
} else {
assert_ne!(self.use_count[*local], 0);
self.use_count[*local] -= 1;
assert_ne!(self.use_count[local], 0);
self.use_count[local] -= 1;
}
}
}

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

@ -462,14 +462,14 @@ fn get_local_uses(body: &Body<'_>) -> IndexVec<Local, usize> {
}
impl Visitor<'_> for LocalUseCounter {
fn visit_local(&mut self, local: &Local, context: PlaceContext, _location: Location) {
fn visit_local(&mut self, local: Local, context: PlaceContext, _location: Location) {
if context.is_storage_marker()
|| context == PlaceContext::NonUse(NonUseContext::VarDebugInfo)
{
return;
}
self.local_uses[*local] += 1;
self.local_uses[local] += 1;
}
}

2
compiler/rustc_monomorphize/src/collector.rs
View File

@ -928,7 +928,7 @@ fn visit_operand(&mut self, operand: &mir::Operand<'tcx>, location: Location) {
fn visit_local(
&mut self,
_place_local: &Local,
_place_local: Local,
_context: mir::visit::PlaceContext,
_location: Location,
) {

6
compiler/rustc_save_analysis/src/lib.rs
View File

@ -623,9 +623,9 @@ pub fn get_path_res(&self, hir_id: hir::HirId) -> Res {
}
},
Node::Binding(&hir::Pat {
kind: hir::PatKind::Binding(_, canonical_id, ..), ..
}) => Res::Local(canonical_id),
Node::Pat(&hir::Pat { kind: hir::PatKind::Binding(_, canonical_id, ..), .. }) => {
Res::Local(canonical_id)
}
_ => Res::Err,
}

2
compiler/rustc_typeck/src/check/demand.rs
View File

@ -223,7 +223,7 @@ fn annotate_expected_due_to_let_ty(
None,
hir::Path { res: hir::def::Res::Local(hir_id), .. },
)) => {
if let Some(hir::Node::Binding(pat)) = self.tcx.hir().find(*hir_id) {
if let Some(hir::Node::Pat(pat)) = self.tcx.hir().find(*hir_id) {
let parent = self.tcx.hir().get_parent_node(pat.hir_id);
primary_span = pat.span;
secondary_span = pat.span;

1
compiler/rustc_typeck/src/check/generator_interior/drop_ranges/cfg_build.rs
View File

@ -251,7 +251,6 @@ fn find_target_expression_from_destination(
| hir::Node::Ty(..)
| hir::Node::TypeBinding(..)
| hir::Node::TraitRef(..)
| hir::Node::Binding(..)
| hir::Node::Pat(..)
| hir::Node::Arm(..)
| hir::Node::Local(..)

3
src/bootstrap/builder.rs
View File

@ -1760,7 +1760,8 @@ pub fn cargo(
let needs_unstable_opts = target.contains("linux")
|| target.contains("windows")
|| target.contains("bsd")
|| target.contains("dragonfly");
|| target.contains("dragonfly")
|| target.contains("illumos");
if needs_unstable_opts {
rustflags.arg("-Zunstable-options");

5
src/test/rustdoc-ui/issue-79494.rs Normal file
View File

@ -0,0 +1,5 @@
// only-x86_64-unknown-linux-gnu
#![feature(const_transmute)]
const ZST: &[u8] = unsafe { std::mem::transmute(1usize) }; //~ ERROR cannot transmute between types of different sizes, or dependently-sized types

12
src/test/rustdoc-ui/issue-79494.stderr Normal file
View File

@ -0,0 +1,12 @@
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/issue-79494.rs:5:29
|
LL | const ZST: &[u8] = unsafe { std::mem::transmute(1usize) };
| ^^^^^^^^^^^^^^^^^^^
|
= note: source type: `usize` (64 bits)
= note: target type: `&[u8]` (128 bits)
error: aborting due to previous error
For more information about this error, try `rustc --explain E0512`.

16
src/tools/clippy/clippy_lints/src/escape.rs
View File

@ -1,7 +1,7 @@
use clippy_utils::diagnostics::span_lint_hir;
use clippy_utils::ty::contains_ty;
use rustc_hir::intravisit;
use rustc_hir::{self, AssocItemKind, Body, FnDecl, HirId, HirIdSet, Impl, ItemKind, Node};
use rustc_hir::{self, AssocItemKind, Body, FnDecl, HirId, HirIdSet, Impl, ItemKind, Node, Pat, PatKind};
use rustc_infer::infer::TyCtxtInferExt;
use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::mir::FakeReadCause;
@ -132,7 +132,10 @@ fn check_fn(
// TODO: Replace with Map::is_argument(..) when it's fixed
fn is_argument(map: rustc_middle::hir::map::Map<'_>, id: HirId) -> bool {
match map.find(id) {
Some(Node::Binding(_)) => (),
Some(Node::Pat(Pat {
kind: PatKind::Binding(..),
..
})) => (),
_ => return false,
}
@ -144,15 +147,6 @@ fn consume(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId) {
if cmt.place.projections.is_empty() {
if let PlaceBase::Local(lid) = cmt.place.base {
self.set.remove(&lid);
let map = &self.cx.tcx.hir();
if let Some(Node::Binding(_)) = map.find(cmt.hir_id) {
if self.set.contains(&lid) {
// let y = x where x is known
// remove x, insert y
self.set.insert(cmt.hir_id);
self.set.remove(&lid);
}
}
}
}
}

2
src/tools/clippy/clippy_lints/src/explicit_write.rs
View File

@ -125,7 +125,7 @@ fn look_in_block<'tcx, 'hir>(cx: &LateContext<'tcx>, kind: &'tcx ExprKind<'hir>)
// Find id of the local that expr_end_of_block resolves to
if let ExprKind::Path(QPath::Resolved(None, expr_path)) = expr_end_of_block.kind;
if let Res::Local(expr_res) = expr_path.res;
if let Some(Node::Binding(res_pat)) = cx.tcx.hir().find(expr_res);
if let Some(Node::Pat(res_pat)) = cx.tcx.hir().find(expr_res);
// Find id of the local we found in the block
if let PatKind::Binding(BindingAnnotation::Unannotated, local_hir_id, _ident, None) = local.pat.kind;

2
src/tools/clippy/clippy_lints/src/loops/mut_range_bound.rs
View File

@ -43,7 +43,7 @@ fn mut_warn_with_span(cx: &LateContext<'_>, span: Option<Span>) {
fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Option<HirId> {
if_chain! {
if let Some(hir_id) = path_to_local(bound);
if let Node::Binding(pat) = cx.tcx.hir().get(hir_id);
if let Node::Pat(pat) = cx.tcx.hir().get(hir_id);
if let PatKind::Binding(BindingAnnotation::Mutable, ..) = pat.kind;
then {
return Some(hir_id);

2
src/tools/clippy/clippy_lints/src/loops/same_item_push.rs
View File

@ -63,7 +63,7 @@ fn emit_lint(cx: &LateContext<'_>, vec: &Expr<'_>, pushed_item: &Expr<'_>) {
Res::Local(hir_id) => {
let node = cx.tcx.hir().get(hir_id);
if_chain! {
if let Node::Binding(pat) = node;
if let Node::Pat(pat) = node;
if let PatKind::Binding(bind_ann, ..) = pat.kind;
if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
let parent_node = cx.tcx.hir().get_parent_node(hir_id);

3
src/tools/clippy/clippy_lints/src/manual_rem_euclid.rs
View File

@ -71,8 +71,7 @@ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
&& let Some(const3) = check_for_unsigned_int_constant(cx, right)
// Also ensures the const is nonzero since zero can't be a divisor
&& const1 == const2 && const2 == const3
&& let Some(hir_id) = path_to_local(expr3)
&& let Some(Node::Binding(_)) = cx.tcx.hir().find(hir_id) {
&& let Some(hir_id) = path_to_local(expr3) {
// Apply only to params or locals with annotated types
match cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
Some(Node::Param(..)) => (),

2
src/tools/clippy/clippy_lints/src/methods/iter_skip_next.rs
View File

@ -22,7 +22,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
|diag| {
if_chain! {
if let Some(id) = path_to_local(recv);
if let Node::Binding(pat) = cx.tcx.hir().get(id);
if let Node::Pat(pat) = cx.tcx.hir().get(id);
if let PatKind::Binding(ann, _, _, _) = pat.kind;
if ann != BindingAnnotation::Mutable;
then {

2
src/tools/clippy/clippy_utils/src/lib.rs
View File

@ -183,7 +183,7 @@ pub fn expr_or_init<'a, 'b, 'tcx: 'b>(cx: &LateContext<'tcx>, mut expr: &'a Expr
pub fn find_binding_init<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx Expr<'tcx>> {
let hir = cx.tcx.hir();
if_chain! {
if let Some(Node::Binding(pat)) = hir.find(hir_id);
if let Some(Node::Pat(pat)) = hir.find(hir_id);
if matches!(pat.kind, PatKind::Binding(BindingAnnotation::Unannotated, ..));
let parent = hir.get_parent_node(hir_id);
if let Some(Node::Local(local)) = hir.find(parent);