Prefer litValue, eliminate litToBigInt

3 files changed, 21 insertions, 21 deletions

diff --git a/src/main/scala/chisel3/util/BitPat.scala b/src/main/scala/chisel3/util/BitPat.scala
index 3a3a7061..6ff08bea 100644
--- a/src/main/scala/chisel3/util/BitPat.scala
+++ b/src/main/scala/chisel3/util/BitPat.scala
@@ -75,7 +75,7 @@ object BitPat {
     */
   def apply(x: UInt): BitPat = {
     val len = if (x.isWidthKnown) x.getWidth else 0
-    apply("b" + x.litToBigInt.toString(2).reverse.padTo(len, "0").reverse.mkString)
+    apply("b" + x.litValue.toString(2).reverse.padTo(len, "0").reverse.mkString)
   }
 }
 
diff --git a/src/main/scala/chisel3/util/Conditional.scala b/src/main/scala/chisel3/util/Conditional.scala
index 1d2805ad..bf2d4268 100644
--- a/src/main/scala/chisel3/util/Conditional.scala
+++ b/src/main/scala/chisel3/util/Conditional.scala
@@ -28,8 +28,8 @@ class SwitchContext[T <: Bits](cond: T, whenContext: Option[WhenContext], lits:
   def is(v: Iterable[T])(block: => Unit): SwitchContext[T] = {
     if (!v.isEmpty) {
       val newLits = v.map { w =>
-        require(w.litToBigIntOption.isDefined, "is condition must be literal")
-        val value = w.litToBigInt
+        require(w.litOption.isDefined, "is condition must be literal")
+        val value = w.litValue
         require(!lits.contains(value), "all is conditions must be mutually exclusive!")
         value
       }
diff --git a/src/test/scala/chiselTests/LiteralExtractorSpec.scala b/src/test/scala/chiselTests/LiteralExtractorSpec.scala
index 8354297b..e3cf2587 100644
--- a/src/test/scala/chiselTests/LiteralExtractorSpec.scala
+++ b/src/test/scala/chiselTests/LiteralExtractorSpec.scala
@@ -9,24 +9,24 @@ import chisel3.testers.BasicTester
 import org.scalatest._
 
 class LiteralExtractorSpec extends ChiselFlatSpec {
-  "litToBigInt" should "return the literal value" in {
-    assert(0.U.litToBigInt === BigInt(0))
-    assert(1.U.litToBigInt === BigInt(1))
-    assert(42.U.litToBigInt === BigInt(42))
-    assert(42.U.litToBigInt === 42.U.litToBigInt)
+  "litValue" should "return the literal value" in {
+    assert(0.U.litValue === BigInt(0))
+    assert(1.U.litValue === BigInt(1))
+    assert(42.U.litValue === BigInt(42))
+    assert(42.U.litValue === 42.U.litValue)
 
-    assert(0.S.litToBigInt === BigInt(0))
-    assert(-1.S.litToBigInt === BigInt(-1))
-    assert(-42.S.litToBigInt === BigInt(-42))
+    assert(0.S.litValue === BigInt(0))
+    assert(-1.S.litValue === BigInt(-1))
+    assert(-42.S.litValue === BigInt(-42))
 
-    assert(true.B.litToBigInt === BigInt(1))
-    assert(false.B.litToBigInt === BigInt(0))
+    assert(true.B.litValue === BigInt(1))
+    assert(false.B.litValue === BigInt(0))
 
-    assert(1.25.F(2.BP).litToBigInt === BigInt("101", 2))
-    assert(2.25.F(2.BP).litToBigInt === BigInt("1001", 2))
+    assert(1.25.F(2.BP).litValue === BigInt("101", 2))
+    assert(2.25.F(2.BP).litValue === BigInt("1001", 2))
 
-    assert(-1.25.F(2.BP).litToBigInt === BigInt("-101", 2))
-    assert(-2.25.F(2.BP).litToBigInt === BigInt("-1001", 2))
+    assert(-1.25.F(2.BP).litValue === BigInt("-101", 2))
+    assert(-2.25.F(2.BP).litValue === BigInt("-1001", 2))
   }
 
   "litToBoolean" should "return the literal value" in {
@@ -46,10 +46,10 @@ class LiteralExtractorSpec extends ChiselFlatSpec {
     assert(1.25.F(1.BP).litToDouble == 1.5)
   }
 
-  "litToBigIntOption" should "return None for non-literal hardware" in {
+  "litOption" should "return None for non-literal hardware" in {
     elaborate { new RawModule {
       val a = Wire(UInt())
-      assert(a.litToBigIntOption == None)
+      assert(a.litOption == None)
     }}
   }
 
@@ -114,8 +114,8 @@ class LiteralExtractorSpec extends ChiselFlatSpec {
       }
     }
     val myBundleLiteral = (new MyBundle).Lit(42.U, true.B)
-    assert(myBundleLiteral.a.litToBigInt == 42)
-    assert(myBundleLiteral.b.litToBigInt == 1)
+    assert(myBundleLiteral.a.litValue == 42)
+    assert(myBundleLiteral.b.litValue == 1)
     assert(myBundleLiteral.b.litToBoolean == true)
   }
 }