As I noted in a previous comment, the TC in the list of parameters of type Test (and in the error message) is not the TC that you defined a few lines earlier - this is a new constructor type that obscures the TC flag.
(As a side note, I would strongly recommend not using shadow type parameters. Shadow variables at the value level can be misleading, but shading type parameters are almost always a recipe for confusion.)
Type constructor parameters are discussed in section 4.4 of the specification. From this section:
A type constructor parameter adds a sentence of a nested type parameter to a type parameter ... The above coverage restrictions are generalized to the case of nested type parameter sentences that declare higher-order parameters. Type parameters of a higher order (type parameters of a parameter of type t) are visible only in their immediately surrounding parameter sentence (possibly including sentences at a deeper level of nesting) and within t.
Your T here is one of these higher order parameters. It can be limited (like any other type parameter), but it is not. This causes an error: you are trying to provide a type constructor that constrains its type parameter ( TC2 ) as the value of the parameter of the type constructor that does not share the constraint (in fact, it does not have a constraint at all).
To get an intuitive idea of why this is a problem, consider the following characteristic:
trait Foo[X[_]] { def create[A]: X[A] }
This is a perfectly reasonable thing to write: I could create an instance, for example, as follows:
object ListFoo extends Foo[List] { def create[A]: List[A] = Nil }
Now suppose I have a type constructor with a constraint:
trait MyIntOptionThingy[A <: Option[Int]]
The compiler forbids me to create an instance of Foo[MyIntOptionThingy] , because a parameter of type MyIntOptionThingy more strictly limited to a parameter of the type of a list of parameters of type X in Foo . If you think about it, it makes sense: how could I define create for any A when the only A that would work on MyIntOptionThingy are Some[Int] , None.type and Option[Int] ?