Merge pull request #330 from DFiantHDL/scala3p8

v0.17.0

Author: soronpo

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = 3.10.1
+version = 3.10.5
 runner.dialect = scala3
 
 maxColumn = 100

build.sbt

@@ -5,7 +5,7 @@ commands += DFHDLCommands.docExamplesRefUpdate
 
 // format: off
 val projectName = "dfhdl"
-val compilerVersion = "3.7.4"
+val compilerVersion = "3.8.1"
 
 inThisBuild(
   List(
@@ -33,6 +33,7 @@ name := projectName
 ThisBuild / organization := "io.github.dfianthdl"
 ThisBuild / scalaVersion := compilerVersion
 ThisBuild / versionScheme := Some("semver-spec")
+ThisBuild / resolvers += Resolver.scalaNightlyRepository
 //ThisBuild / version      := "0.3.0-SNAPSHOT"
 
 // PROJECTS
@@ -55,6 +56,7 @@ lazy val internals = project
   .settings(
     name := s"$projectName-internals",
     settings,
+    implicitConversionSettings,
     libraryDependencies ++= commonDependencies
   )
 
@@ -71,13 +73,15 @@ lazy val compiler_ir = (project in file("compiler/ir"))
   .settings(
     name := s"$projectName-compiler-ir",
     settings,
+    implicitConversionSettings,
     libraryDependencies += dependencies.upickle
   ).dependsOn(internals)
 
 lazy val core = project
   .settings(
     name := s"$projectName-core",
     settings,
+    implicitConversionSettings,
     pluginTestUseSettings,
     libraryDependencies ++= commonDependencies,
     Compile / resourceGenerators += Def.task {
@@ -123,6 +127,10 @@ lazy val platforms = project
   .settings(
     name := s"$projectName-platforms",
     settings,
+    // Override global license: platforms module is published under Apache 2.0
+    licenses := List(
+      "Apache-2.0" -> url("https://www.apache.org/licenses/LICENSE-2.0.txt")
+    ),
     pluginUseSettings,
     libraryDependencies ++= commonDependencies
   )
@@ -136,11 +144,11 @@ lazy val platforms = project
 lazy val dependencies =
   new {
     private val scodecV = "1.2.4"
-    private val munitV = "1.2.1"
-    private val airframelogV = "2025.1.21"
-    private val oslibV = "0.11.6"
-    private val scallopV = "5.2.0"
-    private val upickleV = "4.4.1"
+    private val munitV = "1.2.2"
+    private val airframelogV = "2025.1.27"
+    private val oslibV = "0.11.7"
+    private val scallopV = "5.3.0"
+    private val upickleV = "4.4.2"
 
     val scodec = "org.scodec" %% "scodec-bits" % scodecV
     val munit = "org.scalameta" %% "munit" % munitV % Test
@@ -177,8 +185,8 @@ def compilerOptionsVersionDependent(scalaVersion: String) = {
 lazy val compilerOptions = Seq(
   "-unchecked",
   "-feature",
+  "-preview",
   "-language:strictEquality",
-  "-language:implicitConversions",
   "-deprecation",
   //TODO: remove when fixed scalac issues:
   //https://github.com/lampepfl/dotty/issues/19299
@@ -216,3 +224,9 @@ lazy val commonSettings = Seq(
     compilerOptions ++ compilerOptionsVersionDependent(scalaVersion.value)
   }
 )
+
+lazy val implicitConversionSettings = Seq(
+  Compile / scalacOptions ++= Seq(
+    "-language:implicitConversions"
+  )
+)

compiler/ir/src/main/scala/dfhdl/compiler/analysis/DFOwnerAnalysis.scala

@@ -3,6 +3,7 @@ package analysis
 import dfhdl.internals.*
 import ir.*
 import scala.annotation.tailrec
+import scala.collection.mutable
 extension (owner: DFOwner)
   def members(memberView: MemberView)(using MemberGetSet): List[DFMember] =
     getSet.designDB.getMembersOf(owner, memberView)
@@ -29,3 +30,29 @@ extension (domainOwner: DFDomainOwner)
         if (dependency == thatDomainOwner) true
         else dependency.isDependentOn(thatDomainOwner)
       case None => false
+
+extension (design: DFDesignBlock)
+  // collect all local parameters that are used in IOs
+  def getIOLocalParams(using getSet: MemberGetSet): List[DFVal.CanBeExpr] =
+    val ioLocalParams = mutable.LinkedHashSet.empty[DFVal.CanBeExpr]
+    def collectIOLocalParams(ref: DFRefAny): Unit = ref.get match
+      // skip existing design parameters
+      case _: DFVal.DesignParam => // do nothing
+      // skip global parameters
+      case gp: DFVal.CanBeGlobal if gp.isGlobal => // do nothing
+      // check this value and its dependencies
+      case dfVal: DFVal.CanBeExpr =>
+        // already collected
+        if (!ioLocalParams.contains(dfVal))
+          // collect dependencies
+          dfVal.getRefs.foreach(collectIOLocalParams)
+          // if the value is named collect this value too
+          if (!dfVal.isAnonymous)
+            ioLocalParams.add(dfVal)
+      case _ => // do nothing
+    design.members(MemberView.Folded).foreach {
+      case port @ DclPort() => port.getRefs.foreach(collectIOLocalParams)
+      case _                => // do nothing
+    }
+    ioLocalParams.toList
+end extension

compiler/ir/src/main/scala/dfhdl/compiler/analysis/DFValAnalysis.scala

@@ -281,12 +281,13 @@ extension (dfVal: DFVal)
                 val maxValue = relVal.dfType match
                   case vector: DFVector => vector.length - 1
                   case bits: DFBits     => bits.width - 1
+                  case xInt: DFDecimal  => xInt.width - 1
                   case _                => ???
                 s"_${i.toPaddedString(maxValue)}"
               case _ => "_sel"
           case applyRange: DFVal.Alias.ApplyRange =>
-            (applyRange.dfType: @unchecked) match
-              case DFBits(_) =>
+            applyRange.dfType.runtimeChecked match
+              case DFBits(_) | DFUInt(_) | DFSInt(_) =>
                 val idxHigh = applyRange.idxHighRef.getInt.toPaddedString(applyRange.width - 1)
                 val idxLow = applyRange.idxLowRef.getInt.toPaddedString(applyRange.width - 1)
                 s"_${idxHigh}_${idxLow}"

compiler/ir/src/main/scala/dfhdl/compiler/ir/Config.scala

@@ -1,11 +1,13 @@
 package dfhdl.compiler.ir
 import upickle.default.*
-opaque type ConfigN[T] = T | None.type
+into opaque type ConfigN[T] = T | None.type
 object ConfigN:
   given [T]: Conversion[None.type, ConfigN[T]] with
     def apply(x: None.type): ConfigN[T] = x
   given [T]: Conversion[T, ConfigN[T]] with
     def apply(x: T): ConfigN[T] = x
+  given [F, T](using conv: Conversion[F, T]): Conversion[F, ConfigN[T]] with
+    def apply(x: F): ConfigN[T] = conv(x)
   given [T1, T2](using CanEqual[T1, T2]): CanEqual[ConfigN[T1], ConfigN[T2]] = CanEqual.derived
   given [T]: CanEqual[ConfigN[T], None.type] = CanEqual.derived
   given [T]: CanEqual[None.type, ConfigN[T]] = CanEqual.derived
@@ -14,9 +16,9 @@ object ConfigN:
   given [L, R]: CanEqual[ConfigN[L], ConfigN[R]] = CanEqual.derived
   given [T](using ReadWriter[T]): ReadWriter[ConfigN[T]] = readwriter[ujson.Value].bimap(
     value =>
-      (value: @unchecked) match
-        case None     => ujson.Null
-        case value: T => writeJs(value)
+      value.runtimeChecked match
+        case None                => ujson.Null
+        case value: T @unchecked => writeJs(value)
     ,
     json =>
       json match

compiler/ir/src/main/scala/dfhdl/compiler/ir/DB.scala

@@ -203,17 +203,17 @@ final case class DB(
       case MemberView.Folded =>
         ownerMemberTable(owner)
       case MemberView.Flattened =>
-        def recur(owner: DFOwner, includeOwner: Boolean = true): List[DFMember] =
+        def recur(owner: DFOwner): List[DFMember] =
           val members = ownerMemberTable(owner)
           members.flatMap {
             case d: DFDesignBlock => Some(d)
-            case o: DFOwner       => if (includeOwner) o :: recur(o) else recur(o)
+            case o: DFOwner       => o :: recur(o)
             case m                => Some(m)
           }
         end recur
         owner match
           case d: DFDesignBlock => designMemberTable(d)
-          case _                => recur(owner, includeOwner = false)
+          case _                => recur(owner)
 
   // holds a hash table that lists members of each owner. The member list order is maintained.
   lazy val ownerMemberTable: Map[DFOwner, List[DFMember]] =
@@ -652,7 +652,7 @@ final case class DB(
             !magnetConnectionTable.contains(p) && !p.hasNonBubbleInit =>
         val ownerDesign = p.getOwnerDesign
         s"""|DFiant HDL connectivity error!
-            |Position:  ${ownerDesign.meta.position}
+            |Position:  ${p.meta.position}
             |Hierarchy: ${ownerDesign.getFullName}
             |Message:   Found a dangling (unconnected/unassigned and uninitialized) output port `${p.getName}`.""".stripMargin
     }

compiler/ir/src/main/scala/dfhdl/compiler/ir/DFMember.scala

@@ -217,9 +217,26 @@ sealed trait DFVal extends DFMember.Named:
       case DFVal.DesignParam(dfValRef = DFRef(dfVal)) =>
         stripAsIsAndDesignParam(dfVal)
       case _ => dfVal
+    // TODO: maybe we need a better way to check equivalent expressions, with symbolic algebra comparison?
+    // with such comparison, it is possible to simplify expressions at least in the common cases.
     (stripAsIsAndDesignParam(this), stripAsIsAndDesignParam(that)) match
-      case (lhs: DFVal.CanBeExpr, rhs: DFVal.CanBeExpr) => lhs.protIsSimilarTo(rhs)
-      case (lhs, rhs)                                   => lhs == rhs
+      // literal constants are considered to be similar to expressions if they are
+      // at a higher level of hierarchy than the expression
+      case (lhs: DFVal.Const, rhs: DFVal.CanBeExpr)
+          if !lhs.isGlobal && !rhs.isGlobal &&
+            lhs.getOwnerDesign.isOutsideOwner(rhs.getOwnerDesign) ||
+            lhs.isGlobal && lhs.isAnonymous =>
+        lhs.dfType.isSimilarTo(rhs.dfType) && lhs.getConstData.equals(rhs.getConstData)
+      case (lhs: DFVal.CanBeExpr, rhs: DFVal.Const)
+          if !lhs.isGlobal && !rhs.isGlobal &&
+            rhs.getOwnerDesign.isOutsideOwner(lhs.getOwnerDesign) ||
+            rhs.isGlobal && rhs.isAnonymous =>
+        rhs.dfType.isSimilarTo(lhs.dfType) && rhs.getConstData.equals(lhs.getConstData)
+      case (lhs: DFVal.CanBeExpr, rhs: DFVal.CanBeExpr) =>
+        lhs.protIsSimilarTo(rhs)
+      case (lhs, rhs) => lhs == rhs
+    end match
+  end isSimilarTo
   protected def protGetConstData(using MemberGetSet): Option[Any]
   private var cachedConstDataReady: Boolean = false
   private var cachedConstData: Option[Any] = None
@@ -599,7 +616,7 @@ object DFVal:
       case >>, <<, **, ror, rol, reverse, repeat
       case unary_-, unary_~, unary_!
       case rising, falling
-      case clog2, max, min, sel
+      case clog2, max, min, abs, sel
       // special-case of initFile construct for vectors of bits
       case InitFile(format: InitFileFormat, path: String)
     object Op:
@@ -763,9 +780,9 @@ object DFVal:
         meta: Meta,
         tags: DFTags
     ) extends Partial derives ReadWriter:
-      def elementWidth(using MemberGetSet): Int = (dfType: @unchecked) match
-        case DFBits(_)                     => 1
-        case DFVector(cellType = cellType) => cellType.width
+      def elementWidth(using MemberGetSet): Int = dfType.runtimeChecked match
+        case DFBits(_) | DFUInt(_) | DFSInt(_) => 1
+        case DFVector(cellType = cellType)     => cellType.width
       protected def protIsFullyAnonymous(using MemberGetSet): Boolean =
         relValRef.get.isFullyAnonymous
       protected def protGetConstData(using MemberGetSet): Option[Any] =
@@ -789,9 +806,8 @@ object DFVal:
           case that: ApplyRange =>
             this.dfType.isSimilarTo(that.dfType) &&
             this.relValRef.get.isSimilarTo(that.relValRef.get) &&
-            this.idxHighRef.isSimilarTo(that.idxHighRef) && this.idxLowRef.isSimilarTo(
-              that.idxLowRef
-            )
+            this.idxHighRef.isSimilarTo(that.idxHighRef) &&
+            this.idxLowRef.isSimilarTo(that.idxLowRef)
           case _ => false
       protected def setMeta(meta: Meta): this.type = copy(meta = meta).asInstanceOf[this.type]
       protected def setTags(tags: DFTags): this.type = copy(tags = tags).asInstanceOf[this.type]
@@ -834,12 +850,15 @@ object DFVal:
                   val data = relValData.asInstanceOf[(BitVector, BitVector)]
                   if (data._2.bit(idxInt)) None
                   else Some(data._1.bit(idxInt))
+                case DFUInt(_) | DFSInt(_) =>
+                  relValData.asInstanceOf[Option[BigInt]].map(_.testBit(idxInt))
                 case DFVector(_, _) =>
                   relValData.asInstanceOf[Vector[?]](idxInt)
                 case _ => ???
               Some(outData)
             case Some(_: None.type) => Some(None)
             case _                  => None
+          end match
         )
       end protGetConstData
       protected def `prot_=~`(that: DFMember)(using MemberGetSet): Boolean = that match
@@ -1486,19 +1505,20 @@ object DFDesignBlock:
     case Normal, Def, Simulation
     case BlackBox(source: Source)
   object InstMode:
+    import constraints.DeviceID.Vendor
     object BlackBox:
       enum Source derives CanEqual, ReadWriter:
         case NA
         case Files(path: List[String])
         case Library(libName: String, nameSpace: String)
-        case Qsys(typeName: String)
+        case VendorIP(vendor: Vendor, typeName: String)
 
   extension (dsn: DFDesignBlock)
     def isDuplicate: Boolean = dsn.hasTagOf[DuplicateTag]
     def isBlackBox: Boolean = dsn.instMode.isInstanceOf[InstMode.BlackBox]
-    def isQsysIPBlackbox: Boolean = dsn.instMode match
-      case InstMode.BlackBox(_: InstMode.BlackBox.Source.Qsys) => true
-      case _                                                   => false
+    def isVendorIPBlackbox: Boolean = dsn.instMode match
+      case InstMode.BlackBox(_: InstMode.BlackBox.Source.VendorIP) => true
+      case _                                                       => false
     def inSimulation: Boolean = dsn.instMode == InstMode.Simulation
     def getCommonDesignWith(dsn2: DFDesignBlock)(using MemberGetSet): DFDesignBlock =
       def getOwnerDesignChain(dsn: DFDesignBlock): List[DFDesignBlock] =

compiler/ir/src/main/scala/dfhdl/compiler/ir/DFRef.scala

@@ -90,7 +90,7 @@ object IntParamRef:
     def isInt: Boolean = intParamRef match
       case int: Int => true
       case _        => false
-    def getInt(using MemberGetSet): Int = (intParamRef: @unchecked) match
+    def getInt(using MemberGetSet): Int = intParamRef.runtimeChecked match
       case Int(int) => int
     def isRef: Boolean = intParamRef match
       case ref: DFRef.TypeRef => true
@@ -135,7 +135,7 @@ end IntParamRef
 
 extension (intCompanion: Int.type)
   def unapply(intParamRef: IntParamRef)(using MemberGetSet): Option[Int] =
-    (intParamRef: @unchecked) match
+    intParamRef.runtimeChecked match
       case int: Int            => Some(int)
       case DFRef(dfVal: DFVal) =>
         dfVal.getConstData.asInstanceOf[Option[Option[BigInt]]].flatten.map(_.toInt)

compiler/ir/src/main/scala/dfhdl/compiler/ir/Data.scala

@@ -2,7 +2,7 @@ package dfhdl.compiler.ir
 import dfhdl.internals.BitVector
 import upickle.default.*
 import scala.collection.mutable.ArrayBuffer
-opaque type Data = Any
+into opaque type Data = Any
 object Data:
   given Conversion[Any, Data] = identity
   given ReadWriter[BitVector] = readwriter[String].bimap(