<> connection and port/variable construction operation is working under the new single transparent inline method mechanism

Author: Oron Port

core/src/main/scala/dfhdl/core/Container.scala

@@ -52,9 +52,3 @@ abstract class RTDomainContainer(cfg: RTDomainCfg) extends DomainContainer(Domai
     DFOpaque(Rst())
   end Rst
 end RTDomainContainer
-
-object RTDomainContainer:
-  object Ops:
-    extension [D <: RTDomainContainer](domain: D)
-      def <>[R <: Resource](resource: R)(using dfc: DFC, cc: Resource.CanConnect[R, D]): Unit =
-        cc.connect(resource, domain)

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

@@ -101,26 +101,6 @@ object DFType:
   type Supported = DFTypeAny | FieldsOrTuple | DFEncoding | DFOpaqueA | Byte | Int | Long |
     Boolean | Double | String | Object | Unit
 
-  object Ops:
-    extension [T <: Supported](t: T)
-      infix def <>[A, C, I, P](modifier: Modifier[A, C, I, P])(using
-          @implicitNotFound("Port/Variable declarations cannot be global") dfc: DFC,
-          tc: DFType.TC[T],
-          ck: DFC.Scope.Local,
-          dt: DomainType
-      ): DFVal[tc.Type, Modifier[A & ck.type & dt.type, C, I, P]] =
-        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]])
-    end extension
-  end Ops
-
   trait TC[T]:
     type Type <: DFTypeAny
     def apply(t: T)(using DFC): Type

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

@@ -1236,25 +1236,30 @@ object DFVal extends DFValLP:
         exactOp2["as", DFC, DFValAny](lhs, aliasType)
     end extension
     extension [L](inline lhs: L)
-      transparent inline def <~>[R](inline rhs: R)(using DFC): Any =
+      transparent inline def <>[R](inline rhs: R)(using DFC): Any =
         // operator `<>` as a constructor is unidirectional
         // operator `<>` as a connection is bidirectional and commutative
-        // TODO: possibly use match on lhs and rhs together fixing scalac issue
-        // https://github.com/scala/scala3/issues/24076
-        inline lhs match
-          case lhs: DFValAny => inline rhs match
-              // if both LHS and RHS are DFVals, we call `specialConnect` to handle possible
-              // connection in either direction where both implicit directions are available
-              // case rhs: DFValAny => ConnectOps.specialConnect(lhs, rhs)
-              // otherwise, we invoke the implicit given operation in both directions by turning
-              // on the bothWays flag for all other cases
-              case _ => exactOp2["<>", DFC, Any](lhs, rhs)
-          case _ => inline rhs match
-              // if the RHS is a modifier, this is a port/variable constructor,
-              // so we invoke the the implicit given operation only in one way
-              case _: ModifierAny => exactOp2["<>", DFC, Any](lhs, rhs)
-              case _              => exactOp2["<>", DFC, Any](lhs, rhs, bothWays = true)
-        end match
+        inline val lhsIsDFVal = inline compiletime.erasedValue[L] match
+          case _: DFValAny => true
+          case _           => false
+        inline val rhsIsDFVal = inline compiletime.erasedValue[R] match
+          case _: DFValAny => true
+          case _           => false
+        inline val rhsIsModifier = inline compiletime.erasedValue[R] match
+          case _: ModifierAny => true
+          case _              => false
+        // if both LHS and RHS are DFVals, we call `specialConnect` to handle possible
+        // connection in either direction where both implicit directions are available
+        inline if (lhsIsDFVal && rhsIsDFVal)
+          inline lhs match
+            case lhs: DFValAny => inline rhs match
+                case rhs: DFValAny => ConnectOps.specialConnect(lhs, rhs)
+        // if the RHS is a modifier, this is a port/variable constructor,
+        // so we invoke the the implicit given operation only in one way
+        else if (rhsIsModifier) exactOp2["<>", DFC, Any](lhs, rhs)
+        // otherwise, we invoke the implicit given operation in both directions by turning
+        // on the bothWays flag for all other cases
+        else exactOp2["<>", DFC, Any](lhs, rhs, bothWays = true)
     end extension
 
     extension [T <: DFTypeAny, A, C, I, S <: Int, V](dfVal: DFVal[T, Modifier[A, C, I, Any]])
@@ -1557,21 +1562,22 @@ object ConnectOps:
       inline lhs: L,
       inline rhs: R
   )(using DFC): Unit =
-    inline val connectableL = inline lhs match
+    inline val connectableL = inline compiletime.erasedValue[L] match
       case _: DFVal[DFTypeAny, Modifier[Any, Modifier.Connectable, Any, Any]] => true
       case _                                                                  => false
-    inline val connectableR = inline rhs match
+    inline val connectableR = inline compiletime.erasedValue[R] match
       case _: DFVal[DFTypeAny, Modifier[Any, Modifier.Connectable, Any, Any]] => true
       case _                                                                  => false
     inline if (connectableL || connectableR)
       inline if (IsGiven[TC_Connect[L, R]])
         val tcL = compiletime.summonInline[TC_Connect[L, R]]
         inline if (IsGiven[TC_Connect[R, L]])
           val tcR = compiletime.summonInline[TC_Connect[R, L]]
-          // since we have both candidates, we try the RHS first, so if both fail at runtime,
-          // the error message will be from the LHS as fallback.
-          try tcR.connect(rhs, lhs)
-          catch case e: Throwable => tcL.connect(lhs, rhs)
+          try tcL.connect(lhs, rhs)
+          catch
+            case eL: Throwable =>
+              try tcR.connect(rhs, lhs)
+              catch case eR: Throwable => throw eL
         else tcL.connect(lhs, rhs)
       else if (IsGiven[TC_Connect[R, L]])
         compiletime.summonInline[TC_Connect[R, L]].connect(rhs, lhs)
@@ -1599,17 +1605,6 @@ object ConnectOps:
     def apply(lhs: L, rhs: R)(using DFC): Out = trydf {
       lhs.connect(tc(lhs.dfType, rhs))
     }(using dfc, CTName("<>"))
-  extension [T <: DFTypeAny, C](dfPort: DFVal[T, Modifier[Any, C, Any, Any]])
-    def <>(rhs: DFVal.TC_Or_OPEN_Or_Resource.Exact[T])(using
-        DFC
-    )(using
-        connectableOnly: ConnectableOnly[C, rhs.ExactFrom]
-    ): Unit =
-      given CTName = CTName("<>")
-      trydf {
-        rhs.tc.connect(dfPort, rhs.exactFrom)
-      }
-  end extension
 end ConnectOps
 
 extension (dfVal: ir.DFVal)

core/src/main/scala/dfhdl/hdl.scala

@@ -2,7 +2,6 @@ package dfhdl
 protected object hdl:
   class dsn extends scala.annotation.StaticAnnotation
   import core.IntP
-  export core.DFType.Ops.*
   export core.DFBoolOrBit.Val.Ops.*
   export core.DFBits.StrInterpOps.{h, b}
   export core.DFBits.Val.Ops.*
@@ -25,7 +24,6 @@ protected object hdl:
   export internals.CommonOps.*
   export core.{dfType}
   export core.DFPhysical.Val.Ops.*
-  export platforms.resources.Resource.Ops.*
   export core.COMB_LOOP
   type Time = core.DFTime
   val Time = core.DFTime
@@ -34,7 +32,6 @@ protected object hdl:
   export core.DFRange.Ops.*
   export core.Step.Ops.*
   export core.Wait.Ops.*
-  export core.RTDomainContainer.Ops.*
   type Step = core.Step
   type DFC = core.DFC
   val DFC = core.DFC

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

@@ -81,15 +81,5 @@ object Resource extends ResourceLP:
       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 =
-        cc.connect(resource, that)
-      def <>[T <: DFValAny | RTDomainContainer](that: T)(using
-          dfc: DFC,
-          cc: CanConnect[R, T]
-      ): Unit = trydf {
-        cc.connect(resource, that)
-      }
-  export Resource.Ops.*
+  export dfhdl.hdl.<>
 end Resource

core/src/test/scala/CoreSpec/DFTypeSpec.scala

@@ -89,14 +89,14 @@ class DFTypeSpec extends DFSpec:
       """z(3, 0).prev"""
     )
     assertCompileError(
-      "The LHS of a connection must be a connectable DFHDL value (var/port)."
+      "At least one of the connection arguments must be a connectable DFHDL value (var/port)."
     )(
       """z(3, 0) <> all(0)"""
     )
     val tplx = tpl <> VAR
     tplx._1 := 1
     assertCompileError(
-      "The LHS of a connection must be a connectable DFHDL value (var/port)."
+      "At least one of the connection arguments must be a connectable DFHDL value (var/port)."
     )(
       """tplx._1 <> 1"""
     )

core/src/test/scala/CoreSpec/GlobalsSpec.scala

@@ -3,10 +3,14 @@ import dfhdl.*
 
 class GlobalsSpec extends NoDFCSpec:
   test("Global errors") {
-    assertCompileError("Port/Variable declarations cannot be global")(
+    assertCompileError(
+      "Missing local design context.\nEither this operation is not supported in global context or `using DFC` is missing."
+    )(
       """val x = Bit <> VAR"""
     )
-    assertCompileError("Port/Variable declarations cannot be global")(
+    assertCompileError(
+      "Missing local design context.\nEither this operation is not supported in global context or `using DFC` is missing."
+    )(
       """val x = Bit <> IN"""
     )
   }

lib/src/test/scala/ElaborationChecksSpec.scala

@@ -158,7 +158,7 @@ class ElaborationChecksSpec extends DesignSpec:
           |DFiant HDL elaboration error!
           |Position:  ${currentFilePos}ElaborationChecksSpec.scala:154:19 - 154:28
           |Hierarchy: Top.y
-          |Operation: ``
+          |Operation: `Port/Variable constructor`
           |Message:   Ports can only be directly owned by a design, a domain or an interface.
           |""".stripMargin
     )