Move splitRef and mergeRef from LowerTypes to Utils

Make EmptyExpression part of WIR

3 files changed, 37 insertions, 39 deletions

diff --git a/src/main/scala/firrtl/Utils.scala b/src/main/scala/firrtl/Utils.scala
index 30dff01c..f54d8cd6 100644
--- a/src/main/scala/firrtl/Utils.scala
+++ b/src/main/scala/firrtl/Utils.scala
@@ -580,6 +580,41 @@ object Utils extends LazyLogging {
        case _ => NoInfo
     }}
 
+  /** Splits an Expression into root Ref and tail
+    *
+    * @example
+    *   Given:   SubField(SubIndex(SubField(Ref("a", UIntType(IntWidth(32))), "b"), 2), "c")
+    *   Returns: (Ref("a"), SubField(SubIndex(Ref("b"), 2), "c"))
+    *   a.b[2].c -> (a, b[2].c)
+    * @example
+    *   Given:   SubField(SubIndex(Ref("b"), 2), "c")
+    *   Returns: (Ref("b"), SubField(SubIndex(EmptyExpression, 2), "c"))
+    *   b[2].c -> (b, EMPTY[2].c)
+    * @note This function only supports WRef, WSubField, and WSubIndex
+    */
+  def splitRef(e: Expression): (WRef, Expression) = e match {
+    case e: WRef => (e, EmptyExpression)
+    case e: WSubIndex =>
+      val (root, tail) = splitRef(e.exp)
+      (root, WSubIndex(tail, e.value, e.tpe, e.gender))
+    case e: WSubField =>
+      val (root, tail) = splitRef(e.exp)
+      tail match {
+        case EmptyExpression => (root, WRef(e.name, e.tpe, root.kind, e.gender))
+        case exp => (root, WSubField(tail, e.name, e.tpe, e.gender))
+      }
+  }
+
+  /** Adds a root reference to some SubField/SubIndex chain */
+  def mergeRef(root: WRef, body: Expression): Expression = body match {
+    case e: WRef =>
+      WSubField(root, e.name, e.tpe, e.gender)
+    case e: WSubIndex =>
+      WSubIndex(mergeRef(root, e.exp), e.value, e.tpe, e.gender)
+    case e: WSubField =>
+      WSubField(mergeRef(root, e.exp), e.name, e.tpe, e.gender)
+    case EmptyExpression => root
+  }
 
 // =============== RECURISVE MAPPERS ===================
    def mapr (f: Width => Width, t:Type) : Type = {
diff --git a/src/main/scala/firrtl/WIR.scala b/src/main/scala/firrtl/WIR.scala
index 7360a77b..cdac2ca5 100644
--- a/src/main/scala/firrtl/WIR.scala
+++ b/src/main/scala/firrtl/WIR.scala
@@ -55,6 +55,8 @@ case class WSubIndex(exp:Expression,value:Int,tpe:Type,gender:Gender) extends Ex
 case class WSubAccess(exp:Expression,index:Expression,tpe:Type,gender:Gender) extends Expression
 case class WVoid() extends Expression { def tpe = UnknownType() }
 case class WInvalid() extends Expression { def tpe = UnknownType() }
+// Useful for splitting then remerging references
+case object EmptyExpression extends Expression { def tpe = UnknownType() }
 case class WDefInstance(info:Info,name:String,module:String,tpe:Type) extends Stmt with IsDeclaration
 
 case object ADDW_OP extends PrimOp 
diff --git a/src/main/scala/firrtl/passes/LowerTypes.scala b/src/main/scala/firrtl/passes/LowerTypes.scala
index 47e78170..2caa2ce2 100644
--- a/src/main/scala/firrtl/passes/LowerTypes.scala
+++ b/src/main/scala/firrtl/passes/LowerTypes.scala
@@ -69,45 +69,6 @@ object LowerTypes extends Pass {
   private def error(msg: String)(implicit sinfo: Info, mname: String) =
     throw new LowerTypesException(s"$sinfo: [module $mname] $msg")
 
-  // Useful for splitting then remerging references
-  private case object EmptyExpression extends Expression { def tpe = UnknownType() }
-
-  /** Splits an Expression into root Ref and tail
-    *
-    * @example
-    *   Given:   SubField(SubIndex(SubField(Ref("a", UIntType(IntWidth(32))), "b"), 2), "c")
-    *   Returns: (Ref("a"), SubField(SubIndex(Ref("b"), 2), "c"))
-    *   a.b[2].c -> (a, b[2].c)
-    * @example
-    *   Given:   SubField(SubIndex(Ref("b"), 2), "c")
-    *   Returns: (Ref("b"), SubField(SubIndex(EmptyExpression, 2), "c"))
-    *   b[2].c -> (b, EMPTY[2].c)
-    * @note This function only supports WRef, WSubField, and WSubIndex
-    */
-  private def splitRef(e: Expression): (WRef, Expression) = e match {
-    case e: WRef => (e, EmptyExpression)
-    case e: WSubIndex =>
-      val (root, tail) = splitRef(e.exp)
-      (root, WSubIndex(tail, e.value, e.tpe, e.gender))
-    case e: WSubField =>
-      val (root, tail) = splitRef(e.exp)
-      tail match {
-        case EmptyExpression => (root, WRef(e.name, e.tpe, root.kind, e.gender))
-        case exp => (root, WSubField(tail, e.name, e.tpe, e.gender))
-      }
-  }
-
-  /** Adds a root reference to some SubField/SubIndex chain */
-  private def mergeRef(root: WRef, body: Expression): Expression = body match {
-    case e: WRef =>
-      WSubField(root, e.name, e.tpe, e.gender)
-    case e: WSubIndex =>
-      WSubIndex(mergeRef(root, e.exp), e.value, e.tpe, e.gender)
-    case e: WSubField =>
-      WSubField(mergeRef(root, e.exp), e.name, e.tpe, e.gender)
-    case EmptyExpression => root
-  }
-
   // TODO Improve? Probably not the best way to do this
   private def splitMemRef(e1: Expression): (WRef, WRef, WRef, Option[Expression]) = {
     val (mem, tail1) = splitRef(e1)