The phase performs the following transformations (more or less...):

(1) An class which is not an interface and is not static gets an outer accessor (@see outerDefs). (1a) A class which is not a trait gets an outer field.

(4) A constructor of a non-trait inner class gets an outer parameter.

(5) A reference C.this where C refers to an outer class is replaced by a selection this.$outer$$C1 ... .$outer$$Cn (@see outerPath)

(7) A call to a constructor Q.(args) or Q.$init$(args) where Q != this and the constructor belongs to a non-static class is augmented by an outer argument. E.g. Q.(OUTER, args) where OUTER is the qualifier corresponding to the singleton type Q.

(8) A call to a constructor this.(args) in a secondary constructor is augmented to this.(OUTER, args) where OUTER is the last parameter of the secondary constructor.

(9) Remove private modifier from class members M that are accessed from an inner class.

(10) Remove protected modifier from class members M that are accessed without a super qualifier accessed from an inner class or trait.

(11) Remove private and protected modifiers from type symbols

Note: The whole transform is run in phase explicitOuter.next.

TODO: Make this doc reflect what's actually going on. Some of the deviations are motivated by separate compilation (name mangling based on usage is inherently unstable). Now that traits are compiled 1:1 to interfaces, they can have private members, so there's also less need to make trait members non-private (they still may need to be implemented in subclasses, though we could make those protected...).