summaryrefslogtreecommitdiff
path: root/plugin
diff options
context:
space:
mode:
Diffstat (limited to 'plugin')
-rw-r--r--plugin/src/main/scala/chisel3/internal/plugin/BundleComponent.scala278
1 files changed, 152 insertions, 126 deletions
diff --git a/plugin/src/main/scala/chisel3/internal/plugin/BundleComponent.scala b/plugin/src/main/scala/chisel3/internal/plugin/BundleComponent.scala
index eca3b158..f9452f5a 100644
--- a/plugin/src/main/scala/chisel3/internal/plugin/BundleComponent.scala
+++ b/plugin/src/main/scala/chisel3/internal/plugin/BundleComponent.scala
@@ -42,6 +42,8 @@ private[plugin] class BundleComponent(val global: Global, arguments: ChiselPlugi
def inferType(t: Tree): Type = localTyper.typed(t, nsc.Mode.TYPEmode).tpe
val bundleTpe: Type = inferType(tq"chisel3.Bundle")
+ val recordTpe: Type = inferType(tq"chisel3.Record")
+ val autoCloneTpe: Type = inferType(tq"chisel3.experimental.AutoCloneType")
val dataTpe: Type = inferType(tq"chisel3.Data")
val ignoreSeqTpe: Type = inferType(tq"chisel3.IgnoreSeqInBundle")
val seqOfDataTpe: Type = inferType(tq"scala.collection.Seq[chisel3.Data]")
@@ -49,7 +51,11 @@ private[plugin] class BundleComponent(val global: Global, arguments: ChiselPlugi
val itStringAnyTpe: Type = inferType(tq"scala.collection.Iterable[(String,Any)]")
// Not cached because it should only be run once per class (thus once per Type)
- def isBundle(sym: Symbol): Boolean = { sym.tpe <:< bundleTpe }
+ def isABundle(sym: Symbol): Boolean = { sym.tpe <:< bundleTpe }
+
+ def isARecord(sym: Symbol): Boolean = { sym.tpe <:< recordTpe }
+
+ def isAnAutoCloneType(sym: Symbol): Boolean = { sym.tpe <:< autoCloneTpe }
def isIgnoreSeqInBundle(sym: Symbol): Boolean = { sym.tpe <:< ignoreSeqTpe }
@@ -86,7 +92,7 @@ private[plugin] class BundleComponent(val global: Global, arguments: ChiselPlugi
def isVarArgs(sym: Symbol): Boolean = definitions.isRepeatedParamType(sym.tpe)
- def getConstructorAndParams(body: List[Tree]): (Option[DefDef], Seq[Symbol]) = {
+ def getConstructorAndParams(body: List[Tree], isBundle: Boolean): (Option[DefDef], Seq[Symbol]) = {
val paramAccessors = mutable.ListBuffer[Symbol]()
var primaryConstructor: Option[DefDef] = None
body.foreach {
@@ -96,154 +102,174 @@ private[plugin] class BundleComponent(val global: Global, arguments: ChiselPlugi
primaryConstructor = Some(con)
case d: DefDef if isNullaryMethodNamed("_cloneTypeImpl", d) =>
val msg = "Users cannot override _cloneTypeImpl. Let the compiler plugin generate it."
- global.globalError(d.pos, msg)
- case d: DefDef if isNullaryMethodNamed("_elementsImpl", d) =>
+ global.reporter.error(d.pos, msg)
+ case d: DefDef if isNullaryMethodNamed("_elementsImpl", d) && isBundle =>
val msg = "Users cannot override _elementsImpl. Let the compiler plugin generate it."
- global.globalError(d.pos, msg)
- case d: DefDef if isNullaryMethodNamed("_usingPlugin", d) =>
+ global.reporter.error(d.pos, msg)
+ case d: DefDef if isNullaryMethodNamed("_usingPlugin", d) && isBundle =>
val msg = "Users cannot override _usingPlugin, it is for the compiler plugin's use only."
- global.globalError(d.pos, msg)
+ global.reporter.error(d.pos, msg)
case d: DefDef if isNullaryMethodNamed("cloneType", d) =>
- val msg = "Users cannot override cloneType. Let the compiler plugin generate it."
- global.globalError(d.pos, msg)
+ val prefix = if (isBundle) "Bundles" else "Records extending AutoCloneType"
+ val msg = s"$prefix cannot override cloneType. Let the compiler plugin generate it."
+ global.reporter.error(d.pos, msg)
case _ =>
}
(primaryConstructor, paramAccessors.toList)
}
- override def transform(tree: Tree): Tree = tree match {
-
- case bundle: ClassDef if isBundle(bundle.symbol) && !bundle.mods.hasFlag(Flag.ABSTRACT) =>
- // ==================== Generate _cloneTypeImpl ====================
- val (con, params) = getConstructorAndParams(bundle.impl.body)
- if (con.isEmpty) {
- global.reporter.warning(bundle.pos, "Unable to determine primary constructor!")
- return super.transform(tree)
- }
+ def warnOnCloneType(body: List[Tree]): Unit = {
+ body.foreach {
+ case d: DefDef if isNullaryMethodNamed("cloneType", d) =>
+ val msg = "It is no longer necessary to implement cloneType. " +
+ "Mix in chisel3.experimental.AutoCloneType to let the compiler plugin generate it. " +
+ "This will become an error in Chisel 3.6."
+ global.reporter.warning(d.pos, msg)
+ case _ => // Do nothing
+ }
+ }
- val constructor = con.get
- val thiz = gen.mkAttributedThis(bundle.symbol)
-
- // The params have spaces after them (Scalac implementation detail)
- val paramLookup: String => Symbol = params.map(sym => sym.name.toString.trim -> sym).toMap
-
- val cloneTypeImplOpt = if (!bundle.mods.hasFlag(Flag.ABSTRACT)) {
- // Create a this.<ref> for each field matching order of constructor arguments
- // List of Lists because we can have multiple parameter lists
- val conArgs: List[List[Tree]] =
- constructor.vparamss.map(_.map { vp =>
- val p = paramLookup(vp.name.toString)
- // Make this.<ref>
- val select = gen.mkAttributedSelect(thiz.asInstanceOf[Tree], p)
- // Clone any Data parameters to avoid field aliasing, need full clone to include direction
- val cloned = if (isData(vp.symbol)) cloneTypeFull(select.asInstanceOf[Tree]) else select
- // Need to splat varargs
- if (isVarArgs(vp.symbol)) q"$cloned: _*" else cloned
- })
-
- val tparamList = bundle.tparams.map { t => Ident(t.symbol) }
- val ttpe =
- if (tparamList.nonEmpty) AppliedTypeTree(Ident(bundle.symbol), tparamList) else Ident(bundle.symbol)
- val newUntyped = New(ttpe, conArgs)
- val neww = localTyper.typed(newUntyped)
-
- // Create the symbol for the method and have it be associated with the Bundle class
- val cloneTypeSym =
- bundle.symbol.newMethod(TermName("_cloneTypeImpl"), bundle.symbol.pos.focus, Flag.OVERRIDE | Flag.PROTECTED)
- // Handwritten cloneTypes don't have the Method flag set, unclear if it matters
- cloneTypeSym.resetFlag(Flags.METHOD)
- // Need to set the type to chisel3.Bundle for the override to work
- cloneTypeSym.setInfo(NullaryMethodType(bundleTpe))
-
- Some(localTyper.typed(DefDef(cloneTypeSym, neww)))
- } else {
- // Don't create if this Bundle is abstract
- None
- }
+ def generateAutoCloneType(record: ClassDef, thiz: global.This, isBundle: Boolean): Option[Tree] = {
+ val (con, params) = getConstructorAndParams(record.impl.body, isBundle)
+ if (con.isEmpty) {
+ global.reporter.warning(record.pos, "Unable to determine primary constructor!")
+ return None
+ }
- // ==================== Generate val elements ====================
+ val constructor = con.get
+
+ // The params have spaces after them (Scalac implementation detail)
+ val paramLookup: String => Symbol = params.map(sym => sym.name.toString.trim -> sym).toMap
+
+ // Create a this.<ref> for each field matching order of constructor arguments
+ // List of Lists because we can have multiple parameter lists
+ val conArgs: List[List[Tree]] =
+ constructor.vparamss.map(_.map { vp =>
+ val p = paramLookup(vp.name.toString)
+ // Make this.<ref>
+ val select = gen.mkAttributedSelect(thiz.asInstanceOf[Tree], p)
+ // Clone any Data parameters to avoid field aliasing, need full clone to include direction
+ val cloned = if (isData(vp.symbol)) cloneTypeFull(select.asInstanceOf[Tree]) else select
+ // Need to splat varargs
+ if (isVarArgs(vp.symbol)) q"$cloned: _*" else cloned
+ })
+
+ val tparamList = record.tparams.map { t => Ident(t.symbol) }
+ val ttpe =
+ if (tparamList.nonEmpty) AppliedTypeTree(Ident(record.symbol), tparamList) else Ident(record.symbol)
+ val newUntyped = New(ttpe, conArgs)
+ val neww = localTyper.typed(newUntyped)
+
+ // Create the symbol for the method and have it be associated with the Record class
+ val cloneTypeSym =
+ record.symbol.newMethod(TermName("_cloneTypeImpl"), record.symbol.pos.focus, Flag.OVERRIDE | Flag.PROTECTED)
+ // Handwritten cloneTypes don't have the Method flag set, unclear if it matters
+ cloneTypeSym.resetFlag(Flags.METHOD)
+
+ // Need to set the return type correctly for the override to work
+ // For binary compatibility reasons in 3.5, Bundles have to return chisel3.Bundle
+ val returnType = if (isBundle) bundleTpe else recordTpe
+ cloneTypeSym.setInfo(NullaryMethodType(returnType))
+
+ Some(localTyper.typed(DefDef(cloneTypeSym, neww)))
+ }
- /* Test to see if the bundle found is amenable to having it's elements
- * converted to an immediate form that will not require reflection
- */
- def isSupportedBundleType: Boolean = {
- arguments.genBundleElements && !bundle.mods.hasFlag(Flag.ABSTRACT)
+ def generateElements(bundle: ClassDef, thiz: global.This): Tree = {
+ /* extract the true fields from the super classes a given bundle
+ * depth argument can be helpful for debugging
+ */
+ def getAllBundleFields(bundleSymbol: Symbol, depth: Int = 0): List[(String, Tree)] = {
+
+ def isBundleField(member: Symbol): Boolean = {
+ if (!member.isAccessor) {
+ false
+ } else if (isData(member.tpe.typeSymbol)) {
+ true
+ } else if (isOptionOfData(member)) {
+ true
+ } else if (isSeqOfData(member)) {
+ // This field is passed along, even though it is illegal
+ // An error for this will be generated in `Bundle.elements`
+ // It would be possible here to check for Seq[Data] and make a compiler error, but
+ // that would be a API error difference. See reference in docs/chisel-plugin.md
+ // If Bundle is subclass of IgnoreSeqInBundle then don't pass this field along
+
+ !isIgnoreSeqInBundle(bundleSymbol)
+ } else {
+ // none of the above
+ false
+ }
}
- val elementsImplOpt = if (isSupportedBundleType) {
- /* extract the true fields from the super classes a given bundle
- * depth argument can be helpful for debugging
- */
- def getAllBundleFields(bundleSymbol: Symbol, depth: Int = 0): List[(String, Tree)] = {
-
- def isBundleField(member: Symbol): Boolean = {
- if (!member.isAccessor) {
- false
- } else if (isData(member.tpe.typeSymbol)) {
- true
- } else if (isOptionOfData(member)) {
- true
- } else if (isSeqOfData(member)) {
- // This field is passed along, even though it is illegal
- // An error for this will be generated in `Bundle.elements`
- // It would be possible here to check for Seq[Data] and make a compiler error, but
- // that would be a API error difference. See reference in docs/chisel-plugin.md
- // If Bundle is subclass of IgnoreSeqInBundle then don't pass this field along
-
- !isIgnoreSeqInBundle(bundleSymbol)
- } else {
- // none of the above
- false
- }
- }
+ val currentFields = bundleSymbol.info.members.flatMap {
- val currentFields = bundleSymbol.info.members.flatMap {
-
- case member if member.isPublic =>
- if (isBundleField(member)) {
- // The params have spaces after them (Scalac implementation detail)
- Some(member.name.toString.trim -> gen.mkAttributedSelect(thiz.asInstanceOf[Tree], member))
- } else {
- None
- }
-
- case _ => None
- }.toList
-
- val allParentFields = bundleSymbol.parentSymbols.flatMap { parentSymbol =>
- val fieldsFromParent = if (depth < 1 && !isExactBundle(bundleSymbol)) {
- val foundFields = getAllBundleFields(parentSymbol, depth + 1)
- foundFields
- } else {
- List()
- }
- fieldsFromParent
+ case member if member.isPublic =>
+ if (isBundleField(member)) {
+ // The params have spaces after them (Scalac implementation detail)
+ Some(member.name.toString.trim -> gen.mkAttributedSelect(thiz.asInstanceOf[Tree], member))
+ } else {
+ None
}
- allParentFields ++ currentFields
+
+ case _ => None
+ }.toList
+
+ val allParentFields = bundleSymbol.parentSymbols.flatMap { parentSymbol =>
+ val fieldsFromParent = if (depth < 1 && !isExactBundle(bundleSymbol)) {
+ val foundFields = getAllBundleFields(parentSymbol, depth + 1)
+ foundFields
+ } else {
+ List()
}
+ fieldsFromParent
+ }
+ allParentFields ++ currentFields
+ }
- val elementArgs = getAllBundleFields(bundle.symbol)
+ val elementArgs = getAllBundleFields(bundle.symbol)
- val elementsImplSym =
- bundle.symbol.newMethod(TermName("_elementsImpl"), bundle.symbol.pos.focus, Flag.OVERRIDE | Flag.PROTECTED)
- elementsImplSym.resetFlag(Flags.METHOD)
- elementsImplSym.setInfo(NullaryMethodType(itStringAnyTpe))
+ val elementsImplSym =
+ bundle.symbol.newMethod(TermName("_elementsImpl"), bundle.symbol.pos.focus, Flag.OVERRIDE | Flag.PROTECTED)
+ elementsImplSym.resetFlag(Flags.METHOD)
+ elementsImplSym.setInfo(NullaryMethodType(itStringAnyTpe))
- val elementsImpl = localTyper.typed(
- DefDef(elementsImplSym, q"scala.collection.immutable.Vector.apply[(String, Any)](..$elementArgs)")
- )
+ val elementsImpl = localTyper.typed(
+ DefDef(elementsImplSym, q"scala.collection.immutable.Vector.apply[(String, Any)](..$elementArgs)")
+ )
- Some(elementsImpl)
- } else {
- // No code generated for elements accessor
- None
+ elementsImpl
+ }
+
+ override def transform(tree: Tree): Tree = tree match {
+
+ case record: ClassDef if isARecord(record.symbol) && !record.mods.hasFlag(Flag.ABSTRACT) =>
+ val isBundle: Boolean = isABundle(record.symbol)
+ val isAutoCloneType: Boolean = isAnAutoCloneType(record.symbol)
+
+ if (!isAutoCloneType) {
+ warnOnCloneType(record.impl.body)
+ // Other than warning, there is nothing to do on Records that don't mixin AutoCloneType
+ return super.transform(record)
}
+ val thiz: global.This = gen.mkAttributedThis(record.symbol)
+
+ // ==================== Generate _cloneTypeImpl ====================
+ val cloneTypeImplOpt = generateAutoCloneType(record, thiz, isBundle)
+
+ // ==================== Generate val elements (Bundles only) ====================
+ val elementsImplOpt =
+ if (isBundle && arguments.genBundleElements) Some(generateElements(record, thiz)) else None
+
// ==================== Generate _usingPlugin ====================
- // Unclear why quasiquotes work here but didn't for cloneTypeSym, maybe they could.
- val usingPluginOpt = Some(localTyper.typed(q"override protected def _usingPlugin: Boolean = true"))
+ val usingPluginOpt = if (isBundle) {
+ // Unclear why quasiquotes work here but didn't for cloneTypeSym, maybe they could.
+ Some(localTyper.typed(q"override protected def _usingPlugin: Boolean = true"))
+ } else {
+ None
+ }
- val withMethods = deriveClassDef(bundle) { t =>
+ val withMethods = deriveClassDef(record) { t =>
deriveTemplate(t)(_ ++ cloneTypeImplOpt ++ usingPluginOpt ++ elementsImplOpt)
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-31 13:25:29 +0000