Better handling of type parameters in constructor pattern

In a constructor pattern `C[T](x)` with some type parameter(s), we have two choices.

 1. Interpret it as `C[T].unapply(selector)`
 2. Interpret it as `C.unapply[T](selector)`.

So far we always picked the first choice, which means that usually it will fail with a
message such as "`C` does not take type parameters".

In this PR, we pick the second choice if it can be typechecked without errors and
fall back to the first choice otherwise.

Author: odersky

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

@@ -1260,28 +1260,41 @@ trait Applications extends Compatibility {
      */
     def trySelectUnapply(qual: untpd.Tree)(fallBack: (Tree, TyperState) => Tree): Tree = {
       // try first for non-overloaded, then for overloaded ocurrences
-      def tryWithName(name: TermName)(fallBack: (Tree, TyperState) => Tree)(using Context): Tree = {
-        def tryWithProto(pt: Type)(using Context) = {
-          val result = typedExpr(untpd.Select(qual, name), new UnapplyFunProto(pt, this))
+      def tryWithName(name: TermName)(fallBack: (Tree, TyperState) => Tree)(using Context): Tree =
+
+        def tryWithProto(qual: untpd.Tree, targs: List[Tree], pt: Type)(using Context) =
+          val proto = UnapplyFunProto(pt, this)
+          val unapp = untpd.Select(qual, name)
+          val result =
+            if targs.isEmpty then typedExpr(unapp, proto)
+            else typedExpr(unapp, PolyProto(targs, proto)).appliedToTypeTrees(targs)
           if !result.symbol.exists
              || result.symbol.name == name
              || ctx.reporter.hasErrors
           then result
           else notAnExtractor(result)
           	// It might be that the result of typedExpr is an `apply` selection or implicit conversion.
           	// Reject in this case.
-        }
-        tryEither {
-          tryWithProto(selType)
-        } {
-          (sel, state) =>
-            tryEither {
-              tryWithProto(WildcardType)
-            } {
-              (_, _) => fallBack(sel, state)
-            }
-        }
-      }
+
+        def tryWithTypeArgs(qual: untpd.Tree, targs: List[Tree])(fallBack: (Tree, TyperState) => Tree): Tree =
+          tryEither {
+            tryWithProto(qual, targs, selType)
+          } {
+            (sel, state) =>
+              tryEither {
+                tryWithProto(qual, targs, WildcardType)
+              } {
+                (_, _) => fallBack(sel, state)
+              }
+          }
+
+        qual match
+          case TypeApply(qual1, targs) =>
+            tryWithTypeArgs(qual1, targs.mapconserve(typedType(_)))((t, ts) =>
+              tryWithTypeArgs(qual, Nil)(fallBack))
+          case _ =>
+            tryWithTypeArgs(qual, Nil)(fallBack)
+      end tryWithName
 
       // try first for unapply, then for unapplySeq
       tryWithName(nme.unapply) {

tests/run/unapply-tparam.scala

@@ -0,0 +1,36 @@
+class Foo[T] {
+  def unapply(x: Int): Option[Int] = Some(4)
+}
+
+object Foo {
+  def unapply[T](x: T): Option[Int] = Some(5)
+}
+
+object Bar {
+  def unapply[T](x: T): Option[Int] = Some(5)
+}
+
+class Baz[T] {
+  def unapply(x: Int): Option[Int] = Some(4)
+}
+
+object Baz
+
+
+object Test extends App {
+  1 match {
+    case Foo(x) => assert(x == 5)
+  }
+
+  1 match {
+    case Foo[Int](x) => assert(x == 5)  // Type params on object takes precedence
+  }
+
+  1 match {
+    case Bar[Int](x) => assert(x == 5)
+  }
+
+  1 match {
+    case Baz[Int](x) => assert(x == 4)  // Otherwise type params are for the class
+  }
+}