Refactor WIR WSub{Field,Index,Access} - rename exp -> expr #521 (#586)

7 files changed, 34 insertions, 34 deletions

diff --git a/src/main/scala/firrtl/passes/CheckCombLoops.scala b/src/main/scala/firrtl/passes/CheckCombLoops.scala
index bf89fc3f..624945c3 100644
--- a/src/main/scala/firrtl/passes/CheckCombLoops.scala
+++ b/src/main/scala/firrtl/passes/CheckCombLoops.scala
@@ -46,11 +46,11 @@ object CheckCombLoops extends Pass {
     case r: WRef =>
       LogicNode(r.name)
     case s: WSubField =>
-      s.exp match {
+      s.expr match {
         case modref: WRef =>
           LogicNode(s.name,Some(modref.name))
         case memport: WSubField =>
-          memport.exp match {
+          memport.expr match {
             case memref: WRef =>
               LogicNode(s.name,Some(memref.name),Some(memport.name))
             case _ => throwInternalError
diff --git a/src/main/scala/firrtl/passes/Checks.scala b/src/main/scala/firrtl/passes/Checks.scala
index 3389224e..74c532cc 100644
--- a/src/main/scala/firrtl/passes/Checks.scala
+++ b/src/main/scala/firrtl/passes/Checks.scala
@@ -137,7 +137,7 @@ object CheckHighForm extends Pass {
           errors.append(new NegUIntException(info, mname))
         case ex: DoPrim => checkHighFormPrimop(info, mname, ex)
         case _: WRef | _: UIntLiteral | _: Mux | _: ValidIf =>
-        case ex: WSubAccess => validSubexp(info, mname)(ex.exp)
+        case ex: WSubAccess => validSubexp(info, mname)(ex.expr)
         case ex => ex map validSubexp(info, mname)
       }
       (e map checkHighFormW(info, mname)
@@ -340,14 +340,14 @@ object CheckTypes extends Pass {
 
     def check_types_e(info:Info, mname: String)(e: Expression): Expression = {
       e match {
-        case (e: WSubField) => e.exp.tpe match {
+        case (e: WSubField) => e.expr.tpe match {
           case (t: BundleType) => t.fields find (_.name == e.name) match {
             case Some(_) =>
             case None => errors.append(new SubfieldNotInBundle(info, mname, e.name))
           }
           case _ => errors.append(new SubfieldOnNonBundle(info, mname, e.name))
         }
-        case (e: WSubIndex) => e.exp.tpe match {
+        case (e: WSubIndex) => e.expr.tpe match {
           case (t: VectorType) if e.value < t.size =>
           case (t: VectorType) =>
             errors.append(new IndexTooLarge(info, mname, e.value))
@@ -355,7 +355,7 @@ object CheckTypes extends Pass {
             errors.append(new IndexOnNonVector(info, mname))
         }
         case (e: WSubAccess) =>
-          e.exp.tpe match {
+          e.expr.tpe match {
             case _: VectorType =>
             case _ => errors.append(new IndexOnNonVector(info, mname))
           }
@@ -491,11 +491,11 @@ object CheckGenders extends Pass {
 
     def get_gender(e: Expression, genders: GenderMap): Gender = e match {
       case (e: WRef) => genders(e.name)
-      case (e: WSubIndex) => get_gender(e.exp, genders)
-      case (e: WSubAccess) => get_gender(e.exp, genders)
-      case (e: WSubField) => e.exp.tpe match {case t: BundleType =>
+      case (e: WSubIndex) => get_gender(e.expr, genders)
+      case (e: WSubAccess) => get_gender(e.expr, genders)
+      case (e: WSubField) => e.expr.tpe match {case t: BundleType =>
         val f = (t.fields find (_.name == e.name)).get
-        times(get_gender(e.exp, genders), f.flip)
+        times(get_gender(e.expr, genders), f.flip)
       }
       case _ => MALE
     }
diff --git a/src/main/scala/firrtl/passes/InferTypes.scala b/src/main/scala/firrtl/passes/InferTypes.scala
index 2de2a76e..24482076 100644
--- a/src/main/scala/firrtl/passes/InferTypes.scala
+++ b/src/main/scala/firrtl/passes/InferTypes.scala
@@ -25,9 +25,9 @@ object InferTypes extends Pass {
     def infer_types_e(types: TypeMap)(e: Expression): Expression =
       e map infer_types_e(types) match {
         case e: WRef => e copy (tpe = types(e.name))
-        case e: WSubField => e copy (tpe = field_type(e.exp.tpe, e.name))
-        case e: WSubIndex => e copy (tpe = sub_type(e.exp.tpe))
-        case e: WSubAccess => e copy (tpe = sub_type(e.exp.tpe))
+        case e: WSubField => e copy (tpe = field_type(e.expr.tpe, e.name))
+        case e: WSubIndex => e copy (tpe = sub_type(e.expr.tpe))
+        case e: WSubAccess => e copy (tpe = sub_type(e.expr.tpe))
         case e: DoPrim => PrimOps.set_primop_type(e)
         case e: Mux => e copy (tpe = mux_type_and_widths(e.tval, e.fval))
         case e: ValidIf => e copy (tpe = e.value.tpe)
diff --git a/src/main/scala/firrtl/passes/LowerTypes.scala b/src/main/scala/firrtl/passes/LowerTypes.scala
index b48ab338..6b1b5d66 100644
--- a/src/main/scala/firrtl/passes/LowerTypes.scala
+++ b/src/main/scala/firrtl/passes/LowerTypes.scala
@@ -34,8 +34,8 @@ object LowerTypes extends Transform {
     */
   def loweredName(e: Expression): String = e match {
     case e: WRef => e.name
-    case e: WSubField => s"${loweredName(e.exp)}$delim${e.name}"
-    case e: WSubIndex => s"${loweredName(e.exp)}$delim${e.value}"
+    case e: WSubField => s"${loweredName(e.expr)}$delim${e.name}"
+    case e: WSubIndex => s"${loweredName(e.expr)}$delim${e.value}"
   }
   def loweredName(s: Seq[String]): String = s mkString delim
   def renameExps(renames: RenameMap, n: String, t: Type, root: String): Seq[String] =
diff --git a/src/main/scala/firrtl/passes/Passes.scala b/src/main/scala/firrtl/passes/Passes.scala
index 68f278a9..4a90bd08 100644
--- a/src/main/scala/firrtl/passes/Passes.scala
+++ b/src/main/scala/firrtl/passes/Passes.scala
@@ -68,7 +68,7 @@ object ToWorkingIR extends Pass {
 object PullMuxes extends Pass {
    def run(c: Circuit): Circuit = {
      def pull_muxes_e(e: Expression): Expression = e map pull_muxes_e match {
-       case ex: WSubField => ex.exp match {
+       case ex: WSubField => ex.expr match {
          case exx: Mux => Mux(exx.cond,
            WSubField(exx.tval, ex.name, ex.tpe, ex.gender),
            WSubField(exx.fval, ex.name, ex.tpe, ex.gender), ex.tpe)
@@ -76,7 +76,7 @@ object PullMuxes extends Pass {
            WSubField(exx.value, ex.name, ex.tpe, ex.gender), ex.tpe)
          case _ => ex  // case exx => exx causes failed tests
        }
-       case ex: WSubIndex => ex.exp match {
+       case ex: WSubIndex => ex.expr match {
          case exx: Mux => Mux(exx.cond,
            WSubIndex(exx.tval, ex.value, ex.tpe, ex.gender),
            WSubIndex(exx.fval, ex.value, ex.tpe, ex.gender), ex.tpe)
@@ -84,7 +84,7 @@ object PullMuxes extends Pass {
            WSubIndex(exx.value, ex.value, ex.tpe, ex.gender), ex.tpe)
          case _ => ex  // case exx => exx causes failed tests
        }
-       case ex: WSubAccess => ex.exp match {
+       case ex: WSubAccess => ex.expr match {
          case exx: Mux => Mux(exx.cond,
            WSubAccess(exx.tval, ex.index, ex.tpe, ex.gender),
            WSubAccess(exx.fval, ex.index, ex.tpe, ex.gender), ex.tpe)
@@ -111,11 +111,11 @@ object ExpandConnects extends Pass {
         def set_gender(e: Expression): Expression = e map set_gender match {
           case ex: WRef => WRef(ex.name, ex.tpe, ex.kind, genders(ex.name))
           case ex: WSubField =>
-            val f = get_field(ex.exp.tpe, ex.name)
-            val genderx = times(gender(ex.exp), f.flip)
-            WSubField(ex.exp, ex.name, ex.tpe, genderx)
-          case ex: WSubIndex => WSubIndex(ex.exp, ex.value, ex.tpe, gender(ex.exp))
-          case ex: WSubAccess => WSubAccess(ex.exp, ex.index, ex.tpe, gender(ex.exp))
+            val f = get_field(ex.expr.tpe, ex.name)
+            val genderx = times(gender(ex.expr), f.flip)
+            WSubField(ex.expr, ex.name, ex.tpe, genderx)
+          case ex: WSubIndex => WSubIndex(ex.expr, ex.value, ex.tpe, gender(ex.expr))
+          case ex: WSubAccess => WSubAccess(ex.expr, ex.index, ex.tpe, gender(ex.expr))
           case ex => ex
         }
         s match {
diff --git a/src/main/scala/firrtl/passes/RemoveAccesses.scala b/src/main/scala/firrtl/passes/RemoveAccesses.scala
index 5d74d5ba..253e6a15 100644
--- a/src/main/scala/firrtl/passes/RemoveAccesses.scala
+++ b/src/main/scala/firrtl/passes/RemoveAccesses.scala
@@ -32,23 +32,23 @@ object RemoveAccesses extends Pass {
   private def getLocations(e: Expression): Seq[Location] = e match {
     case e: WRef => create_exps(e).map(Location(_,one))
     case e: WSubIndex =>
-      val ls = getLocations(e.exp)
+      val ls = getLocations(e.expr)
       val start = get_point(e)
       val end = start + get_size(e.tpe)
-      val stride = get_size(e.exp.tpe)
+      val stride = get_size(e.expr.tpe)
       for ((l, i) <- ls.zipWithIndex
         if ((i % stride) >= start) & ((i % stride) < end)) yield l
     case e: WSubField =>
-      val ls = getLocations(e.exp)
+      val ls = getLocations(e.expr)
       val start = get_point(e)
       val end = start + get_size(e.tpe)
-      val stride = get_size(e.exp.tpe)
+      val stride = get_size(e.expr.tpe)
       for ((l, i) <- ls.zipWithIndex
         if ((i % stride) >= start) & ((i % stride) < end)) yield l
     case e: WSubAccess =>
-      val ls = getLocations(e.exp)
+      val ls = getLocations(e.expr)
       val stride = get_size(e.tpe)
-      val wrap = e.exp.tpe.asInstanceOf[VectorType].size
+      val wrap = e.expr.tpe.asInstanceOf[VectorType].size
       ls.zipWithIndex map {case (l, i) =>
         val c = (i / stride) % wrap
         val basex = l.base
@@ -131,7 +131,7 @@ object RemoveAccesses extends Pass {
           * Otherwise, map to children.
           */
         def fixMale(e: Expression): Expression = e match {
-          case w: WSubAccess => removeMale(WSubAccess(w.exp, fixMale(w.index), w.tpe, w.gender))
+          case w: WSubAccess => removeMale(WSubAccess(w.expr, fixMale(w.index), w.tpe, w.gender))
           //case w: WSubIndex => removeMale(w)
           //case w: WSubField => removeMale(w)
           case x => x map fixMale
@@ -142,7 +142,7 @@ object RemoveAccesses extends Pass {
           * Otherwise, map to children.
           */
         def fixFemale(e: Expression): Expression = e match {
-          case w: WSubAccess => WSubAccess(fixFemale(w.exp), fixMale(w.index), w.tpe, w.gender)
+          case w: WSubAccess => WSubAccess(fixFemale(w.expr), fixMale(w.index), w.tpe, w.gender)
           case x => x map fixFemale
         }
 
diff --git a/src/main/scala/firrtl/passes/Uniquify.scala b/src/main/scala/firrtl/passes/Uniquify.scala
index 61bd68d0..54b94939 100644
--- a/src/main/scala/firrtl/passes/Uniquify.scala
+++ b/src/main/scala/firrtl/passes/Uniquify.scala
@@ -152,7 +152,7 @@ object Uniquify extends Transform {
         }
         else (e, Map())
       case e: WSubField =>
-        val (subExp, subMap) = rec(e.exp, m)
+        val (subExp, subMap) = rec(e.expr, m)
         val (retName, retMap) =
           if (subMap.contains(e.name)) {
             val node = subMap(e.name)
@@ -162,10 +162,10 @@ object Uniquify extends Transform {
           }
         (WSubField(subExp, retName, e.tpe, e.gender), retMap)
       case e: WSubIndex =>
-        val (subExp, subMap) = rec(e.exp, m)
+        val (subExp, subMap) = rec(e.expr, m)
         (WSubIndex(subExp, e.value, e.tpe, e.gender), subMap)
       case e: WSubAccess =>
-        val (subExp, subMap) = rec(e.exp, m)
+        val (subExp, subMap) = rec(e.expr, m)
         val index = uniquifyNamesExp(e.index, map)
         (WSubAccess(subExp, index, e.tpe, e.gender), subMap)
       case (_: UIntLiteral | _: SIntLiteral) => (exp, m)