From a49138e46e09a019ecf26077a488cf579bd1a135 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?O=C4=9Fuz=20A=C4=9Fcayaz=C4=B1?= Date: Thu, 5 Oct 2023 11:13:05 +0300 Subject: [PATCH] impl stable for kinds --- compiler/rustc_smir/src/rustc_smir/mod.rs | 228 +++++++++++----------- 1 file changed, 114 insertions(+), 114 deletions(-) diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs index 8467eaba44de6..7d1122c2fd21d 100644 --- a/compiler/rustc_smir/src/rustc_smir/mod.rs +++ b/compiler/rustc_smir/src/rustc_smir/mod.rs @@ -230,72 +230,64 @@ pub(crate) trait Stable<'tcx> { impl<'tcx> Stable<'tcx> for mir::Statement<'tcx> { type T = stable_mir::mir::Statement; fn stable(&self, tables: &mut Tables<'tcx>) -> Self::T { - use rustc_middle::mir::StatementKind::*; - let span = self.source_info.span.stable(tables); - match &self.kind { - 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( + Statement { kind: self.kind.stable(tables), span: self.source_info.span.stable(tables) } + } +} + +impl<'tcx> Stable<'tcx> for mir::StatementKind<'tcx> { + type T = stable_mir::mir::StatementKind; + fn stable(&self, tables: &mut Tables<'tcx>) -> Self::T { + match self { + mir::StatementKind::Assign(assign) => stable_mir::mir::StatementKind::Assign( + assign.0.stable(tables), + assign.1.stable(tables), + ), + mir::StatementKind::FakeRead(fake_read_place) => { + 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), - }, - 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 { + ) + } + mir::StatementKind::SetDiscriminant { place, variant_index } => { + stable_mir::mir::StatementKind::SetDiscriminant { + place: place.as_ref().stable(tables), + variant_index: variant_index.stable(tables), + } + } + mir::StatementKind::Deinit(place) => { + stable_mir::mir::StatementKind::Deinit(place.stable(tables)) + } + + mir::StatementKind::StorageLive(place) => { + stable_mir::mir::StatementKind::StorageLive(place.stable(tables)) + } + + mir::StatementKind::StorageDead(place) => { + stable_mir::mir::StatementKind::StorageDead(place.stable(tables)) + } + mir::StatementKind::Retag(retag, place) => { + stable_mir::mir::StatementKind::Retag(retag.stable(tables), place.stable(tables)) + } + mir::StatementKind::PlaceMention(place) => { + stable_mir::mir::StatementKind::PlaceMention(place.stable(tables)) + } + mir::StatementKind::AscribeUserType(place_projection, variance) => { + 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 } + } } - Intrinsic(intrinstic) => Statement { - kind: stable_mir::mir::StatementKind::Intrinsic(intrinstic.stable(tables)), - span, - }, - ConstEvalCounter => { - Statement { kind: stable_mir::mir::StatementKind::ConstEvalCounter, span } + mir::StatementKind::Coverage(coverage) => { + stable_mir::mir::StatementKind::Coverage(opaque(coverage)) + } + mir::StatementKind::Intrinsic(intrinstic) => { + stable_mir::mir::StatementKind::Intrinsic(intrinstic.stable(tables)) + } + mir::StatementKind::ConstEvalCounter => { + stable_mir::mir::StatementKind::ConstEvalCounter } - Nop => Statement { kind: stable_mir::mir::StatementKind::Nop, span }, + mir::StatementKind::Nop => stable_mir::mir::StatementKind::Nop, } } } @@ -844,76 +836,84 @@ impl<'tcx> Stable<'tcx> for mir::InlineAsmOperand<'tcx> { impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> { type T = stable_mir::mir::Terminator; fn stable(&self, tables: &mut Tables<'tcx>) -> Self::T { - use rustc_middle::mir::TerminatorKind::*; use stable_mir::mir::Terminator; + Terminator { kind: self.kind.stable(tables), span: self.source_info.span.stable(tables) } + } +} + +impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> { + type T = stable_mir::mir::TerminatorKind; + fn stable(&self, tables: &mut Tables<'tcx>) -> Self::T { 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 } - } - SwitchInt { discr, targets } => Terminator { - kind: TerminatorKind::SwitchInt { - discr: discr.stable(tables), - targets: targets - .iter() - .map(|(value, target)| stable_mir::mir::SwitchTarget { - value, - target: target.as_usize(), - }) - .collect(), - otherwise: targets.otherwise().as_usize(), - }, - span, + match self { + mir::TerminatorKind::Goto { target } => { + TerminatorKind::Goto { target: target.as_usize() } + } + mir::TerminatorKind::SwitchInt { discr, targets } => TerminatorKind::SwitchInt { + discr: discr.stable(tables), + targets: targets + .iter() + .map(|(value, target)| stable_mir::mir::SwitchTarget { + value, + target: target.as_usize(), + }) + .collect(), + otherwise: targets.otherwise().as_usize(), }, - 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 { + mir::TerminatorKind::UnwindResume => TerminatorKind::Resume, + mir::TerminatorKind::UnwindTerminate(_) => TerminatorKind::Abort, + mir::TerminatorKind::Return => TerminatorKind::Return, + mir::TerminatorKind::Unreachable => TerminatorKind::Unreachable, + mir::TerminatorKind::Drop { place, target, unwind, replace: _ } => { + TerminatorKind::Drop { place: place.stable(tables), target: target.as_usize(), unwind: unwind.stable(tables), - }, - span, - }, - Call { func, args, destination, target, unwind, call_source: _, fn_span: _ } => { - Terminator { - kind: TerminatorKind::Call { - func: func.stable(tables), - args: args.iter().map(|arg| arg.stable(tables)).collect(), - destination: destination.stable(tables), - target: target.map(|t| t.as_usize()), - unwind: unwind.stable(tables), - }, - span, } } - Assert { cond, expected, msg, target, unwind } => Terminator { - kind: TerminatorKind::Assert { + mir::TerminatorKind::Call { + func, + args, + destination, + target, + unwind, + call_source: _, + fn_span: _, + } => TerminatorKind::Call { + func: func.stable(tables), + args: args.iter().map(|arg| arg.stable(tables)).collect(), + destination: destination.stable(tables), + target: target.map(|t| t.as_usize()), + unwind: unwind.stable(tables), + }, + mir::TerminatorKind::Assert { cond, expected, msg, target, unwind } => { + TerminatorKind::Assert { cond: cond.stable(tables), expected: *expected, msg: msg.stable(tables), target: target.as_usize(), unwind: unwind.stable(tables), - }, - span, - }, - InlineAsm { template, operands, options, line_spans, destination, unwind } => { - Terminator { - kind: TerminatorKind::InlineAsm { - template: format!("{template:?}"), - operands: operands.iter().map(|operand| operand.stable(tables)).collect(), - options: format!("{options:?}"), - line_spans: format!("{line_spans:?}"), - destination: destination.map(|d| d.as_usize()), - unwind: unwind.stable(tables), - }, - span, } } - Yield { .. } | GeneratorDrop | FalseEdge { .. } | FalseUnwind { .. } => unreachable!(), + mir::TerminatorKind::InlineAsm { + template, + operands, + options, + line_spans, + destination, + unwind, + } => TerminatorKind::InlineAsm { + template: format!("{template:?}"), + operands: operands.iter().map(|operand| operand.stable(tables)).collect(), + options: format!("{options:?}"), + line_spans: format!("{line_spans:?}"), + destination: destination.map(|d| d.as_usize()), + unwind: unwind.stable(tables), + }, + mir::TerminatorKind::Yield { .. } + | mir::TerminatorKind::GeneratorDrop + | mir::TerminatorKind::FalseEdge { .. } + | mir::TerminatorKind::FalseUnwind { .. } => unreachable!(), } } }