Trouble with intersection types

Hi folks,

Here's a shortish test case boiled down from a larger example,

  trait AbstractModule {
    type t <: T
    def newT : t
    abstract class T
  }

  trait DerivedModule1 extends AbstractModule {
    type t <: DerivedT1
    trait DerivedT1 extends T {
      def derivedT1 = Console.println("derivedT1")
    }
  }

  trait DerivedModule2 extends AbstractModule {
    type t <: DerivedT2
    trait DerivedT2 extends T {
      def derivedT2 = Console.println("derivedT2")
    }
  }

  object ConcreteModule extends DerivedModule1 with DerivedModule2 {
    type t = ConcreteT
    def newT = new ConcreteT
    class ConcreteT extends DerivedT1 with DerivedT2
  }

  object TestT extends Application {
    run1(ConcreteModule)
    run2(ConcreteModule)
    run12(ConcreteModule)
  
    def run1(m : DerivedModule1) = {
      val t = m.newT
      t.derivedT1
    }

    def run2(m : DerivedModule2) = {
      val t = m.newT
      t.derivedT2
    }

    def run12(m : DerivedModule1 with DerivedModule2) = {
      val t = m.newT
      t.derivedT1 // <-- error: value derivedT1 is not a member of m.t
      t.derivedT2
    }
  }

This really feels like it ought to work. If I add the following trait,

  trait CombinedModule extends DerivedModule1 with DerivedModule2 {
    type t <: DerivedT1 with DerivedT2
  }

and modify ConcreteModule and run12 to use it,

  object ConcreteModule extends CombinedModule {
    type t = ConcreteT
    def newT = new ConcreteT
    class ConcreteT extends DerivedT1 with DerivedT2
  }

  def run12(m : CombinedModule) = {
    val f = m.newT
    f.derivedT1
    f.derivedT2
  }

then everything works as expected ... but surely this is more or less 
equivalent to the original? Is this a compiler bug or am I missing 
something obvious?

Cheers,


Miles