Tweak check to fail if type param follows explicit param

Author: som-snytt

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

@@ -1570,25 +1570,25 @@ trait Applications extends Compatibility {
     def trySelectUnapply(qual: untpd.Tree)(fallBack: (Tree, TyperState) => Tree): Tree = {
       // try first for non-overloaded, then for overloaded occurrences
       def tryWithName(name: TermName)(fallBack: (Tree, TyperState) => Tree)(using Context): Tree =
-        // `true` if there are type parameters not followed by explicit term parameters.
-        def hasTrailingTypeParams(paramss: List[List[Symbol]], trailingTypeParams: Boolean): Boolean =
-          paramss match
-          case params :: paramss =>
-            val isTrailingTypeParams =
+        // `true` if there are no type parameters following the first explicit term parameter.
+        def hasOnlyLeadingTypeParams(paramss: List[List[Symbol]]): Boolean =
+          def checkForIt(paramss: List[List[Symbol]], leading: Boolean): Boolean =
+            paramss match
+            case params :: paramss =>
               params match
-              case param :: _ if param.isType => true
-              case param :: _ if param.isTerm && !param.isOneOf(GivenOrImplicit) => false
-              case _ => trailingTypeParams
-            hasTrailingTypeParams(paramss, isTrailingTypeParams)
-          case nil => trailingTypeParams
+              case param :: _ if param.isType && !leading => false
+              case param :: _ if param.isTerm && !param.isOneOf(GivenOrImplicit) => checkForIt(paramss, leading = false)
+              case _ => checkForIt(paramss, leading)
+            case nil => true
+          checkForIt(paramss, leading = true)
 
         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 && hasTrailingTypeParams(result.symbol.paramSymss, trailingTypeParams = false) then
+          if result.symbol.exists && !hasOnlyLeadingTypeParams(result.symbol.paramSymss) then
             // We don't accept `unapply` or `unapplySeq` methods with type
             // parameters after the last explicit term parameter because we
             // can't encode them: `UnApply` nodes cannot take type paremeters.

tests/pos/i23499.scala

@@ -0,0 +1,28 @@
+
+
+def summonsTest = 
+  given Type[String] = ???
+  val opt1: Option[Wrapper[String]] = Wrapper.unapply[String] // ok
+  val opt2 = Wrapper.unapply[String]
+  opt2.map(_.getValue) // only error when using workaround
+
+def patternMatchTest =
+  Type[String] match 
+    case Wrapper(v) => v.getValue // was error // was error
+
+type Type[A] = Class[A] // any rhs would work here
+object Type:
+  def apply[A]: Type[A] = ???
+
+trait Wrapper[T]:
+  def getValue: T = ???
+object Wrapper:
+  def unapply[T](implicit ev: Type[T]): Option[Wrapper[T]] = None
+    
+  /* Workaround: 
+  @annotation.targetName("unapplyValue")
+  def unapply[T](ev: Type[T]): Option[Wrapper[T]] = unapply(using ev)
+  
+  @annotation.targetName("unapplySummon")
+  def unapply[T](using Type[T]): Option[Wrapper[T]] = ???
+  */