blob: e82458720fe08ada0a4166d392ac5ec2d1b46345 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
// SPDX-License-Identifier: Apache-2.0
package firrtlTests
import org.scalatest._
import firrtl.ir._
import firrtl.Utils
import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers
object SerializerSpec {
case class WrapStmt(stmt: Statement) extends Statement {
def serialize: String = s"wrap(${stmt.serialize})"
def foreachExpr(f: Expression => Unit): Unit = stmt.foreachExpr(f)
def foreachInfo(f: Info => Unit): Unit = stmt.foreachInfo(f)
def foreachStmt(f: Statement => Unit): Unit = stmt.foreachStmt(f)
def foreachString(f: String => Unit): Unit = stmt.foreachString(f)
def foreachType(f: Type => Unit): Unit = stmt.foreachType(f)
def mapExpr(f: Expression => Expression): Statement = this.copy(stmt.mapExpr(f))
def mapInfo(f: Info => Info): Statement = this.copy(stmt.mapInfo(f))
def mapStmt(f: Statement => Statement): Statement = this.copy(stmt.mapStmt(f))
def mapString(f: String => String): Statement = this.copy(stmt.mapString(f))
def mapType(f: Type => Type): Statement = this.copy(stmt.mapType(f))
}
case class WrapExpr(expr: Expression) extends Expression {
def serialize: String = s"wrap(${expr.serialize})"
def tpe: Type = expr.tpe
def foreachExpr(f: Expression => Unit): Unit = expr.foreachExpr(f)
def foreachType(f: Type => Unit): Unit = expr.foreachType(f)
def foreachWidth(f: Width => Unit): Unit = expr.foreachWidth(f)
def mapExpr(f: Expression => Expression): Expression = this.copy(expr.mapExpr(f))
def mapType(f: Type => Type): Expression = this.copy(expr.mapType(f))
def mapWidth(f: Width => Width): Expression = this.copy(expr.mapWidth(f))
}
}
class SerializerSpec extends AnyFlatSpec with Matchers {
import SerializerSpec._
"ir.Serializer" should "support custom Statements" in {
val stmt = WrapStmt(DefWire(NoInfo, "myWire", Utils.BoolType))
val ser = "wrap(wire myWire : UInt<1>)"
Serializer.serialize(stmt) should be(ser)
}
it should "support custom Expression" in {
val expr = WrapExpr(Reference("foo"))
val ser = "wrap(foo)"
Serializer.serialize(expr) should be(ser)
}
it should "support nested custom Statements and Expressions" in {
val expr = SubField(WrapExpr(Reference("foo")), "bar")
val stmt = WrapStmt(DefNode(NoInfo, "n", expr))
val stmts = Block(stmt :: Nil)
val ser = "wrap(node n = wrap(foo).bar)"
Serializer.serialize(stmts) should be(ser)
}
}
|
