preparing for <> operator change and adapting to DFVal value class removal changes

Author: Oron Port

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

@@ -9,6 +9,9 @@ import scala.annotation.Annotation
 import scala.annotation.implicitNotFound
 import ir.annotation.HWAnnotation
 
+@implicitNotFound(
+  "Missing local design context.\nEither this operation is not supported in global context or `using DFC` is missing."
+)
 final case class DFC(
     nameOpt: Option[String],
     position: Position,

core/src/main/scala/dfhdl/core/DFType.scala

@@ -101,34 +101,6 @@ object DFType:
   type Supported = DFTypeAny | FieldsOrTuple | DFEncoding | DFOpaqueA | Byte | Int | Long |
     Boolean | Double | String | Object | Unit
 
-  given evPortVarConstructor[
-      T <: Supported,
-      A,
-      C,
-      I,
-      P,
-      M <: Modifier[A, C, I, P]
-  ](using
-      tc: DFType.TC[T],
-      checkLocal: AssertGiven[DFC.Scope.Local, "Port/Variable declarations cannot be global"],
-      ck: DFC.Scope,
-      dt: DomainType
-  ): ExactOp2Aux["<>", DFC, Any, T, M, DFVal[
-    tc.Type,
-    Modifier[A & ck.type & dt.type, C, I, P]
-  ]] = new ExactOp2["<>", DFC, Any, T, M]:
-    type Out = DFVal[tc.Type, Modifier[A & ck.type & dt.type, C, I, P]]
-    def apply(t: T, modifier: M)(using DFC): Out = trydf {
-      if (modifier.value.isPort)
-        dfc.owner.asIR match
-          case _: ir.DFDomainOwner =>
-          case _                   =>
-            throw new IllegalArgumentException(
-              "Ports can only be directly owned by a design, a domain or an interface."
-            )
-      DFVal.Dcl(tc(t), modifier.asInstanceOf[Modifier[A & ck.type & dt.type, C, I, P]])
-    }(using dfc, CTName("Port/Variable constructor"))
-  end evPortVarConstructor
   object Ops:
     extension [T <: Supported](t: T)
       infix def <>[A, C, I, P](modifier: Modifier[A, C, I, P])(using
@@ -163,6 +135,11 @@ object DFType:
       ]
   object TC extends TCLP:
     type Aux[T, OT <: DFTypeAny] = TC[T] { type Type = OT }
+    def apply[T, OT <: DFTypeAny](value: OT): Aux[T, OT] =
+      new TC[T]:
+        type Type = OT
+        def apply(t: T)(using DFC): Type = value
+
     given ofDFType[T <: DFTypeAny]: TC[T] with
       type Type = T
       def apply(t: T)(using DFC): Type = t
@@ -206,25 +183,16 @@ object DFType:
         )
       val clsTpe = compPrefix.select(clsSym)
       clsTpe.asType match
-        case '[t & DFEncoding] =>
-          '{
-            new TC[T]:
-              type Type = DFEnum[t & DFEncoding]
-              def apply(t: T)(using DFC): Type = summonInline[DFEnum[t & DFEncoding]]
-          }
-        case '[t & DFStruct.Fields] =>
-          '{
-            new TC[T]:
-              type Type = DFStruct[t & DFStruct.Fields]
-              def apply(t: T)(using DFC): Type =
-                summonInline[DFStruct[t & DFStruct.Fields]]
-          }
-        case '[t & DFOpaque.Abstract] =>
+        case '[DFEncoding] =>
+          val clsType = clsTpe.asTypeOf[DFEncoding]
+          '{ apply[T, DFEnum[clsType.Underlying]](summonInline[DFEnum[clsType.Underlying]]) }
+        case '[DFStruct.Fields] =>
+          val clsType = clsTpe.asTypeOf[DFStruct.Fields]
+          '{ apply[T, DFStruct[clsType.Underlying]](summonInline[DFStruct[clsType.Underlying]]) }
+        case '[DFOpaque.Abstract] =>
+          val clsType = clsTpe.asTypeOf[DFOpaque.Abstract]
           '{
-            new TC[T]:
-              type Type = DFOpaque[t & DFOpaque.Abstract]
-              def apply(t: T)(using DFC): Type =
-                summonInline[DFOpaque[t & DFOpaque.Abstract]]
+            apply[T, DFOpaque[clsType.Underlying]](summonInline[DFOpaque[clsType.Underlying]])
           }
         case _ =>
           val badTypeStr = clsTpe.show

core/src/main/scala/dfhdl/core/DFVal.scala

@@ -16,11 +16,12 @@ import dfhdl.platforms.resources.Resource
 
 import scala.reflect.ClassTag
 final class DFVal[+T <: DFTypeAny, +M <: ModifierAny](val irValue: ir.DFVal | DFError)
-    extends AnyVal
-    with DFMember[ir.DFVal]
+    extends DFMember[ir.DFVal]
     with Selectable:
   type Fields = DFVal.Fields[T @uncheckedVariance, M @uncheckedVariance]
 
+  def wait(using DFC): Unit =
+    trydf { Wait(this.asValOf[DFBoolOrBit]) }
   def selectDynamic(name: String)(using DFC): Any = trydf {
     val ir.DFStruct(structName, fieldMap) = this.asIR.dfType: @unchecked
     val dfType = fieldMap(name)
@@ -1577,6 +1578,7 @@ object ConnectOps:
       L <: DFVal[T, M],
       R
   ](using
+      skipResource: util.NotGiven[R <:< Resource],
       connectableOnly: ConnectableOnly2[C],
       tc: DFVal.TC_Or_OPEN_Or_Resource[T, R]
   ): ExactOp2Aux["<>", DFC, Any, L, R, Unit] = new ExactOp2["<>", DFC, Any, L, R]:

core/src/main/scala/dfhdl/core/DFVector.scala

@@ -63,7 +63,7 @@ object DFVector:
 
   object Ops:
     extension [T <: DFType.Supported, D <: IntP](t: T)(using tc: DFType.TC[T])
-      infix def X(
+      def X(
           cellDim: IntParam[D]
       )(using
           dfc: DFCG

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

@@ -62,7 +62,7 @@ trait Design extends Container, HasClsMetaArgs:
 
   def customTopChecks(): Unit = {}
   private def handleResourceConstraints(): Unit =
-    import dfhdl.{<>, OUT, NOTHING}
+    import dfhdl.{OUT, NOTHING}
     import ir.constraints.{IO, SigConstraint}
     import dfhdl.platforms.resources.*
     import dfhdl.platforms.devices.Pin
@@ -83,9 +83,11 @@ trait Design extends Container, HasClsMetaArgs:
         else (IO(pullMode = unusedPullMode) :: constraints).merge
       val updatedAnnotations = ir.annotation.Unused.Keep :: updatedConstraints
       val port =
-        DFBit.<>(OUT)(using dfc.setName(s"Pin_${pinID}_unused").setAnnotations(updatedAnnotations))
-      if (driveZero) port <> DFVal.Const(DFBit, Some(false), named = false)
-      else port <> NOTHING(DFBit)(using dfc.anonymize)
+        DFVal.Dcl(DFBit, OUT)(using
+          dfc.setName(s"Pin_${pinID}_unused").setAnnotations(updatedAnnotations)
+        )
+      if (driveZero) port.connect(DFVal.Const(DFBit, Some(false), named = false))
+      else port.connect(NOTHING(DFBit)(using dfc.anonymize))
     end addUnusedPinPort
     val usedPinIDs: Set[String] =
       dfc.mutableDB.ResourceOwnershipContext

core/src/main/scala/dfhdl/core/Modifier.scala

@@ -1,5 +1,6 @@
 package dfhdl.core
-import dfhdl.compiler.ir.DFVal.Modifier as IRModifier
+import dfhdl.compiler.ir
+import ir.DFVal.Modifier as IRModifier
 import dfhdl.internals.*
 
 //A: Access, C: Connectivity, I: Initialization, P: Parameteric (Const or not)
@@ -43,6 +44,35 @@ object Modifier:
   object INOUT extends DclPort[PortINOUT](IRModifier(IRModifier.INOUT, IRModifier.Ordinary))
   type CONST = Modifier[Any, Any, Any, dfhdl.core.CONST]
   extension (modifier: ModifierAny) def asIR: IRModifier = modifier.value
+
+  given evPortVarConstructor[
+      T <: DFType.Supported,
+      A,
+      C,
+      I,
+      P,
+      M <: Modifier[A, C, I, P]
+  ](using
+      tc: DFType.TC[T],
+      checkLocal: AssertGiven[DFC.Scope.Local, "Port/Variable declarations cannot be global"],
+      ck: DFC.Scope,
+      dt: DomainType
+  ): ExactOp2Aux["<>", DFC, Any, T, M, DFVal[
+    tc.Type,
+    Modifier[A & ck.type & dt.type, C, I, P]
+  ]] = new ExactOp2["<>", DFC, Any, T, M]:
+    type Out = DFVal[tc.Type, Modifier[A & ck.type & dt.type, C, I, P]]
+    def apply(t: T, modifier: M)(using DFC): Out = trydf {
+      if (modifier.value.isPort)
+        dfc.owner.asIR match
+          case _: ir.DFDomainOwner =>
+          case _                   =>
+            throw new IllegalArgumentException(
+              "Ports can only be directly owned by a design, a domain or an interface."
+            )
+      DFVal.Dcl(tc(t), modifier.asInstanceOf[Modifier[A & ck.type & dt.type, C, I, P]])
+    }(using dfc, CTName("Port/Variable constructor"))
+  end evPortVarConstructor
 end Modifier
 
 sealed trait VAL

core/src/main/scala/dfhdl/core/Wait.scala

@@ -32,8 +32,8 @@ object Wait:
   // with our own wait method, so we need to extend this in the Container trait, instead
   // of relying on export like the rest of the core API.
   trait ContainerOps:
-    extension (lhs: DFConstOf[DFTime]) final def wait(using DFC): Wait = trydf { Wait(lhs) }
-    extension (lhs: Cycles) final def wait(using DFC, CYInRT): Wait = trydf { Wait(lhs) }
+    final def wait(lhs: DFConstOf[DFTime])(using DFC): Unit = trydf { Wait(lhs) }
+    final def wait(lhs: Cycles)(using DFC, CYInRT): Unit = trydf { Wait(lhs) }
     inline def java_wait(): Unit = this.wait()
     inline def java_wait(timeoutMillis: Long): Unit = this.wait(timeoutMillis)
     inline def java_wait(timeoutMillis: Long, nanos: Int): Unit = this.wait(timeoutMillis, nanos)

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

@@ -66,13 +66,21 @@ private trait ResourceLP:
 
 object Resource extends ResourceLP:
   @implicitNotFound("Cannot connect the resource ${R} with ${T}")
-  trait CanConnect[R <: Resource, T]:
+  trait CanConnect[-R <: Resource, -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)
 
+  given [R <: Resource, T <: Resource | DFValAny | RTDomainContainer](using
+      cc: CanConnect[R, T]
+  ): ExactOp2Aux["<>", DFC, Any, R, T, Unit] =
+    new ExactOp2["<>", DFC, Any, R, T]:
+      type Out = Unit
+      def apply(resource1: R, resourceOrValue: T)(using DFC): Out =
+        cc.connect(resource1, resourceOrValue)
+  end given
   object Ops:
     extension [R <: Resource](resource: R)
       def <>[T <: Resource](that: T)(using dfc: DFC, cc: CanConnect[R, T]): Unit =

internals/src/main/scala/dfhdl/internals/Exact.scala

@@ -320,29 +320,29 @@ private def exactOp2Macro[Op, Ctx, OutUB](
   import quotes.reflect.*
   val lhsExactInfo = lhs.exactInfo
   val rhsExactInfo = rhs.exactInfo
-  Expr.summon[ExactOp2[
+  Expr.summonOrError[ExactOp2[
     Op,
     Ctx,
     OutUB,
     lhsExactInfo.Underlying,
     rhsExactInfo.Underlying
   ]] match
-    case Some(expr) => '{
+    case Right(expr) => '{
         $expr(${ lhsExactInfo.exactExpr }, ${ rhsExactInfo.exactExpr })(using $ctx)
       }
-    case None =>
+    case Left(msg) =>
       if (bothWays.value.get)
-        Expr.summon[ExactOp2[
+        Expr.summonOrError[ExactOp2[
           Op,
           Ctx,
           OutUB,
           rhsExactInfo.Underlying,
           lhsExactInfo.Underlying
         ]] match
-          case Some(expr) => '{
+          case Right(expr) => '{
               $expr(${ rhsExactInfo.exactExpr }, ${ lhsExactInfo.exactExpr })(using $ctx)
             }
-          case None =>
+          case Left(msg) =>
             IsGiven.controlledMacroError("Unsupported argument types for this operation.")
       else
         IsGiven.controlledMacroError("Unsupported argument types for this operation.")

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

@@ -63,6 +63,16 @@ extension [T](lhs: Iterable[T])
     lhs.groupBy(new Unique(_)).values.map(_.toList)
 end extension
 
+extension (exprObject: Expr.type)(using Quotes)
+  def summonOrError[T: Type]: Either[String, Expr[T]] =
+    import quotes.reflect.*
+    Implicits.search(TypeRepr.of[T]) match
+      case iss: ImplicitSearchSuccess =>
+        Right(iss.tree.asExprOf[T])
+      case isf: ImplicitSearchFailure =>
+        Left(isf.explanation)
+end extension
+
 extension (using quotes: Quotes)(tpe: quotes.reflect.TypeRepr)
   def asTypeOf[T <: AnyKind]: Type[T] =
     import quotes.reflect.*