From 50c122c86465eb0ce85459d018c1b4ab5eca4bda Mon Sep 17 00:00:00 2001
From: rochala <rochala@tutanota.com>
Date: Mon, 1 Aug 2022 17:00:20 +0200
Subject: [PATCH] support completions in Export clause

---
 .../tools/dotc/interactive/Completion.scala   | 20 +++++++-----------
 .../tools/languageserver/CompletionTest.scala | 21 +++++++++++++++++--
 2 files changed, 27 insertions(+), 14 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/interactive/Completion.scala b/compiler/src/dotty/tools/dotc/interactive/Completion.scala
index 4d953bdb16cc..73b00027e733 100644
--- a/compiler/src/dotty/tools/dotc/interactive/Completion.scala
+++ b/compiler/src/dotty/tools/dotc/interactive/Completion.scala
@@ -60,22 +60,18 @@ object Completion {
    */
   def completionMode(path: List[Tree], pos: SourcePosition): Mode =
     path match {
-      case Ident(_) :: Import(_, _) :: _ =>
-        Mode.Import
+      case Ident(_) :: Import(_, _) :: _ => Mode.ImportOrExport
       case (ref: RefTree) :: _ =>
         if (ref.name.isTermName) Mode.Term
         else if (ref.name.isTypeName) Mode.Type
         else Mode.None
 
       case (sel: untpd.ImportSelector) :: _ =>
-        if sel.imported.span.contains(pos.span) then Mode.Import
+        if sel.imported.span.contains(pos.span) then Mode.ImportOrExport
         else Mode.None // Can't help completing the renaming
 
-      case Import(_, _) :: _ =>
-        Mode.Import
-
-      case _ =>
-        Mode.None
+      case (_: ImportOrExport) :: _ => Mode.ImportOrExport
+      case _ => Mode.None
     }
 
   /** When dealing with <errors> in varios palces we check to see if they are
@@ -103,8 +99,8 @@ object Completion {
       case (sel: untpd.ImportSelector) :: _ =>
         completionPrefix(sel.imported :: Nil, pos)
 
-      case Import(expr, selectors) :: _ =>
-        selectors.find(_.span.contains(pos.span)).map { selector =>
+      case (tree: untpd.ImportOrExport) :: _ =>
+        tree.selectors.find(_.span.contains(pos.span)).map { selector =>
           completionPrefix(selector :: Nil, pos)
         }.getOrElse("")
 
@@ -146,7 +142,7 @@ object Completion {
         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 Import(expr, _) :: _                                     => completer.directMemberCompletions(expr)
+        case (tree: ImportOrExport) :: _                              => completer.directMemberCompletions(tree.expr)
         case (_: untpd.ImportSelector) :: Import(expr, _) :: _        => completer.directMemberCompletions(expr)
         case _                                                        => completer.scopeCompletions
       }
@@ -566,7 +562,7 @@ object Completion {
     val Type: Mode = new Mode(2)
 
     /** Both term and type symbols are allowed */
-    val Import: Mode = new Mode(4) | Term | Type
+    val ImportOrExport: Mode = new Mode(4) | Term | Type
   }
 }
 
diff --git a/language-server/test/dotty/tools/languageserver/CompletionTest.scala b/language-server/test/dotty/tools/languageserver/CompletionTest.scala
index e1fc2ac687b2..76749b08796f 100644
--- a/language-server/test/dotty/tools/languageserver/CompletionTest.scala
+++ b/language-server/test/dotty/tools/languageserver/CompletionTest.scala
@@ -1454,7 +1454,24 @@ class CompletionTest {
           |    testMet$m2
           |    Test(1, 2)
           """
-            .completion(m1, expected)
-            .completion(m2, expected)
+      .completion(m1, expected)
+      .completion(m2, expected)
+  }
+
+  @Test def exportCompletions: Unit = {
+    code"""object Foo:
+          |  def xDef = 1
+          |  val xVal = 1
+          |  class xClass()
+          |  object xObject {}
+          |object Test:
+          |  export Foo.x${m1}
+          """
+      .completion(m1, Set(
+        ("xDef", Method, "=> Int"),
+        ("xVal", Field, "Int"),
+        ("xObject", Module, "Foo.xObject"),
+        ("xClass", Module, "Foo.xClass"),
+        ("xClass", Class, "Foo.xClass")))
   }
 }