Make Tuple2 Lookupable (backport #2372)

core/src/main/scala/chisel3/experimental/hierarchy/Lookupable.scala

@@ -19,7 +19,7 @@ import chisel3.internal.{throwException, AggregateViewBinding, Builder, ChildBin
   */
 @implicitNotFound(
   "@public is only legal within a class or trait marked @instantiable, and only on vals of type" +
-    " Data, BaseModule, IsInstantiable, IsLookupable, or Instance[_], or in an Iterable, Option, or Either"
+    " Data, BaseModule, IsInstantiable, IsLookupable, or Instance[_], or in an Iterable, Option, Either, or Tuple2"
 )
 trait Lookupable[-B] {
   type C // Return type of the lookup
@@ -402,6 +402,28 @@ object Lookupable {
       }
     }
   }
+
+  implicit def lookupTuple2[X, Y](
+    implicit sourceInfo: SourceInfo,
+    compileOptions:      CompileOptions,
+    lookupableX:         Lookupable[X],
+    lookupableY:         Lookupable[Y]
+  ) = new Lookupable[(X, Y)] {
+    type C = (lookupableX.C, lookupableY.C)
+    def definitionLookup[A](that: A => (X, Y), definition: Definition[A]): C = {
+      val ret = that(definition.proto)
+      (
+        lookupableX.definitionLookup[A](_ => ret._1, definition),
+        lookupableY.definitionLookup[A](_ => ret._2, definition)
+      )
+    }
+    def instanceLookup[A](that: A => (X, Y), instance: Instance[A]): C = {
+      import instance._
+      val ret = that(proto)
+      (lookupableX.instanceLookup[A](_ => ret._1, instance), lookupableY.instanceLookup[A](_ => ret._2, instance))
+    }
+  }
+
   implicit def lookupIsInstantiable[B <: IsInstantiable](
     implicit sourceInfo: SourceInfo,
     compileOptions:      CompileOptions

src/test/scala/chiselTests/experimental/hierarchy/DefinitionSpec.scala

@@ -329,6 +329,16 @@ class DefinitionSpec extends ChiselFunSpec with Utils {
       annos should contain(MarkAnnotation("~Top|HasEither>x".rt, "xright"))
       annos should contain(MarkAnnotation("~Top|HasEither>y".rt, "yleft"))
     }
+    it("3.12: should work on tuple2") {
+      class Top() extends Module {
+        val i = Definition(new HasTuple2())
+        mark(i.xy._1, "x")
+        mark(i.xy._2, "y")
+      }
+      val (_, annos) = getFirrtlAndAnnos(new Top)
+      annos should contain(MarkAnnotation("~Top|HasTuple2>x".rt, "x"))
+      annos should contain(MarkAnnotation("~Top|HasTuple2>y".rt, "y"))
+    }
   }
   describe("4: toDefinition") {
     it("4.0: should work on modules") {

src/test/scala/chiselTests/experimental/hierarchy/Examples.scala

@@ -200,6 +200,12 @@ object Examples {
     @public val y: Either[Bool, UInt] = Left(Wire(Bool()).suggestName("y"))
   }
   @instantiable
+  class HasTuple2() extends Module {
+    val x = Wire(UInt(3.W))
+    val y = Wire(Bool())
+    @public val xy = (x, y)
+  }
+  @instantiable
   class HasVec() extends Module {
     @public val x = VecInit(1.U, 2.U, 3.U)
   }

src/test/scala/chiselTests/experimental/hierarchy/InstanceSpec.scala

@@ -298,7 +298,18 @@ class InstanceSpec extends ChiselFunSpec with Utils {
       annos should contain(MarkAnnotation("~Top|Top/i:HasEither>x".rt, "xright"))
       annos should contain(MarkAnnotation("~Top|Top/i:HasEither>y".rt, "yleft"))
     }
-    it("3.12: should properly support val modifiers") {
+    it("3.12: should work on tuple2") {
+      class Top() extends Module {
+        val i = Instance(Definition(new HasTuple2()))
+        mark(i.xy._1, "x")
+        mark(i.xy._2, "y")
+      }
+      val (_, annos) = getFirrtlAndAnnos(new Top)
+      annos should contain(MarkAnnotation("~Top|Top/i:HasTuple2>x".rt, "x"))
+      annos should contain(MarkAnnotation("~Top|Top/i:HasTuple2>y".rt, "y"))
+    }
+
+    it("3.13: should properly support val modifiers") {
       class SupClass extends Module {
         val value = 10
         val overriddenVal = 10