object XXXXX {
  
  trait Def {
    type Element >: Null <: Elt
    type Info
    trait Elt { self:Element=>
      def foo():Int
    }
    trait EltBuilder {
      def apply(i: Info): Element
    }
    trait Impl {
      val core:Def.this.type = Def.this
      type Elt        = core.Elt
      type Element    = core.Element
      type Info       = core.Info
      type EltBuilder = core.EltBuilder
      type Elt0 <: Element
      def builder:EltBuilder
    }
    trait Motor extends Impl with DefMotor
  }
  trait DefMotor { self:Def#Impl=>
    def foo(m:Element):Int
    trait Proc { this:Element=>
      def foo():Int = self.foo(this)
    }
  }
  
  class Info1(val name:String)
  trait Def1 extends Def {
    type Info <: Info1
    trait Elt extends super.Elt { this:Element=>
      def name:String
    }
    trait Element extends Elt
    trait Motor extends super.Motor with Def1Motor
  }
  trait Def1Motor extends DefMotor { this:Def1#Impl=>
    class Elt0(val name: String) extends core.Element with Proc
  }
  
  trait Def2[+Data] extends Def1 {
    trait Elt extends super.Elt { this:Element=>
      def data:Data
      def getData(i:Info):Data
    }
    trait Element extends super.Element with Elt
    trait Motor extends super.Motor with Def2Motor[Data]
  }
  trait Def2Motor[+Data] extends Def1Motor { self:Def2[Data]#Impl=>
    def getData(parent:Element,i:Info):Data
    class Elt0(name: String, val data:Data) extends super.Elt0(name) with core.Element {
      def getData(i:Info):Data = self.getData(this,i)
    }
  }
  
  class Info3(name:String,val length:Int) extends Info1(name)
  trait Def3[+Data] extends Def2[Data] {
    type Info <: Info3
    trait Elt extends super.Elt { this:Element=>
      def get:Int
    }
    trait Element extends super.Element with Elt
    trait Motor extends super.Motor with Def3Motor[Data]
  }
  trait Def3Motor[+Data] extends Def2Motor[Data] { self:Def3[Data]#Impl=>
    class Elt0(name: String, data:Data) extends super.Elt0(name, data) with core.Element {
      def get:Int = name.length
    }
    val builder = new EltBuilder {
      def apply(i:Info) = new Elt0(i.name,null.asInstanceOf[Data])
    }
  }
  
  object App extends Def3[String] {
    type Info = Info3
  }
  class App extends App.Motor {
    def foo(e:Element)                   = e.data.length+e.name.length
    def getData(e:Element,i:Info):String = e.name+i.length
  }
  
  def main(args:Array[String]) {
    val app = new App
    val t0 = new app.Elt0("coucou","abc")
    val t1 = new app.Elt0("hello","def")
    println(t0.getData(new Info3("azerty",7)))
  }

}

java.lang.AbstractMethodError: XXXXX$App.getData(LXXXXX$Def2$Element;LXXXXX$Info1;)Ljava/lang/Object;
	at XXXXX$Def2Motor$Elt0.getData(<console>:60)
	at XXXXX$.main(<console>:94)