Handle partially qualified dotted-name completion

When completing an invisible item with a partially qualified prefix
(e.g: 'P2' instead of 'P1.P2.'), we should not try
to rely on the prefix being typed by the user: we should
just import the fully qualified unit.

Add a test for this.

For eng/ide/ada_language_server#1610

Author: AnthonyLeonardoGracio

source/ada/lsp-ada_documents.adb

@@ -189,47 +189,35 @@ package body LSP.Ada_Documents is
          --  "Ada.Text_IO.Put_Line" subprogram).
 
       begin
-         Missing_Unit_Name :=  VSS.Strings.Conversions.To_Virtual_String
-           (Langkit_Support.Text.To_UTF8
-              (Missing_Unit_Root_Decl.P_Fully_Qualified_Name));
+         Missing_Unit_Name :=
+           VSS.Strings.Conversions.To_Virtual_String
+             (Langkit_Support.Text.To_UTF8
+                (Missing_Unit_Root_Decl.P_Fully_Qualified_Name));
 
          --  We are completing a dotted name but its prefix does not match
          --  with the completion item's defining name's unit: this means we
-         --  are dealing with renames (e.g: 'GNAT.Strings.Strings_Access'
-         --  is a forward declaration of 'System.Strings.String_Access'). In
-         --  that case, use the prefix specified by the user instead of the
-         --  completion item's defining name's unit: the user explcitly wants
-         --  to use the renamed symbol instead of the base one.
-
+         --  are dealing with either renames (e.g: 'GNAT.Strings.Strings_Access'
+         --  is a forward declaration of 'System.Strings.String_Access') or
+         --  partially qualified dotted completion (e.g: the user typed
+         --  'Child.' to reference a 'Parent.Child.' package).
+         --  If the prefix corresponds to a known LAL unit (will be the case for
+         --  renames), import the unit corresponding to the prefix instead.
+         --  We don't want to this for partially qualified names: we still want
+         --  to import the fully qualified unit (so import 'Parent.Child' even
+         --  if the user just type 'Child.')
          if Is_Dotted_Name
            and then not Missing_Unit_Name.Starts_With (Dotted_Node_Prefix)
+           and then not Get_From_Provider
+                          (Context => Context.LAL_Context,
+                           Name    =>
+                             Langkit_Support.Text.To_Text
+                               (VSS.Strings.Conversions.To_UTF_8_String
+                                  (Dotted_Node_Prefix)),
+                           Kind    => Libadalang.Common.Unit_Specification)
+                          .Root
+                          .Is_Null
          then
-            declare
-               Dotted_Prefix_Parts : VSS.String_Vectors.
-                 Virtual_String_Vector :=
-                 Dotted_Node_Prefix.Split
-                   (Separator => VSS.Characters.Latin.Full_Stop);
-            begin
-               --  Check if the unit specified as a prefix actually exists.
-               --  If not, it might be a renamed package
-               --  declaration/instantiation: in that case we want to add a
-               --  with-clause on the enclosing unit (e.g: the prefix before
-               --  the last '.').
-
-               while Get_From_Provider
-                 (Context => Context.LAL_Context,
-                  Name    => Langkit_Support.Text.To_Text
-                    (VSS.Strings.Conversions.To_UTF_8_String
-                         (Dotted_Node_Prefix)),
-                  Kind    => Libadalang.Common.Unit_Specification).Root.Is_Null
-               loop
-                  Dotted_Prefix_Parts.Delete_Last;
-                  Dotted_Node_Prefix :=
-                    Dotted_Prefix_Parts.Join (VSS.Characters.Latin.Full_Stop);
-               end loop;
-
-               Missing_Unit_Name := Dotted_Node_Prefix;
-            end;
+            Missing_Unit_Name := Dotted_Node_Prefix;
          end if;
 
          --  We should not add any qualifier if the user accepted the

testsuite/ada_lsp/completion_invisible_partially_qualified_prefix/default.gpr

@@ -0,0 +1,2 @@
+project Default is
+end Default;

testsuite/ada_lsp/completion_invisible_partially_qualified_prefix/p1-p2-subp.adb

@@ -0,0 +1,4 @@
+function P1.P2.Subp return Integer is
+begin
+   return 0;
+end P1.P2.Subp;

testsuite/ada_lsp/completion_invisible_partially_qualified_prefix/p1-p2-subp.ads

@@ -0,0 +1 @@
+function P1.P2.Subp return Integer;

testsuite/ada_lsp/completion_invisible_partially_qualified_prefix/p1-p2.ads

@@ -0,0 +1,3 @@
+package P1.P2 is
+   type T is null record;
+end P1.P2;

testsuite/ada_lsp/completion_invisible_partially_qualified_prefix/p1-p3.ads

@@ -0,0 +1,3 @@
+package P1.P3 is
+   Obj : Integer := P2.
+end P1.P3;

testsuite/ada_lsp/completion_invisible_partially_qualified_prefix/p1.ads

@@ -0,0 +1,3 @@
+package P1 is
+   pragma Pure;
+end P1;

testsuite/ada_lsp/completion_invisible_partially_qualified_prefix/test.py

@@ -0,0 +1,71 @@
+from typing import List
+from drivers import pylsp
+from lsprotocol.types import (
+    Command,
+    CompletionContext,
+    CompletionItem,
+    CompletionList,
+    CompletionParams,
+    CompletionTriggerKind,
+    TextDocumentIdentifier,
+)
+
+
+@pylsp.test()
+async def test(lsp: pylsp.ALSLanguageClient) -> None:
+    file_uri = lsp.didOpenFile("p1-p3.ads")
+
+    await lsp.awaitIndexingEnd()
+
+    # Complete 'P1.' in 'P1.P3' package spec. This should list
+    # the top-level subprogram unit 'P1.P2.Subp' as an invisible
+    # completion item.
+
+    result = await lsp.text_document_completion_async(
+        CompletionParams(
+            TextDocumentIdentifier(file_uri),
+            pylsp.Pos(2, 24),
+            CompletionContext(CompletionTriggerKind.Invoked),
+        )
+    )
+    EXPECTED_LABEL = "Subp (invisible)"
+    EXPECTED_COMMAND = Command(
+        title="",
+        command="als-auto-import",
+        arguments=[
+            {
+                "context": pylsp.URI("default.gpr"),
+                "where": {
+                    "textDocument": {"uri": file_uri},
+                    "position": {"line": 1, "character": 23},
+                },
+                "import": "P1.P2.Subp",
+                "qualifier": "",
+            }
+        ],
+    )
+
+    def find_expected_completion_item(
+        items: List[CompletionItem],
+        expected_label,
+        expected_command,
+    ):
+        """
+        Find the expected completion item in the given completion items' list.
+        """
+        expected_items = [
+            item
+            for item in items
+            if item.label == expected_label and item.command == expected_command
+        ]
+        return len(expected_items) == 1
+
+    # Verify that we are able to find the expected completion invisible item
+    # for 'P1.P2.Subp'
+    assert isinstance(
+        result, CompletionList
+    ), "The returned completion list result should be of type CompletionList"
+    lsp.assertEqual(
+        find_expected_completion_item(result.items, EXPECTED_LABEL, EXPECTED_COMMAND),
+        True,
+    )

testsuite/ada_lsp/completion_invisible_partially_qualified_prefix/test.yaml

@@ -0,0 +1 @@
+driver: pylsp