add completions for specific MatchType cases

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

@@ -302,6 +302,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 +363,12 @@ 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 =
+      qual.tpe.widenDealias match 
+        case ctx.typer.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

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

@@ -1499,6 +1499,22 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     assignType(cpy.Closure(tree)(env1, meth1, target), meth1, target)
   }
 
+  /** Extractor for match types hidden behind an AppliedType/MatchAlias */
+  object MatchTypeInDisguise {
+    def unapply(tp: AppliedType)(using Context): 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
+    }
+  }
+
   def typedMatch(tree: untpd.Match, pt: Type)(using Context): Tree =
     tree.selector match {
       case EmptyTree =>
@@ -1526,21 +1542,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         val selType = rawSelectorTpe match
           case c: ConstantType if tree.isInline => c
           case otherTpe => otherTpe.widen
-        /** 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
-          }
-        }
 
         /** Does `tree` has the same shape as the given match type?
          *  We only support typed patterns with empty guards, but

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)
+
+  }
 }