Improved Chisel Naming via Compiler Plugins + Prefixing (#1448)

Added prefixing and a compiler plugin to improve naming. Only works for Scala 2.12 and above.

Co-authored-by: Jack Koenig <koenig@sifive.com>

18 files changed, 1111 insertions, 46 deletions

diff --git a/build.sbt b/build.sbt
index ea0c0a15..74406b2b 100644
--- a/build.sbt
+++ b/build.sbt
@@ -125,6 +125,54 @@ lazy val chiselSettings = Seq (
   }
 )
 
+autoCompilerPlugins := true
+
+// Plugin must be fully cross-versioned (published for Scala minor version)
+// The plugin only works in Scala 2.12+
+lazy val pluginScalaVersions = Seq(
+  "2.11.12", // Only to support chisel3 cross building for 2.11, plugin does nothing in 2.11
+  // scalamacros paradise version used is not published for 2.12.0 and 2.12.1
+  "2.12.2",
+  "2.12.3",
+  "2.12.4",
+  "2.12.5",
+  "2.12.6",
+  "2.12.7",
+  "2.12.8",
+  "2.12.9",
+  "2.12.10",
+  "2.12.11"
+)
+
+lazy val plugin = (project in file("plugin")).
+  settings(name := "chisel3-plugin").
+  settings(commonSettings: _*).
+  settings(publishSettings: _*).
+  settings(
+    libraryDependencies += "org.scala-lang" % "scala-compiler" % scalaVersion.value,
+    scalacOptions += "-Xfatal-warnings",
+    crossScalaVersions := pluginScalaVersions,
+    // Must be published for Scala minor version
+    crossVersion := CrossVersion.full,
+    crossTarget := {
+      // workaround for https://github.com/sbt/sbt/issues/5097
+      target.value / s"scala-${scalaVersion.value}"
+    },
+    // Only publish for Scala 2.12
+    publish / skip := !scalaVersion.value.startsWith("2.12")
+  )
+
+lazy val usePluginSettings = Seq(
+  scalacOptions in Compile ++= {
+    val jar = (plugin / Compile / Keys.`package`).value
+    val addPlugin = "-Xplugin:" + jar.getAbsolutePath
+    // add plugin timestamp to compiler options to trigger recompile of
+    // main after editing the plugin. (Otherwise a 'clean' is needed.)
+    val dummy = "-Jdummy=" + jar.lastModified
+    Seq(addPlugin, dummy)
+  }
+)
+
 lazy val macros = (project in file("macros")).
   settings(name := "chisel3-macros").
   settings(commonSettings: _*).
@@ -162,9 +210,10 @@ lazy val chisel = (project in file(".")).
   settings(commonSettings: _*).
   settings(chiselSettings: _*).
   settings(publishSettings: _*).
+  settings(usePluginSettings: _*).
   dependsOn(macros).
   dependsOn(core).
-  aggregate(macros, core).
+  aggregate(macros, core, plugin).
   settings(
     scalacOptions in Test ++= Seq("-language:reflectiveCalls"),
     scalacOptions in Compile in doc ++= Seq(
diff --git a/core/src/main/scala/chisel3/Data.scala b/core/src/main/scala/chisel3/Data.scala
index 46c98bae..983307a6 100644
--- a/core/src/main/scala/chisel3/Data.scala
+++ b/core/src/main/scala/chisel3/Data.scala
@@ -283,6 +283,14 @@ abstract class Data extends HasId with NamedComponent with SourceInfoDoc {
     }
   }
 
+  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
+      case Some(PortBinding(m)) if hasAutoSeed && Builder.currentModule.contains(m) => this
+      case _ => super.autoSeed(name)
+    }
+  }
+
   // User-specified direction, local at this node only.
   // Note that the actual direction of this node can differ from child and parent specifiedDirection.
   private var _specifiedDirection: SpecifiedDirection = SpecifiedDirection.Unspecified
@@ -490,7 +498,11 @@ abstract class Data extends HasId with NamedComponent with SourceInfoDoc {
     * @param that the $coll to connect to
     * @group Connect
     */
-  final def := (that: Data)(implicit sourceInfo: SourceInfo, connectionCompileOptions: CompileOptions): Unit = this.connect(that)(sourceInfo, connectionCompileOptions)
+  final def := (that: => Data)(implicit sourceInfo: SourceInfo, connectionCompileOptions: CompileOptions): Unit = {
+    prefix(this) {
+      this.connect(that)(sourceInfo, connectionCompileOptions)
+    }
+  }
 
   /** Connect this $coll to that $coll bi-directionally and element-wise.
     *
@@ -499,7 +511,11 @@ abstract class Data extends HasId with NamedComponent with SourceInfoDoc {
     * @param that the $coll to connect to
     * @group Connect
     */
-  final def <> (that: Data)(implicit sourceInfo: SourceInfo, connectionCompileOptions: CompileOptions): Unit = this.bulkConnect(that)(sourceInfo, connectionCompileOptions)
+  final def <> (that: => Data)(implicit sourceInfo: SourceInfo, connectionCompileOptions: CompileOptions): Unit = {
+    prefix(this) {
+      this.bulkConnect(that)(sourceInfo, connectionCompileOptions)
+    }
+  }
 
   @chiselRuntimeDeprecated
   @deprecated("litArg is deprecated, use litOption or litTo*Option", "3.2")
diff --git a/core/src/main/scala/chisel3/Module.scala b/core/src/main/scala/chisel3/Module.scala
index 140e3003..25037b00 100644
--- a/core/src/main/scala/chisel3/Module.scala
+++ b/core/src/main/scala/chisel3/Module.scala
@@ -41,6 +41,8 @@ object Module extends SourceInfoDoc {
 
     // Save then clear clock and reset to prevent leaking scope, must be set again in the Module
     val (saveClock, saveReset)  = (Builder.currentClock, Builder.currentReset)
+    val savePrefix = Builder.getPrefix()
+    Builder.clearPrefix()
     Builder.currentClock = None
     Builder.currentReset = None
 
@@ -67,6 +69,8 @@ object Module extends SourceInfoDoc {
     val component = module.generateComponent()
     Builder.components += component
 
+    Builder.setPrefix(savePrefix)
+
     // Handle connections at enclosing scope
     if(!Builder.currentModule.isEmpty) {
       pushCommand(DefInstance(sourceInfo, module, component.ports))
diff --git a/core/src/main/scala/chisel3/RawModule.scala b/core/src/main/scala/chisel3/RawModule.scala
index 0fcec266..5b609384 100644
--- a/core/src/main/scala/chisel3/RawModule.scala
+++ b/core/src/main/scala/chisel3/RawModule.scala
@@ -42,7 +42,7 @@ abstract class RawModule(implicit moduleCompileOptions: CompileOptions)
 
   private[chisel3] def namePorts(names: HashMap[HasId, String]): Unit = {
     for (port <- getModulePorts) {
-      port.suggestedName.orElse(names.get(port)) match {
+      port.computeName(None, None).orElse(names.get(port)) match {
         case Some(name) =>
           if (_namespace.contains(name)) {
             Builder.error(s"""Unable to name port $port to "$name" in $this,""" +
@@ -75,13 +75,21 @@ abstract class RawModule(implicit moduleCompileOptions: CompileOptions)
     // All suggestions are in, force names to every node.
     for (id <- getIds) {
       id match {
-        case id: BaseModule => id.forceName(default=id.desiredName, _namespace)
-        case id: MemBase[_] => id.forceName(default="_T", _namespace)
+        case id: BaseModule => id.forceName(None, default=id.desiredName, _namespace)
+        case id: MemBase[_] => id.forceName(None, default="MEM", _namespace)
         case id: Data  =>
           if (id.isSynthesizable) {
             id.topBinding match {
-              case OpBinding(_) | MemoryPortBinding(_) | PortBinding(_) | RegBinding(_) | WireBinding(_) =>
-                id.forceName(default="_T", _namespace)
+              case OpBinding(_) =>
+                id.forceName(Some(""), default="T", _namespace)
+              case MemoryPortBinding(_) =>
+                id.forceName(None, default="MPORT", _namespace)
+              case PortBinding(_) =>
+                id.forceName(None, default="PORT", _namespace)
+              case RegBinding(_) =>
+                id.forceName(None, default="REG", _namespace)
+              case WireBinding(_) =>
+                id.forceName(Some(""), default="WIRE", _namespace)
               case _ =>  // don't name literals
             }
           } // else, don't name unbound types
@@ -152,8 +160,8 @@ trait RequireSyncReset extends MultiIOModule {
 abstract class MultiIOModule(implicit moduleCompileOptions: CompileOptions)
     extends RawModule {
   // Implicit clock and reset pins
-  final val clock: Clock = IO(Input(Clock()))
-  final val reset: Reset = IO(Input(mkReset))
+  final val clock: Clock = IO(Input(Clock())).autoSeed("clock")
+  final val reset: Reset = IO(Input(mkReset)).autoSeed("reset")
 
   private[chisel3] def mkReset: Reset = {
     // Top module and compatibility mode use Bool for reset
@@ -164,6 +172,7 @@ abstract class MultiIOModule(implicit moduleCompileOptions: CompileOptions)
   // Setup ClockAndReset
   Builder.currentClock = Some(clock)
   Builder.currentReset = Some(reset)
+  Builder.clearPrefix()
 
   private[chisel3] override def initializeInParent(parentCompileOptions: CompileOptions): Unit = {
     implicit val sourceInfo = UnlocatableSourceInfo
diff --git a/core/src/main/scala/chisel3/SeqUtils.scala b/core/src/main/scala/chisel3/SeqUtils.scala
index 9f09b2c2..9f068898 100644
--- a/core/src/main/scala/chisel3/SeqUtils.scala
+++ b/core/src/main/scala/chisel3/SeqUtils.scala
@@ -3,7 +3,7 @@
 package chisel3
 
 import chisel3.experimental.FixedPoint
-import chisel3.internal.throwException
+import chisel3.internal.{prefix, throwException}
 
 import scala.language.experimental.macros
 import chisel3.internal.sourceinfo._
@@ -23,8 +23,12 @@ private[chisel3] object SeqUtils {
     if (in.tail.isEmpty) {
       in.head.asUInt
     } else {
-      val left = asUInt(in.slice(0, in.length/2))
-      val right = asUInt(in.slice(in.length/2, in.length))
+      val left = prefix("left") {
+        asUInt(in.slice(0, in.length/2))
+      }.autoSeed("left")
+      val right = prefix("right") {
+        asUInt(in.slice(in.length/2, in.length))
+      }.autoSeed("right")
       right ## left
     }
   }
diff --git a/core/src/main/scala/chisel3/experimental/package.scala b/core/src/main/scala/chisel3/experimental/package.scala
index da103318..71fd186c 100644
--- a/core/src/main/scala/chisel3/experimental/package.scala
+++ b/core/src/main/scala/chisel3/experimental/package.scala
@@ -136,4 +136,18 @@ package object experimental {
       }
     }
   }
+
+  // Use to add a prefix to any component generated in input scope
+  val prefix = chisel3.internal.prefix
+  // Use to remove prefixes not in provided scope
+  val noPrefix = chisel3.internal.noPrefix
+  // Used by Chisel's compiler plugin to automatically name signals
+  def autoNameRecursively[T <: Any](name: String, nameMe: T): T = {
+    chisel3.internal.Builder.nameRecursively(
+      name.replace(" ", ""),
+      nameMe,
+      (id: chisel3.internal.HasId, n: String) => id.autoSeed(n)
+    )
+    nameMe
+  }
 }
diff --git a/core/src/main/scala/chisel3/internal/Builder.scala b/core/src/main/scala/chisel3/internal/Builder.scala
index 510919bc..ceb14900 100644
--- a/core/src/main/scala/chisel3/internal/Builder.scala
+++ b/core/src/main/scala/chisel3/internal/Builder.scala
@@ -9,6 +9,7 @@ import chisel3.experimental._
 import chisel3.internal.firrtl._
 import chisel3.internal.naming._
 import _root_.firrtl.annotations.{CircuitName, ComponentName, IsMember, ModuleName, Named, ReferenceTarget}
+import chisel3.internal.Builder.Prefix
 
 import scala.collection.mutable
 
@@ -88,25 +89,133 @@ private[chisel3] trait HasId extends InstanceId {
   override def hashCode: Int = super.hashCode()
   override def equals(that: Any): Boolean = super.equals(that)
 
-  // Facilities for 'suggesting' a name to this.
-  // Post-name hooks called to carry the suggestion to other candidates as needed
-  private var suggested_name: Option[String] = None
-  private val postname_hooks = scala.collection.mutable.ListBuffer.empty[String=>Unit]
-  // Only takes the first suggestion!
-  def suggestName(name: =>String): this.type = {
-    if(suggested_name.isEmpty) suggested_name = Some(name)
-    for(hook <- postname_hooks) { hook(name) }
+  // Contains suggested seed (user-decided seed)
+  private var suggested_seed: Option[String] = None
+
+  // Contains the seed computed automatically by the compiler plugin
+  private var auto_seed: Option[String] = None
+
+  // Prefix at time when this class is constructed
+  private val construction_prefix: Prefix = Builder.getPrefix()
+
+  // Prefix when the latest [[suggestSeed]] or [[autoSeed]] is called
+  private var prefix_seed: Prefix = List.empty[Either[String, Data]]
+
+  // Post-seed hooks called to carry the suggested seeds to other candidates as needed
+  private val suggest_postseed_hooks = scala.collection.mutable.ListBuffer.empty[String=>Unit]
+
+  // Post-seed hooks called to carry the auto seeds to other candidates as needed
+  private val auto_postseed_hooks = scala.collection.mutable.ListBuffer.empty[String=>Unit]
+
+  /** Takes the last seed suggested. Multiple calls to this function will take the last given seed, unless
+    * this HasId is a module port (see overridden method in Data.scala).
+    *
+    * If the final computed name conflicts with the final name of another signal, the final name may get uniquified by
+    * appending a digit at the end of the name.
+    *
+    * Is a lower priority than [[suggestName]], in that regardless of whether [[autoSeed]]
+    * was called, [[suggestName]] will always take precedence if it was called.
+ *
+    * @param seed Seed for the name of this component
+    * @return this object
+    */
+  def autoSeed(seed: String): this.type = {
+    auto_seed = Some(seed)
+    for(hook <- auto_postseed_hooks) { hook(seed) }
+    prefix_seed = Builder.getPrefix()
     this
   }
-  private[chisel3] def suggestedName: Option[String] = suggested_name
-  private[chisel3] def addPostnameHook(hook: String=>Unit): Unit = postname_hooks += hook
+
+  /** Takes the first seed suggested. Multiple calls to this function will be ignored.
+    * If the final computed name conflicts with another name, it may get uniquified by appending
+    * a digit at the end.
+    *
+    * Is a higher priority than [[autoSeed]], in that regardless of whether [[autoSeed]]
+    * was called, [[suggestName]] will always take precedence.
+ *
+    * @param seed The seed for the name of this component
+    * @return this object
+    */
+  def suggestName(seed: =>String): this.type = {
+    if(suggested_seed.isEmpty) suggested_seed = Some(seed)
+    prefix_seed = Builder.getPrefix()
+    for(hook <- suggest_postseed_hooks) { hook(seed) }
+    this
+  }
+
+  /** Computes the name of this HasId, if one exists
+    * @param defaultPrefix Optionally provide a default prefix for computing the name
+    * @param defaultSeed Optionally provide default seed for computing the name
+    * @return the name, if it can be computed
+    */
+  def computeName(defaultPrefix: Option[String], defaultSeed: Option[String]): Option[String] = {
+    // Recursively builds a name if referenced fields of an aggregate type
+    def buildAggName(id: HasId): Option[String] = {
+      def recArg(node: Arg): Option[String] = node match {
+        case Slot(imm, name) => recArg(imm).map(_ + "_" + name)
+        case Index(imm, ILit(num)) => recArg(imm).map(_ + "_" + num)
+        case Index(imm, n: LitArg) => recArg(imm).map(_ + "_" + n.num)
+        case Index(imm, _: Node) => recArg(imm)
+        case Node(id) => recArg(id.getOptionRef.get)
+        case Ref(name) => Some(name)
+        case ModuleIO(mod, name) if _parent.contains(mod) => Some(name)
+        case ModuleIO(mod, name) => recArg(mod.getRef).map(_ + "_" + name)
+      }
+      id.getOptionRef.flatMap(recArg)
+    }
+
+    /** Computes a name of this signal, given the seed and prefix
+      * @param seed
+      * @param prefix
+      * @return
+      */
+    def buildName(seed: String, prefix: Prefix): String = {
+      val builder = new StringBuilder()
+      prefix.foreach {
+        case Left(s: String) => builder ++= s + "_"
+        case Right(d: HasId) =>
+          buildAggName(d) match {
+            case Some(n) => builder ++= n + "_"
+            case _ =>
+          }
+        case _ =>
+      }
+      builder ++= seed
+      builder.toString
+    }
+
+    if(hasSeed) {
+      Some(buildName(seedOpt.get, prefix_seed))
+    } else {
+      defaultSeed.map { default =>
+        defaultPrefix match {
+          case Some(p) => buildName(default, Left(p) +: construction_prefix)
+          case None => buildName(default, construction_prefix)
+        }
+      }
+    }
+  }
+
+  /** This resolves the precedence of [[autoSeed]] and [[suggestName]]
+ *
+    * @return the current calculation of a name, if it exists
+    */
+  private[chisel3] def seedOpt: Option[String] = suggested_seed.orElse(auto_seed)
+
+  /** @return Whether either autoName or suggestName has been called */
+  def hasSeed: Boolean = seedOpt.isDefined
+
+  private[chisel3] def hasAutoSeed: Boolean = auto_seed.isDefined
+
+  private[chisel3] def addSuggestPostnameHook(hook: String=>Unit): Unit = suggest_postseed_hooks += hook
+  private[chisel3] def addAutoPostnameHook(hook: String=>Unit): Unit = auto_postseed_hooks += hook
 
   // Uses a namespace to convert suggestion into a true name
   // Will not do any naming if the reference already assigned.
   // (e.g. tried to suggest a name to part of a Record)
-  private[chisel3] def forceName(default: =>String, namespace: Namespace): Unit =
+  private[chisel3] def forceName(prefix: Option[String], default: =>String, namespace: Namespace): Unit =
     if(_ref.isEmpty) {
-      val candidate_name = suggested_name.getOrElse(default)
+      val candidate_name = computeName(prefix, Some(default)).get
       val available_name = namespace.name(candidate_name)
       setRef(Ref(available_name))
     }
@@ -124,7 +233,7 @@ private[chisel3] trait HasId extends InstanceId {
     case Some(p) => p._component match {
       case Some(c) => _ref match {
         case Some(arg) => arg fullName c
-        case None => suggested_name.getOrElse("??")
+        case None => computeName(None, None).get
       }
       case None => throwException("signalName/pathName should be called after circuit elaboration")
     }
@@ -158,9 +267,14 @@ private[chisel3] trait HasId extends InstanceId {
       }
     }
     val valNames = getValNames(this.getClass)
-    def isPublicVal(m: java.lang.reflect.Method) =
-      m.getParameterTypes.isEmpty && valNames.contains(m.getName) && !m.getDeclaringClass.isAssignableFrom(rootClass)
-    this.getClass.getMethods.sortWith(_.getName < _.getName).filter(isPublicVal(_))
+    def isPublicVal(m: java.lang.reflect.Method) = {
+      val noParameters = m.getParameterTypes.isEmpty
+      val aVal = valNames.contains(m.getName)
+      val notAssignable = !m.getDeclaringClass.isAssignableFrom(rootClass)
+      val notWeirdVal = !m.getName.contains('$')
+      noParameters && aVal && notAssignable && notWeirdVal
+    }
+    this.getClass.getMethods.filter(isPublicVal).sortWith(_.getName < _.getName)
   }
 }
 /** Holds the implementation of toNamed for Data and MemBase */
@@ -199,6 +313,9 @@ private[chisel3] class ChiselContext() {
 
   // Record the Bundle instance, class name, method name, and reverse stack trace position of open Bundles
   val bundleStack: ArrayBuffer[(Bundle, String, String, Int)] = ArrayBuffer()
+
+  // Records the different prefixes which have been scoped at this point in time
+  val prefixStack: ArrayBuffer[Either[String, HasId]] = ArrayBuffer()
 }
 
 private[chisel3] class DynamicContext() {
@@ -223,6 +340,10 @@ private[chisel3] class DynamicContext() {
 }
 
 private[chisel3] object Builder {
+
+  // Represents the current state of the prefixes given
+  type Prefix = List[Either[String, Data]]
+
   // All global mutable state must be referenced via dynamicContextVar!!
   private val dynamicContextVar = new DynamicVariable[Option[DynamicContext]](None)
   private def dynamicContext: DynamicContext = {
@@ -258,6 +379,43 @@ private[chisel3] object Builder {
   def annotations: ArrayBuffer[ChiselAnnotation] = dynamicContext.annotations
   def namingStack: NamingStack = dynamicContext.namingStack
 
+  // Puts either a prefix string or hasId onto the prefix stack
+  def pushPrefix(d: Either[String, HasId]): Unit = {
+    chiselContext.get().prefixStack += d
+  }
+
+  // Puts a prefix string onto the prefix stack
+  def pushPrefix(d: String): Unit = {
+    chiselContext.get().prefixStack += Left(d)
+  }
+
+  // Puts a prefix data onto the prefix stack
+  def pushPrefix(d: HasId): Unit = {
+    chiselContext.get().prefixStack += Right(d)
+  }
+
+  // Remove a prefix from top of the stack
+  def popPrefix(): Either[String, HasId] = {
+    val ps = chiselContext.get().prefixStack
+    ps.remove(ps.size - 1)
+  }
+
+  // Removes all prefixes from the prefix stack
+  def clearPrefix(): Unit = {
+    val ps = chiselContext.get().prefixStack
+    ps.clear()
+  }
+
+  // Clears existing prefixes and sets to new prefix stack
+  def setPrefix(prefix: Prefix): Unit = {
+    val ps = chiselContext.get().prefixStack
+    clearPrefix()
+    ps.insertAll(0, prefix)
+  }
+
+  // Returns the prefix stack at this moment
+  def getPrefix(): Prefix = chiselContext.get().prefixStack.toList.asInstanceOf[Prefix]
+
   def currentModule: Option[BaseModule] = dynamicContextVar.value match {
     case Some(dyanmicContext) => dynamicContext.currentModule
     case _ => None
@@ -411,7 +569,7 @@ private[chisel3] object Builder {
     dynamicContextVar.withValue(Some(new DynamicContext())) {
       errors.info("Elaborating design...")
       val mod = f
-      mod.forceName(mod.name, globalNamespace)
+      mod.forceName(None, mod.name, globalNamespace)
       errors.checkpoint()
       errors.info("Done elaborating.")
 
@@ -446,7 +604,7 @@ object DynamicNamingStack {
     }
     prefixRef
   }
-  
+
   def length() : Int = Builder.namingStackOption.get.length
 }
 
diff --git a/core/src/main/scala/chisel3/internal/Namer.scala b/core/src/main/scala/chisel3/internal/Namer.scala
index 999971a4..0153c0df 100644
--- a/core/src/main/scala/chisel3/internal/Namer.scala
+++ b/core/src/main/scala/chisel3/internal/Namer.scala
@@ -72,7 +72,7 @@ class NamingContext extends NamingContextInterface {
   val descendants = new IdentityHashMap[AnyRef, ListBuffer[NamingContext]]()
   val anonymousDescendants = ListBuffer[NamingContext]()
   val items = ListBuffer[(AnyRef, String)]()
-  var closed = false  // a sanity check to ensure no more name() calls are done after name_prefix
+  var closed = false  // a sanity check to ensure no more name() calls are done after namePrefix
 
   /** Adds a NamingContext object as a descendant - where its contained objects will have names
     * prefixed with the name given to the reference object, if the reference object is named in the
@@ -87,7 +87,7 @@ class NamingContext extends NamingContextInterface {
   }
 
   def name[T](obj: T, name: String): T = {
-    assert(!closed, "Can't name elements after name_prefix called")
+    assert(!closed, "Can't name elements after namePrefix called")
     obj match {
       case _: NoChiselNamePrefix => // Don't name things with NoChiselNamePrefix
       case ref: AnyRef => items += ((ref, name))
@@ -149,6 +149,6 @@ class NamingStack {
       namingStack.top.addDescendant(prefixRef, until)
     }
   }
-  
+
   def length() : Int = namingStack.length
 }
diff --git a/core/src/main/scala/chisel3/internal/firrtl/IR.scala b/core/src/main/scala/chisel3/internal/firrtl/IR.scala
index 44fdb833..1783f68f 100644
--- a/core/src/main/scala/chisel3/internal/firrtl/IR.scala
+++ b/core/src/main/scala/chisel3/internal/firrtl/IR.scala
@@ -72,11 +72,11 @@ abstract class Arg {
 case class Node(id: HasId) extends Arg {
   override def fullName(ctx: Component): String = id.getOptionRef match {
     case Some(arg) => arg.fullName(ctx)
-    case None => id.suggestedName.getOrElse("??")
+    case None => id.instanceName
   }
   def name: String = id.getOptionRef match {
     case Some(arg) => arg.name
-    case None => id.suggestedName.getOrElse("??")
+    case None => id.instanceName
   }
 }
 
diff --git a/core/src/main/scala/chisel3/internal/prefix.scala b/core/src/main/scala/chisel3/internal/prefix.scala
new file mode 100644
index 00000000..fbb1318c
--- /dev/null
+++ b/core/src/main/scala/chisel3/internal/prefix.scala
@@ -0,0 +1,84 @@
+// See LICENSE for license details.
+
+package chisel3.internal
+
+/** Use to add a prefix to any components generated in the provided scope.
+  *
+  * @example {{{
+  *
+  * val x1 = prefix("first") {
+  *   // Anything generated here will be prefixed with "first"
+  * }
+  *
+  * val x2 = prefix(mysignal) {
+  *   // Anything generated here will be prefixed with the name of mysignal
+  * }
+  *
+  * }}}
+  *
+  */
+private[chisel3] object prefix { // scalastyle:ignore
+
+  /** Use to add a prefix to any components generated in the provided scope
+    * The prefix is the name of the provided which, which may not be known yet.
+    *
+    * @param name The signal/instance whose name will be the prefix
+    * @param f a function for which any generated components are given the prefix
+    * @tparam T The return type of the provided function
+    * @return The return value of the provided function
+    */
+  def apply[T](name: HasId)(f: => T): T = {
+    Builder.pushPrefix(name)
+    val ret = f
+    Builder.popPrefix()
+    ret
+  }
+
+  /** Use to add a prefix to any components generated in the provided scope
+    * The prefix is a string, which must be known when this function is used.
+    *
+    * @param name The name which will be the prefix
+    * @param f a function for which any generated components are given the prefix
+    * @tparam T The return type of the provided function
+    * @return The return value of the provided function
+    */
+  def apply[T](name: String)(f: => T): T = {
+    Builder.pushPrefix(name)
+    val ret = f
+    // Sometimes val's can occur between the Module.apply and Module constructor
+    // This causes extra prefixes to be added, and subsequently cleared in the
+    // Module constructor. Thus, we need to just make sure if the previous push
+    // was an incorrect one, to not pop off an empty stack
+    if(Builder.getPrefix().nonEmpty) Builder.popPrefix()
+    ret
+  }
+}
+
+/** Use to eliminate any existing prefixes within the provided scope.
+  *
+  * @example {{{
+  *
+  * val x1 = noPrefix {
+  *   // Anything generated here will not be prefixed by anything outside this scope
+  * }
+  *
+  * }}}
+  *
+  */
+private[chisel3] object noPrefix {
+
+  /** Use to clear existing prefixes so no signals within the scope are prefixed by signals/names
+    * outside the scope
+    *
+    * @param f a function for which any generated components are given the prefix
+    * @tparam T The return type of the provided function
+    * @return The return value of the provided function
+    */
+  def apply[T](f: => T): T = {
+    val prefix = Builder.getPrefix()
+    Builder.clearPrefix()
+    val ret = f
+    Builder.setPrefix(prefix)
+    ret
+  }
+}
diff --git a/macros/src/main/scala/chisel3/internal/naming/NamingAnnotations.scala b/macros/src/main/scala/chisel3/internal/naming/NamingAnnotations.scala
index 88baa2b1..d8f2ff40 100644
--- a/macros/src/main/scala/chisel3/internal/naming/NamingAnnotations.scala
+++ b/macros/src/main/scala/chisel3/internal/naming/NamingAnnotations.scala
@@ -112,7 +112,7 @@ class NamingTransforms(val c: Context) {
     }
   }
 
-  /** Applies the val name transform to a class body. 
+  /** Applies the val name transform to a class body.
     * Closes context on top level or return local context to englobing context.
     * Closing context only makes sense when top level a Module.
     * A Module is always the naming top level.
@@ -128,7 +128,7 @@ class NamingTransforms(val c: Context) {
     if($globalNamingStack.length == 1){
       $contextVar.namePrefix("")
     }
-    $globalNamingStack.popReturnContext(this, $contextVar) 
+    $globalNamingStack.popReturnContext(this, $contextVar)
     """
   }
 
diff --git a/plugin/src/main/resources/scalac-plugin.xml b/plugin/src/main/resources/scalac-plugin.xml
new file mode 100644
index 00000000..b2b44fc6
--- /dev/null
+++ b/plugin/src/main/resources/scalac-plugin.xml
@@ -0,0 +1,4 @@
+<plugin>
+    <name>chiselplugin</name>
+    <classname>chisel3.plugin.ChiselPlugin</classname>
+</plugin>
diff --git a/plugin/src/main/scala-2.12/chisel3/plugin/ChiselPlugin.scala b/plugin/src/main/scala-2.12/chisel3/plugin/ChiselPlugin.scala
new file mode 100644
index 00000000..785a253d
--- /dev/null
+++ b/plugin/src/main/scala-2.12/chisel3/plugin/ChiselPlugin.scala
@@ -0,0 +1,139 @@
+// See LICENSE for license details.
+
+package chisel3.plugin
+
+import scala.tools.nsc
+import nsc.{Global, Phase}
+import nsc.plugins.Plugin
+import nsc.plugins.PluginComponent
+import scala.reflect.internal.Flags
+import scala.tools.nsc.transform.TypingTransformers
+
+// The plugin to be run by the Scala compiler during compilation of Chisel code
+class ChiselPlugin(val global: Global) extends Plugin {
+  val name = "chiselplugin"
+  val description = "Plugin for Chisel 3 Hardware Description Language"
+  val components = List[PluginComponent](new ChiselComponent(global))
+}
+
+// The component of the chisel plugin. Not sure exactly what the difference is between
+//   a Plugin and a PluginComponent.
+class ChiselComponent(val global: Global) extends PluginComponent with TypingTransformers {
+  import global._
+  val runsAfter = List[String]("typer")
+  override val runsRightAfter: Option[String] = Some("typer")
+  val phaseName: String = "chiselcomponent"
+  def newPhase(_prev: Phase): ChiselComponentPhase = new ChiselComponentPhase(_prev)
+  class ChiselComponentPhase(prev: Phase) extends StdPhase(prev) {
+    override def name: String = phaseName
+    def apply(unit: CompilationUnit): Unit = {
+      // This plugin doesn't work on Scala 2.11. Rather than complicate the sbt build flow,
+      // instead we just check the version and if its an early Scala version, the plugin does nothing
+      if(scala.util.Properties.versionNumberString.split('.')(1).toInt >= 12) {
+        unit.body = new MyTypingTransformer(unit).transform(unit.body)
+      }
+    }
+  }
+
+  class MyTypingTransformer(unit: CompilationUnit)
+    extends TypingTransformer(unit) {
+
+    // Determines if the chisel plugin should match on this type
+    def shouldMatch(q: Type, bases: Seq[Tree]): Boolean = {
+
+      // If subtype of Data or BaseModule, its a match!
+      def terminate(t: Type): Boolean = bases.exists { base => t <:< inferType(base) }
+
+      // Recurse through subtype hierarchy finding containers
+      // Seen is only updated when we recurse into type parameters, thus it is typically small
+      def recShouldMatch(s: Type, seen: Set[Type]): Boolean = {
+        def outerMatches(t: Type): Boolean = {
+          val str = t.toString
+          str.startsWith("Option[") || str.startsWith("Iterable[")
+        }
+        if (terminate(s)) {
+          true
+        } else if (seen.contains(s)) {
+          false
+        } else if (outerMatches(s)) {
+          // These are type parameters, loops *are* possible here
+          recShouldMatch(s.typeArgs.head, seen + s)
+        } else {
+          // This is the standard inheritance hierarchy, Scalac catches loops here
+          s.parents.exists( p => recShouldMatch(p, seen) )
+        }
+      }
+
+      // If doesn't match container pattern, exit early
+      def earlyExit(t: Type): Boolean = {
+        !(t.matchesPattern(inferType(tq"Iterable[_]")) || t.matchesPattern(inferType(tq"Option[_]")))
+      }
+
+      // First check if a match, then check early exit, then recurse
+      if(terminate(q)){
+        true
+      } else if(earlyExit(q)) {
+        false
+      } else {
+        recShouldMatch(q, Set.empty)
+      }
+    }
+
+    // Given a type tree, infer the type and return it
+    def inferType(t: Tree): Type = localTyper.typed(t, nsc.Mode.TYPEmode).tpe
+
+    // Indicates whether a ValDef is properly formed to get name
+    def okVal(dd: ValDef, bases: Tree*): Boolean = {
+
+      // These were found through trial and error
+      def okFlags(mods: Modifiers): Boolean = {
+        val badFlags = Set(
+          Flag.PARAM,
+          Flag.SYNTHETIC,
+          Flag.DEFERRED,
+          Flags.TRIEDCOOKING,
+          Flags.CASEACCESSOR,
+          Flags.PARAMACCESSOR
+        )
+        badFlags.forall{ x => !mods.hasFlag(x)}
+      }
+
+      // Ensure expression isn't null, as you can't call `null.autoName("myname")`
+      val isNull = dd.rhs match {
+        case Literal(Constant(null)) => true
+        case _ => false
+      }
+      okFlags(dd.mods) && shouldMatch(inferType(dd.tpt), bases) && !isNull && dd.rhs != EmptyTree
+    }
+
+    // Whether this val is directly enclosed by a Bundle type
+    def inBundle(dd: ValDef): Boolean = {
+      dd.symbol.logicallyEnclosingMember.thisType <:< inferType(tq"chisel3.Bundle")
+    }
+
+    // Method called by the compiler to modify source tree
+    override def transform(tree: Tree): Tree = tree match {
+      // If a Data and in a Bundle, just get the name but not a prefix
+      case dd @ ValDef(mods, name, tpt, rhs) if okVal(dd, tq"chisel3.Data") && inBundle(dd) =>
+        val TermName(str: String) = name
+        val newRHS = super.transform(rhs)
+        val named = q"chisel3.experimental.autoNameRecursively($str, $newRHS)"
+        treeCopy.ValDef(dd, mods, name, tpt, localTyper typed named)
+      // If a Data or a Memory, get the name and a prefix
+      case dd @ ValDef(mods, name, tpt, rhs) if okVal(dd, tq"chisel3.Data", tq"chisel3.MemBase[_]") =>
+        val TermName(str: String) = name
+        val newRHS = super.transform(rhs)
+        val prefixed = q"chisel3.experimental.prefix.apply[$tpt](name=$str)(f=$newRHS)"
+        val named = q"chisel3.experimental.autoNameRecursively($str, $prefixed)"
+        treeCopy.ValDef(dd, mods, name, tpt, localTyper typed named)
+      // If an instance, just get a name but no prefix
+      case dd @ ValDef(mods, name, tpt, rhs) if okVal(dd, tq"chisel3.experimental.BaseModule") =>
+        val TermName(str: String) = name
+        val newRHS = super.transform(rhs)
+        val named = q"chisel3.experimental.autoNameRecursively($str, $newRHS)"
+        treeCopy.ValDef(dd, mods, name, tpt, localTyper typed named)
+      // Otherwise, continue
+      case _ => super.transform(tree)
+    }
+  }
+}
diff --git a/src/main/scala/chisel3/util/TransitName.scala b/src/main/scala/chisel3/util/TransitName.scala
index 3b9a3869..992f48d2 100644
--- a/src/main/scala/chisel3/util/TransitName.scala
+++ b/src/main/scala/chisel3/util/TransitName.scala
@@ -43,7 +43,9 @@ object TransitName {
     * @return the `from` parameter
     */
   def apply[T<:HasId](from: T, to: HasId): T = {
-    from.addPostnameHook((given_name: String) => {to.suggestName(given_name)})
+    // To transit a name, we need to hook on both the suggestName and autoSeed mechanisms
+    from.addSuggestPostnameHook((given_name: String) => {to.suggestName(given_name)})
+    from.addAutoPostnameHook((given_name: String) => {to.autoSeed(given_name)})
     from
   }
 
@@ -55,7 +57,9 @@ object TransitName {
     * @return the `from` parameter
     */
   def withSuffix[T<:HasId](suffix: String)(from: T, to: HasId): T = {
-    from.addPostnameHook((given_name: String) => {to.suggestName(given_name + suffix)})
+    // To transit a name, we need to hook on both the suggestName and autoSeed mechanisms
+    from.addSuggestPostnameHook((given_name: String) => {to.suggestName(given_name + suffix)})
+    from.addAutoPostnameHook((given_name: String) => {to.autoSeed(given_name + suffix)})
     from
   }
 
diff --git a/src/test/scala/chiselTests/BetterNamingTests.scala b/src/test/scala/chiselTests/BetterNamingTests.scala
index 032b634e..dd17a015 100644
--- a/src/test/scala/chiselTests/BetterNamingTests.scala
+++ b/src/test/scala/chiselTests/BetterNamingTests.scala
@@ -36,12 +36,14 @@ class IterableNaming extends NamedModuleTester {
                         expectName(WireDefault(2.U), "optSet_2"),
                         expectName(WireDefault(3.U), "optSet_3")))
 
-  val stack = mutable.Stack[Module]()
-  for (i <- 0 until 4) {
-    val j = 3 - i
-    stack.push(expectName(Module(new Other(i)), s"stack_$j"))
+  val stack = {
+    val s = mutable.Stack[Module]()
+    for (i <- 0 until 4) {
+      val j = 3 - i
+      s.push(expectName(Module(new Other(i)), s"stack_$j"))
+    }
+    s
   }
-
   def streamFrom(x: Int): Stream[Module] =
     expectName(Module(new Other(x)), s"list_$x") #:: streamFrom(x + 1)
   val stream = streamFrom(0) // Check that we don't get into infinite loop
diff --git a/src/test/scala/chiselTests/ChiselSpec.scala b/src/test/scala/chiselTests/ChiselSpec.scala
index 2ee6fbcf..7980e772 100644
--- a/src/test/scala/chiselTests/ChiselSpec.scala
+++ b/src/test/scala/chiselTests/ChiselSpec.scala
@@ -14,6 +14,9 @@ import firrtl.annotations.DeletedAnnotation
 import firrtl.util.BackendCompilationUtilities
 import java.io.ByteArrayOutputStream
 import java.security.Permission
+
+import chisel3.aop.Aspect
+import chisel3.stage.{ChiselGeneratorAnnotation, ChiselStage, NoRunFirrtlCompilerAnnotation, PrintFullStackTraceAnnotation}
 import org.scalatestplus.scalacheck.ScalaCheckPropertyChecks
 import scala.reflect.ClassTag
 
@@ -270,6 +273,27 @@ trait Utils {
     }
   }
 
+
+  /** A tester which runs generator and uses an aspect to check the returned object
+    * @param gen function to generate a Chisel module
+    * @param f a function to check the Chisel module
+    * @tparam T the Chisel module class
+    */
+  def aspectTest[T <: RawModule](gen: () => T)(f: T => Unit)(implicit scalaMajorVersion: Int): Unit = {
+    // Runs chisel stage
+    def run[T <: RawModule](gen: () => T, annotations: AnnotationSeq): AnnotationSeq = {
+      new ChiselStage().run(Seq(ChiselGeneratorAnnotation(gen), NoRunFirrtlCompilerAnnotation, PrintFullStackTraceAnnotation) ++ annotations)
+    }
+    // Creates a wrapping aspect to contain checking function
+    case object BuiltAspect extends Aspect[T] {
+      override def toAnnotation(top: T): AnnotationSeq = {f(top); Nil}
+    }
+    val currentMajorVersion = scala.util.Properties.versionNumberString.split('.')(1).toInt
+    if(currentMajorVersion >= scalaMajorVersion) {
+      run(gen, Seq(BuiltAspect))
+    }
+  }
+
   /** Run some code and rethrow an exception with a specific type if an exception of that type occurs anywhere in the
     * stack trace.
     *
@@ -306,5 +330,4 @@ trait Utils {
     }
 
   }
-
 }
diff --git a/src/test/scala/chiselTests/naming/NamePluginSpec.scala b/src/test/scala/chiselTests/naming/NamePluginSpec.scala
new file mode 100644
index 00000000..fc90264d
--- /dev/null
+++ b/src/test/scala/chiselTests/naming/NamePluginSpec.scala
@@ -0,0 +1,207 @@
+// See LICENSE for license details.
+
+package chiselTests.naming
+
+import chisel3._
+import chisel3.aop.Select
+import chisel3.experimental.{prefix, treedump}
+import chiselTests.{ChiselFlatSpec, Utils}
+
+class NamePluginSpec extends ChiselFlatSpec with Utils {
+  implicit val minimumScalaVersion: Int = 12
+
+  "Scala plugin" should "name internally scoped components" in {
+    class Test extends MultiIOModule {
+      { val mywire = Wire(UInt(3.W))}
+    }
+    aspectTest(() => new Test) {
+      top: Test => Select.wires(top).head.toTarget.ref should be("mywire")
+    }
+  }
+
+  "Scala plugin" should "name internally scoped instances" in {
+    class Inner extends MultiIOModule { }
+    class Test extends MultiIOModule {
+      { val myinstance = Module(new Inner) }
+    }
+    aspectTest(() => new Test) {
+      top: Test => Select.instances(top).head.instanceName should be("myinstance")
+    }
+  }
+
+  "Scala plugin" should "interact with prefixing" in {
+    class Test extends MultiIOModule {
+      def builder() = {
+        val wire = Wire(UInt(3.W))
+      }
+      prefix("first") {
+        builder()
+      }
+      prefix("second") {
+        builder()
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test => Select.wires(top).map(_.instanceName) should be (List("first_wire", "second_wire"))
+    }
+  }
+
+  "Scala plugin" should "interact with prefixing so last val name wins" in {
+    class Test extends MultiIOModule {
+      def builder() = {
+        val wire1 = Wire(UInt(3.W))
+        val wire2 = Wire(UInt(3.W))
+        wire2
+      }
+      {
+        val x1 = prefix("first") {
+          builder()
+        }
+      }
+      {
+        val x2 = prefix("second") {
+          builder()
+        }
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test => Select.wires(top).map(_.instanceName) should be (List("x1_first_wire1", "x1", "x2_second_wire1", "x2"))
+    }
+  }
+
+  "Naming on option" should "work" in {
+
+    class Test extends MultiIOModule {
+      def builder(): Option[UInt] = {
+        val a = Wire(UInt(3.W))
+        Some(a)
+      }
+
+      { val blah = builder() }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(top).map(_.instanceName) should be (List("blah"))
+    }
+  }
+
+
+  "Naming on iterables" should "work" in {
+
+    class Test extends MultiIOModule {
+      def builder(): Seq[UInt] = {
+        val a = Wire(UInt(3.W))
+        val b = Wire(UInt(3.W))
+        Seq(a, b)
+      }
+      {
+        val blah = {
+          builder()
+        }
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(top).map(_.instanceName) should be (List("blah_0", "blah_1"))
+    }
+  }
+
+  "Naming on nested iterables" should "work" in {
+
+    class Test extends MultiIOModule {
+      def builder(): Seq[Seq[UInt]] = {
+        val a = Wire(UInt(3.W))
+        val b = Wire(UInt(3.W))
+        val c = Wire(UInt(3.W))
+        val d = Wire(UInt(3.W))
+        Seq(Seq(a, b), Seq(c, d))
+      }
+      {
+        val blah = {
+          builder()
+        }
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(top).map(_.instanceName) should be (
+          List(
+            "blah_0_0",
+            "blah_0_1",
+            "blah_1_0",
+            "blah_1_1"
+          ))
+    }
+  }
+
+  "Naming on custom case classes" should "not work" in {
+    case class Container(a: UInt, b: UInt)
+
+    class Test extends MultiIOModule {
+      def builder(): Container = {
+        val a = Wire(UInt(3.W))
+        val b = Wire(UInt(3.W))
+        Container(a, b)
+      }
+
+      { val blah = builder() }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(top).map(_.instanceName) should be (List("a", "b"))
+    }
+  }
+
+  "Multiple names on an IO within a module" should "get the first name" in {
+    class Test extends RawModule {
+      {
+        val a = IO(Output(UInt(3.W)))
+        val b = a
+      }
+    }
+
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.ios(top).map(_.instanceName) should be (List("a"))
+    }
+  }
+
+  "Multiple names on a non-IO" should "get the last name" in {
+    class Test extends MultiIOModule {
+      {
+        val a = Wire(UInt(3.W))
+        val b = a
+      }
+    }
+
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(top).map(_.instanceName) should be (List("b"))
+    }
+  }
+
+  "Unapply assignments" should "still be named" in {
+    class Test extends MultiIOModule {
+      {
+        val (a, b) = (Wire(UInt(3.W)), Wire(UInt(3.W)))
+      }
+    }
+
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(top).map(_.instanceName) should be (List("a", "b"))
+    }
+  }
+
+  "Recursive types" should "not infinitely loop" in {
+    // When this fails, it causes a StackOverflow when compiling the tests
+    // Unfortunately, this doesn't seem to work with assertCompiles(...), it probably ignores the
+    // custom project scalacOptions
+    def func(x: String) = {
+      // We only check types of vals, we don't actually want to run this code though
+      val y = scala.xml.XML.loadFile(x)
+      y
+    }
+  }
+}
+
diff --git a/src/test/scala/chiselTests/naming/PrefixSpec.scala b/src/test/scala/chiselTests/naming/PrefixSpec.scala
new file mode 100644
index 00000000..df350829
--- /dev/null
+++ b/src/test/scala/chiselTests/naming/PrefixSpec.scala
@@ -0,0 +1,348 @@
+// See LICENSE for license details.
+
+package chiselTests.naming
+
+import chisel3._
+import chisel3.aop.Select
+import chisel3.experimental.{dump, noPrefix, prefix, treedump}
+import chiselTests.{ChiselPropSpec, Utils}
+
+class PrefixSpec extends ChiselPropSpec with Utils {
+  implicit val minimumMajorVersion: Int = 12
+  property("Scala plugin should interact with prefixing so last plugin name wins?") {
+    class Test extends MultiIOModule {
+      def builder(): UInt = {
+        val wire1 = Wire(UInt(3.W))
+        val wire2 = Wire(UInt(3.W))
+        wire2
+      }
+
+      {
+        val x1 = prefix("first") {
+          builder()
+        }
+      }
+      {
+        val x2 = prefix("second") {
+          builder()
+        }
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test => Select.wires(top).map(_.instanceName) should be (List("x1_first_wire1", "x1", "x2_second_wire1", "x2"))
+    }
+  }
+
+  property("Nested prefixes should work") {
+    class Test extends MultiIOModule {
+      def builder2(): UInt = {
+        val wire1 = Wire(UInt(3.W))
+        val wire2 = Wire(UInt(3.W))
+        wire2
+      }
+      def builder(): UInt = {
+        val wire1 = Wire(UInt(3.W))
+        val wire2 = Wire(UInt(3.W))
+        prefix("foo") {
+          builder2()
+        }
+      }
+      { val x1 = builder() }
+      { val x2 = builder() }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(top).map(_.instanceName) should be (
+          List(
+            "x1_wire1",
+            "x1_wire2",
+            "x1_foo_wire1",
+            "x1",
+            "x2_wire1",
+            "x2_wire2",
+            "x2_foo_wire1",
+            "x2"
+          )
+        )
+    }
+  }
+
+  property("Prefixing seeded with signal") {
+    class Test extends MultiIOModule {
+      @treedump
+      @dump
+      def builder(): UInt = {
+        val wire = Wire(UInt(3.W))
+        wire := 3.U
+        wire
+      }
+      {
+        val x1 = Wire(UInt(3.W))
+        x1 := {
+          builder()
+        }
+        val x2 = Wire(UInt(3.W))
+        x2 := {
+          builder()
+        }
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(top).map(_.instanceName) should be (List("x1", "x1_wire", "x2", "x2_wire"))
+    }
+  }
+
+  property("Automatic prefixing should work") {
+
+    class Test extends MultiIOModule {
+      def builder(): UInt = {
+        val a = Wire(UInt(3.W))
+        val b = Wire(UInt(3.W))
+        b
+      }
+
+      {
+        val ADAM = builder()
+        val JACOB = builder()
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(top).map(_.instanceName) should be (List("ADAM_a", "ADAM", "JACOB_a", "JACOB"))
+    }
+  }
+
+  property("No prefixing annotation on defs should work") {
+
+    class Test extends MultiIOModule {
+      def builder(): UInt = noPrefix {
+        val a = Wire(UInt(3.W))
+        val b = Wire(UInt(3.W))
+        b
+      }
+
+      { val noprefix = builder() }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(top).map(_.instanceName) should be (List("a", "noprefix"))
+    }
+  }
+
+  property("Prefixing on temps should work") {
+
+    class Test extends MultiIOModule {
+      def builder(): UInt = {
+        val a = Wire(UInt(3.W))
+        val b = Wire(UInt(3.W))
+        a +& (b * a)
+      }
+
+      { val blah = builder() }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.ops(top).map(x => (x._1, x._2.instanceName)) should be (List(
+          ("mul", "_blah_T"),
+          ("add", "blah")
+        ))
+    }
+  }
+
+  property("Prefixing should not leak into child modules") {
+    class Child extends MultiIOModule {
+      {
+        val wire = Wire(UInt())
+      }
+    }
+
+    class Test extends MultiIOModule {
+      {
+        val child = prefix("InTest") {
+          Module(new Child)
+        }
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(Select.instances(top).head).map(_.instanceName) should be (List("wire"))
+    }
+  }
+
+  property("Prefixing should not leak into child modules, example 2") {
+    class Child extends MultiIOModule {
+      {
+        val wire = Wire(UInt())
+      }
+    }
+
+    class Test extends MultiIOModule {
+      val x = IO(Input(UInt(3.W)))
+      val y = {
+        lazy val module = new Child
+        val child = Module(module)
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(Select.instances(top).head).map(_.instanceName) should be (List("wire"))
+    }
+  }
+
+  property("Instance names should not be added to prefix") {
+    class Child(tpe: UInt) extends MultiIOModule {
+      {
+        val io = IO(Input(tpe))
+      }
+    }
+
+    class Test extends MultiIOModule {
+      {
+        lazy val module = {
+          val x = UInt(3.W)
+          new Child(x)
+        }
+        val child = Module(module)
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.ios(Select.instances(top).head).map(_.instanceName) should be (List("clock", "reset", "io"))
+    }
+  }
+
+
+  property("Prefixing should not be caused by nested Iterable[Iterable[Any]]") {
+    class Test extends MultiIOModule {
+      {
+        val iia = {
+          val wire = Wire(UInt(3.W))
+          List(List("Blah"))
+        }
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(top).map(_.instanceName) should be (List("wire"))
+    }
+  }
+
+  property("Prefixing should be caused by nested Iterable[Iterable[Data]]") {
+    class Test extends MultiIOModule {
+      {
+        val iia = {
+          val wire = Wire(UInt(3.W))
+          List(List(3.U))
+        }
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(top).map(_.instanceName) should be (List("iia_wire"))
+    }
+  }
+
+  property("Prefixing should be the prefix during the last call to autoName/suggestName") {
+    class Test extends MultiIOModule {
+      {
+        val wire = {
+          val x = Wire(UInt(3.W)).suggestName("mywire")
+          x
+        }
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.wires(top).map(_.instanceName) should be (List("mywire"))
+        Select.wires(top).map(_.instanceName) shouldNot be (List("wire_mywire"))
+    }
+  }
+
+  property("Prefixing have intuitive behavior") {
+    class Test extends MultiIOModule {
+      {
+        val wire = {
+          val x = Wire(UInt(3.W)).suggestName("mywire")
+          val y = Wire(UInt(3.W)).suggestName("mywire2")
+          y := x
+          y
+        }
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test => Select.wires(top).map(_.instanceName) should be (List("wire_mywire", "mywire2"))
+    }
+  }
+
+  property("Prefixing on connection to subfields work") {
+    class Test extends MultiIOModule {
+      {
+        val wire = Wire(new Bundle {
+          val x = UInt(3.W)
+          val y = UInt(3.W)
+          val vec = Vec(4, UInt(3.W))
+        })
+        wire.x := RegNext(3.U)
+        wire.y := RegNext(3.U)
+        wire.vec(0) := RegNext(3.U)
+        wire.vec(wire.x) := RegNext(3.U)
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.registers(top).map(_.instanceName) should be (List(
+          "wire_x_REG",
+          "wire_y_REG",
+          "wire_vec_0_REG",
+          "wire_vec_REG"
+        ))
+    }
+  }
+
+  property("Prefixing on connection to IOs should work") {
+    class Child extends MultiIOModule {
+      val in = IO(Input(UInt(3.W)))
+      val out = IO(Output(UInt(3.W)))
+      out := RegNext(in)
+    }
+    class Test extends MultiIOModule {
+      {
+        val child = Module(new Child)
+        child.in := RegNext(3.U)
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.registers(top).map(_.instanceName) should be (List(
+          "child_in_REG"
+        ))
+        Select.registers(Select.instances(top).head).map(_.instanceName) should be (List(
+          "out_REG"
+        ))
+    }
+  }
+
+  property("Prefixing on bulk connects should work") {
+    class Child extends MultiIOModule {
+      val in = IO(Input(UInt(3.W)))
+      val out = IO(Output(UInt(3.W)))
+      out := RegNext(in)
+    }
+    class Test extends MultiIOModule {
+      {
+        val child = Module(new Child)
+        child.in <> RegNext(3.U)
+      }
+    }
+    aspectTest(() => new Test) {
+      top: Test =>
+        Select.registers(top).map(_.instanceName) should be (List(
+          "child_in_REG"
+        ))
+        Select.registers(Select.instances(top).head).map(_.instanceName) should be (List(
+          "out_REG"
+        ))
+    }
+  }
+}