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

10 files changed, 58 insertions, 58 deletions

diff --git a/src/main/scala/firrtl/Emitter.scala b/src/main/scala/firrtl/Emitter.scala
index 933d98c5..696856a6 100644
--- a/src/main/scala/firrtl/Emitter.scala
+++ b/src/main/scala/firrtl/Emitter.scala
@@ -187,7 +187,7 @@ class VerilogEmitter extends SeqTransform with Emitter {
   }
   def wref(n: String, t: Type) = WRef(n, t, ExpKind, UNKNOWNGENDER)
   def remove_root(ex: Expression): Expression = ex match {
-    case ex: WSubField => ex.exp match {
+    case ex: WSubField => ex.expr match {
       case (e: WSubField) => remove_root(e)
       case (_: WRef) => WRef(ex.name, ex.tpe, InstanceKind, UNKNOWNGENDER)
     }
@@ -223,7 +223,7 @@ class VerilogEmitter extends SeqTransform with Emitter {
       case (e: ValidIf) => emit(Seq(cast(e.value)),top + 1)
       case (e: WRef) => w write e.serialize
       case (e: WSubField) => w write LowerTypes.loweredName(e)
-      case (e: WSubAccess) => w write s"${LowerTypes.loweredName(e.exp)}[${LowerTypes.loweredName(e.index)}]"
+      case (e: WSubAccess) => w write s"${LowerTypes.loweredName(e.expr)}[${LowerTypes.loweredName(e.index)}]"
       case (e: WSubIndex) => w write e.serialize
       case (e: Literal) => v_print(e)
       case (e: VRandom) => w write s"{${e.nWords}{$$random}}"
diff --git a/src/main/scala/firrtl/Utils.scala b/src/main/scala/firrtl/Utils.scala
index 586fe1e7..3bde6f11 100644
--- a/src/main/scala/firrtl/Utils.scala
+++ b/src/main/scala/firrtl/Utils.scala
@@ -210,12 +210,12 @@ object Utils extends LazyLogging {
   
    def get_point (e:Expression) : Int = e match {
      case (e: WRef) => 0
-     case (e: WSubField) => e.exp.tpe match {case b: BundleType =>
+     case (e: WSubField) => e.expr.tpe match {case b: BundleType =>
        (b.fields takeWhile (_.name != e.name) foldLeft 0)(
          (point, f) => point + get_size(f.tpe))
     }
     case (e: WSubIndex) => e.value * get_size(e.tpe)
-    case (e: WSubAccess) => get_point(e.exp)
+    case (e: WSubAccess) => get_point(e.expr)
   }
 
   /** Returns true if t, or any subtype, contains a flipped field
@@ -476,9 +476,9 @@ object Utils extends LazyLogging {
 // =========== ACCESSORS =========
   def kind(e: Expression): Kind = e match {
     case ex: WRef => ex.kind
-    case ex: WSubField => kind(ex.exp)
-    case ex: WSubIndex => kind(ex.exp)
-    case ex: WSubAccess => kind(ex.exp)
+    case ex: WSubField => kind(ex.expr)
+    case ex: WSubIndex => kind(ex.expr)
+    case ex: WSubAccess => kind(ex.expr)
     case ex => ExpKind
   }
   def gender(e: Expression): Gender = e match {
@@ -530,10 +530,10 @@ object Utils extends LazyLogging {
   def splitRef(e: Expression): (WRef, Expression) = e match {
     case e: WRef => (e, EmptyExpression)
     case e: WSubIndex =>
-      val (root, tail) = splitRef(e.exp)
+      val (root, tail) = splitRef(e.expr)
       (root, WSubIndex(tail, e.value, e.tpe, e.gender))
     case e: WSubField =>
-      val (root, tail) = splitRef(e.exp)
+      val (root, tail) = splitRef(e.expr)
       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))
@@ -545,9 +545,9 @@ object Utils extends LazyLogging {
     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)
+      WSubIndex(mergeRef(root, e.expr), e.value, e.tpe, e.gender)
     case e: WSubField =>
-      WSubField(mergeRef(root, e.exp), e.name, e.tpe, e.gender)
+      WSubField(mergeRef(root, e.expr), e.name, e.tpe, e.gender)
     case EmptyExpression => root
   }
 
diff --git a/src/main/scala/firrtl/WIR.scala b/src/main/scala/firrtl/WIR.scala
index 946906fa..d2e1457c 100644
--- a/src/main/scala/firrtl/WIR.scala
+++ b/src/main/scala/firrtl/WIR.scala
@@ -37,24 +37,24 @@ object WRef {
   def apply(reg: DefRegister): WRef = new WRef(reg.name, reg.tpe, RegKind, UNKNOWNGENDER)
   def apply(n: String, t: Type = UnknownType, k: Kind = ExpKind): WRef = new WRef(n, t, k, UNKNOWNGENDER)
 }
-case class WSubField(exp: Expression, name: String, tpe: Type, gender: Gender) extends Expression {
-  def serialize: String = s"${exp.serialize}.$name"
-  def mapExpr(f: Expression => Expression): Expression = this.copy(exp = f(exp))
+case class WSubField(expr: Expression, name: String, tpe: Type, gender: Gender) extends Expression {
+  def serialize: String = s"${expr.serialize}.$name"
+  def mapExpr(f: Expression => Expression): Expression = this.copy(expr = f(expr))
   def mapType(f: Type => Type): Expression = this.copy(tpe = f(tpe))
   def mapWidth(f: Width => Width): Expression = this
 }
 object WSubField {
-  def apply(exp: Expression, n: String): WSubField = new WSubField(exp, n, field_type(exp.tpe, n), UNKNOWNGENDER)
+  def apply(expr: Expression, n: String): WSubField = new WSubField(expr, n, field_type(expr.tpe, n), UNKNOWNGENDER)
 }
-case class WSubIndex(exp: Expression, value: Int, tpe: Type, gender: Gender) extends Expression {
-  def serialize: String = s"${exp.serialize}[$value]"
-  def mapExpr(f: Expression => Expression): Expression = this.copy(exp = f(exp))
+case class WSubIndex(expr: Expression, value: Int, tpe: Type, gender: Gender) extends Expression {
+  def serialize: String = s"${expr.serialize}[$value]"
+  def mapExpr(f: Expression => Expression): Expression = this.copy(expr = f(expr))
   def mapType(f: Type => Type): Expression = this.copy(tpe = f(tpe))
   def mapWidth(f: Width => Width): Expression = this
 }
-case class WSubAccess(exp: Expression, index: Expression, tpe: Type, gender: Gender) extends Expression {
-  def serialize: String = s"${exp.serialize}[${index.serialize}]"
-  def mapExpr(f: Expression => Expression): Expression = this.copy(exp = f(exp), index = f(index))
+case class WSubAccess(expr: Expression, index: Expression, tpe: Type, gender: Gender) extends Expression {
+  def serialize: String = s"${expr.serialize}[${index.serialize}]"
+  def mapExpr(f: Expression => Expression): Expression = this.copy(expr = f(expr), index = f(index))
   def mapType(f: Type => Type): Expression = this.copy(tpe = f(tpe))
   def mapWidth(f: Width => Width): Expression = this
 }
@@ -125,9 +125,9 @@ class WrappedExpression(val e1: Expression) {
       case (e1x: UIntLiteral, e2x: UIntLiteral) => e1x.value == e2x.value && eqw(e1x.width, e2x.width)
       case (e1x: SIntLiteral, e2x: SIntLiteral) => e1x.value == e2x.value && eqw(e1x.width, e2x.width)
       case (e1x: WRef, e2x: WRef) => e1x.name equals e2x.name
-      case (e1x: WSubField, e2x: WSubField) => (e1x.name equals e2x.name) && weq(e1x.exp,e2x.exp)
-      case (e1x: WSubIndex, e2x: WSubIndex) => (e1x.value == e2x.value) && weq(e1x.exp,e2x.exp)
-      case (e1x: WSubAccess, e2x: WSubAccess) => weq(e1x.index,e2x.index) && weq(e1x.exp,e2x.exp)
+      case (e1x: WSubField, e2x: WSubField) => (e1x.name equals e2x.name) && weq(e1x.expr,e2x.expr)
+      case (e1x: WSubIndex, e2x: WSubIndex) => (e1x.value == e2x.value) && weq(e1x.expr,e2x.expr)
+      case (e1x: WSubAccess, e2x: WSubAccess) => weq(e1x.index,e2x.index) && weq(e1x.expr,e2x.expr)
       case (WVoid, WVoid) => true
       case (WInvalid, WInvalid) => true
       case (e1x: DoPrim, e2x: DoPrim) => e1x.op == e2x.op &&
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)