Background: Chisel._ vs chisel3._ directionality

In Chisel._, IO has an implicit output direction, and Flipped is used for two things:

1. Define relative direction of a field with respect to its parent bundle
2. To change the implicit output to an implicit input of IO

val io = IO(new Bundle { // implicit output
  val x = Flipped(UInt()) // x is flipped relative to bundle, so it is an input
  val y = UInt() // y is aligned relative to bundle, so it is an output
})

You can declare an input port using the (2) kind of Flipped:

val io = IO(Flipped(new Bundle { // implicit input
  val x = Flipped(UInt()) // x is flipped relative to bundle, so it is an output
  val y = UInt() // y is aligned relative to bundle, so it is an input
}))

In chisel3, IO does not have an implicit direction, but Input and Output are specified on types, which coerce all subfields of the type to the same direction. Flipped inverts the absolute direction so Input -> Output and Output -> Input.

val io = IO(new Bundle { // no implicit direction
  val x = Input(UInt()) // x is an input
  val y = Output(UInt()) // y is an output
}))

You can switch directions with Flipped:

val io = IO(Flipped(new Bundle { // Swap all absolute directions
  val x = Input(UInt()) // x is flipped so it is an output
  val y = Output(UInt()) // y is flipped so it is an input
})))

Unifying directionality with new primitives

Both mechanisms of describing field directions can be unified with the following (conceptual) primitives:

• Flipped: a field's relative direction is reversed with respect to its parent bundle
• Aligned: a field's relative direction is the same with respect to its parent bundle (is implicit)
• Outgoing: an IO whose implicit direction is output
• Incoming: an IO whose implicit direction is input
• stripFlipsOf: a type-generator that aligns all subfields, recursively
• reverseFlipsOf: a type-generator that flips all subfields, recursively

Expressing Chisel._ semantics:

• IO(new Bundle)) becomes Outgoing(new Bundle)
• IO(Flipped(new Bundle)) becomes Incoming(new Bundle); note that Outgoing(reverseFlipsOf(new Bundle)) is the same, but I think it makes sense to have Incoming as well.
• new Bundle { val x = UInt() } is new Bundle { val x = Aligned(UInt()) }, or unchanged as Aligned is implicit
• new Bundle { val x = Flipped(UInt()) } is unchanged

Expressing chisel3._ semantics:

• IO(new Bundle)) becomes Outgoing(new Bundle)
• IO(Flipped(new Bundle)) becomes Incoming(new Bundle)
• new Bundle { val x = Output(UInt()) } is new Bundle { val x = Aligned(stripFlipsOf(UInt())) }
• new Bundle { val x = Input(UInt()) } is new Bundle { val x = Flipped(stripFlipsOf(UInt())) }

How this PR unifies these things

Just like we can express Chisel/chisel3 with new primitives, we can represent the new primitives with Chisel/chisel3 APIs. The only thing that was missing was (1) ALWAYS apply the implicit output from IO (or implicit input if a flip is there), and (2) enable mixing Input/Output with Flipped. This means that effectively, Input becomes Flipped(stripsFlipsOf(..)) and Output becomes Aligned(stripsFlipsOf(..)), and now the semantics can coexist. Basically, this change defines how Chisel._'s relative directions resolve in chisel3. This should not break any code, because previously it was an error.

Future work will be to add the new primitives as they are, and refactor Input/Output etc to just call the new primitives. In the meantime, we can change the semantics so that this change is easier, and we can get rid of compatibility mode.

Contributor Checklist

• Did you add Scaladoc to every public function/method?
• Did you add at least one test demonstrating the PR?
• Did you delete any extraneous printlns/debugging code?
• Did you specify the type of improvement?
• [N/A] Did you add appropriate documentation in docs/src? Will do this later when we add more primitives
• Did you state the API impact?
• Did you specify the code generation impact?
• Did you request a desired merge strategy?
• Did you add text to be included in the Release Notes for this change?

Type of Improvement

• new feature/API

API Impact

Adds an API, where you can now declare bundles that have both Flipped and Input/Output.

Backend Code Generation Impact

None

Desired Merge Strategy

• Squash: The PR will be squashed and merged (choose this if you have no preference.

Release Notes

Remove restriction that Bundles have to only declare fields with absolute directions (Input/Output) or relative directions (Flipped).

Reviewer Checklist (only modified by reviewer)

• Did you add the appropriate labels?
• Did you mark the proper milestone (Bug fix: 3.4.x, [small] API extension: 3.5.x, API modification or big change: 3.6.0)?
• Did you review?
• Did you check whether all relevant Contributor checkboxes have been checked?
• Did you do one of the following when ready to merge:
  • Squash: You/ the contributor Enable auto-merge (squash), clean up the commit message, and label with Please Merge.
  • Merge: Ensure that contributor has cleaned up their commit history, then merge with Create a merge commit.