refactor annotations and split between IR and FE

Author: Oron Port

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

@@ -2,7 +2,7 @@ package dfhdl.compiler
 package ir
 import dfhdl.internals.*
 import upickle.default.*
-import annotation.tailrec
+import scala.annotation.tailrec
 import scala.collection.immutable.ListMap
 import scala.reflect.{ClassTag, classTag}
 
@@ -1480,9 +1480,9 @@ final case class DomainBlock(
     tags: DFTags
 ) extends DFBlock,
       DFDomainOwner derives ReadWriter:
-  def flattenMode: dfhdl.hw.annotation.flattenMode = meta.annotations.collectFirst {
-    case fm: dfhdl.hw.annotation.flattenMode => fm
-  }.getOrElse(dfhdl.hw.annotation.flattenMode.defaultPrefixUnderscore)
+  def flattenMode: annotation.FlattenMode = meta.annotations.collectFirst {
+    case fm: annotation.FlattenMode => fm
+  }.getOrElse(annotation.FlattenMode.defaultPrefixUnderscore)
   protected def `prot_=~`(that: DFMember)(using MemberGetSet): Boolean = that match
     case that: DomainBlock =>
       this.domainType =~ that.domainType &&

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

@@ -1,16 +1,14 @@
 package dfhdl.compiler.ir
 import dfhdl.internals.*
-import dfhdl.hw.annotation.{HWAnnotation, getActiveHWAnnotations}
 import upickle.default.*
-import scala.annotation.Annotation
+import annotation.HWAnnotation
 
 final case class Meta(
     nameOpt: Option[String],
     position: Position,
     docOpt: Option[String],
     annotations: List[HWAnnotation]
-) derives CanEqual,
-      ReadWriter:
+) derives CanEqual, ReadWriter:
   val isAnonymous: Boolean = nameOpt.isEmpty
   val name: String =
     nameOpt.getOrElse(s"anon${this.hashString}")
@@ -30,9 +28,3 @@ end Meta
 object Meta:
   given ReadWriter[Position] = macroRW
   def empty: Meta = Meta(None, Position.unknown, None, Nil)
-  def gen(
-      nameOpt: Option[String],
-      position: Position,
-      docOpt: Option[String],
-      annotations: List[Annotation]
-  ): Meta = Meta(nameOpt, position, docOpt, annotations.getActiveHWAnnotations)

compiler/ir/src/main/scala/dfhdl/hw/annotation.scala renamed to compiler/ir/src/main/scala/dfhdl/compiler/ir/annotation.scala

@@ -1,86 +1,57 @@
-/** this package contains all the dfhdl hardware annotations
-  */
-package dfhdl.hw
-
+package dfhdl.compiler.ir
 import dfhdl.compiler.printing.{Printer, HasCodeString}
-import scala.annotation.StaticAnnotation
 import dfhdl.internals.*
-import scala.annotation.Annotation
 import upickle.default.*
 import dfhdl.internals.StableEnum
-import dfhdl.compiler.ir.ConfigN
-import dfhdl.compiler.ir.{RateNumber, FreqNumber, TimeNumber}
 
 object annotation:
-  sealed abstract class HWAnnotation extends StaticAnnotation, Product, Serializable, HasCodeString
-      derives CanEqual:
-    val isActive: Boolean
+  sealed abstract class HWAnnotation extends Product, Serializable, HasCodeString derives CanEqual
 
-  extension (annotList: List[Annotation])
-    def getActiveHWAnnotations: List[HWAnnotation] = annotList.collect {
-      case annot: HWAnnotation if annot.isActive => annot
-    }
   object HWAnnotation:
     given ReadWriter[HWAnnotation] = ReadWriter.merge(
-      summon[ReadWriter[unused]],
-      summon[ReadWriter[pure]],
-      summon[ReadWriter[flattenMode]],
+      summon[ReadWriter[Unused]],
+      summon[ReadWriter[Pure.type]],
+      summon[ReadWriter[FlattenMode]],
       summon[ReadWriter[constraints.Constraint]]
     )
 
-  sealed trait unused extends HWAnnotation derives ReadWriter
-  object unused:
-    /** `quiet` suppresses the unused warning for the tagged value.
-      */
-    final case class quiet(isActive: Boolean) extends unused:
-      def this() = this(true)
-      def codeString(using Printer): String = "@hw.annotation.unused.quiet"
-
-    /** `keep` suppresses the unused warning, and also attempts to keep the tagged value.
-      */
-    final case class keep(isActive: Boolean) extends unused:
-      def this() = this(true)
-      def codeString(using Printer): String = "@hw.annotation.unused.keep"
-
-    /** `prune` removes all the redundant paths until and including the tagged value.
-      */
-    final case class prune(isActive: Boolean) extends unused:
-      def this() = this(true)
-      def codeString(using Printer): String = "@hw.annotation.unused.prune"
-  end unused
+  enum Unused extends HWAnnotation derives ReadWriter:
+    case Quiet, Keep, Prune
+    def codeString(using Printer): String =
+      this match
+        case Quiet => "@hw.annotation.unused.quiet"
+        case Keep  => "@hw.annotation.unused.keep"
+        case Prune => "@hw.annotation.unused.prune"
 
-  final case class pure(isActive: Boolean) extends HWAnnotation derives ReadWriter:
-    def this() = this(true)
+  case object Pure extends HWAnnotation:
+    given ReadWriter[Pure.type] = macroRW
     def codeString(using Printer): String = "@hw.annotation.pure"
 
   /** Flattening Mode:
     *   - transparent: $memberName
     *   - prefix: $ownerName$sep$memberName
     *   - suffix: $memberName$sep$ownerName
     */
-  enum flattenMode extends HWAnnotation, StableEnum derives CanEqual, ReadWriter:
-    case transparent()
-    case prefix(sep: String)
-    case suffix(sep: String)
-    val isActive: Boolean = true
+  enum FlattenMode extends HWAnnotation, StableEnum derives ReadWriter:
+    case Transparent
+    case Prefix(sep: String)
+    case Suffix(sep: String)
     def codeString(using Printer): String =
       "@hw.annotation.flattenMode." + (
         this match
-          case transparent() => "transparent()"
-          case prefix(sep)   => s"""prefix("$sep")"""
-          case suffix(sep)   => s"""suffix("$sep")"""
+          case Transparent => "transparent()"
+          case Prefix(sep) => s"""prefix("$sep")"""
+          case Suffix(sep) => s"""suffix("$sep")"""
       )
-  object flattenMode:
-    val defaultPrefixUnderscore = flattenMode.prefix("_")
+  object FlattenMode:
+    val defaultPrefixUnderscore = FlattenMode.Prefix("_")
 end annotation
 
 object constraints:
-  sealed abstract class Constraint extends annotation.HWAnnotation derives ReadWriter:
-    val isActive: Boolean = true
+  sealed abstract class Constraint extends annotation.HWAnnotation derives ReadWriter
   sealed abstract class SigConstraint extends Constraint derives ReadWriter:
     val bitIdx: ConfigN[Int]
-  final case class device(name: String, properties: Map[String, String])
-      extends Constraint
+  final case class Device(name: String, properties: Map[String, String]) extends Constraint
       derives CanEqual, ReadWriter:
     def this(name: String, properties: (String, String)*) =
       this(name, properties.toMap)
@@ -97,13 +68,13 @@ object constraints:
       case num: TimeNumber   => s"$name = ${printer.csDFTimeData(num)}"
       case _                 => s"$name = ${value}"
 
-  final case class io(
+  final case class IO(
       bitIdx: ConfigN[Int] = None,
       loc: ConfigN[String] = None,
-      standard: ConfigN[io.Standard] = None,
-      slewRate: ConfigN[io.SlewRate] = None,
+      standard: ConfigN[IO.Standard] = None,
+      slewRate: ConfigN[IO.SlewRate] = None,
       driveStrength: ConfigN[Int] = None,
-      pullMode: ConfigN[io.PullMode] = None
+      pullMode: ConfigN[IO.PullMode] = None
   ) extends SigConstraint derives CanEqual, ReadWriter:
     def codeString(using Printer): String =
       val params = List(
@@ -116,8 +87,8 @@ object constraints:
       ).filter(_.nonEmpty).mkString(", ")
       s"""@io($params)"""
     end codeString
-  end io
-  object io:
+  end IO
+  object IO:
     enum Standard extends StableEnum, HasCodeString derives CanEqual, ReadWriter:
       case LVCMOS33, LVCMOS25, LVCMOS18
       def codeString(using Printer): String = "io.Standard." + this.toString
@@ -128,8 +99,8 @@ object constraints:
       case UP, DOWN
       def codeString(using Printer): String = "io.PullMode." + this.toString
 
-  object timing:
-    final case class ignore(
+  object Timing:
+    final case class Ignore(
         bitIdx: ConfigN[Int] = None,
         maxFreqMinPeriod: ConfigN[RateNumber] = None
     ) extends SigConstraint
@@ -141,10 +112,10 @@ object constraints:
         ).filter(_.nonEmpty).mkString(", ")
         s"""@timing.ignore($params)"""
 
-    final case class clock(
+    final case class Clock(
         rate: RateNumber
     ) extends Constraint derives CanEqual, ReadWriter:
       def codeString(using Printer): String =
         s"""@timing.clock(${csParam("rate", rate)})"""
-  end timing
+  end Timing
 end constraints

compiler/stages/src/main/scala/dfhdl/compiler/analysis/DBAnalysis.scala

@@ -7,8 +7,8 @@ extension (designDB: DB)
     designDB.members.flatMap:
       case dfVal: DFVal if !dfVal.isAnonymous =>
         val isUnused = dfVal.meta.annotations.exists {
-          case u: dfhdl.hw.annotation.unused => u.isActive
-          case _                             => false
+          case u: annotation.Unused => true
+          case _                    => false
         }
         if (isUnused) Some(dfVal)
         else None

compiler/stages/src/main/scala/dfhdl/compiler/stages/AddClkRst.scala

@@ -108,7 +108,7 @@ case object AddClkRst extends Stage:
                   val clkRstSimGen = new EDDomain:
                     override protected def __dfc: DFC =
                       selfDFC.setName("clkRstSimGen")
-                        .setAnnotations(List(dfhdl.hw.annotation.flattenMode.transparent()))
+                        .setAnnotations(List(annotation.FlattenMode.Transparent))
                     val dfcAnon = selfDFC.anonymize.setAnnotations(Nil)
                     locally {
                       given DFC = selfDFC.anonymize.setAnnotations(Nil)

compiler/stages/src/main/scala/dfhdl/compiler/stages/DropDomains.scala

@@ -4,7 +4,7 @@ import dfhdl.compiler.analysis.*
 import dfhdl.compiler.ir.*
 import dfhdl.compiler.patching.*
 import dfhdl.options.CompilerOptions
-import dfhdl.hw.annotation.flattenMode
+import annotation.FlattenMode
 
 /** This stage flattens the domains by removing them and changing their named members according to
   * the flattening mode.
@@ -30,10 +30,10 @@ case object DropDomains extends Stage:
             // looping through domain composition until reaching a non-domain and applying the name flattening
             while (inDomain)
               currentDomain.flattenMode match
-                case flattenMode.transparent() => // no change
-                case flattenMode.prefix(sep)   =>
+                case FlattenMode.Transparent => // no change
+                case FlattenMode.Prefix(sep) =>
                   currentName = s"${currentDomain.getName}$sep$currentName"
-                case flattenMode.suffix(sep) =>
+                case FlattenMode.Suffix(sep) =>
                   currentName = s"${currentName}$sep${currentDomain.getName}"
               currentDomain.getOwner match
                 case domain: DomainBlock => currentDomain = domain

core/src/main/scala/dfhdl/core/DFC.scala

@@ -2,11 +2,12 @@ package dfhdl.core
 import dfhdl.internals.*
 import dfhdl.compiler.ir
 import dfhdl.options.ElaborationOptions
-import dfhdl.hw.annotation.{HWAnnotation, getActiveHWAnnotations}
+import dfhdl.hw.annotation.getActiveHWAnnotations
 import scala.reflect.ClassTag
 import collection.mutable
 import scala.annotation.Annotation
 import scala.annotation.implicitNotFound
+import ir.annotation.HWAnnotation
 
 final case class DFC(
     nameOpt: Option[String],

core/src/main/scala/dfhdl/core/Design.scala

@@ -33,7 +33,7 @@ trait Design extends Container, HasClsMetaArgs:
     setOwner(
       getSet.replace(designBlock)(
         designBlock.copy(
-          dclMeta = ir.Meta.gen(Some(name), position, docOpt, annotations),
+          dclMeta = r__For_Plugin.metaGen(Some(name), position, docOpt, annotations),
           instMode = mkInstMode
         )
       ).asFE

core/src/main/scala/dfhdl/core/MutableDB.scala

@@ -18,7 +18,8 @@ import dfhdl.compiler.ir.{
   SourceFile,
   MemberView,
   RTDomainCfg,
-  DFTags
+  DFTags,
+  annotation
 }
 import dfhdl.compiler.analysis.filterPublicMembers
 
@@ -228,8 +229,8 @@ final class MutableDB():
       current.defInputs = inputs
       val currentDesign = OwnershipContext.currentDesign
       val isPure = currentDesign.dclMeta.annotations.exists {
-        case hw.annotation.pure(true) => true
-        case _                        => false
+        case annotation.Pure => true
+        case _               => false
       }
       if (isPure)
         val key = (currentDesign.dclMeta.position, inputs.map(_.dfType.asIR))

core/src/main/scala/dfhdl/core/r__For_Plugin.scala

@@ -2,12 +2,21 @@ package dfhdl.core
 import dfhdl.compiler.ir
 import DFVal.Func.Op as FuncOp
 import ir.DFConditional.DFCaseBlock.Pattern
-
+import dfhdl.internals.Position
 import collection.immutable.ListMap
 import dfhdl.internals.metaContextIgnore
 import dfhdl.internals.metaContextForward
 import dfhdl.compiler.ir.DFConditional
+import scala.annotation.Annotation
+import dfhdl.hw.annotation.getActiveHWAnnotations
+
 object r__For_Plugin:
+  def metaGen(
+      nameOpt: Option[String],
+      position: Position,
+      docOpt: Option[String],
+      annotations: List[Annotation]
+  ): ir.Meta = ir.Meta(nameOpt, position, docOpt, annotations.getActiveHWAnnotations)
   def toFunc1[R](block: => R): () => R = () => block
   def toTuple2[T1, T2](t1: T1, t2: T2): (T1, T2) = (t1, t2)
   def toTuple3[T1, T2, T3](t1: T1, t2: T2, t3: T3): (T1, T2, T3) = (t1, t2, t3)