Remove trivially dead code from now-redundant WIR/IR match patterns

2 files changed, 0 insertions, 14 deletions

diff --git a/src/main/scala/firrtl/Utils.scala b/src/main/scala/firrtl/Utils.scala
index 75266731..c4f282bf 100644
--- a/src/main/scala/firrtl/Utils.scala
+++ b/src/main/scala/firrtl/Utils.scala
@@ -214,12 +214,6 @@ object Utils extends LazyLogging {
   def niceName(e: Expression): String = niceName(1)(e)
   def niceName(depth: Int)(e: Expression): String = {
     e match {
-      case WRef(name, _, _, _) if name(0) == '_' => name
-      case WRef(name, _, _, _) => "_" + name
-      case WSubAccess(expr, index, _, _) if depth <= 0 => niceName(depth)(expr)
-      case WSubAccess(expr, index, _, _) => niceName(depth)(expr) + niceName(depth - 1)(index)
-      case WSubField(expr, field, _, _) => niceName(depth)(expr) + "_" + field
-      case WSubIndex(expr, index, _, _) => niceName(depth)(expr) + "_" + index
       case Reference(name, _, _, _) if name(0) == '_' => name
       case Reference(name, _, _, _) => "_" + name
       case SubAccess(expr, index, _, _) if depth <= 0 => niceName(depth)(expr)
@@ -297,11 +291,8 @@ object Utils extends LazyLogging {
     var ref = "???"
     def onExp(expr: Expression): Expression = {
       expr map onExp match {
-        case e: WRef => ref = e.name
         case e: Reference => ref = e.name
-        case e: WSubField => tokens += TargetToken.Field(e.name)
         case e: SubField => tokens += TargetToken.Field(e.name)
-        case e: WSubIndex => tokens += TargetToken.Index(e.value)
         case e: SubIndex => tokens += TargetToken.Index(e.value)
         case other => throwInternalError("Cannot call Utils.toTarget on non-referencing expression")
       }
@@ -389,7 +380,6 @@ object Utils extends LazyLogging {
   def inline(nodeMap: NodeMap, stop: String => Boolean = {x: String => false})(e: Expression): Expression = {
     def onExp(e: Expression): Expression = e map onExp match {
       case Reference(name, _, _, _) if nodeMap.contains(name) && !stop(name) => onExp(nodeMap(name))
-      case WRef(name, _, _, _) if nodeMap.contains(name) && !stop(name) => onExp(nodeMap(name))
       case other => other
     }
     onExp(e)
diff --git a/src/main/scala/firrtl/annotations/Target.scala b/src/main/scala/firrtl/annotations/Target.scala
index 254e2dfd..10c74e77 100644
--- a/src/main/scala/firrtl/annotations/Target.scala
+++ b/src/main/scala/firrtl/annotations/Target.scala
@@ -103,13 +103,9 @@ sealed trait Target extends Named {
 
 object Target {
   def asTarget(m: ModuleTarget)(e: Expression): ReferenceTarget = e match {
-    case w: WRef => m.ref(w.name)
     case r: ir.Reference => m.ref(r.name)
-    case w: WSubIndex => asTarget(m)(w.expr).index(w.value)
     case s: ir.SubIndex => asTarget(m)(s.expr).index(s.value)
-    case w: WSubField => asTarget(m)(w.expr).field(w.name)
     case s: ir.SubField => asTarget(m)(s.expr).field(s.name)
-    case w: WSubAccess => asTarget(m)(w.expr).field("@" + w.index.serialize)
     case s: ir.SubAccess => asTarget(m)(s.expr).field("@" + s.index.serialize)
     case d: DoPrim => m.ref("@" + d.serialize)
     case d: Mux => m.ref("@" + d.serialize)