fix(analyzer): fold constant switch arm conditions like an if chain

Author: dalance

crates/analyzer/src/conv/statement.rs

@@ -1058,6 +1058,18 @@ impl Conv<&SwitchStatement> for ir::StatementBlock {
                 SwitchItemGroup::Defaul(_) => None,
             };
 
+            // A dead arm's out-of-range select must not reach the range check or the
+            // simulator, and an always-taken arm must not leave the chain with an
+            // empty false side that reads as an uncovered branch.
+            let (true_side_only, false_side_only) = match &cond {
+                Some(cond) => eval_cond_true_false(context, cond),
+                None => (false, false),
+            };
+
+            if false_side_only {
+                continue;
+            }
+
             let convert = |c: &mut Context| -> IrResult<ir::StatementBlock> {
                 match item.switch_item.switch_item_group0.as_ref() {
                     // A bare statement arm has no StatementBlockItem wrapper, so
@@ -1078,6 +1090,12 @@ impl Conv<&SwitchStatement> for ir::StatementBlock {
 
             match cond {
                 Some(cond) => {
+                    // Nothing after this arm can run, including `default` - which is
+                    // the fallback no matter where it was listed.
+                    if true_side_only {
+                        default = true_side.0;
+                        break;
+                    }
                     arms.push((cond, true_side.0, item.switch_item.as_ref().into()));
                 }
                 None => {

crates/analyzer/src/ir/tests.rs

@@ -3280,3 +3280,59 @@ fn const_fold_else_if() {
 
     check_ir(code, exp);
 }
+
+#[test]
+fn const_fold_switch_arm() {
+    let code = r#"
+    module ModuleA (
+        a: input  logic   ,
+        o: output logic<4>,
+    ) {
+        always_comb {
+            for i in 0..4 {
+                switch {
+                    i >: 3  : o[i] = 0;
+                    a       : o[i] = 1;
+                    i <: 4  : o[i] = 0;
+                    default : o[i] = 1;
+                }
+            }
+        }
+    }
+    "#;
+
+    let exp = r#"module ModuleA {
+  input var0(a): logic = 1'hx;
+  output var1(o): logic<4> = 4'hx;
+  const var2([0].i): signed bit<32> = 32'sh00000000;
+  const var3([1].i): signed bit<32> = 32'sh00000001;
+  const var4([2].i): signed bit<32> = 32'sh00000002;
+  const var5([3].i): signed bit<32> = 32'sh00000003;
+
+  comb {
+    if var0 {
+      var1[32'sh00000000] = 32'sh00000001;
+    } else {
+      var1[32'sh00000000] = 32'sh00000000;
+    }
+    if var0 {
+      var1[32'sh00000001] = 32'sh00000001;
+    } else {
+      var1[32'sh00000001] = 32'sh00000000;
+    }
+    if var0 {
+      var1[32'sh00000002] = 32'sh00000001;
+    } else {
+      var1[32'sh00000002] = 32'sh00000000;
+    }
+    if var0 {
+      var1[32'sh00000003] = 32'sh00000001;
+    } else {
+      var1[32'sh00000003] = 32'sh00000000;
+    }
+  }
+}
+"#;
+
+    check_ir(code, exp);
+}

crates/analyzer/src/tests.rs

@@ -8951,6 +8951,25 @@ fn unassign_variable() {
 
     let errors = analyze(code);
     assert!(errors.is_empty());
+
+    // With every arm folded away and no `default`, nothing drives `o` - reported
+    // as unassigned, not as an uncovered branch on always-false `if`s.
+    let code = r#"
+    module ModuleA (
+        o: output logic<4>,
+    ) {
+        always_comb {
+            for i in 0..4 {
+                switch {
+                    i >: 10: o[i] = 1;
+                }
+            }
+        }
+    }
+    "#;
+
+    let errors = analyze(code);
+    assert!(matches!(errors[0], AnalyzerError::UnassignVariable { .. }));
 }
 
 #[test]
@@ -9981,6 +10000,72 @@ fn uncovered_branch() {
 
     let errors = analyze(code);
     assert!(errors.is_empty());
+
+    // A compile-time-true `switch` arm makes the missing `default` unreachable.
+    let code = r#"
+    module ModuleA (
+        i_a: input  logic   ,
+        o  : output logic<4>,
+    ) {
+        always_comb {
+            for i in 0..4 {
+                switch {
+                    i_a    : o[i] = 1;
+                    i <: 4 : o[i] = 0;
+                }
+            }
+        }
+    }
+    "#;
+
+    let errors = analyze(code);
+    assert!(errors.is_empty());
+}
+
+#[test]
+fn switch_const_false_arm_body_unchecked() {
+    // A dead arm's body is never converted, so conversion-time checks stop seeing
+    // it. That is the point here: unrolling the `for` puts this select out of range.
+    let code = r#"
+    module ModuleA (
+        o: output logic<4>,
+    ) {
+        always_comb {
+            for i in 0..4 {
+                switch {
+                    i >: 3 : o[i + 1] = 1;
+                    default: o[i] = 0;
+                }
+            }
+        }
+    }
+    "#;
+
+    let errors = analyze(code);
+    assert!(errors.is_empty());
+
+    // The same skip also hides condition-independent errors like a wrong argument
+    // count. `if` behaves this way too; pinned so `switch` is revisited with it.
+    let code = r#"
+    module ModuleA (
+        o: output logic<4>,
+    ) {
+        function f (a: input logic) -> logic {
+            return a;
+        }
+        always_comb {
+            for i in 0..4 {
+                switch {
+                    i >: 10: o[i] = f(1, 2, 3);
+                    default: o[i] = 0;
+                }
+            }
+        }
+    }
+    "#;
+
+    let errors = analyze(code);
+    assert!(errors.is_empty());
 }
 
 #[test]