1 files changed, 32 insertions, 36 deletions

diff --git a/src/main/scala/firrtl/passes/CheckChirrtl.scala b/src/main/scala/firrtl/passes/CheckChirrtl.scala
index 8f37c8bf..a9a14982 100644
--- a/src/main/scala/firrtl/passes/CheckChirrtl.scala
+++ b/src/main/scala/firrtl/passes/CheckChirrtl.scala
@@ -5,7 +5,7 @@ package firrtl.passes
 import firrtl._
 import firrtl.ir._
 import firrtl.Utils._
-import firrtl.Mappers._
+import firrtl.traversals.Foreachers._
 
 object CheckChirrtl extends Pass {
   type NameSet = collection.mutable.HashSet[String]
@@ -40,54 +40,51 @@ object CheckChirrtl extends Pass {
         errors append new InvalidLOCException(info, mname)
       case _ => // Do Nothing
     }
-    def checkChirrtlW(info: Info, mname: String)(w: Width): Width = w match {
-      case w: IntWidth if (w.width < BigInt(0)) =>
-        errors.append(new NegWidthException(info, mname))
-        w
-      case _ => w
+    def checkChirrtlW(info: Info, mname: String)(w: Width): Unit = w match {
+      case w: IntWidth if (w.width < BigInt(0)) => errors.append(new NegWidthException(info, mname))
+      case _ =>
     }
 
-    def checkChirrtlT(info: Info, mname: String)(t: Type): Type =
-      t map checkChirrtlT(info, mname) match {
+    def checkChirrtlT(info: Info, mname: String)(t: Type): Unit = {
+      t.foreach(checkChirrtlT(info, mname))
+      t match {
         case t: VectorType if t.size < 0 =>
           errors append new NegVecSizeException(info, mname)
-          t map checkChirrtlW(info, mname)
+          t.foreach(checkChirrtlW(info, mname))
         //case FixedType(width, point) => FixedType(checkChirrtlW(width), point)
-        case _ => t map checkChirrtlW(info, mname)
+        case _ => t.foreach(checkChirrtlW(info, mname))
       }
+    }
 
-    def validSubexp(info: Info, mname: String)(e: Expression): Expression = {
-      e match {
-        case _: Reference | _: SubField | _: SubIndex | _: SubAccess |
-             _: Mux | _: ValidIf => // No error
-        case _ => errors append new InvalidAccessException(info, mname)
-      }
-      e
+    def validSubexp(info: Info, mname: String)(e: Expression): Unit = e match {
+      case _: Reference | _: SubField | _: SubIndex | _: SubAccess |
+           _: Mux | _: ValidIf => // No error
+      case _ => errors append new InvalidAccessException(info, mname)
     }
 
-    def checkChirrtlE(info: Info, mname: String, names: NameSet)(e: Expression): Expression = {
+    def checkChirrtlE(info: Info, mname: String, names: NameSet)(e: Expression): Unit = {
       e match {
         case _: DoPrim | _:Mux | _:ValidIf | _: UIntLiteral =>
         case ex: Reference if !names(ex.name) =>
           errors append new UndeclaredReferenceException(info, mname, ex.name)
         case ex: SubAccess => validSubexp(info, mname)(ex.expr)
-        case ex => ex map validSubexp(info, mname)
+        case ex => ex.foreach(validSubexp(info, mname))
       }
-      (e map checkChirrtlW(info, mname)
-         map checkChirrtlT(info, mname)
-         map checkChirrtlE(info, mname, names))
+      e.foreach(checkChirrtlW(info, mname))
+      e.foreach(checkChirrtlT(info, mname))
+      e.foreach(checkChirrtlE(info, mname, names))
     }
 
-    def checkName(info: Info, mname: String, names: NameSet)(name: String): String = {
+    def checkName(info: Info, mname: String, names: NameSet)(name: String): Unit = {
       if (names(name))
         errors append new NotUniqueException(info, mname, name)
       names += name
-      name 
     }
 
-    def checkChirrtlS(minfo: Info, mname: String, names: NameSet)(s: Statement): Statement = {
+    def checkChirrtlS(minfo: Info, mname: String, names: NameSet)(s: Statement): Unit = {
       val info = get_info(s) match {case NoInfo => minfo case x => x}
-      s map checkName(info, mname, names) match {
+      s.foreach(checkName(info, mname, names))
+      s match {
         case sx: DefMemory =>
           if (hasFlip(sx.dataType)) errors append new MemWithFlipException(info, mname, sx.name)
           if (sx.depth <= 0) errors append new NegMemSizeException(info, mname)
@@ -97,27 +94,26 @@ object CheckChirrtl extends Pass {
         case sx: PartialConnect => checkValidLoc(info, mname, sx.loc)
         case _ => // Do Nothing
       }
-      (s map checkChirrtlT(info, mname)
-         map checkChirrtlE(info, mname, names)
-         map checkChirrtlS(info, mname, names))
+      s.foreach(checkChirrtlT(info, mname))
+      s.foreach(checkChirrtlE(info, mname, names))
+      s.foreach(checkChirrtlS(info, mname, names))
     }
 
-    def checkChirrtlP(mname: String, names: NameSet)(p: Port): Port = {
+    def checkChirrtlP(mname: String, names: NameSet)(p: Port): Unit = {
       if (names(p.name))
         errors append new NotUniqueException(NoInfo, mname, p.name)
       names += p.name
-      (p.tpe map checkChirrtlT(p.info, mname)
-             map checkChirrtlW(p.info, mname))
-      p
+      p.tpe.foreach(checkChirrtlT(p.info, mname))
+      p.tpe.foreach(checkChirrtlW(p.info, mname))
     }
 
     def checkChirrtlM(m: DefModule) {
       val names = new NameSet
-      (m map checkChirrtlP(m.name, names)
-         map checkChirrtlS(m.info, m.name, names))
+      m.foreach(checkChirrtlP(m.name, names))
+      m.foreach(checkChirrtlS(m.info, m.name, names))
     }
     
-    c.modules foreach checkChirrtlM
+    c.modules.foreach(checkChirrtlM)
     c.modules count (_.name == c.main) match {
       case 1 =>
       case _ => errors append new NoTopModuleException(c.info, c.main)