TailRec transformation of inner methods in parameterized classes is broken

[smarter]

The following code:

class Parameterized[T] {
  def outer(outerParam: T): Unit = {
    def loop(loopParam: T): Unit =
    {
      loop(outerParam)
    }
    loop(outerParam)
  }
}

Is transformed after TailRec into:

class Parameterized[T]()  extends Object() { 
   Parameterized$$T
   private[this] type T = Parameterized$$T
   def outer(val outerParam: Parameterized$$T): Unit = {
     def loop(val loopParam: Parameterized$$T): Unit = {
       def tailLabel1[type T](val $this: Parameterized[T])(val loopParam: T): 
         Unit
        = {
         tailLabel1[T]($this)(outerParam)
       }
       tailLabel1[Parameterized$$T](Parameterized.this)(loopParam)
     }
     loop(outerParam)
   }
 }
 val Parameterized: Parameterized$ = new Parameterized$()
}

This should not typecheck because outerParam in tailLabel1 has the type Parameterized$$T which is different from the type parameter T of tailLabel1. -Ycheck does not detect this problem because of a bug in the subtyping checks fixed in smarter@f9512c6 . The problem is that FullParameterization does not handle inner methods correctly.
@DarkDimius, @odersky: why is it necessary to make the labels created by TailRec fully parameterized?

[DarkDimius]

@smarter thanks for catching the bug!

Tailrec needs to reconstruct control flow in order to decide if method is in tail position. This is pretty easy before patmat but after it isn't.

If placed after patmat tailrec will need to know about how <label> DefDefs are compiled, to reconstruct information weather particular call is in tail position. I've played around this, it makes implementation code twice as big and requires additional deep traversal, adding 15% to compilation time of methods that have not-so-big patterns. Comparing with many other phases that we have, tailrec is a costly one, and by running it on compact high-level representation we get both better speed and easier implementation.

I guess this bug originates from FullParameterization being also used by ExtensionMethods, where all type parameters loose connection with originating class.