Fix switch on discriminant detection in a presence of coverage counters

compiler/rustc_mir_dataflow/src/impls/mod.rs

@@ -710,25 +710,28 @@ fn switch_on_enum_discriminant<'mir, 'tcx>(
     block: &'mir mir::BasicBlockData<'tcx>,
     switch_on: mir::Place<'tcx>,
 ) -> Option<(mir::Place<'tcx>, &'tcx ty::AdtDef)> {
-    match block.statements.last().map(|stmt| &stmt.kind) {
+    for statement in block.statements.iter().rev() {
-        Some(mir::StatementKind::Assign(box (lhs, mir::Rvalue::Discriminant(discriminated))))
+        match &statement.kind {
+            mir::StatementKind::Assign(box (lhs, mir::Rvalue::Discriminant(discriminated)))
                 if *lhs == switch_on =>
             {
                 match &discriminated.ty(body, tcx).ty.kind() {
-                ty::Adt(def, _) => Some((*discriminated, def)),
+                    ty::Adt(def, _) => return Some((*discriminated, def)),
 
                     // `Rvalue::Discriminant` is also used to get the active yield point for a
                     // generator, but we do not need edge-specific effects in that case. This may
                     // change in the future.
-                ty::Generator(..) => None,
+                    ty::Generator(..) => return None,
 
                     t => bug!("`discriminant` called on unexpected type {:?}", t),
                 }
             }
-
+            mir::StatementKind::Coverage(_) => continue,
-        _ => None,
+            _ => return None,
         }
     }
+    None
+}
 
 struct OnMutBorrow<F>(F);
 

src/test/ui/consts/precise-drop-with-coverage.rs

@@ -0,0 +1,16 @@
+// Checks that code coverage doesn't interfere with const_precise_live_drops.
+// Regression test for issue #93848.
+//
+// check-pass
+// compile-flags: --crate-type=lib -Cinstrument-coverage  -Zno-profiler-runtime
+
+#![feature(const_precise_live_drops)]
+
+#[inline]
+pub const fn transpose<T, E>(this: Option<Result<T, E>>) -> Result<Option<T>, E> {
+    match this {
+        Some(Ok(x)) => Ok(Some(x)),
+        Some(Err(e)) => Err(e),
+        None => Ok(None),
+    }
+}