scala generic instance, cannot reference variable within the generic type

Stuck on this problem. Can use a workaround, but hate to lose the type-safety. Sample code:

package test
trait RecDefClass

trait RecDefObj {
  def runTest = doInstance(Test())
  def doInstance[T <: RecDefClass](instance:T)
}

case class Test(id:Long = 1, name:String = "Name of Test") extends RecDefClass

object Test extends RecDefObj {
  def main(args:Array[String]):Unit = {
    runTest
  }
  def doInstance[Test](instance:Test) = {
    println("Class of 'instance'    -- " + instance.getClass.getName)
    println("Class of object Test   -- " + this.getClass.getName)
    println("toString of 'instance' -- " + instance.toString)
    val fixed = instance.asInstanceOf[Test]
    // instance.id
    // fixed.id
  }
}

The code on line 21 -- instance.id -- generates a compile error. Even line 22 -- fixed.id -- generates a compile error (even though 'fixed' was coerced to be of type Test).

With these lines commented out, the code executes and produces this:

Class of 'instance'    -- test.Test
Class of object Test   -- test.Test$
toString of 'instance' -- Test(1,Name of Test)

exactly as expected.

Any thoughts, suggestions?

Thanks

def doInstance[T <: RecDefClass](instance:T) vs doInstance[Test](instance:Test). You widened the generic (as if you did def doInstance[Test <: Any](instance:Test)). You did NOT applied Test as type parameter on definition (it's not C++ template specialization).

Original accepted T <: RecDefClass, the implementation uses type parameter Test - which means that it no longer expects it to be <: RecDefClass, it can be whatever type you pass inside, just that this time you named it Test.

This [Test] type parameter overshadows type Test from above, meaning that this Test is NOT the case case but some T <: Any. That's why the compiler complains.

In other words:

When you are defining def something[Test](...) you are creating a NEW type Test seen only inside something. This Test would overshade other types having the same name.

When you are calling something[Test] you are telling compiler that object coming in will use Test type (as known outside) in place of whatever type parameter was called both in arguments and in returned value.

Your code is thus equal to

object Test extends RecDefObj {
  def main(args:Array[String]):Unit = {
    runTest
  }
  def doInstance[T <: Any](instance:T) = {
    println("Class of 'instance'    -- " + instance.getClass.getName)
    // instance doesn't have to be of instance `Test`
    // so the code below is lying
    println("Class of object Test   -- " + this.getClass.getName)
    println("toString of 'instance' -- " + instance.toString)
    // [Test] inside overshaded case class Test outside
    // so this is what you actually got
    val fixed = instance.asInstanceOf[T]
    // instance.id
    // fixed.id
  }
}