Merge pull request #297 from DFiantHDL/opsrefactor

almost at v0.16.0

Author: soronpo

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = 3.9.9
+version = 3.9.10
 runner.dialect = scala3
 
 maxColumn = 100

build.sbt

@@ -5,7 +5,7 @@ commands += DFHDLCommands.docExamplesRefUpdate
 
 // format: off
 val projectName = "dfhdl"
-val compilerVersion = "3.7.2"
+val compilerVersion = "3.7.4-RC1"
 
 inThisBuild(
   List(
@@ -135,11 +135,11 @@ lazy val platforms = project
 lazy val dependencies =
   new {
     private val scodecV = "1.2.4"
-    private val munitV = "1.1.1"
-    private val airframelogV = "2025.1.16"
-    private val oslibV = "0.9.2"
+    private val munitV = "1.2.0"
+    private val airframelogV = "2025.1.19"
+    private val oslibV = "0.11.5"
     private val scallopV = "5.2.0"
-    private val upickleV = "4.2.1"
+    private val upickleV = "4.3.2"
 
     val scodec = "org.scodec" %% "scodec-bits" % scodecV
     val munit = "org.scalameta" %% "munit" % munitV % Test
@@ -153,7 +153,8 @@ lazy val commonDependencies = Seq(
   dependencies.scodec,
   dependencies.munit,
   dependencies.airframelog,
-  dependencies.scallop
+  dependencies.scallop,
+  dependencies.oslib
 )
 
 // SETTINGS

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

@@ -462,8 +462,7 @@ extension (members: List[DFMember])
           case _ => Nil
       }
     members.view.filter(_.isPublicMember).flatMap {
-      case p: DFVal.DesignParam => getPublicMembersDeps(p).reverse
-      case m                    => Some(m)
+      case m => getPublicMembersDeps(m).reverse
     }.toList.distinct
 end extension
 

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

@@ -16,7 +16,8 @@ object StateAnalysis:
     val currentBlock = summon[DFBlock]
     val access = immutable.BitSet.empty ++ (relBitLow until relBitLow + relWidth)
     value match
-      case DFVal.Alias.AsIs(dfType = toType, relValRef = relValRef) =>
+      case dfVal: DFVal.Alias if dfVal.relValRef.get.dfType.isUnbounded => currentSet
+      case DFVal.Alias.AsIs(dfType = toType, relValRef = relValRef)     =>
         val relVal = relValRef.get
         if (toType.width == relVal.width)
           // casting maintains relative bit consumption

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

@@ -37,9 +37,14 @@ object ConfigN:
     def flatMap[R](f: T => ConfigN[R]): ConfigN[R] = x match
       case None                => None
       case value: T @unchecked => f(value)
+    def toOption: Option[T] = x match
+      case None                => None
+      case value: T @unchecked => Some(value)
     def toList: List[T] = x match
       case None                => Nil
       case value: T @unchecked => List(value)
+    def nonEmpty: Boolean = x != None
+    def isEmpty: Boolean = x == None
   end extension
   extension [T <: DFRefAny](x: ConfigN[T])
     def =~(that: ConfigN[T])(using MemberGetSet): Boolean = (x, that) match

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

@@ -5,6 +5,7 @@ import upickle.default.*
 import scala.annotation.tailrec
 import scala.collection.immutable.ListMap
 import scala.reflect.{ClassTag, classTag}
+import dfhdl.compiler.ir.PhysicalNumber.Ops.MHz
 
 sealed trait DFMember extends Product, Serializable, HasRefCompare[DFMember] derives CanEqual:
   val ownerRef: DFOwner.Ref
@@ -19,7 +20,7 @@ sealed trait DFMember extends Product, Serializable, HasRefCompare[DFMember] der
   final def getOwner(using MemberGetSet): DFOwner = ownerRef.get match
     case o: DFOwner        => o
     case _: DFMember.Empty =>
-      throw new IllegalArgumentException(s"No owner found for member $this.")
+      throw new Exception(s"No owner found for member $this.")
   final def getOwnerNamed(using MemberGetSet): DFOwnerNamed = getOwner match
     case b: DFOwnerNamed => b
     case o               => o.getOwnerNamed
@@ -133,6 +134,16 @@ object DFMember:
       case _                => None
     })
     def toJson(using Writer[DFMember]): String = write(member)
+    def getConstraints: List[constraints.Constraint] =
+      val allAnnotations = member match
+        case design: DFDesignBlock =>
+          design.dclMeta.annotations.view ++ design.meta.annotations
+        case interface: DFInterfaceOwner =>
+          interface.dclMeta.annotations.view ++ interface.meta.annotations
+        case _ => member.meta.annotations.view
+      allAnnotations.collect {
+        case c: constraints.Constraint => c
+      }.toList
   end extension
 
   sealed trait Empty extends DFMember:
@@ -217,7 +228,9 @@ sealed trait DFVal extends DFMember.Named:
     if (cachedConstDataReady) cachedConstData
     else
       cachedConstData = protGetConstData
-      cachedConstDataReady = true
+      // disable None constant data caching during mutation, since some data like CLK_FREQ
+      // cannot be attained during mutation and returns None
+      if (!(getSet.isMutable && cachedConstData == None)) cachedConstDataReady = true
       cachedConstData
   def updateDFType(dfType: DFType): this.type
 end DFVal
@@ -226,13 +239,12 @@ object DFVal:
   type Ref = DFRef.TwoWay[DFVal, DFMember]
   given ReadWriter[DFVal] = ReadWriter.merge(
     summon[ReadWriter[DFVal.Dcl]],
-    summon[ReadWriter[DFVal.OPEN]],
+    summon[ReadWriter[DFVal.Special]],
     summon[ReadWriter[DFVal.Alias]],
     summon[ReadWriter[DFVal.Const]],
     summon[ReadWriter[DFVal.DesignParam]],
     summon[ReadWriter[DFVal.Func]],
-    summon[ReadWriter[DFVal.PortByNameSelect]],
-    summon[ReadWriter[DFVal.NOTHING]]
+    summon[ReadWriter[DFVal.PortByNameSelect]]
   )
   final case class Modifier(dir: Modifier.Dir, special: Modifier.Special)
       derives CanEqual,
@@ -278,18 +290,18 @@ object DFVal:
           case _            => false
       case _ => false
     def isOpen: Boolean = dfVal match
-      case _: DFVal.OPEN => true
-      case _             => false
+      case DFVal.Special(kind = DFVal.Special.OPEN) => true
+      case _                                        => false
     def isDesignParam: Boolean = dfVal match
       case _: DFVal.DesignParam => true
       case _                    => false
     def isReg: Boolean = dfVal match
       case dcl: DFVal.Dcl => dcl.modifier.isReg
       case _              => false
-    @tailrec def dealias(using MemberGetSet): Option[DFVal.Dcl | DFVal.OPEN] = dfVal match
+    @tailrec def dealias(using MemberGetSet): Option[DFVal.Dcl | DFVal.Special] = dfVal match
       case dcl: DFVal.Dcl                           => Some(dcl)
       case portByNameSelect: DFVal.PortByNameSelect => Some(portByNameSelect.getPortDcl)
-      case open: DFVal.OPEN                         => Some(open)
+      case open: DFVal.Special if open.isOpen       => Some(open)
       case alias: DFVal.Alias                       => alias.relValRef.get.dealias
       case _                                        => None
     @tailrec private def departial(range: Range)(using MemberGetSet): (DFVal, Range) =
@@ -455,38 +467,28 @@ object DFVal:
     type Ref = DFRef.TwoWay[DFVal, DesignParam]
     type DefaultRef = DFRef.TwoWay[DFVal | DFMember.Empty, DesignParam]
 
-  final case class OPEN(
-      dfType: DFType,
-      ownerRef: DFOwner.Ref
-  ) extends DFVal derives ReadWriter:
-    val meta: Meta = Meta(None, Position.unknown, None, Nil)
-    val tags: DFTags = DFTags.empty
-    protected def protIsFullyAnonymous(using MemberGetSet): Boolean = true
-    protected def protGetConstData(using MemberGetSet): Option[Any] = None
-    protected def `prot_=~`(that: DFMember)(using MemberGetSet): Boolean = that match
-      case _: OPEN => true
-      case _       => false
-    protected def setMeta(meta: Meta): this.type = this
-    protected def setTags(tags: DFTags): this.type = this
-    lazy val getRefs: List[DFRef.TwoWayAny] = dfType.getRefs ++ meta.getRefs
-    def updateDFType(dfType: DFType): this.type = copy(dfType = dfType).asInstanceOf[this.type]
-    def copyWithNewRefs(using RefGen): this.type = copy(
-      dfType = dfType.copyWithNewRefs,
-      ownerRef = ownerRef.copyAsNewRef
-    ).asInstanceOf[this.type]
-  end OPEN
-
-  final case class NOTHING(
+  final case class Special(
       dfType: DFType,
+      kind: Special.Kind,
       ownerRef: DFOwner.Ref,
       meta: Meta,
       tags: DFTags
   ) extends CanBeExpr derives ReadWriter:
     protected def protIsFullyAnonymous(using MemberGetSet): Boolean = true
-    protected def protGetConstData(using MemberGetSet): Option[Any] = None
+    protected def protGetConstData(using MemberGetSet): Option[Any] = kind match
+      case Special.CLK_FREQ =>
+        if (getSet.isMutable) None // disable during elaboration
+        else
+          Some(getSet.designDB.explicitRTDomainCfgMap(
+            this.getOwnerDomain
+          ).clkCfg.toOption.map(_.rate.to_freq).getOrElse(0.MHz))
+      case _ => None
     protected def `prot_=~`(that: DFMember)(using MemberGetSet): Boolean = that match
-      case _: NOTHING => true
-      case _          => false
+      case that: Special =>
+        this.dfType =~ that.dfType && this.kind == that.kind &&
+        this.meta =~ that.meta && this.tags =~ that.tags
+
+      case _ => false
     protected[ir] def protIsSimilarTo(that: CanBeExpr)(using MemberGetSet): Boolean =
       this == that
     protected def setMeta(meta: Meta): this.type = copy(meta = meta).asInstanceOf[this.type]
@@ -498,7 +500,11 @@ object DFVal:
       dfType = dfType.copyWithNewRefs,
       ownerRef = ownerRef.copyAsNewRef
     ).asInstanceOf[this.type]
-  end NOTHING
+  end Special
+  object Special:
+    enum Kind extends StableEnum derives CanEqual, ReadWriter:
+      case NOTHING, OPEN, CLK_FREQ
+    export Kind.{NOTHING, OPEN, CLK_FREQ}
 
   final case class Dcl(
       dfType: DFType,
@@ -1013,7 +1019,7 @@ object DFNet:
         MemberGetSet
     ): Option[
       (
-          toVal: DFVal.Dcl | DFVal.OPEN | DFInterfaceOwner,
+          toVal: DFVal.Dcl | DFVal.Special | DFInterfaceOwner,
           fromVal: DFVal | DFInterfaceOwner,
           swapped: Boolean
       )
@@ -1098,19 +1104,21 @@ object DFOwner:
 
 final case class DFInterfaceOwner(
     domainType: DomainType,
+    dclMeta: Meta,
     ownerRef: DFOwner.Ref,
     meta: Meta,
     tags: DFTags
 ) extends DFDomainOwner derives ReadWriter:
   protected def `prot_=~`(that: DFMember)(using MemberGetSet): Boolean = that match
     case that: DFInterfaceOwner =>
       this.domainType =~ that.domainType &&
-      this.meta =~ that.meta && this.tags =~ that.tags
+      this.dclMeta =~ that.dclMeta && this.meta =~ that.meta && this.tags =~ that.tags
     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]
   lazy val getRefs: List[DFRef.TwoWayAny] = domainType.getRefs ++ meta.getRefs
   def copyWithNewRefs(using RefGen): this.type = copy(
+    dclMeta = dclMeta.copyWithNewRefs,
     meta = meta.copyWithNewRefs,
     domainType = domainType.copyWithNewRefs,
     ownerRef = ownerRef.copyAsNewRef
@@ -1447,15 +1455,26 @@ final case class DFDesignBlock(
   protected def `prot_=~`(that: DFMember)(using MemberGetSet): Boolean = that match
     case that: DFDesignBlock =>
       this.domainType =~ that.domainType &&
-      this.dclMeta == that.dclMeta &&
+      this.dclMeta =~ that.dclMeta &&
       this.instMode == that.instMode &&
       this.meta =~ that.meta && this.tags =~ that.tags
     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]
-  lazy val getRefs: List[DFRef.TwoWayAny] = domainType.getRefs
+  lazy val getRefs: List[DFRef.TwoWayAny] = domainType.getRefs ++ dclMeta.getRefs
+
+  /** Whether this design is considered to be a device's top-level design. THIS MAY NOT BE THE TOP
+    * DESIGN, for example if the design is in a simulation. A design is considered to be a device
+    * top-level design if it has a device ID constraint (usually as a result of a device resource
+    * instantiated within).
+    */
+  lazy val isDeviceTop: Boolean = this.getConstraints.exists {
+    case _: constraints.DeviceID => true
+    case _                       => false
+  }
   def copyWithNewRefs(using RefGen): this.type = copy(
     meta = meta.copyWithNewRefs,
+    dclMeta = dclMeta.copyWithNewRefs,
     domainType = domainType.copyWithNewRefs,
     ownerRef = ownerRef.copyAsNewRef
   ).asInstanceOf[this.type]
@@ -1465,17 +1484,21 @@ object DFDesignBlock:
   import InstMode.BlackBox.Source
   enum InstMode extends StableEnum derives CanEqual, ReadWriter:
     case Normal, Def, Simulation
-    case BlackBox(verilogSrc: Source, vhdlSrc: Source)
+    case BlackBox(source: Source)
   object InstMode:
     object BlackBox:
       enum Source extends StableEnum derives CanEqual, ReadWriter:
         case NA
-        case File(path: String)
+        case Files(path: List[String])
         case Library(libName: String, nameSpace: String)
+        case Qsys(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 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/DFMember.scala

@@ -69,7 +69,10 @@ object DFType:
           dt.cellType.decompose(pf)
         case _ => Nil
       ListSet.from(deps.collect(pf) ++ List(dfType).collect(pf))
-
+    def isUnbounded: Boolean = dfType match
+      case _: DFUnbounded => true
+      case _              => false
+  end extension
 end DFType
 
 sealed trait ComposedDFType extends DFType
@@ -527,7 +530,7 @@ case object DFDouble extends DFType.Companion[DFDouble, Option[Double]] with DFD
 /////////////////////////////////////////////////////////////////////////////
 
 sealed trait DFUnbounded extends DFType:
-  def noTypeErr = throw new IllegalArgumentException(
+  def noTypeErr = throw new Exception(
     s"Unexpected access to $this data type"
   )
   def width(using MemberGetSet): Int = noTypeErr

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

@@ -24,6 +24,7 @@ object Data:
         case Some(stringValue: String)        => writeJs(("string", stringValue))
         case time: TimeNumber                 => writeJs(("time", (time.value, time.unit)))
         case freq: FreqNumber                 => writeJs(("freq", (freq.value, freq.unit)))
+        case number: LiteralNumber            => writeJs(("number", number.value))
         case vectorData: Vector[Data]         =>
           given ReadWriter[Vector[Data]] = vectorDataWriter
           writeJs(("vector", vectorData))
@@ -50,6 +51,8 @@ object Data:
         case ujson.Arr(ArrayBuffer(ujson.Str("freq"), freqValue)) =>
           val (value, unit) = read[(BigDecimal, FreqNumber.Unit)](freqValue)
           FreqNumber(value, unit)
+        case ujson.Arr(ArrayBuffer(ujson.Str("number"), numberValue)) =>
+          LiteralNumber(read[BigDecimal](numberValue))
         case ujson.Arr(ArrayBuffer(ujson.Str("vector"), vectorData)) =>
           given ReadWriter[Vector[Data]] = vectorDataWriter
           read[Vector[Data]](vectorData)