Merge branch 'topic/#1686' into 'master'

Allow navigation queries right after entities

See merge request eng/ide/ada_language_server!2051

Author: AnthonyLeonardoGracio

source/ada/lsp-ada_documents.adb

@@ -1202,10 +1202,70 @@ package body LSP.Ada_Documents is
       Context  : LSP.Ada_Contexts.Context;
       Position : LSP.Structures.Position) return Libadalang.Analysis.Ada_Node
    is
-      Unit : constant Libadalang.Analysis.Analysis_Unit := Self.Unit (Context);
+      use Langkit_Support.Slocs;
+
+      Unit         : constant Libadalang.Analysis.Analysis_Unit :=
+        Self.Unit (Context);
+
+      function Get_Sloc return Langkit_Support.Slocs.Source_Location;
+      --  Return the source location corresponding to Position.
+      --  This function handles properly the case where the position is
+      --  at the end of an indentifier token and at the start of the next
+      --  token (e.g: 'An_Identifier^;' where '^' is the cursor's position):
+      --  in that case we want to retrieve the node corresponding to
+      --  the previous identifier token.
+
+      --------------
+      -- Get_Sloc --
+      --------------
+
+      function Get_Sloc return Langkit_Support.Slocs.Source_Location is
+         use type Langkit_Support.Slocs.Source_Location;
+         use Libadalang.Common;
+
+         Initial_Sloc : constant Langkit_Support.Slocs.Source_Location :=
+           Self.To_Source_Location (Position);
+         Token        : constant Libadalang.Common.Token_Reference :=
+           Self.Get_Token_At (Context, Position);
+         Prev_Token : constant Libadalang.Common.Token_Reference :=
+           (if Token /= No_Token
+            then Libadalang.Common.Previous (Token)
+            else No_Token);
+      begin
+         --  No previous token, return the initial SLOC
+         if Prev_Token = No_Token then
+            return Initial_Sloc;
+         end if;
+
+         declare
+            Token_Data       : constant Libadalang.Common.Token_Data_Type :=
+              Libadalang.Common.Data (Token);
+            Token_Range      :
+              constant Libadalang.Slocs.Source_Location_Range :=
+                Token_Data.Sloc_Range;
+            Prev_Token_Data  : constant Libadalang.Common.Token_Data_Type :=
+              Libadalang.Common.Data (Prev_Token);
+            Prev_Token_Range :
+              constant Libadalang.Slocs.Source_Location_Range :=
+                Prev_Token_Data.Sloc_Range;
+         begin
+            --  The current token is an identifier and its start SLOC and
+            --  the previous one's end SLOC are equal: consider that the query
+            --  is being done on the previous identifier token.
+            if Prev_Token_Data.Kind = Ada_Identifier
+              and then Initial_Sloc = Token_Range.Start_Sloc
+              and then Initial_Sloc = Prev_Token_Range.End_Sloc
+            then
+               return Prev_Token_Range.Start_Sloc;
+            else
+               return Initial_Sloc;
+            end if;
+         end;
+      end Get_Sloc;
+
    begin
       return (if Unit.Root.Is_Null then Libadalang.Analysis.No_Ada_Node
-              else Unit.Root.Lookup (Self.To_Source_Location (Position)));
+              else Unit.Root.Lookup (Get_Sloc));
    end Get_Node_At;
 
    --------------------------

source/ada/lsp-ada_handlers.adb

@@ -3370,6 +3370,8 @@ package body LSP.Ada_Handlers is
       ----------------------
 
       procedure Compute_Response is
+         use Libadalang.Common;
+
          Context  : constant LSP.Ada_Context_Sets.Context_Access :=
            Self.Contexts.Get_Best_Context (Value.textDocument.uri);
          Document : constant LSP.Ada_Documents.Document_Access :=
@@ -3379,15 +3381,9 @@ package body LSP.Ada_Handlers is
 
          Position : LSP.Structures.Position := Value.position;
          Node     : Libadalang.Analysis.Ada_Node;
-
+         Token    : Libadalang.Common.Token_Reference :=
+           Document.Get_Token_At (Context.all, Position);
       begin
-         --  Move the cursor to the previous character: this is more resilient
-         --  to invalid code.
-
-         if Position.character > 0 then
-            Position.character := @ - 1;
-         end if;
-
          Node := Document.Get_Node_At (Context.all, Position);
 
          declare
@@ -3414,8 +3410,8 @@ package body LSP.Ada_Handlers is
             end if;
          end;
 
-         --  Try to get signatures before the cursor location
-         --  i.e "Foo (1,|" => "Foo (1|,"
+         --  Try to get signatures at the the cursor location
+         --  i.e "Foo (1,|"
 
          LSP.Ada_Completions.Parameters.Propose_Signatures
            (Context         => Context,
@@ -3424,37 +3420,41 @@ package body LSP.Ada_Handlers is
             Prev_Signatures => Value.context,
             Res             => Response.Value);
 
-         --  Retry to get signature in the previous non whitespace token
-         --  i.e. "Foo (1, 2 + |" => "Foo (1, 2 +|"
-
          if Response.Value.signatures.Is_Empty then
-            declare
-               use all type Libadalang.Common.Token_Kind;
-               use type Libadalang.Common.Token_Reference;
 
-               Token : Libadalang.Common.Token_Reference :=
-                 Document.Get_Token_At (Context.all, Position);
+            --  Retry to get matching signatures from the previous non whitespace/non comma
+            --  token.
+            --  This is more resilient on invalid code, since we'll have more chances to
+            --  retrieve a valid CallExpr node, rather than an ErrorStmt one.
+            --  i.e. "Foo (1, 2 + |" => "Foo (1, 2 +|" or "Foo (1, 2,|" => "Foo (1, 2|,"
 
-            begin
-               if Token /= Libadalang.Common.No_Token
-                 and then Libadalang.Common.Kind
-                            (Libadalang.Common.Data (Token)) = Ada_Whitespace
-               then
+            if Token /= No_Token
+              and then Position.character > 0
+              and then (Token.Data.Is_Trivia
+                        or else Token.Data.Kind = Ada_Comma)
+            then
+               declare
+                  Prev_Token : constant Token_Reference :=
+                    Libadalang.Common.Previous (Token, Exclude_Trivia => True);
+               begin
                   Token :=
-                    Libadalang.Common.Previous
-                      (Token, Exclude_Trivia => True);
-               end if;
-
-               Position := LSP.Ada_Handlers.Locations.Start_Position (Token);
-            end;
-
-            Node := Document.Get_Node_At (Context.all, Position);
-            LSP.Ada_Completions.Parameters.Propose_Signatures
-              (Context         => Context,
-               Node            => Node,
-               Cursor          => Location,
-               Prev_Signatures => Value.context,
-               Res             => Response.Value);
+                    (if Prev_Token /= No_Token then Prev_Token else Token);
+
+                  --  Recompute the position from the new token and retrieve
+                  --  the corresponding node.
+                  Position :=
+                    LSP.Ada_Handlers.Locations.Start_Position (Token);
+                  Node := Document.Get_Node_At (Context.all, Position);
+
+                  --  Get the matching signatures
+                  LSP.Ada_Completions.Parameters.Propose_Signatures
+                    (Context         => Context,
+                     Node            => Node,
+                     Cursor          => Location,
+                     Prev_Signatures => Value.context,
+                     Res             => Response.Value);
+               end;
+            end if;
          end if;
 
          --  Retry to get signatures in the cursor position.