Convert cloneType to an extension method

This removes much of the use of this.type in Chisel which is necessary
to upgrade to Scala 3.

Author: adkian-sifive

core/src/main/scala-2/chisel3/Bits.scala

@@ -160,10 +160,10 @@ sealed abstract class Bits(private[chisel3] val width: Width) extends BitsImpl w
     * @note For [[SInt]]s only, this will do sign extension.
     * @group Bitwise
     */
-  final def pad(that: Int): this.type = macro SourceInfoTransform.thatArg
+  final def pad(that: Int): Bits = macro SourceInfoWhiteboxTransform.thatArg
 
   /** @group SourceInfoTransformMacro */
-  def do_pad(that: Int)(implicit sourceInfo: SourceInfo): this.type = _padImpl(that)
+  def do_pad(that: Int)(implicit sourceInfo: SourceInfo): Bits = _padImpl(that)
 
   /** Bitwise inversion operator
     *
@@ -182,8 +182,6 @@ sealed abstract class Bits(private[chisel3] val width: Width) extends BitsImpl w
     * $sumWidthInt
     * @group Bitwise
     */
-  // REVIEW TODO: redundant
-  // REVIEW TODO: should these return this.type or Bits?
   final def <<(that: BigInt): Bits = macro SourceInfoWhiteboxTransform.thatArg
 
   /** @group SourceInfoTransformMacro */

core/src/main/scala/chisel3/AggregateImpl.scala

@@ -4,6 +4,7 @@ package chisel3
 
 import chisel3.experimental.VecLiterals.AddVecLiteralConstructor
 import chisel3.experimental.dataview.{isView, reify, reifyIdentityView, InvalidViewException}
+import chisel3.Data.DataExtensions
 
 import scala.collection.immutable.{SeqMap, VectorMap}
 import scala.collection.mutable.{HashSet, LinkedHashMap}
@@ -421,9 +422,7 @@ private[chisel3] abstract class VecImpl[T <: Data] private[chisel3] (gen: => T,
     */
   def apply(idx: Int): T = self(idx)
 
-  override def cloneType: this.type = {
-    new Vec(gen.cloneTypeFull, length).asInstanceOf[this.type]
-  }
+  override def _cloneType: Vec[T] = new Vec(gen.cloneTypeFull, length)
 
   override def getElements: Seq[Data] = self
 
@@ -491,7 +490,7 @@ private[chisel3] abstract class VecImpl[T <: Data] private[chisel3] (gen: => T,
     elementInitializers: (Int, T)*
   )(
     implicit sourceInfo: SourceInfo
-  ): this.type = {
+  ): Vec[T] = {
 
     def checkLiteralConstruction(): Unit = {
       val dupKeys = elementInitializers.map { x => x._1 }.groupBy(x => x).flatMap {
@@ -543,7 +542,7 @@ private[chisel3] abstract class VecImpl[T <: Data] private[chisel3] (gen: => T,
     requireIsChiselType(this, "vec literal constructor model")
     checkLiteralConstruction()
 
-    val clone = cloneType
+    val clone = this.cloneType
     val cloneFields = getRecursiveFields(clone, "(vec root)").toMap
 
     // Create the Vec literal binding from litArgs of arguments
@@ -832,8 +831,10 @@ private[chisel3] trait RecordImpl extends AggregateImpl { thiz: Record =>
     }
   }
 
-  override def cloneType: this.type = {
-    val clone = _cloneTypeImpl.asInstanceOf[this.type]
+  // Note that _cloneTypeImpl is implemented by the compiler plugin and must be a different method name because
+  // We want to run checkClone after calling _cloneTypeImpl
+  final override def _cloneType: Data = {
+    val clone = _cloneTypeImpl
     checkClone(clone)
     clone
   }
@@ -953,10 +954,10 @@ private[chisel3] trait RecordImpl extends AggregateImpl { thiz: Record =>
     * )
     * }}}
     */
-  private[chisel3] def _makeLit(elems: (this.type => (Data, Data))*)(implicit sourceInfo: SourceInfo): this.type = {
+  private[chisel3] def _makeLit(elems: (Data => (Data, Data))*)(implicit sourceInfo: SourceInfo): Data = {
 
     requireIsChiselType(this, "bundle literal constructor model")
-    val clone = cloneType
+    val clone = this.cloneType
     val cloneFields = getRecursiveFields(clone, "_").toMap
 
     // Create the Bundle literal binding from litargs of arguments

core/src/main/scala/chisel3/BitsImpl.scala

@@ -2,6 +2,7 @@
 
 package chisel3
 
+import chisel3.Data.DataExtensions
 import chisel3.experimental.{requireIsHardware, SourceInfo}
 import chisel3.internal.{_resizeToWidth, throwException, BaseModule}
 import chisel3.internal.Builder.pushOp
@@ -21,9 +22,9 @@ private[chisel3] trait BitsImpl extends Element { self: Bits =>
   // Arguments against: generates down to a FIRRTL UInt anyways
 
   // Only used for in a few cases, hopefully to be removed
-  private[chisel3] def cloneTypeWidth(width: Width): this.type
+  private[chisel3] def cloneTypeWidth(width: Width): Bits
 
-  def cloneType: this.type = cloneTypeWidth(this.width)
+  override def _cloneType: Data = cloneTypeWidth(this.width)
 
   /** A non-ambiguous name of this `Bits` instance for use in generated Verilog names
     * Inserts the width directly after the typeName, e.g. UInt4, SInt1
@@ -167,7 +168,7 @@ private[chisel3] trait BitsImpl extends Element { self: Bits =>
   // Pad literal to that width
   protected def _padLit(that: Int): this.type
 
-  protected def _padImpl(that: Int)(implicit sourceInfo: SourceInfo): this.type = this.width match {
+  protected def _padImpl(that: Int)(implicit sourceInfo: SourceInfo): Bits = this.width match {
     case KnownWidth(w) if w >= that => this
     case _ if this.isLit            => this._padLit(that)
     case _                          => binop(sourceInfo, cloneTypeWidth(this.width.max(Width(that))), PadOp, that)
@@ -222,8 +223,7 @@ private[chisel3] trait UIntImpl extends BitsImpl with Num[UInt] { self: UInt =>
     }
   }
 
-  private[chisel3] override def cloneTypeWidth(w: Width): this.type =
-    new UInt(w).asInstanceOf[this.type]
+  private[chisel3] override def cloneTypeWidth(w: Width): UInt = new UInt(w)
 
   override protected def _padLit(that: Int): this.type = {
     val value = this.litValue
@@ -403,8 +403,7 @@ private[chisel3] trait SIntImpl extends BitsImpl with Num[SInt] { self: SInt =>
     }
   }
 
-  private[chisel3] override def cloneTypeWidth(w: Width): this.type =
-    new SInt(w).asInstanceOf[this.type]
+  private[chisel3] override def cloneTypeWidth(w: Width): SInt = new SInt(w)
 
   override protected def _padLit(that: Int): this.type = {
     val value = this.litValue
@@ -529,7 +528,7 @@ private[chisel3] trait ResetTypeImpl extends Element { self: Reset =>
 
   override def toString: String = stringAccessor("Reset")
 
-  def cloneType: this.type = Reset().asInstanceOf[this.type]
+  override def _cloneType: Data = Reset()
 
   override def litOption: Option[BigInt] = None
 
@@ -558,7 +557,7 @@ private[chisel3] trait AsyncResetImpl extends Element { self: AsyncReset =>
 
   override def toString: String = stringAccessor("AsyncReset")
 
-  def cloneType: this.type = AsyncReset().asInstanceOf[this.type]
+  override def _cloneType: Data = AsyncReset()
 
   override def litOption: Option[BigInt] = None
 
@@ -599,9 +598,9 @@ private[chisel3] trait BoolImpl extends UIntImpl { self: Bool =>
     }
   }
 
-  private[chisel3] override def cloneTypeWidth(w: Width): this.type = {
+  private[chisel3] override def cloneTypeWidth(w: Width): Bool = {
     require(!w.known || w.get == 1)
-    new Bool().asInstanceOf[this.type]
+    new Bool()
   }
 
   /** Convert to a [[scala.Option]] of [[scala.Boolean]] */

core/src/main/scala/chisel3/ChiselEnumImpl.scala

@@ -30,7 +30,7 @@ private[chisel3] abstract class EnumTypeImpl(private[chisel3] val factory: Chise
     }
   }
 
-  override def cloneType: this.type = factory().asInstanceOf[this.type]
+  override def _cloneType: Data = factory()
 
   private[chisel3] def compop(sourceInfo: SourceInfo, op: PrimOp, other: EnumType): Bool = {
     requireIsHardware(this, "bits operated on")

core/src/main/scala/chisel3/ClockImpl.scala

@@ -13,7 +13,7 @@ private[chisel3] trait ClockImpl extends Element {
 
   override def toString: String = stringAccessor("Clock")
 
-  def cloneType: this.type = Clock().asInstanceOf[this.type]
+  override def _cloneType: Data = Clock()
 
   override def connect(that: Data)(implicit sourceInfo: SourceInfo): Unit =
     that match {

core/src/main/scala/chisel3/DataImpl.scala

@@ -4,6 +4,7 @@ package chisel3
 
 import chisel3.experimental.dataview.reify
 
+import chisel3.Data.DataExtensions
 import chisel3.experimental.{requireIsChiselType, requireIsHardware, Analog, BaseModule}
 import chisel3.experimental.{prefix, SourceInfo, UnlocatableSourceInfo}
 import chisel3.experimental.dataview.{reifyIdentityView, reifySingleTarget, DataViewable}
@@ -781,28 +782,12 @@ private[chisel3] trait DataImpl extends HasId with NamedComponent { self: Data =
   private[chisel3] def width: Width
   private[chisel3] def firrtlConnect(that: Data)(implicit sourceInfo: SourceInfo): Unit
 
-  /** Internal API; Chisel users should look at chisel3.chiselTypeOf(...).
+  /** Private implementation of cloneType
     *
-    * cloneType must be defined for any Chisel object extending Data.
-    * It is responsible for constructing a basic copy of the object being cloned.
-    *
-    * @return a copy of the object.
-    */
-  def cloneType: this.type
-
-  /** Internal API; Chisel users should look at chisel3.chiselTypeOf(...).
-    *
-    * Returns a copy of this data type, with hardware bindings (if any) removed.
-    * Directionality data and probe information is still preserved.
+    * _cloneType must be defined for any Chisel object extending Data.
+    * It is implemented by Chisel itself or by the compiler plugin for user-defined types.
     */
-  private[chisel3] def cloneTypeFull: this.type = {
-    val clone = this.cloneType // get a fresh object, without bindings
-    // Only the top-level direction needs to be fixed up, cloneType should do the rest
-    clone.specifiedDirection = specifiedDirection
-    probe.setProbeModifier(clone, probeInfo)
-    clone.isConst = isConst
-    clone
-  }
+  def _cloneType: Data
 
   /** The "strong connect" operator.
     *
@@ -994,6 +979,7 @@ private[chisel3] trait ObjectDataImpl {
     *
     * @param lhs The [[Data]] hardware on the left-hand side of the equality
     */
+  // TODO fold this into DataExtensions
   implicit class DataEquality[T <: Data](lhs: T)(implicit sourceInfo: SourceInfo) {
 
     /** Dynamic recursive equality operator for generic [[Data]]
@@ -1072,6 +1058,33 @@ private[chisel3] trait ObjectDataImpl {
       }
     }
   }
+
+  implicit class DataExtensions[T <: Data](self: T) {
+
+    /** Internal API; Chisel users should look at chisel3.chiselTypeOf(...).
+      *
+      * cloneType must be defined for any Chisel object extending Data.
+      * It is responsible for constructing a basic copy of the object being cloned.
+      *
+      * @return a copy of the object.
+      */
+    def cloneType: T = self._cloneType.asInstanceOf[T]
+
+    /** Internal API; Chisel users should look at chisel3.chiselTypeOf(...).
+      *
+      * Returns a copy of this data type, with hardware bindings (if any) removed.
+      * Directionality data and probe information is still preserved.
+      */
+    private[chisel3] def cloneTypeFull: T = {
+      val clone = self.cloneType // get a fresh object, without bindings
+      // Only the top-level direction needs to be fixed up, cloneType should do the rest
+      clone.specifiedDirection = self.specifiedDirection
+      // TODO do we need to exclude probe and const from cloneTypeFull on Properties?
+      probe.setProbeModifier(clone, self.probeInfo)
+      clone.isConst = self.isConst
+      clone.asInstanceOf[T]
+    }
+  }
 }
 
 trait WireFactory {
@@ -1243,7 +1256,8 @@ final case object DontCare extends Element with connectable.ConnectableDocs {
   private[chisel3] override val width: Width = UnknownWidth
 
   bind(DontCareBinding(), SpecifiedDirection.Output)
-  override def cloneType: this.type = DontCare
+
+  override def _cloneType: Data = DontCare
 
   override def toString: String = "DontCare()"
 

core/src/main/scala/chisel3/IO.scala

@@ -1,5 +1,6 @@
 package chisel3
 
+import chisel3.Data.DataExtensions
 import chisel3.internal.{throwException, Builder}
 import chisel3.experimental.{noPrefix, requireIsChiselType, SourceInfo}
 import chisel3.properties.{Class, Property}

core/src/main/scala/chisel3/Intrinsic.scala

@@ -3,6 +3,7 @@
 package chisel3
 
 import chisel3._
+import chisel3.Data.DataExtensions
 import chisel3.experimental.{requireIsChiselType, Param, SourceInfo}
 import chisel3.internal.firrtl.ir._
 import chisel3.internal.Builder

core/src/main/scala/chisel3/MemImpl.scala

@@ -9,6 +9,7 @@ import chisel3.internal.binding._
 import chisel3.internal.Builder.pushCommand
 import chisel3.internal.firrtl.ir._
 import chisel3.experimental.{requireIsChiselType, requireIsHardware, SourceInfo, SourceLine}
+import chisel3.Data.DataExtensions
 
 private[chisel3] trait ObjectMemImpl {
 

core/src/main/scala/chisel3/ModuleImpl.scala

@@ -28,6 +28,7 @@ import chisel3.internal.plugin.autoNameRecursively
 import chisel3.util.simpleClassName
 import chisel3.experimental.{annotate, ChiselAnnotation}
 import chisel3.experimental.hierarchy.Hierarchy
+import chisel3.Data.DataExtensions
 
 private[chisel3] trait ObjectModuleImpl {
 
@@ -370,7 +371,7 @@ package internal {
     private[chisel3] class ClonePorts(elts: (String, Data)*) extends Record {
       val elements: ListMap[String, Data] = ListMap(elts.map { case (name, d) => name -> d.cloneTypeFull }: _*)
       def apply(field: String) = elements(field)
-      override def cloneType = (new ClonePorts(elts: _*)).asInstanceOf[this.type]
+      override protected def _cloneTypeImpl: Record = (new ClonePorts(elts: _*))
     }
 
     private[chisel3] def cloneIORecord(