add span to statements

Author: ouz-a

compiler/rustc_smir/src/rustc_smir/mod.rs

@@ -15,7 +15,7 @@ use rustc_middle::mir::interpret::{alloc_range, AllocId};
 use rustc_middle::ty::{self,Ty,TyCtxt,Variance};
 use rustc_span::def_id::{CrateNum,DefId,LOCAL_CRATE};
 use rustc_target::abi::FieldIdx;
-use stable_mir::mir::{CopyNonOverlapping,UserTypeProjection,VariantIdx};
+use stable_mir::mir::{CopyNonOverlapping,Statement,UserTypeProjection,VariantIdx};
 use stable_mir::ty::{FloatTy,GenericParamDef,IntTy,Movability,RigidTy,Span,TyKind,UintTy};
 use stable_mir::{self, opaque,Context};
 use tracing::debug;
@@ -231,40 +231,71 @@ impl<'tcx> Stable<'tcx> for mir::Statement<'tcx> {
 typeT = stable_mir::mir::Statement;
 fnstable(&self,tables:&mutTables<'tcx>) -> Self::T{
 use rustc_middle::mir::StatementKind::*;
+let span = self.source_info.span.stable(tables);
 match&self.kind{
-Assign(assign) => {
- stable_mir::mir::Statement::Assign(assign.0.stable(tables), assign.1.stable(tables))
-}
-FakeRead(fake_read_place) => stable_mir::mir::Statement::FakeRead(
- fake_read_place.0.stable(tables),
- fake_read_place.1.stable(tables),
-),
-SetDiscriminant{place: plc,variant_index: idx } => {
- stable_mir::mir::Statement::SetDiscriminant{
+Assign(assign) => Statement{
+kind: stable_mir::mir::StatementKind::Assign(
+ assign.0.stable(tables),
+ assign.1.stable(tables),
+),
+ span,
+},
+FakeRead(fake_read_place) => Statement{
+kind: stable_mir::mir::StatementKind::FakeRead(
+ fake_read_place.0.stable(tables),
+ fake_read_place.1.stable(tables),
+),
+ span,
+},
+SetDiscriminant{place: plc,variant_index: idx } => Statement{
+kind: stable_mir::mir::StatementKind::SetDiscriminant{
 place: plc.as_ref().stable(tables),
 variant_index: idx.stable(tables),
-}
-}
-Deinit(place) => stable_mir::mir::Statement::Deinit(place.stable(tables)),
-StorageLive(place) => stable_mir::mir::Statement::StorageLive(place.stable(tables)),
-StorageDead(place) => stable_mir::mir::Statement::StorageDead(place.stable(tables)),
-Retag(retag, place) => {
- stable_mir::mir::Statement::Retag(retag.stable(tables), place.stable(tables))
-}
-PlaceMention(place) => stable_mir::mir::Statement::PlaceMention(place.stable(tables)),
-AscribeUserType(place_projection, variance) => {
- stable_mir::mir::Statement::AscribeUserType{
+},
+ span,
+},
+Deinit(place) => Statement{
+kind: stable_mir::mir::StatementKind::Deinit(place.stable(tables)),
+ span,
+},
+StorageLive(place) => Statement{
+kind: stable_mir::mir::StatementKind::StorageLive(place.stable(tables)),
+ span,
+},
+StorageDead(place) => Statement{
+kind: stable_mir::mir::StatementKind::StorageDead(place.stable(tables)),
+ span,
+},
+Retag(retag, place) => Statement{
+kind: stable_mir::mir::StatementKind::Retag(
+ retag.stable(tables),
+ place.stable(tables),
+),
+ span,
+},
+PlaceMention(place) => Statement{
+kind: stable_mir::mir::StatementKind::PlaceMention(place.stable(tables)),
+ span,
+},
+AscribeUserType(place_projection, variance) => Statement{
+kind: stable_mir::mir::StatementKind::AscribeUserType{
 place: place_projection.as_ref().0.stable(tables),
 projections: place_projection.as_ref().1.stable(tables),
 variance: variance.stable(tables),
-}
+},
+ span,
+},
+Coverage(coverage) => {
+Statement{kind: stable_mir::mir::StatementKind::Coverage(opaque(coverage)), span }
 }
-Coverage(coverage) => stable_mir::mir::Statement::Coverage(opaque(coverage)),
-Intrinsic(intrinstic) => {
- stable_mir::mir::Statement::Intrinsic(intrinstic.stable(tables))
+Intrinsic(intrinstic) => Statement{
+kind: stable_mir::mir::StatementKind::Intrinsic(intrinstic.stable(tables)),
+ span,
+},
+ConstEvalCounter => {
+Statement{kind: stable_mir::mir::StatementKind::ConstEvalCounter, span }
 }
-ConstEvalCounter => stable_mir::mir::Statement::ConstEvalCounter,
-Nop => stable_mir::mir::Statement::Nop,
+Nop => Statement{kind: stable_mir::mir::StatementKind::Nop, span },
 }
 }
 }
@@ -816,11 +847,11 @@ impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> {
 use rustc_middle::mir::TerminatorKind::*;
 use stable_mir::mir::Terminator;
 use stable_mir::mir::TerminatorKind;
+let span = self.source_info.span.stable(tables);
 match&self.kind{
-Goto{ target } => Terminator{
-kind:TerminatorKind::Goto{target: target.as_usize()},
-span:self.source_info.span.stable(tables),
-},
+Goto{ target } => {
+Terminator{kind:TerminatorKind::Goto{target: target.as_usize()}, span }
+}
 SwitchInt{ discr, targets } => Terminator{
 kind:TerminatorKind::SwitchInt{
 discr: discr.stable(tables),
@@ -833,31 +864,19 @@ impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> {
 .collect(),
 otherwise: targets.otherwise().as_usize(),
 },
-span:self.source_info.span.stable(tables),
-},
-UnwindResume => Terminator{
-kind:TerminatorKind::Resume,
-span:self.source_info.span.stable(tables),
-},
-UnwindTerminate(_) => Terminator{
-kind:TerminatorKind::Abort,
-span:self.source_info.span.stable(tables),
-},
-Return => Terminator{
-kind:TerminatorKind::Return,
-span:self.source_info.span.stable(tables),
-},
-Unreachable => Terminator{
-kind:TerminatorKind::Unreachable,
-span:self.source_info.span.stable(tables),
+ span,
 },
+UnwindResume => Terminator{kind:TerminatorKind::Resume, span },
+UnwindTerminate(_) => Terminator{kind:TerminatorKind::Abort, span },
+Return => Terminator{kind:TerminatorKind::Return, span },
+Unreachable => Terminator{kind:TerminatorKind::Unreachable, span },
 Drop{ place, target, unwind,replace: _ } => Terminator{
 kind:TerminatorKind::Drop{
 place: place.stable(tables),
 target: target.as_usize(),
 unwind: unwind.stable(tables),
 },
-span:self.source_info.span.stable(tables),
+ span,
 },
 Call{ func, args, destination, target, unwind,call_source: _,fn_span: _ } => {
 Terminator{
@@ -868,7 +887,7 @@ impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> {
 target: target.map(|t| t.as_usize()),
 unwind: unwind.stable(tables),
 },
-span:self.source_info.span.stable(tables),
+ span,
 }
 }
 Assert{ cond, expected, msg, target, unwind } => Terminator{
@@ -879,7 +898,7 @@ impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> {
 target: target.as_usize(),
 unwind: unwind.stable(tables),
 },
-span:self.source_info.span.stable(tables),
+ span,
 },
 InlineAsm{ template, operands, options, line_spans, destination, unwind } => {
 Terminator{
@@ -891,7 +910,7 @@ impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> {
 destination: destination.map(|d| d.as_usize()),
 unwind: unwind.stable(tables),
 },
-span:self.source_info.span.stable(tables),
+ span,
 }
 }
 Yield{ .. } | GeneratorDrop | FalseEdge{ .. } | FalseUnwind{ .. } => unreachable!(),

compiler/stable_mir/src/mir/body.rs

@@ -191,7 +191,13 @@ pub enum NonDivergingIntrinsic {
 }
 
 #[derive(Clone,Debug)]
-pubenumStatement{
+pubstructStatement{
+pubkind:StatementKind,
+pubspan:Span,
+}
+
+#[derive(Clone,Debug)]
+pubenumStatementKind{
 Assign(Place,Rvalue),
 FakeRead(FakeReadCause,Place),
 SetDiscriminant{place:Place,variant_index:VariantIdx},

tests/ui-fulldeps/stable-mir/crate-info.rs

@@ -47,12 +47,12 @@ fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
 assert_eq!(body.blocks.len(),1);
 let block = &body.blocks[0];
 assert_eq!(block.statements.len(),1);
-match&block.statements[0]{
- stable_mir::mir::Statement::Assign(..) => {}
+match&block.statements[0].kind{
+ stable_mir::mir::StatementKind::Assign(..) => {}
  other => panic!("{other:?}"),
 }
-match&block.terminator{
- stable_mir::mir::Terminator::Return => {}
+match&block.terminator.kind{
+ stable_mir::mir::TerminatorKind::Return => {}
  other => panic!("{other:?}"),
 }
 
@@ -61,36 +61,36 @@ fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
 assert_eq!(body.locals.len(),7);
 assert_eq!(body.blocks.len(),4);
 let block = &body.blocks[0];
-match&block.terminator{
- stable_mir::mir::Terminator::Call{ .. } => {}
+match&block.terminator.kind{
+ stable_mir::mir::TerminatorKind::Call{ .. } => {}
  other => panic!("{other:?}"),
 }
 
 let types = get_item(&items,(DefKind::Fn,"types")).unwrap();
 let body = types.body();
 assert_eq!(body.locals.len(),6);
 assert_matches!(
- body.locals[0].kind(),
+ body.locals[0].ty.kind(),
  stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Bool)
 );
 assert_matches!(
- body.locals[1].kind(),
+ body.locals[1].ty.kind(),
  stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Bool)
 );
 assert_matches!(
- body.locals[2].kind(),
+ body.locals[2].ty.kind(),
  stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Char)
 );
 assert_matches!(
- body.locals[3].kind(),
+ body.locals[3].ty.kind(),
  stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Int(stable_mir::ty::IntTy::I32))
 );
 assert_matches!(
- body.locals[4].kind(),
+ body.locals[4].ty.kind(),
  stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Uint(stable_mir::ty::UintTy::U64))
 );
 assert_matches!(
- body.locals[5].kind(),
+ body.locals[5].ty.kind(),
  stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Float(
  stable_mir::ty::FloatTy::F64
 ))
@@ -100,24 +100,24 @@ fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
 let body = drop.body();
 assert_eq!(body.blocks.len(),2);
 let block = &body.blocks[0];
-match&block.terminator{
- stable_mir::mir::Terminator::Drop{ .. } => {}
+match&block.terminator.kind{
+ stable_mir::mir::TerminatorKind::Drop{ .. } => {}
  other => panic!("{other:?}"),
 }
 
 let assert = get_item(&items,(DefKind::Fn,"assert")).unwrap();
 let body = assert.body();
 assert_eq!(body.blocks.len(),2);
 let block = &body.blocks[0];
-match&block.terminator{
- stable_mir::mir::Terminator::Assert{ .. } => {}
+match&block.terminator.kind{
+ stable_mir::mir::TerminatorKind::Assert{ .. } => {}
  other => panic!("{other:?}"),
 }
 
 let monomorphic = get_item(&items,(DefKind::Fn,"monomorphic")).unwrap();
 for block in monomorphic.body().blocks{
-match&block.terminator{
- stable_mir::mir::Terminator::Call{ func, .. } => match func {
+match&block.terminator.kind{
+ stable_mir::mir::TerminatorKind::Call{ func, .. } => match func {
  stable_mir::mir::Operand::Constant(c) => match&c.literal.literal{
  stable_mir::ty::ConstantKind::Allocated(alloc) => {
 assert!(alloc.bytes.is_empty());
@@ -127,7 +127,7 @@ fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
 mut args,
 )) => {
 let func = def.body();
-match func.locals[1]
+match func.locals[1].ty
 .fold(&mut args)
 .continue_value()
 .unwrap()
@@ -149,7 +149,7 @@ fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
 },
  other => panic!("{other:?}"),
 },
- stable_mir::mir::Terminator::Return => {}
+ stable_mir::mir::TerminatorKind::Return => {}
  other => panic!("{other:?}"),
 }
 }