Apply scalafmt

Command:
sbt scalafmtAll

1 files changed, 84 insertions, 68 deletions

diff --git a/core/src/main/scala/chisel3/internal/MonoConnect.scala b/core/src/main/scala/chisel3/internal/MonoConnect.scala
index 6173fc91..b4d9aeff 100644
--- a/core/src/main/scala/chisel3/internal/MonoConnect.scala
+++ b/core/src/main/scala/chisel3/internal/MonoConnect.scala
@@ -12,28 +12,28 @@ import scala.language.experimental.macros
 import chisel3.internal.sourceinfo.SourceInfo
 
 /**
-* MonoConnect.connect executes a mono-directional connection element-wise.
-*
-* Note that this isn't commutative. There is an explicit source and sink
-* already determined before this function is called.
-*
-* The connect operation will recurse down the left Data (with the right Data).
-* An exception will be thrown if a movement through the left cannot be matched
-* in the right. The right side is allowed to have extra Record fields.
-* Vecs must still be exactly the same size.
-*
-* See elemConnect for details on how the root connections are issued.
-*
-* Note that a valid sink must be writable so, one of these must hold:
-* - Is an internal writable node (Reg or Wire)
-* - Is an output of the current module
-* - Is an input of a submodule of the current module
-*
-* Note that a valid source must be readable so, one of these must hold:
-* - Is an internal readable node (Reg, Wire, Op)
-* - Is a literal
-* - Is a port of the current module or submodule of the current module
-*/
+  * MonoConnect.connect executes a mono-directional connection element-wise.
+  *
+  * Note that this isn't commutative. There is an explicit source and sink
+  * already determined before this function is called.
+  *
+  * The connect operation will recurse down the left Data (with the right Data).
+  * An exception will be thrown if a movement through the left cannot be matched
+  * in the right. The right side is allowed to have extra Record fields.
+  * Vecs must still be exactly the same size.
+  *
+  * See elemConnect for details on how the root connections are issued.
+  *
+  * Note that a valid sink must be writable so, one of these must hold:
+  * - Is an internal writable node (Reg or Wire)
+  * - Is an output of the current module
+  * - Is an input of a submodule of the current module
+  *
+  * Note that a valid source must be readable so, one of these must hold:
+  * - Is an internal readable node (Reg, Wire, Op)
+  * - Is a literal
+  * - Is a port of the current module or submodule of the current module
+  */
 
 private[chisel3] object MonoConnect {
   def formatName(data: Data) = s"""${data.earlyName} in ${data.parentNameOpt.getOrElse("(unknown)")}"""
@@ -41,9 +41,13 @@ private[chisel3] object MonoConnect {
   // These are all the possible exceptions that can be thrown.
   // These are from element-level connection
   def UnreadableSourceException(sink: Data, source: Data) =
-    MonoConnectException(s"""${formatName(source)} cannot be read from module ${sink.parentNameOpt.getOrElse("(unknown)")}.""")
+    MonoConnectException(
+      s"""${formatName(source)} cannot be read from module ${sink.parentNameOpt.getOrElse("(unknown)")}."""
+    )
   def UnwritableSinkException(sink: Data, source: Data) =
-    MonoConnectException(s"""${formatName(sink)} cannot be written from module ${source.parentNameOpt.getOrElse("(unknown)")}.""")
+    MonoConnectException(
+      s"""${formatName(sink)} cannot be written from module ${source.parentNameOpt.getOrElse("(unknown)")}."""
+    )
   def SourceEscapedWhenScopeException(source: Data) =
     MonoConnectException(s"Source ${formatName(source)} has escaped the scope of the when in which it was constructed.")
   def SinkEscapedWhenScopeException(sink: Data) =
@@ -56,7 +60,9 @@ private[chisel3] object MonoConnect {
   def MissingFieldException(field: String) =
     MonoConnectException(s"Source Record missing field ($field).")
   def MismatchedException(sink: Data, source: Data) =
-    MonoConnectException(s"Sink (${sink.cloneType.toString}) and Source (${source.cloneType.toString}) have different types.")
+    MonoConnectException(
+      s"Sink (${sink.cloneType.toString}) and Source (${source.cloneType.toString}) have different types."
+    )
   def DontCareCantBeSink =
     MonoConnectException("DontCare cannot be a connection sink")
   def AnalogCantBeMonoSink(sink: Data) =
@@ -64,28 +70,32 @@ private[chisel3] object MonoConnect {
   def AnalogCantBeMonoSource(source: Data) =
     MonoConnectException(s"Source ${formatName(source)} of type Analog cannot participate in a mono connection (:=)")
   def AnalogMonoConnectionException(source: Data, sink: Data) =
-    MonoConnectException(s"Source ${formatName(source)} and sink ${formatName(sink)} of type Analog cannot participate in a mono connection (:=)")
+    MonoConnectException(
+      s"Source ${formatName(source)} and sink ${formatName(sink)} of type Analog cannot participate in a mono connection (:=)"
+    )
 
   def checkWhenVisibility(x: Data): Boolean = {
     x.topBinding match {
-      case mp: MemoryPortBinding => true // TODO (albert-magyar): remove this "bridge" for odd enable logic of current CHIRRTL memories
+      case mp: MemoryPortBinding =>
+        true // TODO (albert-magyar): remove this "bridge" for odd enable logic of current CHIRRTL memories
       case cd: ConditionalDeclarable => cd.visibility.map(_.active()).getOrElse(true)
       case _ => true
     }
   }
 
   /** This function is what recursively tries to connect a sink and source together
-  *
-  * There is some cleverness in the use of internal try-catch to catch exceptions
-  * during the recursive decent and then rethrow them with extra information added.
-  * This gives the user a 'path' to where in the connections things went wrong.
-  */
+    *
+    * There is some cleverness in the use of internal try-catch to catch exceptions
+    * during the recursive decent and then rethrow them with extra information added.
+    * This gives the user a 'path' to where in the connections things went wrong.
+    */
   def connect(
-      sourceInfo: SourceInfo,
-      connectCompileOptions: CompileOptions,
-      sink: Data,
-      source: Data,
-      context_mod: RawModule): Unit =
+    sourceInfo:            SourceInfo,
+    connectCompileOptions: CompileOptions,
+    sink:                  Data,
+    source:                Data,
+    context_mod:           RawModule
+  ): Unit =
     (sink, source) match {
 
       // Handle legal element cases, note (Bool, Bool) is caught by the first two, as Bool is a UInt
@@ -118,8 +128,8 @@ private[chisel3] object MonoConnect {
 
       // Handle Vec case
       case (sink_v: Vec[Data @unchecked], source_v: Vec[Data @unchecked]) =>
-        if(sink_v.length != source_v.length) { throw MismatchedVecException }
-        for(idx <- 0 until sink_v.length) {
+        if (sink_v.length != source_v.length) { throw MismatchedVecException }
+        for (idx <- 0 until sink_v.length) {
           try {
             implicit val compileOptions = connectCompileOptions
             connect(sourceInfo, connectCompileOptions, sink_v(idx), source_v(idx), context_mod)
@@ -129,7 +139,7 @@ private[chisel3] object MonoConnect {
         }
       // Handle Vec connected to DontCare. Apply the DontCare to individual elements.
       case (sink_v: Vec[Data @unchecked], DontCare) =>
-        for(idx <- 0 until sink_v.length) {
+        for (idx <- 0 until sink_v.length) {
           try {
             implicit val compileOptions = connectCompileOptions
             connect(sourceInfo, connectCompileOptions, sink_v(idx), source, context_mod)
@@ -141,7 +151,7 @@ private[chisel3] object MonoConnect {
       // Handle Record case
       case (sink_r: Record, source_r: Record) =>
         // For each field, descend with right
-        for((field, sink_sub) <- sink_r.elements) {
+        for ((field, sink_sub) <- sink_r.elements) {
           try {
             source_r.elements.get(field) match {
               case Some(source_sub) => connect(sourceInfo, connectCompileOptions, sink_sub, source_sub, context_mod)
@@ -158,7 +168,7 @@ private[chisel3] object MonoConnect {
       // Handle Record connected to DontCare. Apply the DontCare to individual elements.
       case (sink_r: Record, DontCare) =>
         // For each field, descend with right
-        for((field, sink_sub) <- sink_r.elements) {
+        for ((field, sink_sub) <- sink_r.elements) {
           try {
             connect(sourceInfo, connectCompileOptions, sink_sub, source, context_mod)
           } catch {
@@ -171,7 +181,7 @@ private[chisel3] object MonoConnect {
       // DontCare as a sink is illegal.
       case (DontCare, _) => throw DontCareCantBeSink
       // Analog is illegal in mono connections.
-      case (_: Analog, _:Analog) => throw AnalogMonoConnectionException(source, sink)
+      case (_: Analog, _: Analog) => throw AnalogMonoConnectionException(source, sink)
       // Analog is illegal in mono connections.
       case (_: Analog, _) => throw AnalogCantBeMonoSink(sink)
       // Analog is illegal in mono connections.
@@ -192,13 +202,19 @@ private[chisel3] object MonoConnect {
 
   // This function checks if element-level connection operation allowed.
   // Then it either issues it or throws the appropriate exception.
-  def elemConnect(implicit sourceInfo: SourceInfo, connectCompileOptions: CompileOptions, _sink: Element, _source: Element, context_mod: RawModule): Unit = {
-    import BindingDirection.{Internal, Input, Output} // Using extensively so import these
+  def elemConnect(
+    implicit sourceInfo:   SourceInfo,
+    connectCompileOptions: CompileOptions,
+    _sink:                 Element,
+    _source:               Element,
+    context_mod:           RawModule
+  ): Unit = {
+    import BindingDirection.{Input, Internal, Output} // Using extensively so import these
     val sink = reify(_sink)
     val source = reify(_source)
     // If source has no location, assume in context module
     // This can occur if is a literal, unbound will error previously
-    val sink_mod: BaseModule   = sink.topBinding.location.getOrElse(throw UnwritableSinkException(sink, source))
+    val sink_mod:   BaseModule = sink.topBinding.location.getOrElse(throw UnwritableSinkException(sink, source))
     val source_mod: BaseModule = source.topBinding.location.getOrElse(context_mod)
 
     val sink_parent = Builder.retrieveParent(sink_mod, context_mod).getOrElse(None)
@@ -216,69 +232,69 @@ private[chisel3] object MonoConnect {
     }
 
     // CASE: Context is same module that both left node and right node are in
-    if( (context_mod == sink_mod) && (context_mod == source_mod) ) {
+    if ((context_mod == sink_mod) && (context_mod == source_mod)) {
       ((sink_direction, source_direction): @unchecked) match {
         //    SINK          SOURCE
         //    CURRENT MOD   CURRENT MOD
-        case (Output,       _) => issueConnect(sink, source)
-        case (Internal,     _) => issueConnect(sink, source)
-        case (Input,        _) => throw UnwritableSinkException(sink, source)
+        case (Output, _)   => issueConnect(sink, source)
+        case (Internal, _) => issueConnect(sink, source)
+        case (Input, _)    => throw UnwritableSinkException(sink, source)
       }
     }
 
     // CASE: Context is same module as sink node and right node is in a child module
-    else if((sink_mod == context_mod) && (source_parent == context_mod)) {
+    else if ((sink_mod == context_mod) && (source_parent == context_mod)) {
       // Thus, right node better be a port node and thus have a direction
       ((sink_direction, source_direction): @unchecked) match {
         //    SINK          SOURCE
         //    CURRENT MOD   CHILD MOD
-        case (Internal,     Output) => issueConnect(sink, source)
-        case (Internal,     Input)  => issueConnect(sink, source)
-        case (Output,       Output) => issueConnect(sink, source)
-        case (Output,       Input)  => issueConnect(sink, source)
-        case (_,            Internal) => {
+        case (Internal, Output) => issueConnect(sink, source)
+        case (Internal, Input)  => issueConnect(sink, source)
+        case (Output, Output)   => issueConnect(sink, source)
+        case (Output, Input)    => issueConnect(sink, source)
+        case (_, Internal) => {
           if (!(connectCompileOptions.dontAssumeDirectionality)) {
             issueConnect(sink, source)
           } else {
             throw UnreadableSourceException(sink, source)
           }
         }
-        case (Input,        Output) if (!(connectCompileOptions.dontTryConnectionsSwapped)) => issueConnect(source, sink)
-        case (Input,        _)    => throw UnwritableSinkException(sink, source)
+        case (Input, Output) if (!(connectCompileOptions.dontTryConnectionsSwapped)) => issueConnect(source, sink)
+        case (Input, _)                                                              => throw UnwritableSinkException(sink, source)
       }
     }
 
     // CASE: Context is same module as source node and sink node is in child module
-    else if((source_mod == context_mod) && (sink_parent == context_mod)) {
+    else if ((source_mod == context_mod) && (sink_parent == context_mod)) {
       // Thus, left node better be a port node and thus have a direction
       ((sink_direction, source_direction): @unchecked) match {
         //    SINK          SOURCE
         //    CHILD MOD     CURRENT MOD
-        case (Input,        _) => issueConnect(sink, source)
-        case (Output,       _) => throw UnwritableSinkException(sink, source)
-        case (Internal,     _) => throw UnwritableSinkException(sink, source)
+        case (Input, _)    => issueConnect(sink, source)
+        case (Output, _)   => throw UnwritableSinkException(sink, source)
+        case (Internal, _) => throw UnwritableSinkException(sink, source)
       }
     }
 
     // CASE: Context is the parent module of both the module containing sink node
     //                                        and the module containing source node
     //   Note: This includes case when sink and source in same module but in parent
-    else if((sink_parent == context_mod) && (source_parent == context_mod)) {
+    else if ((sink_parent == context_mod) && (source_parent == context_mod)) {
       // Thus both nodes must be ports and have a direction
       ((sink_direction, source_direction): @unchecked) match {
         //    SINK          SOURCE
         //    CHILD MOD     CHILD MOD
-        case (Input,        Input)  => issueConnect(sink, source)
-        case (Input,        Output) => issueConnect(sink, source)
-        case (Output,       _)      => throw UnwritableSinkException(sink, source)
-        case (_,            Internal) => {
+        case (Input, Input)  => issueConnect(sink, source)
+        case (Input, Output) => issueConnect(sink, source)
+        case (Output, _)     => throw UnwritableSinkException(sink, source)
+        case (_, Internal) => {
           if (!(connectCompileOptions.dontAssumeDirectionality)) {
             issueConnect(sink, source)
           } else {
             throw UnreadableSourceException(sink, source)
           }
         }
-        case (Internal,     _)      => throw UnwritableSinkException(sink, source)
+        case (Internal, _) => throw UnwritableSinkException(sink, source)
       }
     }