bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Some tracing changes

Browse source
This commit is contained in:
Oli Scherer 2023-07-24 14:07:23 +00:00
parent c06b2b9117
commit 1d45658329
3 changed files with 35 additions and 56 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -504,14 +504,13 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
/// Checks that the types internal to the `place` match up with /// Checks that the types internal to the `place` match up with
/// what would be expected. /// what would be expected.
#[instrument(level = "debug", skip(self, location), ret)]
fn sanitize_place( fn sanitize_place(
&mut self, &mut self,
place: &Place<'tcx>, place: &Place<'tcx>,
location: Location, location: Location,
context: PlaceContext, context: PlaceContext,
) -> PlaceTy<'tcx> { ) -> PlaceTy<'tcx> {
debug!("sanitize_place: {:?}", place);
let mut place_ty = PlaceTy::from_ty(self.body().local_decls[place.local].ty); let mut place_ty = PlaceTy::from_ty(self.body().local_decls[place.local].ty);
for elem in place.projection.iter() { for elem in place.projection.iter() {
@ -614,7 +613,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
} }
} }
#[instrument(skip(self), level = "debug")] #[instrument(skip(self, location), ret, level = "debug")]
fn sanitize_projection( fn sanitize_projection(
&mut self, &mut self,
base: PlaceTy<'tcx>, base: PlaceTy<'tcx>,
@ -623,7 +622,6 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
location: Location, location: Location,
context: PlaceContext, context: PlaceContext,
) -> PlaceTy<'tcx> { ) -> PlaceTy<'tcx> {
debug!("sanitize_projection: {:?} {:?} {:?}", base, pi, place);
let tcx = self.tcx(); let tcx = self.tcx();
let base_ty = base.ty; let base_ty = base.ty;
match pi { match pi {

75
compiler/rustc_hir_typeck/src/mem_categorization.rs
View file

@ -198,13 +198,14 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
} }
/// Like `pat_ty`, but ignores implicit `&` patterns. /// Like `pat_ty`, but ignores implicit `&` patterns.
#[instrument(level = "debug", skip(self), ret)]
fn pat_ty_unadjusted(&self, pat: &hir::Pat<'_>) -> McResult<Ty<'tcx>> { fn pat_ty_unadjusted(&self, pat: &hir::Pat<'_>) -> McResult<Ty<'tcx>> {
let base_ty = self.node_ty(pat.hir_id)?; let base_ty = self.node_ty(pat.hir_id)?;
debug!("pat_ty(pat={:?}) base_ty={:?}", pat, base_ty); trace!(?base_ty);
// This code detects whether we are looking at a `ref x`, // This code detects whether we are looking at a `ref x`,
// and if so, figures out what the type *being borrowed* is. // and if so, figures out what the type *being borrowed* is.
let ret_ty = match pat.kind { match pat.kind {
PatKind::Binding(..) => { PatKind::Binding(..) => {
let bm = *self let bm = *self
.typeck_results .typeck_results
@ -217,21 +218,18 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
// but what we want here is the type of the underlying value being borrowed. // but what we want here is the type of the underlying value being borrowed.
// So peel off one-level, turning the &T into T. // So peel off one-level, turning the &T into T.
match base_ty.builtin_deref(false) { match base_ty.builtin_deref(false) {
Some(t) => t.ty, Some(t) => Ok(t.ty),
None => { None => {
debug!("By-ref binding of non-derefable type {:?}", base_ty); debug!("By-ref binding of non-derefable type");
return Err(()); Err(())
} }
} }
} else { } else {
base_ty Ok(base_ty)
} }
} }
_ => base_ty, _ => Ok(base_ty),
}; }
debug!("pat_ty(pat={:?}) ret_ty={:?}", pat, ret_ty);
Ok(ret_ty)
} }
pub(crate) fn cat_expr(&self, expr: &hir::Expr<'_>) -> McResult<PlaceWithHirId<'tcx>> { pub(crate) fn cat_expr(&self, expr: &hir::Expr<'_>) -> McResult<PlaceWithHirId<'tcx>> {
@ -299,13 +297,11 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
} }
} }
#[instrument(level = "debug", skip(self))] #[instrument(level = "debug", skip(self), ret)]
pub(crate) fn cat_expr_unadjusted( pub(crate) fn cat_expr_unadjusted(
&self, &self,
expr: &hir::Expr<'_>, expr: &hir::Expr<'_>,
) -> McResult<PlaceWithHirId<'tcx>> { ) -> McResult<PlaceWithHirId<'tcx>> {
debug!("cat_expr: id={} expr={:?}", expr.hir_id, expr);
let expr_ty = self.expr_ty(expr)?; let expr_ty = self.expr_ty(expr)?;
match expr.kind { match expr.kind {
hir::ExprKind::Unary(hir::UnOp::Deref, ref e_base) => { hir::ExprKind::Unary(hir::UnOp::Deref, ref e_base) => {
@ -319,7 +315,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
hir::ExprKind::Field(ref base, _) => { hir::ExprKind::Field(ref base, _) => {
let base = self.cat_expr(base)?; let base = self.cat_expr(base)?;
debug!("cat_expr(cat_field): id={} expr={:?} base={:?}", expr.hir_id, expr, base); debug!(?base);
let field_idx = self let field_idx = self
.typeck_results .typeck_results
@ -389,7 +385,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
} }
} }
#[instrument(level = "debug", skip(self, span))] #[instrument(level = "debug", skip(self, span), ret)]
pub(crate) fn cat_res( pub(crate) fn cat_res(
&self, &self,
hir_id: hir::HirId, hir_id: hir::HirId,
@ -430,6 +426,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
/// Note: the actual upvar access contains invisible derefs of closure /// Note: the actual upvar access contains invisible derefs of closure
/// environment and upvar reference as appropriate. Only regionck cares /// environment and upvar reference as appropriate. Only regionck cares
/// about these dereferences, so we let it compute them as needed. /// about these dereferences, so we let it compute them as needed.
#[instrument(level = "debug", skip(self), ret)]
fn cat_upvar(&self, hir_id: hir::HirId, var_id: hir::HirId) -> McResult<PlaceWithHirId<'tcx>> { fn cat_upvar(&self, hir_id: hir::HirId, var_id: hir::HirId) -> McResult<PlaceWithHirId<'tcx>> {
let closure_expr_def_id = self.body_owner; let closure_expr_def_id = self.body_owner;
@ -439,24 +436,20 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
}; };
let var_ty = self.node_ty(var_id)?; let var_ty = self.node_ty(var_id)?;
let ret = PlaceWithHirId::new(hir_id, var_ty, PlaceBase::Upvar(upvar_id), Vec::new()); Ok(PlaceWithHirId::new(hir_id, var_ty, PlaceBase::Upvar(upvar_id), Vec::new()))
debug!("cat_upvar ret={:?}", ret);
Ok(ret)
} }
#[instrument(level = "debug", skip(self), ret)]
pub(crate) fn cat_rvalue( pub(crate) fn cat_rvalue(
&self, &self,
hir_id: hir::HirId, hir_id: hir::HirId,
span: Span, span: Span,
expr_ty: Ty<'tcx>, expr_ty: Ty<'tcx>,
) -> PlaceWithHirId<'tcx> { ) -> PlaceWithHirId<'tcx> {
debug!("cat_rvalue hir_id={:?}, expr_ty={:?}, span={:?}", hir_id, expr_ty, span); PlaceWithHirId::new(hir_id, expr_ty, PlaceBase::Rvalue, Vec::new())
let ret = PlaceWithHirId::new(hir_id, expr_ty, PlaceBase::Rvalue, Vec::new());
debug!("cat_rvalue ret={:?}", ret);
ret
} }
#[instrument(level = "debug", skip(self, node), ret)]
pub(crate) fn cat_projection<N: HirNode>( pub(crate) fn cat_projection<N: HirNode>(
&self, &self,
node: &N, node: &N,
@ -466,14 +459,12 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
) -> PlaceWithHirId<'tcx> { ) -> PlaceWithHirId<'tcx> {
let mut projections = base_place.place.projections; let mut projections = base_place.place.projections;
projections.push(Projection { kind, ty }); projections.push(Projection { kind, ty });
let ret = PlaceWithHirId::new( PlaceWithHirId::new(
node.hir_id(), node.hir_id(),
base_place.place.base_ty, base_place.place.base_ty,
base_place.place.base, base_place.place.base,
projections, projections,
); )
debug!("cat_field ret {:?}", ret);
ret
} }
#[instrument(level = "debug", skip(self))] #[instrument(level = "debug", skip(self))]
@ -497,7 +488,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
self.cat_deref(expr, base) self.cat_deref(expr, base)
} }
#[instrument(level = "debug", skip(self, node))] #[instrument(level = "debug", skip(self, node), ret)]
fn cat_deref( fn cat_deref(
&self, &self,
node: &impl HirNode, node: &impl HirNode,
@ -514,14 +505,12 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
let mut projections = base_place.place.projections; let mut projections = base_place.place.projections;
projections.push(Projection { kind: ProjectionKind::Deref, ty: deref_ty }); projections.push(Projection { kind: ProjectionKind::Deref, ty: deref_ty });
let ret = PlaceWithHirId::new( Ok(PlaceWithHirId::new(
node.hir_id(), node.hir_id(),
base_place.place.base_ty, base_place.place.base_ty,
base_place.place.base, base_place.place.base,
projections, projections,
); ))
debug!("cat_deref ret {:?}", ret);
Ok(ret)
} }
pub(crate) fn cat_pattern<F>( pub(crate) fn cat_pattern<F>(
@ -603,6 +592,13 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
} }
} }
/// Here, `place` is the `PlaceWithHirId` being matched and pat is the pattern it
/// is being matched against.
///
/// In general, the way that this works is that we walk down the pattern,
/// constructing a `PlaceWithHirId` that represents the path that will be taken
/// to reach the value being matched.
#[instrument(skip(self, op), ret, level = "debug")]
fn cat_pattern_<F>( fn cat_pattern_<F>(
&self, &self,
mut place_with_id: PlaceWithHirId<'tcx>, mut place_with_id: PlaceWithHirId<'tcx>,
@ -612,15 +608,6 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
where where
F: FnMut(&PlaceWithHirId<'tcx>, &hir::Pat<'_>), F: FnMut(&PlaceWithHirId<'tcx>, &hir::Pat<'_>),
{ {
// Here, `place` is the `PlaceWithHirId` being matched and pat is the pattern it
// is being matched against.
//
// In general, the way that this works is that we walk down the pattern,
// constructing a `PlaceWithHirId` that represents the path that will be taken
// to reach the value being matched.
debug!("cat_pattern(pat={:?}, place_with_id={:?})", pat, place_with_id);
// If (pattern) adjustments are active for this pattern, adjust the `PlaceWithHirId` correspondingly. // If (pattern) adjustments are active for this pattern, adjust the `PlaceWithHirId` correspondingly.
// `PlaceWithHirId`s are constructed differently from patterns. For example, in // `PlaceWithHirId`s are constructed differently from patterns. For example, in
// //
@ -654,11 +641,11 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
// `deref { deref { place_foo }}` instead of `place_foo` since the pattern is now `Some(x,)` // `deref { deref { place_foo }}` instead of `place_foo` since the pattern is now `Some(x,)`
// and not `&&Some(x,)`, even though its assigned type is that of `&&Some(x,)`. // and not `&&Some(x,)`, even though its assigned type is that of `&&Some(x,)`.
for _ in 0..self.typeck_results.pat_adjustments().get(pat.hir_id).map_or(0, |v| v.len()) { for _ in 0..self.typeck_results.pat_adjustments().get(pat.hir_id).map_or(0, |v| v.len()) {
debug!("cat_pattern: applying adjustment to place_with_id={:?}", place_with_id); debug!("applying adjustment to place_with_id={:?}", place_with_id);
place_with_id = self.cat_deref(pat, place_with_id)?; place_with_id = self.cat_deref(pat, place_with_id)?;
} }
let place_with_id = place_with_id; // lose mutability let place_with_id = place_with_id; // lose mutability
debug!("cat_pattern: applied adjustment derefs to get place_with_id={:?}", place_with_id); debug!("applied adjustment derefs to get place_with_id={:?}", place_with_id);
// Invoke the callback, but only now, after the `place_with_id` has adjusted. // Invoke the callback, but only now, after the `place_with_id` has adjusted.
// //

10
compiler/rustc_hir_typeck/src/upvar.rs
View file

@ -294,10 +294,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Equate the type variables for the upvars with the actual types. // Equate the type variables for the upvars with the actual types.
let final_upvar_tys = self.final_upvar_tys(closure_def_id); let final_upvar_tys = self.final_upvar_tys(closure_def_id);
debug!( debug!(?closure_hir_id, ?args, ?final_upvar_tys);
"analyze_closure: id={:?} args={:?} final_upvar_tys={:?}",
closure_hir_id, args, final_upvar_tys
);
// Build a tuple (U0..Un) of the final upvar types U0..Un // Build a tuple (U0..Un) of the final upvar types U0..Un
// and unify the upvar tuple type in the closure with it: // and unify the upvar tuple type in the closure with it:
@ -338,10 +335,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let upvar_ty = captured_place.place.ty(); let upvar_ty = captured_place.place.ty();
let capture = captured_place.info.capture_kind; let capture = captured_place.info.capture_kind;
debug!( debug!(?captured_place.place, ?upvar_ty, ?capture, ?captured_place.mutability);
"final_upvar_tys: place={:?} upvar_ty={:?} capture={:?}, mutability={:?}",
captured_place.place, upvar_ty, capture, captured_place.mutability,
);
apply_capture_kind_on_capture_ty(self.tcx, upvar_ty, capture, captured_place.region) apply_capture_kind_on_capture_ty(self.tcx, upvar_ty, capture, captured_place.region)
}) })