add completions for specific MatchType cases

Author: rochala

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -23,6 +23,10 @@ import dotty.tools.dotc.util.SourcePosition
 
 import scala.collection.mutable
 import scala.util.control.NonFatal
+import dotty.tools.dotc.core.Types.MatchType
+import dotty.tools.dotc.core.Types.AppliedType
+import dotty.tools.dotc.core.Types.TypeRef
+import dotty.tools.dotc.core.Types.MatchAlias
 
 /**
  * One of the results of a completion query.
@@ -302,6 +306,7 @@ object Completion {
     def selectionCompletions(qual: Tree)(using Context): CompletionMap =
       implicitConversionMemberCompletions(qual) ++
         extensionCompletions(qual) ++
+        matchTypeCompletions(qual) ++
         directMemberCompletions(qual)
 
     /** Completions for members of `qual`'s type.
@@ -362,6 +367,28 @@ object Completion {
           implicitConversionTargets(qual)(using ctx.fresh.setExploreTyperState()).flatMap(accessibleMembers)
         membersFromConversion.toSeq.groupByName
 
+    /** Completions for derived members of `MatchType`'s type. */
+    def matchTypeCompletions(qual: Tree)(using Context): CompletionMap =
+      /** Extractor for match types hidden behind an AppliedType/MatchAlias */
+      object MatchTypeInDisguise {
+        def unapply(tp: AppliedType): Option[MatchType] = tp match {
+          case AppliedType(tycon: TypeRef, args) =>
+            tycon.info match {
+              case MatchAlias(alias) =>
+                alias.applyIfParameterized(args) match {
+                  case mt: MatchType => Some(mt)
+                  case _ => None
+                }
+              case _ => None
+            }
+          case _ => None
+        }
+      }
+
+      qual.tpe.widenDealias match 
+        case MatchTypeInDisguise(mt) => accessibleMembers(mt.reduced).groupByName
+        case _ => Map.empty 
+      
     /** Completions from extension methods */
     private def extensionCompletions(qual: Tree)(using Context): CompletionMap =
       def asDefLikeType(tpe: Type): Type = tpe match

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

@@ -1121,4 +1121,20 @@ class CompletionTest {
            |  val x = Bar.`fo${m1}"""
              .withSource.completion(m1, expected)
   }
+
+  @Test def matchTypeCompletion: Unit = {
+    val expected = Set(
+      ("map", Method, "[B](f: Int => B): Foo[B]"),
+    )
+    code"""trait Foo[A] {
+           |  def map[B](f: A => B): Foo[B]
+           |}
+           |case class Bar[F[_]](bar: F[Int])
+           |type M[T] = T match {
+           |  case Int => Foo[Int]
+           |}
+           |def foo(x: Bar[M]) = x.bar.m${m1}"""
+             .withSource.completion(m1, expected)
+
+  }
 }