fix extension definitions with Select, add tests, simplify if

Author: rochala

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

@@ -139,7 +139,6 @@ object Completion:
       .pathTo(pos.span, List(ctx.compilationUnit.untpdTree), true).collect:
         case untpdTree: untpd.Tree => untpdTree
 
-
     tpdPath match
       case (_: Bind) :: _ => tpdPath
       case (_: untpd.TypTree) :: _ => tpdPath
@@ -155,15 +154,20 @@ object Completion:
 
     val completer = new Completer(mode, prefix, pos)
 
-    val completions = tpdPath match
-      // Ignore synthetic select from `This` because in code it was `Ident`
-      // See example in dotty.tools.languageserver.CompletionTest.syntheticThis
-      case Select(qual @ This(_), _) :: _ if qual.span.isSynthetic  => completer.scopeCompletions
-      case Select(qual, _) :: _           if qual.tpe.hasSimpleKind => completer.selectionCompletions(qual)
-      case Select(qual, _) :: _                                     => Map.empty
-      case (tree: ImportOrExport) :: _                              => completer.directMemberCompletions(tree.expr)
-      case (_: untpd.ImportSelector) :: Import(expr, _) :: _        => completer.directMemberCompletions(expr)
-      case _                                                        => completer.scopeCompletions
+    val completions = path0 match
+      case untpd.Select(qual, _) :: _ :: untpd.ExtMethods(_, _) :: _ =>
+        val tpdQual = ctx.typer.typedExpr(qual)
+        completer.selectionCompletions(tpdQual)
+      case _ => tpdPath match
+
+        // Ignore synthetic select from `This` because in code it was `Ident`
+        // See example in dotty.tools.languageserver.CompletionTest.syntheticThis
+        case Select(qual @ This(_), _) :: _ if qual.span.isSynthetic  => completer.scopeCompletions
+        case Select(qual, _) :: _           if qual.tpe.hasSimpleKind => completer.selectionCompletions(qual)
+        case Select(qual, _) :: _                                     => Map.empty
+        case (tree: ImportOrExport) :: _                              => completer.directMemberCompletions(tree.expr)
+        case (_: untpd.ImportSelector) :: Import(expr, _) :: _        => completer.directMemberCompletions(expr)
+        case _                                                        => completer.scopeCompletions
 
     val describedCompletions = describeCompletions(completions)
     val backtickedCompletions =

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

@@ -1533,6 +1533,16 @@ class CompletionTest {
            |"""
       .completion(m1, Set(("Foo",Class,"Foo")))
 
+  @Test def extensionDefinitionCompletionsSelect: Unit =
+    code"""|object Test:
+           |  class TestSelect()
+           |object T:
+           |  extension (x: Test.TestSel$m1)
+           |"""
+      .completion(m1, Set(
+        ("TestSelect", Module, "Test.TestSelect"), ("TestSelect", Class, "Test.TestSelect")
+      ))
+
   @Test def selectDynamic: Unit =
     code"""|import scala.language.dynamics
            |class Foo extends Dynamic {

presentation-compiler/src/main/dotty/tools/pc/completions/Completions.scala

@@ -106,10 +106,8 @@ class Completions(
       else false
 
     if generalExclude then false
-    else if completionMode.is(Mode.ImportOrExport) then true
-    else if completionMode.is(Mode.Term) && isWildcardParam(sym) then false
-    else if completionMode.is(Mode.Term) && (sym.isTerm || sym.is(Package)) then true
-    else !completionMode.is(Mode.Term)
+    else if completionMode.is(Mode.Type) then true
+    else !isWildcardParam(sym) && (sym.isTerm || sym.is(Package))
     end if
   end includeSymbol
 

presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala

@@ -1442,6 +1442,39 @@ class CompletionSuite extends BaseCompletionSuite:
          |""".stripMargin
     )
 
+  @Test def `extension-definition-select` =
+    check(
+      """|object Test:
+         |  class TestSelect()
+         |object T:
+         |  extension (x: Test.TestSel@@)
+         |""".stripMargin,
+      """|TestSelect test.Test
+         |""".stripMargin
+    )
+
+  @Test def `extension-definition-select-mix-1` =
+    check(
+      """|object Test:
+         |  class TestSelect()
+         |object T:
+         |  extension (using Int)(x: Test.TestSel@@)
+         |""".stripMargin,
+      """|TestSelect test.Test
+         |""".stripMargin
+    )
+
+  @Test def `extension-definition-select-mix-2` =
+    check(
+      """|object Test:
+         |  class TestSelect[T]()
+         |object T:
+         |  extension [T](x: Test.TestSel@@)
+         |""".stripMargin,
+      """|TestSelect[T] test.Test
+         |TestSelect test.Test
+         |""".stripMargin
+    )
 
   @Test def `no-square-brackets` =
     checkEdit(