resources context change wip

Author: Oron Port

core/src/main/scala/dfhdl/core/ResourceContainer.scala

@@ -0,0 +1,16 @@
+package dfhdl.core
+import dfhdl.internals.*
+import scala.annotation.Annotation
+
+class ResourceContainer extends OnCreateEvents, HasDFC, HasClsMetaArgs:
+  final lazy val dfc: DFC = __dfc
+  protected def __dfc: DFC =
+    println("Severe error: missing DFHDL context!\nMake sure you enable the DFHDL compiler plugin.")
+    sys.exit(1)
+  protected def setClsNamePos(
+      name: String,
+      position: Position,
+      docOpt: Option[String],
+      annotations: List[Annotation]
+  ): Unit = {}
+end ResourceContainer

core/src/main/scala/dfhdl/hw/annotation.scala

@@ -63,6 +63,7 @@ end annotation
 object constraints:
   sealed abstract class Constraint extends annotation.HWAnnotation:
     val isActive: Boolean = true
+    val asIR: ir.constraints.Constraint
   sealed abstract class SigConstraint extends Constraint:
     val bitIdx: ir.ConfigN[Int]
   final case class device(name: String, properties: (String, String)*) extends Constraint:

internals/src/main/scala/dfhdl/internals/helpers.scala

@@ -460,6 +460,33 @@ object AnnotatedWith:
   end annotWithMacro
 end AnnotatedWith
 
+// getting annotations both from the class and the object
+// E.g.:
+// @annot1
+// class Foo
+// @annot2
+// val foo = new Foo
+// the annotations should be @annot1 and @annot2
+trait CTAnnotations:
+  def annotations: List[StaticAnnotation]
+object CTAnnotations:
+  inline given CTAnnotations = ${ macroImpl }
+  def macroImpl(using Quotes): Expr[CTAnnotations] =
+    import quotes.reflect.*
+    val owner = Symbol.spliceOwner.owner
+    val allAnnotations =
+      owner.termRef.classSymbol.map(_.annotations).getOrElse(Nil) ++ owner.annotations
+    val annotationsExpr =
+      Expr.ofList(allAnnotations.filter(
+        _.tpe <:< TypeRepr.of[StaticAnnotation]
+      ).map(_.asExprOf[StaticAnnotation]))
+    '{
+      new CTAnnotations:
+        def annotations: List[StaticAnnotation] = $annotationsExpr
+    }
+  end macroImpl
+end CTAnnotations
+
 lazy val osIsWindows: Boolean = sys.props("os.name").toLowerCase.contains("windows")
 lazy val osIsLinux: Boolean = sys.props("os.name").toLowerCase.contains("linux")
 lazy val osIsWSL: Boolean =

lib/src/main/scala/dfhdl/platforms/resources/IO.scala

@@ -4,7 +4,9 @@ import dfhdl.compiler.ir.constraints
 
 trait IO extends Resource
 object IO:
-  given [T <: IO, R <: IO]: CanConnect[T, R] = new CanConnect[T, R] {}
+  given [T <: IO, R <: IO]: CanConnect[T, R] = (resource1: T, resource2: R) =>
+    resource1.connect(resource2)
+    resource2.connect(resource1)
 
 trait HasIOConstraints extends IO:
   val ioc: constraints.IO

lib/src/main/scala/dfhdl/platforms/resources/RCtx.scala

@@ -2,18 +2,25 @@ package dfhdl.platforms.resources
 import dfhdl.internals.CTName
 import dfhdl.internals.PrintType
 import scala.annotation.implicitNotFound
+import dfhdl.internals.CTAnnotations
+import dfhdl.compiler.ir.constraints.Constraint
 
 //Resource Context
 @implicitNotFound("Missing RCtx context")
 trait RCtx:
   val id: String
   val owner: ResourceOwner
+  val constraints: List[Constraint]
 
 object RCtx:
   type NonEmptyName[T] = util.NotGiven[T =:= ""]
   given RCtx(using
       ctName: CTName,
+      ctAnnotations: CTAnnotations,
       owner: ResourceOwner = NoResourceOwner
   )(using NonEmptyName[ctName.Out]): RCtx = new RCtx:
     val id = ctName.value
     val owner = owner
+    val constraints = ctAnnotations.annotations.collect {
+      case c: dfhdl.hw.constraints.Constraint => c.asIR
+    }

lib/src/main/scala/dfhdl/platforms/resources/Resource.scala

@@ -1,20 +1,31 @@
 package dfhdl.platforms.resources
 import scala.annotation.implicitNotFound
+import scala.collection.mutable.ListBuffer
 
 trait Resource(using ctx: RCtx):
   final val id: String = ctx.id
   final val owner: ResourceOwner = ctx.owner
+  private val connections = ListBuffer[Resource]()
+  protected[resources] def connect(that: Resource): Unit =
+    connections += that
   owner.add(this)
 
 private trait ResourceLP:
   import Resource.CanConnect
-  given [T <: Resource, R <: Resource](using CanConnect[R, T]): CanConnect[T, R] =
-    new CanConnect[T, R] {}
+  // connection is commutative, so can connect T to R if can connect R to T
+  given [T <: Resource, R <: Resource](using cc: CanConnect[R, T]): CanConnect[T, R] =
+    (resource1: T, resource2: R) =>
+      cc.connect(resource2, resource1)
 
 object Resource extends ResourceLP:
   @implicitNotFound("Cannot connect the resources ${T} and ${R}")
-  trait CanConnect[T <: Resource, R <: Resource]
-  given [T <: Resource, R <: Resource](using T =:= R): CanConnect[T, R] = new CanConnect[T, R] {}
+  trait CanConnect[T <: Resource, R <: Resource]:
+    def connect(resource1: T, resource2: R): Unit
+  given [T <: Resource, R <: Resource](using T =:= R): CanConnect[T, R] =
+    (resource1: T, resource2: R) =>
+      resource1.connect(resource2)
+      resource2.connect(resource1)
 
   extension [T <: Resource](self: T)
-    def <>[R <: Resource](that: R)(using CanConnect[T, R]): Unit = {}
+    def <>[R <: Resource](that: R)(using cc: CanConnect[T, R]): Unit =
+      cc.connect(self, that)

lib/src/main/scala/dfhdl/platforms/resources/ResourceDeps.scala

@@ -2,3 +2,8 @@ package dfhdl.platforms.resources
 
 trait ResourceDeps(using RCtx) extends Resource:
   protected def deps: List[Resource]
+  override protected[resources] def connect(that: Resource): Unit =
+    deps.lazyZip(that.asInstanceOf[ResourceDeps].deps).foreach {
+      case (r1, r2) => r1.connect(r2)
+    }
+    super.connect(that)

lib/src/main/scala/dfhdl/platforms/resources/ResourceGroup.scala

@@ -1,3 +1,12 @@
 package dfhdl.platforms.resources
 
-trait ResourceGroup(using RCtx) extends Resource, ResourceOwner
+trait ResourceGroup(using RCtx) extends Resource, ResourceOwner:
+  override protected[resources] def connect(that: Resource): Unit =
+    getResources.lazyZip(that.asInstanceOf[ResourceGroup].getResources).foreach {
+      // skipping ResourceDeps in the group, since their dependencies are already connected
+      // since they are also children of the same group.
+      // (only when directly connecting two ResourceDeps, their dependencies are connected)
+      case (r1: ResourceDeps, r2: ResourceDeps) => // do nothing
+      case (r1, r2)                             => r1.connect(r2)
+    }
+    super.connect(that)

lib/src/main/scala/dfhdl/platforms/resources/ResourceOwner.scala

@@ -3,6 +3,7 @@ import scala.collection.mutable.ListBuffer
 trait ResourceOwner:
   protected given ResourceOwner = this
   private val resources = ListBuffer[Resource]()
+  def getResources: List[Resource] = resources.toList
   def add(resource: Resource): Unit = resources += resource
 
 sealed trait NoResourceOwner extends ResourceOwner