From 1272bd8bfd1c4b5cd1ddb3e1c3cb760d427b7bd9 Mon Sep 17 00:00:00 2001
From: Aditya Naik
Date: Mon, 22 Jul 2024 15:34:03 -0700
Subject: Remove more incompatible files
---
macros/src/main/scala/chisel3/SourceInfoDoc.scala | 38 ---
.../scala/chisel3/internal/RangeTransform.scala | 196 ---------------
.../internal/RuntimeDeprecationTransform.scala | 52 ----
.../internal/naming/NamingAnnotations.scala | 216 ----------------
.../internal/sourceinfo/SourceInfoTransform.scala | 279 ---------------------
5 files changed, 781 deletions(-)
delete mode 100644 macros/src/main/scala/chisel3/SourceInfoDoc.scala
delete mode 100644 macros/src/main/scala/chisel3/internal/RangeTransform.scala
delete mode 100644 macros/src/main/scala/chisel3/internal/RuntimeDeprecationTransform.scala
delete mode 100644 macros/src/main/scala/chisel3/internal/naming/NamingAnnotations.scala
delete mode 100644 macros/src/main/scala/chisel3/internal/sourceinfo/SourceInfoTransform.scala
(limited to 'macros/src/main')
diff --git a/macros/src/main/scala/chisel3/SourceInfoDoc.scala b/macros/src/main/scala/chisel3/SourceInfoDoc.scala
deleted file mode 100644
index 6e7accc4..00000000
--- a/macros/src/main/scala/chisel3/SourceInfoDoc.scala
+++ /dev/null
@@ -1,38 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-package chisel3
-
-/** Provides ScalaDoc information for "hidden" `do_*` methods
- *
- * Mix this into classes/objects that have `do_*` methods to get access to the shared `SourceInfoTransformMacro`
- * ScalaDoc group and the lengthy `groupdesc` below.
- *
- * @groupdesc SourceInfoTransformMacro
- *
- *
- * '''These internal methods are not part of the public-facing API!'''
- *
- *
- *
- * The equivalent public-facing methods do not have the `do_` prefix or have the same name. Use and look at the
- * documentation for those. If you want left shift, use `<<`, not `do_<<`. If you want conversion to a
- * [[scala.collection.Seq Seq]] of [[Bool]]s look at the `asBools` above, not the one below. Users can safely ignore
- * every method in this group!
- *
- * 🐉🐉🐉 '''Here be dragons...''' 🐉🐉🐉
- *
- *
- *
- * These `do_X` methods are used to enable both implicit passing of SourceInfo and [[chisel3.CompileOptions]]
- * while also supporting chained apply methods. In effect all "normal" methods that you, as a user, will use in your
- * designs, are converted to their "hidden", `do_*`, via macro transformations. Without using macros here, only one
- * of the above wanted behaviors is allowed (implicit passing and chained applies)---the compiler interprets a
- * chained apply as an explicit 'implicit' argument and will throw type errors.
- *
- * The "normal", public-facing methods then take no SourceInfo. However, a macro transforms this public-facing method
- * into a call to an internal, hidden `do_*` that takes an explicit SourceInfo by inserting an
- * `implicitly[SourceInfo]` as the explicit argument.
- *
- * @groupprio SourceInfoTransformMacro 1001
- */
-trait SourceInfoDoc
diff --git a/macros/src/main/scala/chisel3/internal/RangeTransform.scala b/macros/src/main/scala/chisel3/internal/RangeTransform.scala
deleted file mode 100644
index f401241d..00000000
--- a/macros/src/main/scala/chisel3/internal/RangeTransform.scala
+++ /dev/null
@@ -1,196 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-// Macro transforms that statically (at compile time) parse range specifiers and emit the raw
-// (non-human-friendly) range constructor calls.
-
-package chisel3.internal
-
-import scala.language.experimental.macros
-import scala.reflect.macros.blackbox
-import scala.util.matching.Regex
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object RangeTransform {
- val UnspecifiedNumber: Regex = """(\?).*""".r
- val IntegerNumber: Regex = """(-?\d+).*""".r
- val DecimalNumber: Regex = """(-?\d+\.\d+).*""".r
-}
-
-/** Convert the string to IntervalRange, with unknown, open or closed endpoints and a binary point
- * ranges looks like
- * range"[0,4].1" range starts at 0 inclusive ends at 4.inclusively with a binary point of 1
- * range"(0,4).1" range starts at 0 exclusive ends at 4.exclusively with a binary point of 1
- *
- * the min and max of the range are the actually min and max values, thus the binary point
- * becomes a sort of multiplier for the number of bits.
- * E.g. range"[0,3].2" will require at least 4 bits two provide the two decimal places
- *
- * @param c contains the string context to be parsed
- */
-class RangeTransform(val c: blackbox.Context) {
- import c.universe._
- def apply(args: c.Tree*): c.Tree = {
- val stringTrees = c.prefix.tree match {
- case q"$_(scala.StringContext.apply(..$strings))" => strings
- case _ =>
- c.abort(
- c.enclosingPosition,
- s"Range macro unable to parse StringContext, got: ${showCode(c.prefix.tree)}"
- )
- }
- val strings = stringTrees.map {
- case Literal(Constant(string: String)) => string
- case tree =>
- c.abort(
- c.enclosingPosition,
- s"Range macro unable to parse StringContext element, got: ${showRaw(tree)}"
- )
- }
-
- var nextStringIndex: Int = 1
- var nextArgIndex: Int = 0
- var currString: String = strings.head
-
- /** Mutably gets the next numeric value in the range specifier.
- */
- def computeNextValue(): c.Tree = {
- currString = currString.dropWhile(_ == ' ') // allow whitespace
- if (currString.isEmpty) {
- if (nextArgIndex >= args.length) {
- c.abort(c.enclosingPosition, s"Incomplete range specifier")
- }
- val nextArg = args(nextArgIndex)
- nextArgIndex += 1
-
- if (nextStringIndex >= strings.length) {
- c.abort(c.enclosingPosition, s"Incomplete range specifier")
- }
- currString = strings(nextStringIndex)
- nextStringIndex += 1
-
- nextArg
- } else {
- val nextStringVal = currString match {
- case RangeTransform.DecimalNumber(numberString) => numberString
- case RangeTransform.IntegerNumber(numberString) => numberString
- case RangeTransform.UnspecifiedNumber(_) => "?"
- case _ =>
- c.abort(
- c.enclosingPosition,
- s"Bad number or unspecified bound $currString"
- )
- }
- currString = currString.substring(nextStringVal.length)
-
- if (nextStringVal == "?") {
- Literal(Constant("?"))
- } else {
- c.parse(nextStringVal)
- }
- }
- }
-
- // Currently, not allowed to have the end stops (inclusive / exclusive) be interpolated.
- currString = currString.dropWhile(_ == ' ')
- val startInclusive = currString.headOption match {
- case Some('[') => true
- case Some('(') => false
- case Some('?') =>
- c.abort(
- c.enclosingPosition,
- s"start of range as unknown s must be '[?' or '(?' not '?'"
- )
- case Some(other) =>
- c.abort(
- c.enclosingPosition,
- s"Unknown start inclusive/exclusive specifier, got: '$other'"
- )
- case None =>
- c.abort(
- c.enclosingPosition,
- s"No initial inclusive/exclusive specifier"
- )
- }
-
- currString = currString.substring(1) // eat the inclusive/exclusive specifier
- val minArg = computeNextValue()
- currString = currString.dropWhile(_ == ' ')
- if (currString(0) != ',') {
- c.abort(c.enclosingPosition, s"Incomplete range specifier, expected ','")
- }
- if (currString.head != ',') {
- c.abort(
- c.enclosingPosition,
- s"Incomplete range specifier, expected ',', got $currString"
- )
- }
-
- currString = currString.substring(1) // eat the comma
-
- val maxArg = computeNextValue()
- currString = currString.dropWhile(_ == ' ')
-
- val endInclusive = currString.headOption match {
- case Some(']') => true
- case Some(')') => false
- case Some('?') =>
- c.abort(
- c.enclosingPosition,
- s"start of range as unknown s must be '[?' or '(?' not '?'"
- )
- case Some(other) =>
- c.abort(
- c.enclosingPosition,
- s"Unknown end inclusive/exclusive specifier, got: '$other' expecting ')' or ']'"
- )
- case None =>
- c.abort(
- c.enclosingPosition,
- s"Incomplete range specifier, missing end inclusive/exclusive specifier"
- )
- }
- currString = currString.substring(1) // eat the inclusive/exclusive specifier
- currString = currString.dropWhile(_ == ' ')
-
- val binaryPointString = currString.headOption match {
- case Some('.') =>
- currString = currString.substring(1)
- computeNextValue()
- case Some(other) =>
- c.abort(
- c.enclosingPosition,
- s"Unknown end binary point prefix, got: '$other' was expecting '.'"
- )
- case None =>
- Literal(Constant(0))
- }
-
- if (nextArgIndex < args.length) {
- val unused = args.mkString("")
- c.abort(
- c.enclosingPosition,
- s"Unused interpolated values in range specifier: '$unused'"
- )
- }
- if (!currString.isEmpty || nextStringIndex < strings.length) {
- val unused = currString + strings
- .slice(nextStringIndex, strings.length)
- .mkString(", ")
- c.abort(
- c.enclosingPosition,
- s"Unused characters in range specifier: '$unused'"
- )
- }
-
- val startBound =
- q"_root_.chisel3.internal.firrtl.IntervalRange.getBound($startInclusive, $minArg)"
-
- val endBound =
- q"_root_.chisel3.internal.firrtl.IntervalRange.getBound($endInclusive, $maxArg)"
-
- val binaryPoint =
- q"_root_.chisel3.internal.firrtl.IntervalRange.getBinaryPoint($binaryPointString)"
-
- q"_root_.chisel3.internal.firrtl.IntervalRange($startBound, $endBound, $binaryPoint)"
- }
-}
diff --git a/macros/src/main/scala/chisel3/internal/RuntimeDeprecationTransform.scala b/macros/src/main/scala/chisel3/internal/RuntimeDeprecationTransform.scala
deleted file mode 100644
index ff41bd30..00000000
--- a/macros/src/main/scala/chisel3/internal/RuntimeDeprecationTransform.scala
+++ /dev/null
@@ -1,52 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-package chisel3.internal
-
-import scala.reflect.macros.whitebox.Context
-import scala.annotation.{compileTimeOnly, StaticAnnotation}
-import scala.language.experimental.macros
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object RuntimeDeprecatedTransform
-class RuntimeDeprecatedTransform(val c: Context) {
- import c.universe._
-
- /** Adds a Builder.deprecated(...) call based on the contents of a plain @deprecated annotation.
- */
- def runtimeDeprecated(annottees: c.Tree*): c.Tree = {
- val transformed = annottees.map(annottee =>
- annottee match {
- case q"$mods def $tname[..$tparams](...$paramss): $tpt = $expr" => {
- val Modifiers(_, _, annotations) = mods
- val annotationMessage = annotations.collect { // get all messages from deprecated annotations
- case q"new deprecated($desc, $since)" => desc
- } match { // ensure there's only one and return it
- case msg :: Nil => msg
- case _ =>
- c.abort(
- c.enclosingPosition,
- s"@chiselRuntimeDeprecated annotion must be used with exactly one @deprecated annotation, got annotations $annotations"
- )
- }
- val message = s"$tname is deprecated: $annotationMessage"
- val transformedExpr = q""" {
- _root_.chisel3.internal.Builder.deprecated($message)
- $expr
- } """
- q"$mods def $tname[..$tparams](...$paramss): $tpt = $transformedExpr"
- }
- case other =>
- c.abort(
- c.enclosingPosition,
- s"@chiselRuntimeDeprecated annotion may only be used on defs, got ${showCode(other)}"
- )
- }
- )
- q"..$transformed"
- }
-}
-
-@compileTimeOnly("enable macro paradise to expand macro annotations")
-class chiselRuntimeDeprecated extends StaticAnnotation {
- def macroTransform(annottees: Any*): Any = macro chisel3.internal.RuntimeDeprecatedTransform.runtimeDeprecated
-}
diff --git a/macros/src/main/scala/chisel3/internal/naming/NamingAnnotations.scala b/macros/src/main/scala/chisel3/internal/naming/NamingAnnotations.scala
deleted file mode 100644
index 01c3d4c1..00000000
--- a/macros/src/main/scala/chisel3/internal/naming/NamingAnnotations.scala
+++ /dev/null
@@ -1,216 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-// Transform implementations for name-propagation related annotations.
-//
-// Helpful references:
-// http://docs.scala-lang.org/overviews/quasiquotes/syntax-summary.html#definitions
-// for quasiquote structures of various Scala structures
-// http://jsuereth.com/scala/2009/02/05/leveraging-annotations-in-scala.html
-// use of Transformer
-// http://www.scala-lang.org/old/sites/default/files/sids/rytz/Wed,%202010-01-27,%2015:10/annots.pdf
-// general annotations reference
-
-package chisel3.internal.naming
-
-import scala.reflect.macros.whitebox.Context
-import scala.annotation.{compileTimeOnly, StaticAnnotation}
-import scala.language.experimental.macros
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object DebugTransforms
-class DebugTransforms(val c: Context) {
- import c.universe._
-
- /** Passthrough transform that prints the annottee for debugging purposes.
- * No guarantees are made on what this annotation does, and it may very well change over time.
- *
- * The print is warning level to make it visually easier to spot, as well as a reminder that
- * this annotation should not make it to production / committed code.
- */
- def dump(annottees: c.Tree*): c.Tree = {
- val combined = annottees.map({ tree => show(tree) }).mkString("\r\n\r\n")
- annottees.foreach(tree => c.warning(c.enclosingPosition, s"Debug dump:\n$combined"))
- q"..$annottees"
- }
-
- /** Passthrough transform that prints the annottee as a tree for debugging purposes.
- * No guarantees are made on what this annotation does, and it may very well change over time.
- *
- * The print is warning level to make it visually easier to spot, as well as a reminder that
- * this annotation should not make it to production / committed code.
- */
- def treedump(annottees: c.Tree*): c.Tree = {
- val combined = annottees.map({ tree => showRaw(tree) }).mkString("\r\n")
- annottees.foreach(tree => c.warning(c.enclosingPosition, s"Debug tree dump:\n$combined"))
- q"..$annottees"
- }
-}
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object NamingTransforms
-class NamingTransforms(val c: Context) {
- import c.universe._
-
- val globalNamingStack = q"_root_.chisel3.internal.DynamicNamingStack"
-
- /** Base transformer that provides the val name transform.
- * Should not be instantiated, since by default this will recurse everywhere and break the
- * naming context variable bounds.
- */
- trait ValNameTransformer extends Transformer {
- val contextVar: TermName
-
- override def transform(tree: Tree): Tree = tree match {
- // Intentionally not prefixed with $mods, since modifiers usually mean the val definition
- // is in a non-transformable location, like as a parameter list.
- // TODO: is this exhaustive / correct in all cases?
- case q"val $tname: $tpt = $expr" => {
- val TermName(tnameStr: String) = tname
- val transformedExpr = super.transform(expr)
- q"val $tname: $tpt = $contextVar.name($transformedExpr, $tnameStr)"
- }
- case other => super.transform(other)
- }
- }
-
- /** Module-specific val name transform, containing logic to prevent from recursing into inner
- * classes and applies the naming transform on inner functions.
- */
- class ClassBodyTransformer(val contextVar: TermName) extends ValNameTransformer {
- override def transform(tree: Tree): Tree = tree match {
- case q"$mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$earlydefns } with ..$parents { $self => ..$stats }" =>
- tree // don't recurse into inner classes
- case q"$mods trait $tpname[..$tparams] extends { ..$earlydefns } with ..$parents { $self => ..$stats }" =>
- tree // don't recurse into inner classes
- case q"$mods def $tname[..$tparams](...$paramss): $tpt = $expr" => {
- val Modifiers(_, _, annotations) = mods
- // don't apply naming transform twice
- val containsChiselName = annotations.map({ q"new chiselName()" equalsStructure _ }).fold(false)({ _ || _ })
- // transforming overloaded initializers causes errors, and the transform isn't helpful
- val isInitializer = tname == TermName("")
- if (containsChiselName || isInitializer) {
- tree
- } else {
- // apply chiselName transform by default
- val transformedExpr = transformHierarchicalMethod(expr)
- q"$mods def $tname[..$tparams](...$paramss): $tpt = $transformedExpr"
- }
- }
- case other => super.transform(other)
- }
- }
-
- /** Method-specific val name transform, handling the return case.
- */
- class MethodTransformer(val contextVar: TermName) extends ValNameTransformer {
- override def transform(tree: Tree): Tree = tree match {
- // TODO: better error messages when returning nothing
- case q"return $expr" => q"return $globalNamingStack.popReturnContext($expr, $contextVar)"
- // Do not recurse into methods
- case q"$mods def $tname[..$tparams](...$paramss): $tpt = $expr" => tree
- case other => super.transform(other)
- }
- }
-
- /** 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.
- * Transformed classes can be either Module or standard class.
- */
- def transformClassBody(stats: List[c.Tree]): Tree = {
- val contextVar = TermName(c.freshName("namingContext"))
- val transformedBody = (new ClassBodyTransformer(contextVar)).transformTrees(stats)
- // Note: passing "this" to popReturnContext is mandatory for propagation through non-module classes
- q"""
- val $contextVar = $globalNamingStack.pushContext()
- ..$transformedBody
- if($globalNamingStack.length() == 1){
- $contextVar.namePrefix("")
- }
- $globalNamingStack.popReturnContext(this, $contextVar)
- """
- }
-
- /** Applies the val name transform to a method body, doing additional bookkeeping with the
- * context to allow names to propagate and prefix through the function call stack.
- */
- def transformHierarchicalMethod(expr: c.Tree): Tree = {
- val contextVar = TermName(c.freshName("namingContext"))
- val transformedBody = (new MethodTransformer(contextVar)).transform(expr)
-
- q"""{
- val $contextVar = $globalNamingStack.pushContext()
- $globalNamingStack.popReturnContext($transformedBody, $contextVar)
- }
- """
- }
-
- /** Applies naming transforms to vals in the annotated module or method.
- *
- * For methods, a hierarchical naming transform is used, where it will try to give objects names
- * based on the call stack, assuming all functions on the stack are annotated as such and return
- * a non-AnyVal object. Does not recurse into inner functions.
- *
- * For modules, this serves as the root of the call stack hierarchy for naming purposes. Methods
- * will have chiselName annotations (non-recursively), but this does NOT affect inner classes.
- *
- * Basically rewrites all instances of:
- * val name = expr
- * to:
- * val name = context.name(expr, name)
- */
- def chiselName(annottees: c.Tree*): c.Tree = {
- var namedElts: Int = 0
-
- val transformed = annottees.map(annottee =>
- annottee match {
- case q"$mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$earlydefns } with ..$parents { $self => ..$stats }" => {
- val transformedStats = transformClassBody(stats)
- namedElts += 1
- q"$mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$earlydefns } with ..$parents { $self => ..$transformedStats }"
- }
- case q"$mods object $tname extends { ..$earlydefns } with ..$parents { $self => ..$body }" => {
- annottee // Don't fail noisly when a companion object is passed in with the actual class def
- }
- // Currently disallow on traits, this won't work well with inheritance.
- case q"$mods def $tname[..$tparams](...$paramss): $tpt = $expr" => {
- val transformedExpr = transformHierarchicalMethod(expr)
- namedElts += 1
- q"$mods def $tname[..$tparams](...$paramss): $tpt = $transformedExpr"
- }
- case other =>
- c.abort(
- c.enclosingPosition,
- s"@chiselName annotion may only be used on classes and methods, got ${showCode(other)}"
- )
- }
- )
-
- if (namedElts != 1) {
- c.abort(
- c.enclosingPosition,
- s"@chiselName annotation did not match exactly one valid tree, got:\r\n${annottees.map(tree => showCode(tree)).mkString("\r\n\r\n")}"
- )
- }
-
- q"..$transformed"
- }
-}
-
-@compileTimeOnly("enable macro paradise to expand macro annotations")
-class dump extends StaticAnnotation {
- def macroTransform(annottees: Any*): Any = macro chisel3.internal.naming.DebugTransforms.dump
-}
-@compileTimeOnly("enable macro paradise to expand macro annotations")
-class treedump extends StaticAnnotation {
- def macroTransform(annottees: Any*): Any = macro chisel3.internal.naming.DebugTransforms.treedump
-}
-@compileTimeOnly("enable macro paradise to expand macro annotations")
-@deprecated(
- "Use chisel3.experimental.AffectsChiselPrefix instead. @chiselName will be removed in Chisel 3.6",
- "Chisel 3.5"
-)
-class chiselName extends StaticAnnotation {
- def macroTransform(annottees: Any*): Any = macro chisel3.internal.naming.NamingTransforms.chiselName
-}
diff --git a/macros/src/main/scala/chisel3/internal/sourceinfo/SourceInfoTransform.scala b/macros/src/main/scala/chisel3/internal/sourceinfo/SourceInfoTransform.scala
deleted file mode 100644
index d772fd8b..00000000
--- a/macros/src/main/scala/chisel3/internal/sourceinfo/SourceInfoTransform.scala
+++ /dev/null
@@ -1,279 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-// This file transform macro definitions to explicitly add implicit source info to Chisel method
-// calls.
-
-package chisel3.internal.sourceinfo
-
-import scala.language.experimental.macros
-import scala.reflect.macros.blackbox.Context
-import scala.reflect.macros.whitebox
-
-/** Transforms a function call so that it can both provide implicit-style source information and
- * have a chained apply call. Without macros, only one is possible, since having a implicit
- * argument in the definition will cause the compiler to interpret a chained apply as an
- * explicit implicit argument and give type errors.
- *
- * Instead of an implicit argument, the public-facing function no longer takes a SourceInfo at all.
- * The macro transforms the public-facing function into a call to an internal function that takes
- * an explicit SourceInfo by inserting an implicitly[SourceInfo] as the explicit argument.
- */
-trait SourceInfoTransformMacro {
- val c: Context
- import c.universe._
- def thisObj: Tree = c.prefix.tree
- def implicitSourceInfo = q"implicitly[_root_.chisel3.internal.sourceinfo.SourceInfo]"
- def implicitCompileOptions = q"implicitly[_root_.chisel3.CompileOptions]"
-}
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object UIntTransform
-class UIntTransform(val c: Context) extends SourceInfoTransformMacro {
- import c.universe._
- def bitset(off: c.Tree, dat: c.Tree): c.Tree = {
- q"$thisObj.do_bitSet($off, $dat)($implicitSourceInfo, $implicitCompileOptions)"
- }
-}
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object InstTransform
-// Module instantiation transform
-class InstTransform(val c: Context) extends SourceInfoTransformMacro {
- import c.universe._
- def apply[T: c.WeakTypeTag](bc: c.Tree): c.Tree = {
- q"$thisObj.do_apply($bc)($implicitSourceInfo, $implicitCompileOptions)"
- }
-}
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object DefinitionTransform
-// Module instantiation transform
-class DefinitionTransform(val c: Context) extends SourceInfoTransformMacro {
- import c.universe._
- def apply[T: c.WeakTypeTag](proto: c.Tree): c.Tree = {
- q"$thisObj.do_apply($proto)($implicitSourceInfo, $implicitCompileOptions)"
- }
-}
-
-object DefinitionWrapTransform
-// Module instantiation transform
-class DefinitionWrapTransform(val c: Context) extends SourceInfoTransformMacro {
- import c.universe._
- def wrap[T: c.WeakTypeTag](proto: c.Tree): c.Tree = {
- q"$thisObj.do_wrap($proto)($implicitSourceInfo)"
- }
-}
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object InstanceTransform
-// Module instantiation transform
-class InstanceTransform(val c: Context) extends SourceInfoTransformMacro {
- import c.universe._
- def apply[T: c.WeakTypeTag](definition: c.Tree): c.Tree = {
- q"$thisObj.do_apply($definition)($implicitSourceInfo, $implicitCompileOptions)"
- }
-}
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object MemTransform
-class MemTransform(val c: Context) extends SourceInfoTransformMacro {
- import c.universe._
- def apply[T: c.WeakTypeTag](size: c.Tree, t: c.Tree): c.Tree = {
- q"$thisObj.do_apply($size, $t)($implicitSourceInfo, $implicitCompileOptions)"
- }
- def apply_ruw[T: c.WeakTypeTag](size: c.Tree, t: c.Tree, ruw: c.Tree): c.Tree = {
- q"$thisObj.do_apply($size, $t, $ruw)($implicitSourceInfo, $implicitCompileOptions)"
- }
-}
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object MuxTransform
-class MuxTransform(val c: Context) extends SourceInfoTransformMacro {
- import c.universe._
- def apply[T: c.WeakTypeTag](cond: c.Tree, con: c.Tree, alt: c.Tree): c.Tree = {
- val tpe = weakTypeOf[T]
- q"$thisObj.do_apply[$tpe]($cond, $con, $alt)($implicitSourceInfo, $implicitCompileOptions)"
- }
-}
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object VecTransform
-class VecTransform(val c: Context) extends SourceInfoTransformMacro {
- import c.universe._
- def apply_elts(elts: c.Tree): c.Tree = {
- q"$thisObj.do_apply($elts)($implicitSourceInfo, $implicitCompileOptions)"
- }
- def apply_elt0(elt0: c.Tree, elts: c.Tree*): c.Tree = {
- q"$thisObj.do_apply($elt0, ..$elts)($implicitSourceInfo, $implicitCompileOptions)"
- }
- def tabulate(n: c.Tree)(gen: c.Tree): c.Tree = {
- q"$thisObj.do_tabulate($n)($gen)($implicitSourceInfo, $implicitCompileOptions)"
- }
- def tabulate2D(n: c.Tree, m: c.Tree)(gen: c.Tree): c.Tree = {
- q"$thisObj.do_tabulate($n,$m)($gen)($implicitSourceInfo, $implicitCompileOptions)"
- }
- def tabulate3D(n: c.Tree, m: c.Tree, p: c.Tree)(gen: c.Tree): c.Tree = {
- q"$thisObj.do_tabulate($n,$m,$p)($gen)($implicitSourceInfo, $implicitCompileOptions)"
- }
- def fill(n: c.Tree)(gen: c.Tree): c.Tree = {
- q"$thisObj.do_fill($n)($gen)($implicitSourceInfo, $implicitCompileOptions)"
- }
- def fill2D(n: c.Tree, m: c.Tree)(gen: c.Tree): c.Tree = {
- q"$thisObj.do_fill($n,$m)($gen)($implicitSourceInfo, $implicitCompileOptions)"
- }
- def fill3D(n: c.Tree, m: c.Tree, p: c.Tree)(gen: c.Tree): c.Tree = {
- q"$thisObj.do_fill($n,$m,$p)($gen)($implicitSourceInfo, $implicitCompileOptions)"
- }
- def fill4D(n: c.Tree, m: c.Tree, p: c.Tree, q: c.Tree)(gen: c.Tree): c.Tree = {
- q"$thisObj.do_fill($n,$m,$p,$q)($gen)($implicitSourceInfo, $implicitCompileOptions)"
- }
- def iterate(start: c.Tree, len: c.Tree)(f: c.Tree): c.Tree = {
- q"$thisObj.do_iterate($start,$len)($f)($implicitSourceInfo, $implicitCompileOptions)"
- }
- def contains(x: c.Tree)(ev: c.Tree): c.Tree = {
- q"$thisObj.do_contains($x)($implicitSourceInfo, $ev, $implicitCompileOptions)"
- }
- def reduceTree(redOp: c.Tree, layerOp: c.Tree): c.Tree = {
- q"$thisObj.do_reduceTree($redOp,$layerOp)($implicitSourceInfo, $implicitCompileOptions)"
- }
- def reduceTreeDefault(redOp: c.Tree): c.Tree = {
- q"$thisObj.do_reduceTree($redOp)($implicitSourceInfo, $implicitCompileOptions)"
- }
-}
-
-/** "Automatic" source information transform / insertion macros, which generate the function name
- * based on the macro invocation (instead of explicitly writing out every transform).
- */
-abstract class AutoSourceTransform extends SourceInfoTransformMacro {
- import c.universe._
-
- /** Returns the TermName of the transformed function, which is the applied function name with do_
- * prepended.
- */
- def doFuncTerm: TermName = {
- val funcName = c.macroApplication match {
- case q"$_.$funcName[..$_](...$_)" => funcName
- case _ =>
- throw new Exception(
- s"Chisel Internal Error: Could not resolve function name from macro application: ${showCode(c.macroApplication)}"
- )
- }
- TermName("do_" + funcName)
- }
-}
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object SourceInfoTransform
-class SourceInfoTransform(val c: Context) extends AutoSourceTransform {
- import c.universe._
-
- def noArg: c.Tree = {
- q"$thisObj.$doFuncTerm($implicitSourceInfo, $implicitCompileOptions)"
- }
-
- /** Necessary for dummy methods to auto-apply their arguments to this macro */
- def noArgDummy(dummy: c.Tree*): c.Tree = {
- q"$thisObj.$doFuncTerm($implicitSourceInfo, $implicitCompileOptions)"
- }
-
- def thatArg(that: c.Tree): c.Tree = {
- q"$thisObj.$doFuncTerm($that)($implicitSourceInfo, $implicitCompileOptions)"
- }
-
- def nArg(n: c.Tree): c.Tree = {
- q"$thisObj.$doFuncTerm($n)($implicitSourceInfo, $implicitCompileOptions)"
- }
-
- def pArg(p: c.Tree): c.Tree = {
- q"$thisObj.$doFuncTerm($p)($implicitSourceInfo, $implicitCompileOptions)"
- }
-
- def inArg(in: c.Tree): c.Tree = {
- q"$thisObj.$doFuncTerm($in)($implicitSourceInfo, $implicitCompileOptions)"
- }
-
- def xArg(x: c.Tree): c.Tree = {
- q"$thisObj.$doFuncTerm($x)($implicitSourceInfo, $implicitCompileOptions)"
- }
-
- def xyArg(x: c.Tree, y: c.Tree): c.Tree = {
- q"$thisObj.$doFuncTerm($x, $y)($implicitSourceInfo, $implicitCompileOptions)"
- }
-
- def xyzArg(idx: c.Tree, en: c.Tree, clock: c.Tree): c.Tree = {
- q"$thisObj.$doFuncTerm($idx, $en, $clock)($implicitSourceInfo, $implicitCompileOptions)"
- }
-
- def xEnArg(x: c.Tree, en: c.Tree): c.Tree = {
- q"$thisObj.$doFuncTerm($x, $en)($implicitSourceInfo, $implicitCompileOptions)"
- }
-}
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object CompileOptionsTransform
-class CompileOptionsTransform(val c: Context) extends AutoSourceTransform {
- import c.universe._
-
- def thatArg(that: c.Tree): c.Tree = {
- q"$thisObj.$doFuncTerm($that)($implicitCompileOptions)"
- }
-
- def inArg(in: c.Tree): c.Tree = {
- q"$thisObj.$doFuncTerm($in)($implicitCompileOptions)"
- }
-
- def pArg(p: c.Tree): c.Tree = {
- q"$thisObj.$doFuncTerm($p)($implicitCompileOptions)"
- }
-}
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object SourceInfoWhiteboxTransform
-
-/** Special whitebox version of the blackbox SourceInfoTransform, used when fun things need to
- * happen to satisfy the type system while preventing the use of macro overrides.
- */
-class SourceInfoWhiteboxTransform(val c: whitebox.Context) extends AutoSourceTransform {
- import c.universe._
-
- def noArg: c.Tree = {
- q"$thisObj.$doFuncTerm($implicitSourceInfo, $implicitCompileOptions)"
- }
-
- /** Necessary for dummy methods to auto-apply their arguments to this macro */
- def noArgDummy(dummy: c.Tree*): c.Tree = {
- q"$thisObj.$doFuncTerm($implicitSourceInfo, $implicitCompileOptions)"
- }
-
- def thatArg(that: c.Tree): c.Tree = {
- q"$thisObj.$doFuncTerm($that)($implicitSourceInfo, $implicitCompileOptions)"
- }
-}
-
-// Workaround for https://github.com/sbt/sbt/issues/3966
-object IntLiteralApplyTransform
-
-class IntLiteralApplyTransform(val c: Context) extends AutoSourceTransform {
- import c.universe._
-
- def safeApply(x: c.Tree): c.Tree = {
- c.macroApplication match {
- case q"$_.$clazz($lit).$func.apply($arg)" =>
- if (
- Set("U", "S").contains(func.toString) &&
- Set("fromStringToLiteral", "fromIntToLiteral", "fromLongToIteral", "fromBigIntToLiteral").contains(
- clazz.toString
- )
- ) {
- val msg =
- s"""Passing an Int to .$func is usually a mistake: It does *not* set the width but does a bit extract.
- |Did you mean .$func($arg.W)?
- |If you do want bit extraction, use .$func.extract($arg) instead.
- |""".stripMargin
- c.warning(c.enclosingPosition, msg)
- }
- case _ => // do nothing
- }
- q"$thisObj.$doFuncTerm($x)($implicitSourceInfo, $implicitCompileOptions)"
- }
-}
--
cgit v1.2.3