existential scoping is hopelessly broken

[scabug]

I'm putting the finishing touches on my 1000 page homage to futility.

// Fails
class Foo {
  def f(x: Any) = x match { case x: (T forSome { type T }) => x }
  // a.scala:2: error: not found: type T
  //   def f(x: Any) = x match { case x: (T forSome { type T }) => x }
  //                                      ^
}

// Everything in this class compiles
class Foo2 {
  type T <: String

  def f(x: Any) = x match { case x: (T forSome { type T }) => x }
  // Compiles! Uses the T from the surrounding scope.
  def g(x: Any) = x match { case x: T => x }
  // Also compiles - but bizarrely, f gets the classtag treatment while g does not!?
  // def f(x: Any): Foo2.this.T = x match {
  //   case (x @ ClassTag.apply[Foo2.this.T[]](classOf[java.lang.String]).unapply(<unapply-selector>) <unapply> ((_: Foo2.this.T[]))) => x
  // };
  // def g(x: Any): Foo2.this.T = x match {
  //   case (x @ (_: Foo2.this.T)) => x
  // }

  // And for good measure, this compiles too.
  type Q = T forSome { type T }

  def h(x: Any) = x match { case x: Q => x }
}

[scabug]

Imported From: https://issues.scala-lang.org/browse/SI-7730?orig=1
Reporter: @paulp

[scabug]

@retronym said:
The bug stems from this in typedIdent:

          // ignore current variable scope in patterns to enforce linearity
        val startContext = if (mode.typingPatternOrTypePat) context.outer else context
        val nameLookup   = tree.symbol match {
          case NoSymbol   => startContext.lookupSymbol(name, qualifies)
          case sym        => LookupSucceeded(EmptyTree, sym)
        }

Which the any self-respecting deviant would exploit with:

  def f(x: Any) = x match { case (a: AnyRef, x: (a.type forSome { type T })) => x } // !!! compiles

Type patterns are not explicitly specced to allow the forSome syntax: http://www.scala-lang.org/files/archive/spec/2.11/08-pattern-matching.html#type-patterns in the

So one most straight forward fix for the directly reported bug would be to prohibit this.

But we have to be nuanced enough to allow:

def f(x: Any) = x match { case x: Array[(T forSome { type T })] => x }

and to outlaw things like:

def f(x: Any) = x match { case (y: AnyRef, x: Array[({type X = y.type})#X]) => x }

[scabug]

@paulp said:
"Types which are not of one of the forms described above are also accepted as type patterns."

[scabug]

@retronym said:
Oh right, I missed that part. Makes sense in comparison to the syntax spec that allows any type.

This is a first cut a a fix: scala/scala#4348