Avoid making unnecessary clones during binding

core/src/main/scala/chisel3/Aggregate.scala

@@ -1302,8 +1302,18 @@ abstract class Bundle(implicit compileOptions: CompileOptions) extends Record {
         )
       }
     }
+  }
 
+  private case class memoVal[T](var value: Option[T], val fn: () => T) {
+    def get(): T = {
+      if (value.isEmpty) {
+        value = Some(fn())
+      }
+      value.get
+    }
   }
+  private var externalRef = memoVal[Boolean](None, () => elements.exists(_._2._id < _id))
+  private[chisel3] def hasExternalRef(): Boolean = externalRef.get()
 
   override def cloneType: this.type = {
     val clone = _cloneTypeImpl.asInstanceOf[this.type]

core/src/main/scala/chisel3/Data.scala

@@ -55,16 +55,18 @@ object SpecifiedDirection {
     }
 
   private[chisel3] def specifiedDirection[T <: Data](
-    source: T
-  )(dir:    SpecifiedDirection
+    source: => T
+  )(dir:    T => SpecifiedDirection
   )(
     implicit compileOptions: CompileOptions
   ): T = {
+    val prevId = Builder.idGen.value
+    val data = source // evaluate source once (passed by name)
     if (compileOptions.checkSynthesizable) {
-      requireIsChiselType(source)
+      requireIsChiselType(data)
     }
-    val out = source.cloneType.asInstanceOf[T]
-    out.specifiedDirection = dir
+    val out = if (!data.mustClone(prevId)) data else data.cloneType.asInstanceOf[T]
+    out.specifiedDirection = dir(out)
     out
   }
 
@@ -427,19 +429,19 @@ object chiselTypeOf {
   * Thus, an error will be thrown if these are used on bound Data
   */
 object Input {
-  def apply[T <: Data](source: T)(implicit compileOptions: CompileOptions): T = {
-    SpecifiedDirection.specifiedDirection(source)(SpecifiedDirection.Input)
+  def apply[T <: Data](source: => T)(implicit compileOptions: CompileOptions): T = {
+    SpecifiedDirection.specifiedDirection(source)(_ => SpecifiedDirection.Input)
   }
 }
 object Output {
-  def apply[T <: Data](source: T)(implicit compileOptions: CompileOptions): T = {
-    SpecifiedDirection.specifiedDirection(source)(SpecifiedDirection.Output)
+  def apply[T <: Data](source: => T)(implicit compileOptions: CompileOptions): T = {
+    SpecifiedDirection.specifiedDirection(source)(_ => SpecifiedDirection.Output)
   }
 }
 
 object Flipped {
-  def apply[T <: Data](source: T)(implicit compileOptions: CompileOptions): T = {
-    SpecifiedDirection.specifiedDirection(source)(SpecifiedDirection.flip(source.specifiedDirection))
+  def apply[T <: Data](source: => T)(implicit compileOptions: CompileOptions): T = {
+    SpecifiedDirection.specifiedDirection(source)(x => SpecifiedDirection.flip(x.specifiedDirection))
   }
 }
 
@@ -462,6 +464,19 @@ abstract class Data extends HasId with NamedComponent with SourceInfoDoc {
     }
   }
 
+  // must clone a data if
+  // * it has a binding
+  // * its id is older than prevId (not "freshly created")
+  // * it is a bundle with a non-fresh member (external reference)
+  private[chisel3] def mustClone(prevId: Long): Boolean = {
+    if (this.hasBinding || this._id <= prevId) true
+    else
+      this match {
+        case b: Bundle => b.hasExternalRef()
+        case _ => false
+      }
+  }
+
   override def autoSeed(name: String): this.type = {
     topBindingOpt match {
       // Ports are special in that the autoSeed will keep the first name, not the last name
@@ -475,13 +490,6 @@ abstract class Data extends HasId with NamedComponent with SourceInfoDoc {
   private var _specifiedDirection:         SpecifiedDirection = SpecifiedDirection.Unspecified
   private[chisel3] def specifiedDirection: SpecifiedDirection = _specifiedDirection
   private[chisel3] def specifiedDirection_=(direction: SpecifiedDirection) = {
-    if (_specifiedDirection != SpecifiedDirection.Unspecified) {
-      this match {
-        // Anything flies in compatibility mode
-        case t: Record if !t.compileOptions.dontAssumeDirectionality =>
-        case _ => throw RebindingException(s"Attempted reassignment of user-specified direction to $this")
-      }
-    }
     _specifiedDirection = direction
   }
 
@@ -511,6 +519,8 @@ abstract class Data extends HasId with NamedComponent with SourceInfoDoc {
     _binding = Some(target)
   }
 
+  private[chisel3] def hasBinding: Boolean = _binding.isDefined
+
   // Similar to topBindingOpt except it explicitly excludes SampleElements which are bound but not
   // hardware
   private[chisel3] final def isSynthesizable: Boolean = _binding.map {
@@ -882,11 +892,13 @@ trait WireFactory {
   /** Construct a [[Wire]] from a type template
     * @param t The template from which to construct this wire
     */
-  def apply[T <: Data](t: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T = {
+  def apply[T <: Data](source: => T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T = {
+    val prevId = Builder.idGen.value
+    val t = source // evaluate once (passed by name)
     if (compileOptions.declaredTypeMustBeUnbound) {
       requireIsChiselType(t, "wire type")
     }
-    val x = t.cloneTypeFull
+    val x = if (!t.mustClone(prevId)) t else t.cloneTypeFull
 
     // Bind each element of x to being a Wire
     x.bind(WireBinding(Builder.forcedUserModule, Builder.currentWhen))

core/src/main/scala/chisel3/Module.scala

@@ -187,21 +187,26 @@ package experimental {
       * requested (so that all calls to ports will return the same information).
       * Internal API.
       */
-    def apply[T <: Data](iodef: T): T = {
+    def apply[T <: Data](iodef: => T): T = {
       val module = Module.currentModule.get // Impossible to fail
       require(!module.isClosed, "Can't add more ports after module close")
-      requireIsChiselType(iodef, "io type")
+      val prevId = Builder.idGen.value
+      val data = iodef // evaluate once (passed by name)
+      requireIsChiselType(data, "io type")
 
       // Clone the IO so we preserve immutability of data types
+      // Note: we don't clone if the data is fresh (to avoid unnecessary clones)
       val iodefClone =
-        try {
-          iodef.cloneTypeFull
-        } catch {
-          // For now this is going to be just a deprecation so we don't suddenly break everyone's code
-          case e: AutoClonetypeException =>
-            Builder.deprecated(e.getMessage, Some(s"${iodef.getClass}"))
-            iodef
-        }
+        if (!data.mustClone(prevId)) data
+        else
+          try {
+            data.cloneTypeFull
+          } catch {
+            // For now this is going to be just a deprecation so we don't suddenly break everyone's code
+            case e: AutoClonetypeException =>
+              Builder.deprecated(e.getMessage, Some(s"${data.getClass}"))
+              data
+          }
       module.bindIoInPlace(iodefClone)
       iodefClone
     }
@@ -568,7 +573,7 @@ package experimental {
       * TODO(twigg): Specifically walk the Data definition to call out which nodes
       * are problematic.
       */
-    protected def IO[T <: Data](iodef: T): T = chisel3.experimental.IO.apply(iodef)
+    protected def IO[T <: Data](iodef: => T): T = chisel3.experimental.IO.apply(iodef)
 
     //
     // Internal Functions

core/src/main/scala/chisel3/Reg.scala

@@ -34,18 +34,19 @@ object Reg {
     * Value will not change unless the [[Reg]] is given a connection.
     * @param t The template from which to construct this wire
     */
-  def apply[T <: Data](t: T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T = {
+  def apply[T <: Data](source: => T)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T = {
+    val prevId = Builder.idGen.value
+    val t = source // evaluate once (passed by name)
     if (compileOptions.declaredTypeMustBeUnbound) {
       requireIsChiselType(t, "reg type")
     }
-    val reg = t.cloneTypeFull
+    val reg = if (!t.mustClone(prevId)) t else t.cloneTypeFull
     val clock = Node(Builder.forcedClock)
 
     reg.bind(RegBinding(Builder.forcedUserModule, Builder.currentWhen))
     pushCommand(DefReg(sourceInfo, reg, clock))
     reg
   }
-
 }
 
 /** Utility for constructing one-cycle delayed versions of signals

src/test/scala/chiselTests/CompatibilitySpec.scala

@@ -20,7 +20,7 @@ object CompatibilityCustomCompileOptions {
   }
 }
 
-class CompatibiltySpec extends ChiselFlatSpec with ScalaCheckDrivenPropertyChecks with Utils {
+class CompatibilitySpec extends ChiselFlatSpec with ScalaCheckDrivenPropertyChecks with Utils {
   import Chisel._
 
   behavior.of("Chisel compatibility layer")

src/test/scala/chiselTests/LazyCloneSpec.scala

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package chiselTests
+
+import chisel3._
+import chisel3.stage.ChiselStage
+import chiselTests.ChiselFlatSpec
+
+class LazyCloneSpec extends ChiselFlatSpec {
+  behavior.of("LazyClone")
+
+  it should "lazily clone" in {
+    object Foo {
+      var count = 0L
+    }
+
+    class Foo extends Bundle {
+      val a = UInt(8.W)
+      Foo.count += 1
+    }
+
+    class MyModule extends RawModule {
+      val io = IO(Flipped(new Bundle {
+        val foo = Output(new Foo)
+        val bar = Input(new Foo)
+      }))
+    }
+    ChiselStage.elaborate(new MyModule)
+    println(s"copies: ${Foo.count}")
+    Foo.count should be < 12L
+  }
+}