add comments, simplify code and add missing cases

Author: rochala

compiler/src/dotty/tools/dotc/util/Signatures.scala

@@ -106,31 +106,43 @@ object Signatures {
 
   private def extractParamTypess(resultType: Type)(using Context): List[List[Type]] =
     resultType match {
+      // Reference to a type which is not a type class
       case ref: TypeRef if !ref.symbol.isPrimitiveValueClass =>
-        if (
-          ref.symbol.asClass.baseClasses.contains(ctx.definitions.ProductClass) &&
-          !ref.symbol.is(Flags.CaseClass)
-        ) || ref.symbol.isStaticOwner then
-          val productAccessors = ref.memberDenots(
-            underscoreMembersFilter,
-            (name, buf) => buf += ref.member(name).asSingleDenotation
-          )
-          List(productAccessors.map(_.info.finalResultType).toList)
-        else
-          ref.symbol.primaryConstructor.paramInfo.paramInfoss
+        getExtractorMembers(ref)
+      // Option or Some applied type. There is special syntax for multiple returned arguments:
+      //   Option[TupleN] and Option[Seq],
+      // We are not intrested in them, instead we extract proper type parameters from the Option type parameter.
       case AppliedType(TypeRef(_, cls), (appliedType @ AppliedType(tycon, args)) :: Nil)
           if (cls == ctx.definitions.OptionClass || cls == ctx.definitions.SomeClass) =>
         tycon match
           case TypeRef(_, cls) if cls == ctx.definitions.SeqClass => List(List(appliedType))
           case _ => List(args)
-      case AppliedType(_, args) =>
-        List(args)
+      // Applied type extractor. We must extract from applied type to retain type parameters
+      case appliedType: AppliedType => getExtractorMembers(appliedType)
+      // This is necessary to extract proper result type as unapply can return other methods eg. apply
       case MethodTpe(_, _, resultType) =>
         extractParamTypess(resultType.widenDealias)
       case _ =>
         Nil
     }
 
+  // Returns extractors from given type. In case if there are no extractor methods it fallbacks to get method
+  private def getExtractorMembers(resultType: Type)(using Context): List[List[Type]] =
+    val productAccessors = resultType.memberDenots(
+      underscoreMembersFilter,
+      (name, buf) => buf += resultType.member(name).asSingleDenotation
+    )
+    val availableExtractors = if productAccessors.isEmpty then
+      List(resultType.member(core.Names.termName("get")))
+    else
+      productAccessors
+    List(availableExtractors.map(_.info.finalResultType.stripAnnots).toList)
+
+  object underscoreMembersFilter extends NameFilter {
+    def apply(pre: Type, name: Name)(using Context): Boolean = name.startsWith("_")
+    def isStable = true
+  }
+
   def toSignature(denot: SingleDenotation)(using Context): Option[Signature] = {
     val symbol = denot.symbol
     val docComment = ParsedComment.docOf(symbol)
@@ -216,11 +228,6 @@ object Signatures {
     }
   }
 
-  object underscoreMembersFilter extends NameFilter {
-    def apply(pre: Type, name: Name)(using Context): Boolean = name.startsWith("_")
-    def isStable = true
-  }
-
   /**
    * The number of parameters that are applied in `tree`.
    *

language-server/test/dotty/tools/languageserver/SignatureHelpTest.scala

@@ -154,6 +154,24 @@ class SignatureHelpTest {
       .signatureHelp(m2, List(signature), Some(0), 1)
   }
 
+  @Test def productTypeClassMatch: Unit = {
+    val signature = S("", Nil, List(List(P("", "String"), P("", "String"))), None)
+
+    code"""class FirstChars[A](s: A) extends Product:
+          |  def _1 = s
+          |  def _2 = s
+          |
+          |object FirstChars:
+          |  def unapply(s: String): FirstChars[String] = new FirstChars(s)
+          |
+          |object Test:
+          |  "Hi!" match
+          |    case FirstChars(ch${m1}, ch${m2}) => ???
+          """
+      .signatureHelp(m1, List(signature), Some(0), 0)
+      .signatureHelp(m2, List(signature), Some(0), 1)
+  }
+
   @Test def nameBasedMatch: Unit = {
     val signature = S("", Nil, List(List(P("", "Int"), P("", "String"))), None)
 
@@ -173,6 +191,22 @@ class SignatureHelpTest {
       .signatureHelp(m2, List(signature), Some(0), 1)
   }
 
+  @Test def getObjectMatch: Unit = {
+    val signature = S("", Nil, List(List(P("", "String"))), None)
+
+    code"""object ProdEmpty:
+          |  def isEmpty = true
+          |  def unapply(s: String): this.type = this
+          |  def get: String = ""
+          |
+          |object Test:
+          |  "" match
+          |    case ProdEmpty(${m1}) => ???
+          |    case _ => ()
+          """
+      .signatureHelp(m1, List(signature), Some(0), 0)
+  }
+
   @Test def sequenceMatch: Unit = {
     val signature = S("", Nil, List(List(P("", "Seq[Char]"))), None)
 
@@ -212,7 +246,7 @@ class SignatureHelpTest {
   }
 
   @Test def productSequenceMatchForCaseClass: Unit = {
-    val signature = S("", Nil, List(List(P("name", "String"), P("children", "Int*"))), None)
+    val signature = S("", Nil, List(List(P("name", "String"), P("children", "Seq[Int]"))), None)
 
     code"""case class Foo(val name: String, val children: Int*)
           |