coverage. Let MCDC ConditionId start from 0 to keep with llvm 19

compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs

@@ -111,7 +111,7 @@ pub enum RegionKind {
 }
 
 pub mod mcdc {
-    use rustc_middle::mir::coverage::{ConditionInfo, DecisionInfo};
+    use rustc_middle::mir::coverage::{ConditionId, ConditionInfo, DecisionInfo};
 
     /// Must match the layout of `LLVMRustMCDCDecisionParameters`.
     #[repr(C)]
@@ -166,12 +166,13 @@ pub mod mcdc {
 
     impl From<ConditionInfo> for BranchParameters {
         fn from(value: ConditionInfo) -> Self {
+            let to_llvm_cond_id = |cond_id: Option<ConditionId>| {
+                cond_id.and_then(|id| LLVMConditionId::try_from(id.as_usize()).ok()).unwrap_or(-1)
+            };
+            let ConditionInfo { condition_id, true_next_id, false_next_id } = value;
             Self {
-                condition_id: value.condition_id.as_u32() as LLVMConditionId,
-                condition_ids: [
-                    value.false_next_id.as_u32() as LLVMConditionId,
-                    value.true_next_id.as_u32() as LLVMConditionId,
-                ],
+                condition_id: to_llvm_cond_id(Some(condition_id)),
+                condition_ids: [to_llvm_cond_id(false_next_id), to_llvm_cond_id(true_next_id)],
             }
         }
     }

compiler/rustc_middle/src/mir/coverage.rs

@@ -75,7 +75,7 @@ rustc_index::newtype_index! {
 }
 
 impl ConditionId {
-    pub const NONE: Self = Self::from_u32(0);
+    pub const START: Self = Self::from_usize(0);
 }
 
 /// Enum that can hold a constant zero value, the ID of an physical coverage
@@ -307,18 +307,8 @@ pub struct BranchSpan {
 #[derive(TyEncodable, TyDecodable, Hash, HashStable, TypeFoldable, TypeVisitable)]
 pub struct ConditionInfo {
     pub condition_id: ConditionId,
-    pub true_next_id: ConditionId,
-    pub false_next_id: ConditionId,
-}
-
-impl Default for ConditionInfo {
-    fn default() -> Self {
-        Self {
-            condition_id: ConditionId::NONE,
-            true_next_id: ConditionId::NONE,
-            false_next_id: ConditionId::NONE,
-        }
-    }
+    pub true_next_id: Option<ConditionId>,
+    pub false_next_id: Option<ConditionId>,
 }
 
 #[derive(Clone, Debug)]

compiler/rustc_mir_build/src/build/coverageinfo/mcdc.rs

@@ -49,8 +49,9 @@ impl BooleanDecisionCtx {
     }
 
     fn next_condition_id(&mut self) -> ConditionId {
+        let id = ConditionId::from_usize(self.condition_id_counter);
         self.condition_id_counter += 1;
-        ConditionId::from_usize(self.condition_id_counter)
+        id
     }
 
     // At first we assign ConditionIds for each sub expression.
@@ -94,20 +95,23 @@ impl BooleanDecisionCtx {
     // - If the op is AND, the "false_next" of LHS and RHS should be the parent's "false_next". While "true_next" of the LHS is the RHS, the "true next" of RHS is the parent's "true_next".
     // - If the op is OR, the "true_next" of LHS and RHS should be the parent's "true_next". While "false_next" of the LHS is the RHS, the "false next" of RHS is the parent's "false_next".
     fn record_conditions(&mut self, op: LogicalOp) {
-        let parent_condition = self.decision_stack.pop_back().unwrap_or_default();
-        let lhs_id = if parent_condition.condition_id == ConditionId::NONE {
-            ConditionId::from(self.next_condition_id())
-        } else {
-            parent_condition.condition_id
+        let parent_condition = match self.decision_stack.pop_back() {
+            Some(info) => info,
+            None => ConditionInfo {
+                condition_id: self.next_condition_id(),
+                true_next_id: None,
+                false_next_id: None,
+            },
         };
+        let lhs_id = parent_condition.condition_id;
 
         let rhs_condition_id = self.next_condition_id();
 
         let (lhs, rhs) = match op {
             LogicalOp::And => {
                 let lhs = ConditionInfo {
                     condition_id: lhs_id,
-                    true_next_id: rhs_condition_id,
+                    true_next_id: Some(rhs_condition_id),
                     false_next_id: parent_condition.false_next_id,
                 };
                 let rhs = ConditionInfo {
@@ -121,7 +125,7 @@ impl BooleanDecisionCtx {
                 let lhs = ConditionInfo {
                     condition_id: lhs_id,
                     true_next_id: parent_condition.true_next_id,
-                    false_next_id: rhs_condition_id,
+                    false_next_id: Some(rhs_condition_id),
                 };
                 let rhs = ConditionInfo {
                     condition_id: rhs_condition_id,
@@ -142,11 +146,15 @@ impl BooleanDecisionCtx {
         true_marker: BlockMarkerId,
         false_marker: BlockMarkerId,
     ) {
-        let condition_info = self.decision_stack.pop_back().unwrap_or_default();
-        if condition_info.true_next_id == ConditionId::NONE {
+        let condition_info = self.decision_stack.pop_back().unwrap_or(ConditionInfo {
+            condition_id: ConditionId::START,
+            true_next_id: None,
+            false_next_id: None,
+        });
+        if condition_info.true_next_id.is_none() {
             self.decision_info.end_markers.push(true_marker);
         }
-        if condition_info.false_next_id == ConditionId::NONE {
+        if condition_info.false_next_id.is_none() {
             self.decision_info.end_markers.push(false_marker);
         }
 
@@ -297,10 +305,7 @@ impl MCDCInfoBuilder {
         ctx
     }
 
-    fn append_normal_branches(&mut self, mut branches: Vec<MCDCBranchSpan>) {
-        branches
-            .iter_mut()
-            .for_each(|branch| branch.condition_info.condition_id = ConditionId::NONE);
+    fn append_normal_branches(&mut self, branches: Vec<MCDCBranchSpan>) {
         self.normal_branch_spans.extend(branches);
     }