Question

I have a class such as this:

class NormalClass[T <: NormalClass[T]] {
  object One
  object Two
}

and I wish to be able to create a new instance of the above class in a typed trait. The following def make in MetaClass creates an instance of T but it lacks the internal objects associated with NormalClass.

trait MetaClass[T <: NormalClass[T]] {
  def make:T = this.getClass.getSuperclass.newInstance.asInstanceOf[T]
} 

I have two questions, what is the reason for the missing objects and what is the best way, using reflection, to initiate a new class with internal objects from its type

EDIT: More Detail

The problem I am facing is if I then create an instance using make e.g. var f = make and I try to access and object method e.g. f.One.getSomething I get the error value One is not a member of type parameter T.

Answer 1

So I think your problem in particular is the reflection:

this.getClass.getSuperclass.newInstance.asInstanceOf[T]

Here, this is your instance of MetaClass, and there’s no particular reason to believe that the superclass of this is the class you want to instantiate. For example:

class Foo extends NormalClass[Foo]
object Foo extends MetaClass[Foo]

In this case, the superclass of the object Foo is not a NormalClass at all, it’s java.lang.Object. As a result, it won’t have members like One or Two, and you’ll get a ClassCastException if you try to cast it to T.

If you want the make method to instantiate an object of type T, then you need to get the runtime class of T, and then use that to create the new instance. You can accomplish this by implicitly acquiring a ClassTag:

class NormalClass[T <: NormalClass[T]] {
  object One
  object Two
}
trait MetaClass[T <: NormalClass[T]] {
  def make(implicit classTag: scala.reflect.ClassTag[T]): T =
    classTag.runtimeClass.newInstance.asInstanceOf[T]
}

// declare a class and an object for creating instances of that class
class Foo extends NormalClass[Foo]
object Foo extends MetaClass[Foo]

// create a new instance of Foo and access its fields
val foo = Foo.make
foo.One
foo.Two