feat: Improve type checking and error handling in DFIf and DFMatch

This commit enhances type compatibility checks and error reporting for conditional expressions:
- Add `isSimilarTo` method for more flexible type comparisons in DFIf and DFMatch
- Implement detailed error logging for match expressions with different branch types
- Improve type resolution logic to handle parametric width scenarios
- Add test cases for type width mismatches in match expressions

Author: Oron Port

compiler/stages/src/test/scala/StagesSpec/PrintCodeStringSpec.scala

@@ -866,4 +866,53 @@ class PrintCodeStringSpec extends StageSpec:
          |""".stripMargin
     )
   }
+  test("If printing with parametric width") {
+    class IfWithParams(
+        val width: Int <> CONST = 8
+    ) extends DFDesign:
+      val sel   = Bit         <> IN
+      val iBits = Bits(width) <> IN
+      val oBits = Bits(width) <> VAR
+      oBits := (if (sel) iBits else all(0))
+    val top = (new IfWithParams).getCodeString
+    assertNoDiff(
+      top,
+      """|class IfWithParams(val width: Int <> CONST = 8) extends DFDesign:
+         |  val sel = Bit <> IN
+         |  val iBits = Bits(width) <> IN
+         |  val oBits = Bits(width) <> VAR
+         |  oBits := ((
+         |    if (sel) iBits
+         |    else b"0".repeat(width)
+         |  ): Bits[width.type] <> VAL)
+         |end IfWithParams""".stripMargin
+    )
+  }
+  test("Match printing with parametric width") {
+    class MatchWithParams(
+        val width: Int <> CONST = 8
+    ) extends DFDesign:
+      val sel   = Bit         <> IN
+      val iBits = Bits(width) <> IN
+      val oBits = Bits(width) <> VAR
+      oBits := sel match
+        case 0 => all(0)
+        case 1 => iBits
+    end MatchWithParams
+    val top = (new MatchWithParams).getCodeString
+    assertNoDiff(
+      top,
+      """|class MatchWithParams(val width: Int <> CONST = 8) extends DFDesign:
+         |  val sel = Bit <> IN
+         |  val iBits = Bits(width) <> IN
+         |  val oBits = Bits(width) <> VAR
+         |  oBits := ((
+         |    sel match
+         |      case 0 => b"0".repeat(width)
+         |      case 1 => iBits
+         |    end match
+         |  ): Bits[width.type] <> VAL)
+         |end MatchWithParams""".stripMargin
+    )
+  }
 end PrintCodeStringSpec

core/src/main/scala/dfhdl/core/DFIf.scala

@@ -85,7 +85,8 @@ object DFIf:
   def fromBranches[R](
       branches: List[(DFValOf[DFBoolOrBit], () => R)],
       elseOption: Option[() => R]
-  )(using DFC): R = try
+  )(using dfc: DFC): R = try
+    import dfc.getSet
     val header = Header(DFUnit)
     val dfcAnon = summon[DFC].anonymize
     var branchTypes = List.empty[ir.DFType]
@@ -110,7 +111,7 @@ object DFIf:
     val hasNoType = branchTypes.contains(ir.DFUnit)
     // if one branch has DFUnit, the return type is DFUnit.
     // otherwise, all types must be the same.
-    if (hasNoType || branchTypes.allElementsAreEqual)
+    if (hasNoType || branchTypes.forall(_.isSimilarTo(branchTypes.head)))
       val retDFType = if (hasNoType) ir.DFUnit else branchTypes.head
       val DFVal(headerIR: DFIfHeader) = header: @unchecked
       val headerUpdate = headerIR.copy(dfType = retDFType)

core/src/main/scala/dfhdl/core/DFMatch.scala

@@ -52,7 +52,8 @@ object DFMatch:
       selector: DFValAny,
       cases: List[(Pattern, Option[DFValOf[DFBool]], () => R)],
       forceAnonymous: Boolean
-  )(using DFC): R = try
+  )(using dfc: DFC): R = try
+    import dfc.getSet
     val dfcAnon = summon[DFC].anonymize
     val header =
       Header(DFUnit, selector)(using if (forceAnonymous) dfcAnon else dfc)
@@ -61,23 +62,45 @@ object DFMatch:
     val firstCaseRun: () => R = () =>
       firstCaseRet = Some(cases.head._3())
       firstCaseRet.get
+    var dfTypes = List.empty[ir.DFType]
+    var typesAreSimilar = true
     val firstCase =
       singleCase(cases.head._1, cases.head._2, header, firstCaseRun)
+    dfTypes = firstCase._1.asIR :: dfTypes
     val (retDFType, _) =
       cases.drop(1).foldLeft(firstCase) { case ((prevDFType, prevBlock), curCase) =>
         val (dfType, block) =
           singleCase(curCase._1, curCase._2, prevBlock, curCase._3)(using dfcAnon)
+        dfTypes = dfType.asIR :: dfTypes
         val commonDFType =
-          if (dfType.asIR == prevDFType.asIR) prevDFType else DFUnit
+          if (dfType.asIR.isSimilarTo(prevDFType.asIR)) prevDFType
+          else
+            typesAreSimilar = false
+            DFUnit
         (commonDFType, block)
       }
-    retDFType match
-      case DFUnit => firstCaseRet.get
-      case _ =>
-        val DFVal(headerIR: DFMatchHeader) = header: @unchecked
-        val headerUpdate = headerIR.copy(dfType = retDFType.asIR)
-        // updating the type of the if header
-        headerIR.replaceMemberWith(headerUpdate).asValAny.asInstanceOf[R]
+    if (typesAreSimilar)
+      retDFType match
+        case DFUnit => firstCaseRet.get
+        case _ =>
+          val DFVal(headerIR: DFMatchHeader) = header: @unchecked
+          val headerUpdate = headerIR.copy(dfType = retDFType.asIR)
+          // updating the type of the match header
+          headerIR.replaceMemberWith(headerUpdate).asValAny.asInstanceOf[R]
+    else
+      given printer: Printer = DefaultPrinter(using dfc.getSet)
+      val err = DFError.Basic(
+        "match",
+        new IllegalArgumentException(
+          s"""|This DFHDL `match` expression has different return types for cases.
+              |These are its branch types in order:
+              |${dfTypes.view.reverse.map(t => printer.csDFType(t)).mkString("\n")}
+              |""".stripMargin
+        )
+      )
+      dfc.logError(err)
+      err.asVal[DFTypeAny, ModifierAny].asInstanceOf[R]
+    end if
   catch case e: DFError => DFVal(DFError.Derived(e)).asInstanceOf[R]
   end fromCases
 

core/src/test/scala/CoreSpec/DFMatchSpec.scala

@@ -159,4 +159,19 @@ class DFMatchSpec extends DFSpec:
         }
     }
   }
+
+  test("Different return widths error") {
+    assertRuntimeErrorLog(
+      """|This DFHDL `match` expression has different return types for cases.
+         |These are its branch types in order:
+         |Bits(2)
+         |Bits(3)
+         |""".stripMargin
+    ) {
+      val res: Bits[Int] <> VAL =
+        i match
+          case 0 => b"11"
+          case 1 => b"111"
+    }
+  }
 end DFMatchSpec