fix type alias completion, improve previous match type fix

Author: rochala

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

@@ -16,7 +16,7 @@ import dotty.tools.dotc.core.Symbols.{Symbol, defn}
 import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.SymDenotations.SymDenotation
 import dotty.tools.dotc.core.TypeError
-import dotty.tools.dotc.core.Types.{ExprType, MethodOrPoly, NameFilter, NoType, TermRef, Type}
+import dotty.tools.dotc.core.Types.{AppliedType, ExprType, MethodOrPoly, NameFilter, NoType, TermRef, Type}
 import dotty.tools.dotc.parsing.Tokens
 import dotty.tools.dotc.util.Chars
 import dotty.tools.dotc.util.SourcePosition
@@ -310,22 +310,21 @@ object Completion {
       resultMappings
     }
 
-    /** Replaces underlying type with reduced one, when it's MatchType */
-    def reduceUnderlyingMatchType(qual: Tree)(using Context): Tree=
-      qual.tpe.widen match
-        case ctx.typer.MatchTypeInDisguise(mt) => qual.withType(mt)
+    def widenDealiasAppliedTypes(qual: Tree)(using Context): Tree =
+      qual.tpe.widenDealias match
+        case appliedType: AppliedType => qual.withType(appliedType)
         case _ => qual
 
     /** Completions for selections from a term.
      *  Direct members take priority over members from extensions
      *  and so do members from extensions over members from implicit conversions
      */
     def selectionCompletions(qual: Tree)(using Context): CompletionMap =
-      val reducedQual = reduceUnderlyingMatchType(qual)
+      val adjustedQual = widenDealiasAppliedTypes(qual)
 
-      implicitConversionMemberCompletions(reducedQual) ++
-        extensionCompletions(reducedQual) ++
-        directMemberCompletions(reducedQual)
+      implicitConversionMemberCompletions(adjustedQual) ++
+        extensionCompletions(adjustedQual) ++
+        directMemberCompletions(adjustedQual)
 
     /** Completions for members of `qual`'s type.
      *  These include inherited definitions but not members added by extensions or implicit conversions

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

@@ -1522,22 +1522,6 @@ 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 =>
@@ -1565,6 +1549,21 @@ 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)(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
+          }
+        }
 
         /** 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

@@ -1001,7 +1001,7 @@ class CompletionTest {
     )
     code"""import scala.concurrent.Future
           |class Foo(x: Fut${m1})""".withSource
-      .completion(m1, expected) 
+      .completion(m1, expected)
   }
 
   @Test def completeTemplateParents: Unit = {
@@ -1011,7 +1011,7 @@ class CompletionTest {
     )
     code"""import scala.concurrent.Future
           |class Foo extends Futu${m1}""".withSource
-      .completion(m1, expected) 
+      .completion(m1, expected)
   }
 
   @Test def completeTemplateSelfType: Unit = {
@@ -1021,7 +1021,7 @@ class CompletionTest {
     )
     code"""import scala.concurrent.Future
           |class Foo[A]{ self: Futu${m1} => }""".withSource
-      .completion(m1, expected) 
+      .completion(m1, expected)
   }
 
   @Test def backticks: Unit = {
@@ -1061,7 +1061,7 @@ class CompletionTest {
            |  enum Bar:
            |    case `back-tick`
            |    case `match`
-           |  
+           |
            |  val x = Bar.${m1}"""
              .withSource.completion(m1, expected)
   }
@@ -1074,7 +1074,7 @@ class CompletionTest {
            |  enum Bar:
            |    case `back-tick`
            |    case `match`
-           |  
+           |
            |  val x = Bar.`back${m1}"""
              .withSource.completion(m1, expected)
   }
@@ -1086,7 +1086,7 @@ class CompletionTest {
     code"""object Foo:
            |  enum Bar:
            |    case `has space`
-           |  
+           |
            |  val x = Bar.`has s${m1}"""
              .withSource.completion(m1, expected)
   }
@@ -1102,7 +1102,7 @@ class CompletionTest {
            |    val foo = 1
            |    val `foo-bar` = 2
            |    val `bar` = 3
-           |  
+           |
            |  val x = Bar.fo${m1}"""
              .withSource.completion(m1, expected)
   }
@@ -1117,7 +1117,7 @@ class CompletionTest {
            |  object Bar:
            |    val foo = 1
            |    val `foo-bar` = 2
-           |  
+           |
            |  val x = Bar.`fo${m1}"""
              .withSource.completion(m1, expected)
   }
@@ -1146,7 +1146,7 @@ class CompletionTest {
            |  case x: Int => Foo(x)
            |  case x: Any => x
            |}
-           |object Test: 
+           |object Test:
            |  elem(1).foo${m1}"""
              .withSource.completion(m1, expected)
   }
@@ -1245,4 +1245,40 @@ class CompletionTest {
              .withSource.completion(m1, expected)
   }
 
+  @Test def typeAliasCompletions: Unit = {
+    val expected = Set(
+      ("fooTest", Method, "(x: Int): Unit"),
+      )
+
+    code"""class Test() {
+          |  def fooTest(x: Int): Unit = ???
+          |}
+          |type TestAlias = Test
+          |object M:
+          |  val test: TestAlias = new Test()
+          |  test.foo${m1}"""
+            .withSource.completion(m1, expected)
+
+  }
+
+  @Test def higherKindedTypeAliasesCompletions: Unit = {
+    val expected = Set(
+      ("fooTest", Method, "(x: Int): Option[Unit]"),
+      )
+    code"""trait Test[F[_]] {
+          |  def fooTest(x: Int): F[Unit] = ???
+          |}
+          |
+          |type TestAlias[M[_[_]]] = M[Option]
+          |object M:
+          |  val test: TestAlias[Test] = new Test[Option] {}
+          |  val test2: Test[Option] = new Test[Option] {}
+          |  test.foo${m1}
+          |  test2.foo${m2}""".withSource
+            .completion(m1, expected)
+            .completion(m2, expected)
+
+  }
+
+
 }

language-server/test/dotty/tools/languageserver/util/CodeTester.scala

@@ -4,15 +4,12 @@ import dotty.tools.languageserver.util.Code._
 import dotty.tools.languageserver.util.actions._
 import dotty.tools.languageserver.util.embedded.CodeMarker
 import dotty.tools.languageserver.util.server.{TestFile, TestServer}
-
 import dotty.tools.dotc.reporting.ErrorMessageID
 import dotty.tools.dotc.util.Signatures.Signature
 
 import org.eclipse.lsp4j.{ CompletionItem, CompletionItemKind, DocumentHighlightKind, Diagnostic, DiagnosticSeverity }
-
 import org.junit.Assert.assertEquals
 
-import org.junit.Assert.assertEquals
 
 /**
  * Simulates an LSP client for test in a project defined by `sources`.