Merge pull request #302 from ucb-bar/fix_more_styles

Style Fixes for Compiler, LoweringCompiler, WIR

3 files changed, 168 insertions, 168 deletions

diff --git a/src/main/scala/firrtl/Compiler.scala b/src/main/scala/firrtl/Compiler.scala
index 4bc60c00..f566544e 100644
--- a/src/main/scala/firrtl/Compiler.scala
+++ b/src/main/scala/firrtl/Compiler.scala
@@ -43,7 +43,7 @@ case class RenameMap(map: Map[Named, Seq[Named]])
 //                 Transforms
 // -------------------------------------------
 
-case class TransformResult (
+case class TransformResult(
   circuit: Circuit,
   renames: Option[RenameMap] = None,
   annotation: Option[AnnotationMap] = None)
@@ -51,7 +51,7 @@ case class TransformResult (
 // - Transforms a circuit
 // - Can consume multiple CircuitAnnotation's
 trait Transform {
-  def execute (circuit: Circuit, annotationMap: AnnotationMap): TransformResult
+  def execute(circuit: Circuit, annotationMap: AnnotationMap): TransformResult
 }
 
 
@@ -59,34 +59,36 @@ trait Transform {
 //                 Compilers
 // -------------------------------------------
 
-case class CompilerResult (circuit: Circuit, annotationMap: AnnotationMap)
+case class CompilerResult(circuit: Circuit, annotationMap: AnnotationMap)
 
 // - A sequence of transformations
 // - Call compile to executes each transformation in sequence onto
 //    a given circuit.
 trait Compiler {
-   def transforms(w: Writer): Seq[Transform]
-   def compile(circuit: Circuit, annotationMap: AnnotationMap, writer: Writer): CompilerResult = {
-      transforms(writer).foldLeft(CompilerResult(circuit,annotationMap))((in: CompilerResult, xform: Transform) => {
-         val result = xform.execute(in.circuit,in.annotationMap)
-         val remappedAnnotations: Seq[Annotation] = result.renames match {
-            case Some(RenameMap(rmap)) => {
-              // For each key in the rename map (rmap), obtain the
-              // corresponding annotations (in.annotationMap.get(from)). If any
-              // annotations exist, for each annotation, create a sequence of
-              // annotations with the names in rmap's value.
-              for{
-                (oldName, newNames) <- rmap.toSeq
-                tID2OldAnnos <- in.annotationMap.get(oldName).toSeq
-                oldAnno <- tID2OldAnnos.values
-                newAnno <- oldAnno.update(newNames)
-              } yield newAnno
-            }
-            case _ => in.annotationMap.annotations
-         }
-         val full_annotations = new AnnotationMap((remappedAnnotations ++ result.annotation.getOrElse(new AnnotationMap(Seq.empty)).annotations).toSeq)
-         CompilerResult(result.circuit, full_annotations)
-      })
-   }
+  def transforms(w: Writer): Seq[Transform]
+  def compile(circuit: Circuit, annotationMap: AnnotationMap, writer: Writer): CompilerResult =
+    (transforms(writer) foldLeft CompilerResult(circuit, annotationMap)){ (in, xform) =>
+      val result = xform.execute(in.circuit, in.annotationMap)
+      val remappedAnnotations: Seq[Annotation] = result.renames match {
+        case Some(RenameMap(rmap)) =>
+          // For each key in the rename map (rmap), obtain the
+          // corresponding annotations (in.annotationMap.get(from)). If any
+          // annotations exist, for each annotation, create a sequence of
+          // annotations with the names in rmap's value.
+          for {
+            (oldName, newNames) <- rmap.toSeq
+            tID2OldAnnos <- in.annotationMap.get(oldName).toSeq
+            oldAnno <- tID2OldAnnos.values
+            newAnno <- oldAnno.update(newNames)
+          } yield newAnno
+        case _ => in.annotationMap.annotations
+      }
+      val resultAnnotations: Seq[Annotation] = result.annotation match {
+        case None => Nil
+        case Some(p) => p.annotations
+      }
+      CompilerResult(result.circuit,
+        new AnnotationMap(remappedAnnotations ++ resultAnnotations))
+    }
 }
 
diff --git a/src/main/scala/firrtl/LoweringCompilers.scala b/src/main/scala/firrtl/LoweringCompilers.scala
index 4d40d9a8..cd77fa3e 100644
--- a/src/main/scala/firrtl/LoweringCompilers.scala
+++ b/src/main/scala/firrtl/LoweringCompilers.scala
@@ -41,17 +41,15 @@ import Annotations._
 //  2) Don't consume annotations
 //  3) No component or module names are renamed
 trait SimpleRun extends LazyLogging {
-   def run (circuit: Circuit, passes: Seq[Pass]): TransformResult = {
-      val result = passes.foldLeft(circuit) {
-         (c: Circuit, pass: Pass) => {
-            val name = pass.name
-            val x = Utils.time(name) { pass.run(c) }
-            logger.debug(x.serialize)
-            x
-         }
-      }
-      TransformResult(result)
-   }
+  def run (circuit: Circuit, passes: Seq[Pass]): TransformResult = {
+    val result = (passes foldLeft circuit){ (c: Circuit, pass: Pass) =>
+      val name = pass.name
+      val x = Utils.time(name)(pass.run(c))
+      logger.debug(x.serialize)
+      x
+    }
+    TransformResult(result)
+  }
 }
 
 // ===========================================
@@ -60,77 +58,77 @@ trait SimpleRun extends LazyLogging {
 // This transforms "CHIRRTL", the chisel3 IR, to "Firrtl". Note the resulting
 //  circuit has only IR nodes, not WIR.
 // TODO(izraelevitz): Create RenameMap from RemoveCHIRRTL
-class Chisel3ToHighFirrtl () extends Transform with SimpleRun {
-   val passSeq = Seq(
-      passes.CheckChirrtl,
-      passes.CInferTypes,
-      passes.CInferMDir,
-      passes.RemoveCHIRRTL)
-   def execute (circuit: Circuit, annotationMap: AnnotationMap): TransformResult =
-      run(circuit, passSeq)
+class Chisel3ToHighFirrtl extends Transform with SimpleRun {
+  val passSeq = Seq(
+    passes.CheckChirrtl,
+    passes.CInferTypes,
+    passes.CInferMDir,
+    passes.RemoveCHIRRTL)
+  def execute(circuit: Circuit, annotationMap: AnnotationMap): TransformResult =
+    run(circuit, passSeq)
 }
 
 // Converts from the bare intermediate representation (ir.scala)
 //  to a working representation (WIR.scala)
-class IRToWorkingIR () extends Transform with SimpleRun {
-   val passSeq = Seq(passes.ToWorkingIR)
-   def execute (circuit: Circuit, annotationMap: AnnotationMap): TransformResult =
-      run(circuit, passSeq)
+class IRToWorkingIR extends Transform with SimpleRun {
+  val passSeq = Seq(passes.ToWorkingIR)
+  def execute(circuit: Circuit, annotationMap: AnnotationMap): TransformResult =
+    run(circuit, passSeq)
 }
 
 // Resolves types, kinds, and genders, and checks the circuit legality.
 // Operates on working IR nodes and high Firrtl.
-class ResolveAndCheck () extends Transform with SimpleRun {
-   val passSeq = Seq(
-      passes.CheckHighForm,
-      passes.ResolveKinds,
-      passes.InferTypes,
-      passes.CheckTypes,
-      passes.Uniquify,
-      passes.ResolveKinds,
-      passes.InferTypes,
-      passes.ResolveGenders,
-      passes.CheckGenders,
-      passes.InferWidths,
-      passes.CheckWidths)
-   def execute (circuit: Circuit, annotationMap: AnnotationMap): TransformResult =
-      run(circuit, passSeq)
+class ResolveAndCheck extends Transform with SimpleRun {
+  val passSeq = Seq(
+    passes.CheckHighForm,
+    passes.ResolveKinds,
+    passes.InferTypes,
+    passes.CheckTypes,
+    passes.Uniquify,
+    passes.ResolveKinds,
+    passes.InferTypes,
+    passes.ResolveGenders,
+    passes.CheckGenders,
+    passes.InferWidths,
+    passes.CheckWidths)
+  def execute(circuit: Circuit, annotationMap: AnnotationMap): TransformResult =
+    run(circuit, passSeq)
 }
 
 // Expands aggregate connects, removes dynamic accesses, and when
 //  statements. Checks for uninitialized values. Must accept a
 //  well-formed graph.
 // Operates on working IR nodes.
-class HighFirrtlToMiddleFirrtl () extends Transform with SimpleRun {
-   val passSeq = Seq(
-      passes.PullMuxes,
-      passes.ReplaceAccesses,
-      passes.ExpandConnects,
-      passes.RemoveAccesses,
-      passes.ExpandWhens,
-      passes.CheckInitialization,
-      passes.ResolveKinds,
-      passes.InferTypes,
-      passes.ResolveGenders,
-      passes.InferWidths,
-      passes.CheckWidths)
-   def execute (circuit: Circuit, annotationMap: AnnotationMap): TransformResult =
-      run(circuit, passSeq)
+class HighFirrtlToMiddleFirrtl extends Transform with SimpleRun {
+  val passSeq = Seq(
+    passes.PullMuxes,
+    passes.ReplaceAccesses,
+    passes.ExpandConnects,
+    passes.RemoveAccesses,
+    passes.ExpandWhens,
+    passes.CheckInitialization,
+    passes.ResolveKinds,
+    passes.InferTypes,
+    passes.ResolveGenders,
+    passes.InferWidths,
+    passes.CheckWidths)
+  def execute(circuit: Circuit, annotationMap: AnnotationMap): TransformResult =
+    run(circuit, passSeq)
 }
 
 // Expands all aggregate types into many ground-typed components. Must
 //  accept a well-formed graph of only middle Firrtl features.
 // Operates on working IR nodes.
 // TODO(izraelevitz): Create RenameMap from RemoveCHIRRTL
-class MiddleFirrtlToLowFirrtl () extends Transform with SimpleRun {
-   val passSeq = Seq(
-      passes.LowerTypes,
-      passes.ResolveKinds,
-      passes.InferTypes,
-      passes.ResolveGenders,
-      passes.InferWidths)
-   def execute (circuit: Circuit, annotationMap: AnnotationMap): TransformResult =
-      run(circuit, passSeq)
+class MiddleFirrtlToLowFirrtl extends Transform with SimpleRun {
+  val passSeq = Seq(
+    passes.LowerTypes,
+    passes.ResolveKinds,
+    passes.InferTypes,
+    passes.ResolveGenders,
+    passes.InferWidths)
+  def execute(circuit: Circuit, annotationMap: AnnotationMap): TransformResult =
+    run(circuit, passSeq)
 }
 
 // Emits Verilog.
@@ -139,32 +137,32 @@ class MiddleFirrtlToLowFirrtl () extends Transform with SimpleRun {
 //  renames names that conflict with Verilog keywords.
 // Operates on working IR nodes.
 // TODO(izraelevitz): Create RenameMap from VerilogRename
-class EmitVerilogFromLowFirrtl (val writer: Writer) extends Transform with SimpleRun {
-   val passSeq = Seq(
-      passes.RemoveValidIf,
-      passes.ConstProp,
-      passes.PadWidths,
-      passes.ConstProp,
-      passes.Legalize,
-      passes.VerilogWrap,
-      passes.SplitExpressions,
-      passes.CommonSubexpressionElimination,
-      passes.DeadCodeElimination,
-      passes.VerilogRename)
-   def execute (circuit: Circuit, annotationMap: AnnotationMap): TransformResult = {
-      val result = run(circuit, passSeq)
-      (new VerilogEmitter).run(result.circuit, writer)
-      result
-   }
+class EmitVerilogFromLowFirrtl(val writer: Writer) extends Transform with SimpleRun {
+  val passSeq = Seq(
+    passes.RemoveValidIf,
+    passes.ConstProp,
+    passes.PadWidths,
+    passes.ConstProp,
+    passes.Legalize,
+    passes.VerilogWrap,
+    passes.SplitExpressions,
+    passes.CommonSubexpressionElimination,
+    passes.DeadCodeElimination,
+    passes.VerilogRename)
+  def execute(circuit: Circuit, annotationMap: AnnotationMap): TransformResult = {
+    val result = run(circuit, passSeq)
+    (new VerilogEmitter).run(result.circuit, writer)
+    result
+  }
 }
 
 // Emits Firrtl.
 // Operates on WIR/IR nodes.
-class EmitFirrtl (val writer: Writer) extends Transform {
-   def execute (circuit: Circuit, annotationMap: AnnotationMap): TransformResult = {
-      FIRRTLEmitter.run(circuit, writer)
-      TransformResult(circuit)
-   }
+class EmitFirrtl(val writer: Writer) extends Transform {
+  def execute(circuit: Circuit, annotationMap: AnnotationMap): TransformResult = {
+    FIRRTLEmitter.run(circuit, writer)
+    TransformResult(circuit)
+  }
 }
 
 
@@ -174,39 +172,39 @@ class EmitFirrtl (val writer: Writer) extends Transform {
 // Emits input circuit
 // Will replace Chirrtl constructs with Firrtl
 class HighFirrtlCompiler extends Compiler {
-   def transforms(writer: Writer): Seq[Transform] = Seq(
-      new Chisel3ToHighFirrtl(),
-      new IRToWorkingIR(),
-      new EmitFirrtl(writer)
-   )
+  def transforms(writer: Writer): Seq[Transform] = Seq(
+    new Chisel3ToHighFirrtl,
+    new IRToWorkingIR,
+    new EmitFirrtl(writer)
+  )
 }
 
 // Emits lowered input circuit
 class LowFirrtlCompiler extends Compiler {
-   def transforms(writer: Writer): Seq[Transform] = Seq(
-      new Chisel3ToHighFirrtl(),
-      new IRToWorkingIR(),
-      new passes.InlineInstances(TransID(0)),
-      new ResolveAndCheck(),
-      new HighFirrtlToMiddleFirrtl(),
-      new passes.InferReadWrite(TransID(-1)),
-      new passes.ReplSeqMem(TransID(-2)),
-      new MiddleFirrtlToLowFirrtl(),
-      new EmitFirrtl(writer)
-   )
+  def transforms(writer: Writer): Seq[Transform] = Seq(
+    new Chisel3ToHighFirrtl,
+    new IRToWorkingIR,
+    new passes.InlineInstances(TransID(0)),
+    new ResolveAndCheck,
+    new HighFirrtlToMiddleFirrtl,
+    new passes.InferReadWrite(TransID(-1)),
+    new passes.ReplSeqMem(TransID(-2)),
+    new MiddleFirrtlToLowFirrtl,
+    new EmitFirrtl(writer)
+  )
 }
 
 // Emits Verilog
 class VerilogCompiler extends Compiler {
-   def transforms(writer: Writer): Seq[Transform] = Seq(
-      new Chisel3ToHighFirrtl(),
-      new IRToWorkingIR(),
-      new ResolveAndCheck(),
-      new HighFirrtlToMiddleFirrtl(),
-      new passes.InferReadWrite(TransID(-1)),
-      new passes.ReplSeqMem(TransID(-2)),
-      new MiddleFirrtlToLowFirrtl(),
-      new passes.InlineInstances(TransID(0)),
-      new EmitVerilogFromLowFirrtl(writer)
-   )
+  def transforms(writer: Writer): Seq[Transform] = Seq(
+    new Chisel3ToHighFirrtl,
+    new IRToWorkingIR,
+    new ResolveAndCheck,
+    new HighFirrtlToMiddleFirrtl,
+    new passes.InferReadWrite(TransID(-1)),
+    new passes.ReplSeqMem(TransID(-2)),
+    new MiddleFirrtlToLowFirrtl,
+    new passes.InlineInstances(TransID(0)),
+    new EmitVerilogFromLowFirrtl(writer)
+  )
 }
diff --git a/src/main/scala/firrtl/WIR.scala b/src/main/scala/firrtl/WIR.scala
index 06b5be48..3db1c250 100644
--- a/src/main/scala/firrtl/WIR.scala
+++ b/src/main/scala/firrtl/WIR.scala
@@ -113,32 +113,32 @@ case object Dshlw extends PrimOp { override def toString = "dshlw" }
 case object Shlw extends PrimOp { override def toString = "shlw" }
 
 object WrappedExpression {
-   def apply(e: Expression) = new WrappedExpression(e)
-   def we(e: Expression) = new WrappedExpression(e)
-   def weq(e1: Expression, e2: Expression) = we(e1) == we(e2)
+  def apply(e: Expression) = new WrappedExpression(e)
+  def we(e: Expression) = new WrappedExpression(e)
+  def weq(e1: Expression, e2: Expression) = we(e1) == we(e2)
 }
-class WrappedExpression (val e1: Expression) {
-   override def equals (we: Any) = we match {
-     case (we:WrappedExpression) => (e1,we.e1) match {
-       case (e1: UIntLiteral, e2: UIntLiteral) => e1.value == e2.value && eqw(e1.width, e2.width)
-       case (e1: SIntLiteral, e2: SIntLiteral) => e1.value == e2.value && eqw(e1.width, e2.width)
-       case (e1: WRef, e2: WRef) => e1.name equals e2.name
-       case (e1: WSubField, e2: WSubField) => (e1.name equals e2.name) && weq(e1.exp,e2.exp)
-       case (e1: WSubIndex, e2: WSubIndex) => (e1.value == e2.value) && weq(e1.exp,e2.exp)
-       case (e1: WSubAccess, e2: WSubAccess) => weq(e1.index,e2.index) && weq(e1.exp,e2.exp)
-       case (WVoid, WVoid) => true
-       case (WInvalid, WInvalid) => true
-       case (e1: DoPrim, e2: DoPrim) => e1.op == e2.op &&
-          ((e1.consts zip e2.consts) forall {case (x, y) => x == y}) &&
-          ((e1.args zip e2.args) forall {case (x, y) => weq(x, y)})
-       case (e1: Mux, e2: Mux) => weq(e1.cond,e2.cond) && weq(e1.tval,e2.tval) && weq(e1.fval,e2.fval)
-       case (e1: ValidIf, e2: ValidIf) => weq(e1.cond,e2.cond) && weq(e1.value,e2.value)
-       case (e1, e2) => false
-     }
-     case _ => false
-   }
-   override def hashCode = e1.serialize.hashCode
-   override def toString = e1.serialize
+class WrappedExpression(val e1: Expression) {
+  override def equals(we: Any) = we match {
+    case (we: WrappedExpression) => (e1,we.e1) match {
+      case (e1: UIntLiteral, e2: UIntLiteral) => e1.value == e2.value && eqw(e1.width, e2.width)
+      case (e1: SIntLiteral, e2: SIntLiteral) => e1.value == e2.value && eqw(e1.width, e2.width)
+      case (e1: WRef, e2: WRef) => e1.name equals e2.name
+      case (e1: WSubField, e2: WSubField) => (e1.name equals e2.name) && weq(e1.exp,e2.exp)
+      case (e1: WSubIndex, e2: WSubIndex) => (e1.value == e2.value) && weq(e1.exp,e2.exp)
+      case (e1: WSubAccess, e2: WSubAccess) => weq(e1.index,e2.index) && weq(e1.exp,e2.exp)
+      case (WVoid, WVoid) => true
+      case (WInvalid, WInvalid) => true
+      case (e1: DoPrim, e2: DoPrim) => e1.op == e2.op &&
+         ((e1.consts zip e2.consts) forall {case (x, y) => x == y}) &&
+         ((e1.args zip e2.args) forall {case (x, y) => weq(x, y)})
+      case (e1: Mux, e2: Mux) => weq(e1.cond,e2.cond) && weq(e1.tval,e2.tval) && weq(e1.fval,e2.fval)
+      case (e1: ValidIf, e2: ValidIf) => weq(e1.cond,e2.cond) && weq(e1.value,e2.value)
+      case (e1, e2) => false
+    }
+    case _ => false
+  }
+  override def hashCode = e1.serialize.hashCode
+  override def toString = e1.serialize
 }
 
 private[firrtl] sealed trait HasMapWidth {
@@ -170,23 +170,23 @@ case class ExpWidth(arg1: Width) extends Width with HasMapWidth {
 }
 
 object WrappedType {
-  def apply (t:Type) = new WrappedType(t)
-  def wt (t:Type) = apply(t)
+  def apply(t: Type) = new WrappedType(t)
+  def wt(t: Type) = apply(t)
 }
 class WrappedType(val t: Type) {
   def wt(tx: Type) = new WrappedType(tx)
-  override def equals(o:Any): Boolean = o match {
+  override def equals(o: Any): Boolean = o match {
     case (t2: WrappedType) => (t, t2.t) match {
       case (_: UIntType, _: UIntType) => true
       case (_: SIntType, _: SIntType) => true
       case (ClockType, ClockType) => true
       case (t1: VectorType, t2: VectorType) =>
         t1.size == t2.size && wt(t1.tpe) == wt(t2.tpe)
-      case (t1:BundleType,t2:BundleType) =>
+      case (t1: BundleType, t2: BundleType) =>
         t1.fields.size == t2.fields.size && (
-        (t1.fields zip t2.fields) forall {case (f1, f2) =>
+        (t1.fields zip t2.fields) forall { case (f1, f2) =>
           f1.flip == f2.flip && f1.name == f2.name
-        }) && ((t1.fields zip t2.fields) forall {case (f1, f2) =>
+        }) && ((t1.fields zip t2.fields) forall { case (f1, f2) =>
           wt(f1.tpe) == wt(f2.tpe)
         })
       case _ => false