add DFC to all resource connections

Author: Oron Port

core/src/main/scala/dfhdl/platforms/devices/Bank.scala

@@ -1,6 +1,5 @@
 package dfhdl.platforms.devices
 import dfhdl.platforms.resources.*
-import Resource.CanConnect
 
 abstract class Bank extends ResourceGroup:
   type This <: Bank

core/src/main/scala/dfhdl/platforms/resources/ClkResource.scala

@@ -9,9 +9,10 @@ trait ClkResource extends IO:
   val rate: Rate
   injectConstraint(Timing.Clock(rate))
 object ClkResource:
-  given [R <: ClkResource, C <: (Clk <> VAL)](using DFC): CanConnect[R, C] = (r, c) => r.connect(c)
-  given [R <: ClkResource, DC <: core.RTDomainContainer](using dfc: DFC): CanConnect[R, DC] =
-    (clkResource, domainContainer) =>
+  given [R <: ClkResource, C <: (Clk <> VAL)](using DFC): CanConnect[R, C] with
+    def connect(resource: R, dfVal: C)(using DFC): Unit = resource.connect(dfVal)
+  given [R <: ClkResource, DC <: core.RTDomainContainer](using dfc: DFC): CanConnect[R, DC] with
+    def connect(clkResource: R, domainContainer: DC)(using DFC): Unit =
       dfc.mutableDB.ResourceOwnershipContext.connectDomainOwner(
         domainContainer.containedOwner.asIR.asInstanceOf[DFDomainOwner],
         clkResource

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

@@ -19,10 +19,12 @@ trait IO extends Resource:
   end connect
 end IO
 object IO:
-  given [T <: IO, R <: IO]: CanConnect[T, R] = (resource1: T, resource2: R) =>
-    resource1.connectFrom(resource2)
-    resource2.connectFrom(resource1)
+  given [T <: IO, R <: IO]: CanConnect[T, R] with
+    def connect(resource1: T, resource2: R)(using DFC): Unit =
+      resource1.connectFrom(resource2)
+      resource2.connectFrom(resource1)
   given [R <: IO, V <: DFValOf[DFBoolOrBit]](using
       dfc: DFC
-  ): CanConnect[R, V] =
-    (resource: R, dfVal: V) => resource.connect(dfVal)
+  ): CanConnect[R, V] with
+    def connect(resource: R, dfVal: V)(using DFC): Unit =
+      resource.connect(dfVal)

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

@@ -61,21 +61,21 @@ end Resource
 private trait ResourceLP:
   import Resource.CanConnect
   // 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)
+  given [T <: Resource, R <: Resource](using cc: CanConnect[R, T]): CanConnect[T, R] with
+    def connect(resource1: T, resource2: R)(using DFC): Unit = cc.connect(resource2, resource1)
 
 object Resource extends ResourceLP:
   @implicitNotFound("Cannot connect the resource ${R} with ${T}")
   trait CanConnect[R <: Resource, T]:
-    def connect(resource1: R, resource2: T): Unit
-  given [R <: Resource, T <: Resource](using R =:= T): CanConnect[R, T] =
-    (resource1: R, resource2: T) =>
+    def connect(resource1: R, resource2: T)(using DFC): Unit
+  given [R <: Resource, T <: Resource](using R =:= T): CanConnect[R, T] with
+    def connect(resource1: R, resource2: T)(using DFC): Unit =
       resource1.connectFrom(resource2)
       resource2.connectFrom(resource1)
 
   object Ops:
     extension [R <: Resource](resource: R)
-      def <>[T <: Resource](that: T)(using cc: CanConnect[R, T]): Unit =
+      def <>[T <: Resource](that: T)(using dfc: DFC, cc: CanConnect[R, T]): Unit =
         cc.connect(resource, that)
       def <>[T <: DFValAny | RTDomainContainer](that: T)(using
           dfc: DFC,

lib/src/main/scala/dfhdl/platforms/pmods/PmodBoard.scala

@@ -1,18 +1,21 @@
 package dfhdl.platforms.pmods
 import dfhdl.platforms.Board
 import dfhdl.platforms.resources.*
+import dfhdl.DFC
 import Resource.CanConnect
 
 trait PmodBoard extends Board, Resource:
   protected val pmodConn: PmodConn.Male
 object PmodBoard:
   given [B <: PmodBoard, R <: Resource](
       using CanConnect[PmodConn.Male, R]
-  ): CanConnect[B, R] = (b, r) => b.pmodConn <> r
+  ): CanConnect[B, R] with
+    def connect(board: B, resource: R)(using DFC): Unit = board.pmodConn <> resource
 
 trait PmodDualBoard extends Board, Resource:
   protected val pmodDualConn: PmodDualConn.Male
 object PmodDualBoard:
   given [B <: PmodDualBoard, R <: Resource](using
       CanConnect[PmodDualConn.Male, R]
-  ): CanConnect[B, R] = (b, r) => b.pmodDualConn <> r
+  ): CanConnect[B, R] with
+    def connect(board: B, resource: R)(using DFC): Unit = board.pmodDualConn <> resource

lib/src/main/scala/dfhdl/platforms/pmods/PmodConn.scala

@@ -24,7 +24,8 @@ object PmodDualConn:
   class Female(val pm1: PmodConn.Female, val pm2: PmodConn.Female) extends ResourceDeps:
     lazy val upstreamDeps: List[Resource] = List(pm1, pm2)
 
-  given [M <: Male, F <: Female]: CanConnect[M, F] = (m, f) =>
-    m.pm1 <> f.pm1
-    m.pm2 <> f.pm2
+  given [M <: Male, F <: Female]: CanConnect[M, F] with
+    def connect(male: M, female: F)(using DFC): Unit =
+      male.pm1 <> female.pm1
+      male.pm2 <> female.pm2
 end PmodDualConn

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

@@ -49,16 +49,16 @@ object Connector:
       T <: Type,
       CM <: Connector[T, Form.Male.type],
       CF <: Connector[T, Form.Female.type]
-  ]: CanConnect[CM, CF] =
-    (male, female) =>
+  ]: CanConnect[CM, CF] with
+    def connect(male: CM, female: CF)(using DFC): Unit =
       for (i <- 1 to male.`type`.pinCount)
         male.P(male.`type`.pinMap(i)) <> female.P(female.`type`.pinMap(i))
   given femaleMale[
       T <: Type,
       CM <: Connector[T, Form.Male.type],
       CF <: Connector[T, Form.Female.type]
-  ]: CanConnect[CF, CM] =
-    (male, female) =>
+  ]: CanConnect[CF, CM] with
+    def connect(female: CF, male: CM)(using DFC): Unit =
       for (i <- 1 to male.`type`.pinCount)
         male.P(male.`type`.pinMap(i)) <> female.P(female.`type`.pinMap(i))
 end Connector

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

@@ -43,14 +43,14 @@ object IOBus:
           ") is different than the DFHDL value width (" + TW + ")."
       ]
   given [RT <: IO, RL <: Int, R <: IOBus[RT, RL], T <: DFTypeAny, V <: DFValOf[T]](using
-      dfc: DFC,
       wT: Width[T]
   )(using
       check: `RW == TW`.Check[RL, wT.OutI],
       cc: CanConnect[RT, DFValOf[DFBit]]
-  ): CanConnect[R, V] = (resource: R, dfVal: V) =>
-    import dfhdl.core.DFVal.Ops.apply
-    check(resource.length, dfVal.widthInt)
-    for (i <- 0 until resource.ios.length)
-      cc.connect(resource.ios(i), dfVal.bits(i))
+  ): CanConnect[R, V] with
+    def connect(resource: R, dfVal: V)(using DFC): Unit =
+      import dfhdl.core.DFVal.Ops.apply
+      check(resource.length, dfVal.widthInt)
+      for (i <- 0 until resource.ios.length)
+        cc.connect(resource.ios(i), dfVal.bits(i))
 end IOBus

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

@@ -3,6 +3,7 @@ import dfhdl.compiler.ir.constraints
 import dfhdl.compiler.ir.ConfigN
 import dfhdl.platforms.devices.Bank
 import Resource.CanConnect
+import dfhdl.DFC
 
 class Power(val levelVolt: ConfigN[constraints.IO.LevelVolt] = None) extends IO:
   injectConstraint(constraints.IO(levelVolt = levelVolt))
@@ -24,5 +25,7 @@ end Power
 object Power:
   // power is unidirectional, but the connection is commutative.
   // always constraints travel from power to bank, not the other way around.
-  given [B <: Bank, P <: Power]: CanConnect[B, P] = (bank, power) => bank.connectFrom(power)
-  given [P <: Power, B <: Bank]: CanConnect[P, B] = (power, bank) => bank.connectFrom(power)
+  given [B <: Bank, P <: Power]: CanConnect[B, P] with
+    def connect(bank: B, power: P)(using DFC): Unit = bank.connectFrom(power)
+  given [P <: Power, B <: Bank]: CanConnect[P, B] with
+    def connect(power: P, bank: B)(using DFC): Unit = bank.connectFrom(power)

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

@@ -10,7 +10,6 @@ trait ToggleIO[T <: Toggle] extends IO:
 
 object ToggleIO:
   given [T <: Toggle, R <: ToggleIO[T], V <: DFValOf[DFBoolOrBit]](using
-      dfc: DFC,
       t: ShowType[T]
   )(using
       expectedActiveState: GivenOrError[
@@ -19,10 +18,12 @@ object ToggleIO:
           t.Out +
           "`.\nTo fix this, add:\n  `given ExpectedActiveState[" + t.Out + "] = " + t.Out + ".EXPECTED_ACTIVE_STATE`"
       ]
-  ): CanConnect[R, V] = (resource: R, dfVal: V) =>
-    resource.injectConstraint(constraints.IO(invertActiveState =
-      resource.activeState != expectedActiveState.value
-    )).connect(dfVal)
+  ): CanConnect[R, V] with
+    def connect(resource: R, dfVal: V)(using DFC): Unit =
+      resource.injectConstraint(constraints.IO(invertActiveState =
+        resource.activeState != expectedActiveState.value
+      )).connect(dfVal)
+  end given
 end ToggleIO
 
 abstract class ToggleIOComp[T <: Toggle](