Better band-aidy fix for ClassCastException on malformed programs

This patch addressed the problem at a better point I think: to typecheck
```scala
class Foo extends someTree
```
we need to detect correctly if `someTree` should be typechecked as a term or a
type; `Int => 1` should be typechecked as a type, even though it looks like a
term according to `isTerm`.

Really, we shouldn't use isType at all, because the user might write a type in
place of a term or viceversa. I think we only want to know this is a constructor
call or a type; and maybe we should just let the parser tell us which, since it
knows.

Update: we don't crash any more on the above example for some reasons, but we
still have crashes.

Author: Blaisorblade

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1586,7 +1586,13 @@ class Typer extends Namer
     val seenParents = mutable.Set[Symbol]()
 
     def typedParent(tree: untpd.Tree): Tree = {
-      var result = if (tree.isType) typedType(tree)(superCtx) else typedExpr(tree)(superCtx)
+      @tailrec
+      def isTreeType(t: untpd.Tree): Boolean = t match {
+        case _: untpd.Function => true
+        case untpd.Parens(t1) => isTreeType(t1)
+        case _ => tree.isType
+      }
+      var result = if (isTreeType(tree)) typedType(tree)(superCtx) else typedExpr(tree)(superCtx)
       val psym = result.tpe.dealias.typeSymbol
       if (seenParents.contains(psym) && !cls.isRefinementClass) {
         if (!ctx.isAfterTyper) ctx.error(i"$psym is extended twice", tree.pos)

tests/neg/parser-stability-25.scala

@@ -0,0 +1,11 @@
+class A extends (Int => i1) // error
+class B extends (Int => this) // error
+trait C {
+  val bar: Int => this // error
+}
+
+// Test that function types ending in SIP-23 singleton types are understood correctly.
+
+class D extends (Int => 1) {
+  def apply(x: Int) = 2 // error
+}

tests/neg/parser-stability-26.scala

@@ -0,0 +1,2 @@
+// Test that function types ending in SIP-23 singleton types are understood correctly.
+class E extends (Int => 1) // error

tests/pos/singleton-fun-types.scala

@@ -0,0 +1,4 @@
+trait C extends (Int => 1)
+class D extends (Int => 1) {
+  def apply(x: Int) = 1
+}