Apply scalafmt

Command:
sbt scalafmtAll

1 files changed, 165 insertions, 41 deletions

diff --git a/core/src/main/scala/chisel3/experimental/package.scala b/core/src/main/scala/chisel3/experimental/package.scala
index 5397a1c3..ce258a25 100644
--- a/core/src/main/scala/chisel3/experimental/package.scala
+++ b/core/src/main/scala/chisel3/experimental/package.scala
@@ -16,9 +16,9 @@ package object experimental {
   import chisel3.internal.BaseModule
 
   // Implicit conversions for BlackBox Parameters
-  implicit def fromIntToIntParam(x: Int): IntParam = IntParam(BigInt(x))
-  implicit def fromLongToIntParam(x: Long): IntParam = IntParam(BigInt(x))
-  implicit def fromBigIntToIntParam(x: BigInt): IntParam = IntParam(x)
+  implicit def fromIntToIntParam(x:       Int):    IntParam = IntParam(BigInt(x))
+  implicit def fromLongToIntParam(x:      Long):   IntParam = IntParam(BigInt(x))
+  implicit def fromBigIntToIntParam(x:    BigInt): IntParam = IntParam(x)
   implicit def fromDoubleToDoubleParam(x: Double): DoubleParam = DoubleParam(x)
   implicit def fromStringToStringParam(x: String): StringParam = StringParam(x)
 
@@ -32,6 +32,7 @@ package object experimental {
   type ClonePorts = BaseModule.ClonePorts
 
   object CloneModuleAsRecord {
+
     /** Clones an existing module and returns a record of all its top-level ports.
       * Each element of the record is named with a string matching the
       * corresponding port's name and shares the port's type.
@@ -41,13 +42,18 @@ package object experimental {
       * q2_io.enq <> q1.io.deq
       * }}}
       */
-    def apply(proto: BaseModule)(implicit sourceInfo: chisel3.internal.sourceinfo.SourceInfo, compileOptions: CompileOptions): ClonePorts = {
+    def apply(
+      proto: BaseModule
+    )(
+      implicit sourceInfo: chisel3.internal.sourceinfo.SourceInfo,
+      compileOptions:      CompileOptions
+    ): ClonePorts = {
       BaseModule.cloneIORecord(proto)
     }
   }
 
   val requireIsHardware = chisel3.internal.requireIsHardware
-  val requireIsChiselType =  chisel3.internal.requireIsChiselType
+  val requireIsChiselType = chisel3.internal.requireIsChiselType
   type Direction = ActualDirection
   val Direction = ActualDirection
 
@@ -68,6 +74,7 @@ package object experimental {
 
   class dump extends chisel3.internal.naming.dump
   class treedump extends chisel3.internal.naming.treedump
+
   /** Experimental macro for naming Chisel hardware values
     *
     * By default, Chisel uses reflection for naming which only works for public fields of `Bundle`
@@ -94,6 +101,7 @@ package object experimental {
     * }}}
     */
   class chiselName extends chisel3.internal.naming.chiselName
+
   /** Do not name instances of this type in [[chiselName]]
     *
     * By default, `chiselName` will include `val` names of instances of annotated classes as a
@@ -138,6 +146,7 @@ package object experimental {
     */
   object VecLiterals {
     implicit class AddVecLiteralConstructor[T <: Data](x: Vec[T]) {
+
       /** Given a generator of a list tuples of the form [Int, Data]
         * constructs a Vec literal, parallel concept to `BundleLiteral`
         *
@@ -150,15 +159,16 @@ package object experimental {
     }
 
     implicit class AddObjectLiteralConstructor(x: Vec.type) {
+
       /** This provides an literal construction method for cases using
         * object `Vec` as in `Vec.Lit(1.U, 2.U)`
         */
       def Lit[T <: Data](elems: T*)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Vec[T] = {
         require(elems.nonEmpty, s"Lit.Vec(...) must have at least one element")
-        val indexElements = elems.zipWithIndex.map { case (element, index) => (index, element)}
+        val indexElements = elems.zipWithIndex.map { case (element, index) => (index, element) }
         val widestElement = elems.maxBy(_.getWidth)
         val vec: Vec[T] = Vec.apply(indexElements.length, chiselTypeOf(widestElement))
-        vec.Lit(indexElements:_*)
+        vec.Lit(indexElements: _*)
       }
     }
   }
@@ -178,7 +188,7 @@ package object experimental {
     */
   final class HWTuple2[+A <: Data, +B <: Data] private[chisel3] (val _1: A, val _2: B) extends Bundle()(Strict) {
     // Because this implementation exists in chisel3.core, it cannot compile with the plugin, so we implement the behavior manually
-    override protected def _usingPlugin: Boolean = true
+    override protected def _usingPlugin:   Boolean = true
     override protected def _cloneTypeImpl: Bundle = new HWTuple2(chiselTypeClone(_1), chiselTypeClone(_2))
   }
 
@@ -188,12 +198,16 @@ package object experimental {
     * `chisel3.experimental.conversions`
     */
   final class HWTuple3[+A <: Data, +B <: Data, +C <: Data] private[chisel3] (
-    val _1: A, val _2: B, val _3: C
-  ) extends Bundle()(Strict) {
+    val _1: A,
+    val _2: B,
+    val _3: C)
+      extends Bundle()(Strict) {
     // Because this implementation exists in chisel3.core, it cannot compile with the plugin, so we implement the behavior manually
     override protected def _usingPlugin: Boolean = true
     override protected def _cloneTypeImpl: Bundle = new HWTuple3(
-      chiselTypeClone(_1), chiselTypeClone(_2), chiselTypeClone(_3)
+      chiselTypeClone(_1),
+      chiselTypeClone(_2),
+      chiselTypeClone(_3)
     )
   }
 
@@ -203,12 +217,18 @@ package object experimental {
     * `chisel3.experimental.conversions`
     */
   final class HWTuple4[+A <: Data, +B <: Data, +C <: Data, +D <: Data] private[chisel3] (
-    val _1: A, val _2: B, val _3: C, val _4: D
-  ) extends Bundle()(Strict) {
+    val _1: A,
+    val _2: B,
+    val _3: C,
+    val _4: D)
+      extends Bundle()(Strict) {
     // Because this implementation exists in chisel3.core, it cannot compile with the plugin, so we implement the behavior manually
     override protected def _usingPlugin: Boolean = true
     override protected def _cloneTypeImpl: Bundle = new HWTuple4(
-      chiselTypeClone(_1), chiselTypeClone(_2), chiselTypeClone(_3), chiselTypeClone(_4)
+      chiselTypeClone(_1),
+      chiselTypeClone(_2),
+      chiselTypeClone(_3),
+      chiselTypeClone(_4)
     )
   }
 
@@ -218,12 +238,20 @@ package object experimental {
     * `chisel3.experimental.conversions`
     */
   final class HWTuple5[+A <: Data, +B <: Data, +C <: Data, +D <: Data, +E <: Data] private[chisel3] (
-    val _1: A, val _2: B, val _3: C, val _4: D, val _5: E
-  ) extends Bundle()(Strict) {
+    val _1: A,
+    val _2: B,
+    val _3: C,
+    val _4: D,
+    val _5: E)
+      extends Bundle()(Strict) {
     // Because this implementation exists in chisel3.core, it cannot compile with the plugin, so we implement the behavior manually
     override protected def _usingPlugin: Boolean = true
     override protected def _cloneTypeImpl: Bundle = new HWTuple5(
-      chiselTypeClone(_1), chiselTypeClone(_2), chiselTypeClone(_3), chiselTypeClone(_4), chiselTypeClone(_5)
+      chiselTypeClone(_1),
+      chiselTypeClone(_2),
+      chiselTypeClone(_3),
+      chiselTypeClone(_4),
+      chiselTypeClone(_5)
     )
   }
 
@@ -233,12 +261,21 @@ package object experimental {
     * `chisel3.experimental.conversions`
     */
   final class HWTuple6[+A <: Data, +B <: Data, +C <: Data, +D <: Data, +E <: Data, +F <: Data] private[chisel3] (
-    val _1: A, val _2: B, val _3: C, val _4: D, val _5: E, val _6: F
-  ) extends Bundle()(Strict) {
+    val _1: A,
+    val _2: B,
+    val _3: C,
+    val _4: D,
+    val _5: E,
+    val _6: F)
+      extends Bundle()(Strict) {
     // Because this implementation exists in chisel3.core, it cannot compile with the plugin, so we implement the behavior manually
     override protected def _usingPlugin: Boolean = true
     override protected def _cloneTypeImpl: Bundle = new HWTuple6(
-      chiselTypeClone(_1), chiselTypeClone(_2), chiselTypeClone(_3), chiselTypeClone(_4), chiselTypeClone(_5),
+      chiselTypeClone(_1),
+      chiselTypeClone(_2),
+      chiselTypeClone(_3),
+      chiselTypeClone(_4),
+      chiselTypeClone(_5),
       chiselTypeClone(_6)
     )
   }
@@ -248,14 +285,33 @@ package object experimental {
     * Users may not instantiate this class directly. Instead they should use the implicit conversion from `Tuple7` in
     * `chisel3.experimental.conversions`
     */
-  final class HWTuple7[+A <: Data, +B <: Data, +C <: Data, +D <: Data, +E <: Data, +F <: Data, +G <: Data] private[chisel3] (
-    val _1: A, val _2: B, val _3: C, val _4: D, val _5: E, val _6: F, val _7: G
-  ) extends Bundle()(Strict) {
+  final class HWTuple7[
+    +A <: Data,
+    +B <: Data,
+    +C <: Data,
+    +D <: Data,
+    +E <: Data,
+    +F <: Data,
+    +G <: Data
+  ] private[chisel3] (
+    val _1: A,
+    val _2: B,
+    val _3: C,
+    val _4: D,
+    val _5: E,
+    val _6: F,
+    val _7: G)
+      extends Bundle()(Strict) {
     // Because this implementation exists in chisel3.core, it cannot compile with the plugin, so we implement the behavior manually
     override protected def _usingPlugin: Boolean = true
     override protected def _cloneTypeImpl: Bundle = new HWTuple7(
-      chiselTypeClone(_1), chiselTypeClone(_2), chiselTypeClone(_3), chiselTypeClone(_4), chiselTypeClone(_5),
-      chiselTypeClone(_6), chiselTypeClone(_7)
+      chiselTypeClone(_1),
+      chiselTypeClone(_2),
+      chiselTypeClone(_3),
+      chiselTypeClone(_4),
+      chiselTypeClone(_5),
+      chiselTypeClone(_6),
+      chiselTypeClone(_7)
     )
   }
 
@@ -265,15 +321,35 @@ package object experimental {
     * `chisel3.experimental.conversions`
     */
   final class HWTuple8[
-    +A <: Data, +B <: Data, +C <: Data, +D <: Data, +E <: Data, +F <: Data, +G <: Data, +H <: Data
+    +A <: Data,
+    +B <: Data,
+    +C <: Data,
+    +D <: Data,
+    +E <: Data,
+    +F <: Data,
+    +G <: Data,
+    +H <: Data
   ] private[chisel3] (
-    val _1: A, val _2: B, val _3: C, val _4: D, val _5: E, val _6: F, val _7: G, val _8: H
-  ) extends Bundle()(Strict) {
+    val _1: A,
+    val _2: B,
+    val _3: C,
+    val _4: D,
+    val _5: E,
+    val _6: F,
+    val _7: G,
+    val _8: H)
+      extends Bundle()(Strict) {
     // Because this implementation exists in chisel3.core, it cannot compile with the plugin, so we implement the behavior manually
     override protected def _usingPlugin: Boolean = true
     override protected def _cloneTypeImpl: Bundle = new HWTuple8(
-      chiselTypeClone(_1), chiselTypeClone(_2), chiselTypeClone(_3), chiselTypeClone(_4), chiselTypeClone(_5),
-      chiselTypeClone(_6), chiselTypeClone(_7), chiselTypeClone(_8)
+      chiselTypeClone(_1),
+      chiselTypeClone(_2),
+      chiselTypeClone(_3),
+      chiselTypeClone(_4),
+      chiselTypeClone(_5),
+      chiselTypeClone(_6),
+      chiselTypeClone(_7),
+      chiselTypeClone(_8)
     )
   }
 
@@ -283,34 +359,82 @@ package object experimental {
     * `chisel3.experimental.conversions`
     */
   final class HWTuple9[
-    +A <: Data, +B <: Data, +C <: Data, +D <: Data, +E <: Data, +F <: Data, +G <: Data, +H <: Data, +I <: Data
+    +A <: Data,
+    +B <: Data,
+    +C <: Data,
+    +D <: Data,
+    +E <: Data,
+    +F <: Data,
+    +G <: Data,
+    +H <: Data,
+    +I <: Data
   ] private[chisel3] (
-    val _1: A, val _2: B, val _3: C, val _4: D, val _5: E, val _6: F, val _7: G, val _8: H, val _9: I
-  ) extends Bundle()(Strict) {
+    val _1: A,
+    val _2: B,
+    val _3: C,
+    val _4: D,
+    val _5: E,
+    val _6: F,
+    val _7: G,
+    val _8: H,
+    val _9: I)
+      extends Bundle()(Strict) {
     // Because this implementation exists in chisel3.core, it cannot compile with the plugin, so we implement the behavior manually
     override protected def _usingPlugin: Boolean = true
     override protected def _cloneTypeImpl: Bundle = new HWTuple9(
-      chiselTypeClone(_1), chiselTypeClone(_2), chiselTypeClone(_3), chiselTypeClone(_4), chiselTypeClone(_5),
-      chiselTypeClone(_6), chiselTypeClone(_7), chiselTypeClone(_8), chiselTypeClone(_9)
+      chiselTypeClone(_1),
+      chiselTypeClone(_2),
+      chiselTypeClone(_3),
+      chiselTypeClone(_4),
+      chiselTypeClone(_5),
+      chiselTypeClone(_6),
+      chiselTypeClone(_7),
+      chiselTypeClone(_8),
+      chiselTypeClone(_9)
     )
   }
 
-
   /** [[Data]] equivalent of Scala's [[Tuple9]]
     *
     * Users may not instantiate this class directly. Instead they should use the implicit conversion from `Tuple9` in
     * `chisel3.experimental.conversions`
     */
   final class HWTuple10[
-    +A <: Data, +B <: Data, +C <: Data, +D <: Data, +E <: Data, +F <: Data, +G <: Data, +H <: Data, +I <: Data, +J <: Data
+    +A <: Data,
+    +B <: Data,
+    +C <: Data,
+    +D <: Data,
+    +E <: Data,
+    +F <: Data,
+    +G <: Data,
+    +H <: Data,
+    +I <: Data,
+    +J <: Data
   ] private[chisel3] (
-    val _1: A, val _2: B, val _3: C, val _4: D, val _5: E, val _6: F, val _7: G, val _8: H, val _9: I, val _10: J
-  ) extends Bundle()(Strict) {
+    val _1:  A,
+    val _2:  B,
+    val _3:  C,
+    val _4:  D,
+    val _5:  E,
+    val _6:  F,
+    val _7:  G,
+    val _8:  H,
+    val _9:  I,
+    val _10: J)
+      extends Bundle()(Strict) {
     // Because this implementation exists in chisel3.core, it cannot compile with the plugin, so we implement the behavior manually
     override protected def _usingPlugin: Boolean = true
     override protected def _cloneTypeImpl: Bundle = new HWTuple10(
-      chiselTypeClone(_1), chiselTypeClone(_2), chiselTypeClone(_3), chiselTypeClone(_4), chiselTypeClone(_5),
-      chiselTypeClone(_6), chiselTypeClone(_7), chiselTypeClone(_8), chiselTypeClone(_9), chiselTypeClone(_10)
+      chiselTypeClone(_1),
+      chiselTypeClone(_2),
+      chiselTypeClone(_3),
+      chiselTypeClone(_4),
+      chiselTypeClone(_5),
+      chiselTypeClone(_6),
+      chiselTypeClone(_7),
+      chiselTypeClone(_8),
+      chiselTypeClone(_9),
+      chiselTypeClone(_10)
     )
   }
 }