Mixin

This phase performs the following transformations:

1. (done in traitDefs and transformSym) For every concrete trait getter

   def x(): T = expr

make it non-private, and add the definition of its trait setter:

 <mods> def TraitName$_setter_$x(v: T): Unit

2. (done in traitDefs) Make every concrete trait setter

   def x_=(y: T) = ()

deferred by mapping it to

<mods> def x_=(y: T)

3. (done in transformSym) For every module class constructor in traits, remove its Private flag (but do not expand its name), since it will have to be instantiated in the classes that mix in the trait.

4. For a non-trait class C:

   For every trait M directly implemented by the class (see SymUtils.mixin), in reverse linearization order, add the following definitions to C:

   4.1 (done in `traitInits`) For every parameter accessor `<mods> def x(): T` in M,
       in order of textual occurrence, add
   
        <mods> def x() = e
   
       where `e` is the constructor argument in C that corresponds to `x`. Issue
       an error if no such argument exists.
   
   4.2 (done in `traitInits`) For every concrete trait getter `<mods> def x(): T` in M
       which is not a parameter accessor, in order of textual occurrence, produce the following:
   
       4.2.1 If `x` is also a member of `C`, and is a lazy val,
   
         <mods> lazy val x: T = super[M].x
   
       4.2.2 If `x` is also a member of `C`, and is a module,
   
         <mods> lazy module val x: T = new T$(this)
   
       4.2.3 If `x` is also a member of `C`, and is something else:
   
         <mods> def x(): T = _
   
       4.2.5 If `x` is not a member of `C`, nothing gets added.
   
   4.3 (done in `superCallOpt`) The call:
   
         super[M].$init$()
   
   4.4 (done in `setters`) For every concrete setter `<mods> def x_=(y: T)` in M:
   
         <mods> def x_=(y: T) = ()
   
   4.5 (done in `mixinForwarders`) For every method
   `<mods> def f[Ts](ps1)...(psN): U` imn M` that needs to be disambiguated:
   
         <mods> def f[Ts](ps1)...(psN): U = super[M].f[Ts](ps1)...(psN)
   
   A method in M needs to be disambiguated if it is concrete, not overridden in C,
   and if it overrides another concrete method.
   

5. (done in transformTemplate and transformSym) Drop all parameters from trait constructors, and rename them to nme.TRAIT_CONSTRUCTOR.

6. (done in transformSym) Drop ParamAccessor flag from all parameter accessors in traits.

Conceptually, this is the second half of the previous mixin phase. It needs to run after erasure because it copies references to possibly private inner classes and objects into enclosing classes where they are not visible. This can only be done if all references are symbolic.