Import indentation estimation logic from GNATpp

Fix indentation after loop and if statements.

Author: joaopsazevedo

source/ada/lsp-ada_documents.adb

@@ -995,20 +995,213 @@ package body LSP.Ada_Documents is
          Input_Range =>
             Self.To_Source_Location_Range ((Position, Position))));
 
-   ---------------------
-   -- Get_Indentation --
-   ---------------------
+   --------------------------
+   -- Estimate_Indentation --
+   --------------------------
 
-   function Get_Indentation
-     (Self    : Document;
-      Context : LSP.Ada_Contexts.Context;
-      Line    : Positive)
+   function Estimate_Indentation
+     (Self : Document; Context : LSP.Ada_Contexts.Context; Line : Positive)
       return VSS.Strings.Character_Count
    is
-     (VSS.Strings.Character_Count
-        (Laltools.Partial_GNATPP.Estimate_Indentation
-             (Self.Unit (Context),
-              Self.To_Source_Location ((Line, 1)).Line)));
+      use Langkit_Support.Slocs;
+      use Libadalang.Analysis;
+      use Libadalang.Common;
+
+      function Get_Relevant_Parents
+        (Unit  : Libadalang.Analysis.Analysis_Unit;
+         Token : Token_Reference) return Ada_Node_Array;
+      --  Analyze where in the tree this Token is and returns the appropriate
+      --  parent nodes that influence indentation.
+
+      function Parent_Based_Indentation
+        (Parents                  : Ada_Node_Array;
+         Indentation              : Positive := 3;
+         Indentation_Continuation : Positive := 2) return Natural;
+      --  Estimate the indentation starting at zero and incrementing based on
+      --  that Parents kind. Returns earlier if it finds a parent that always
+      --  sets indentation, for instance, a parameter list.
+
+      ------------------------------
+      -- Parent_Based_Indentation --
+      ------------------------------
+
+      function Parent_Based_Indentation
+        (Parents                  : Ada_Node_Array;
+         Indentation              : Positive := 3;
+         Indentation_Continuation : Positive := 2) return Natural
+      is
+         Current_Indentation : Natural := 0;
+
+      begin
+         for Parent of Parents loop
+            case Parent.Kind is
+               when Ada_Loop_Stmt_Range
+                  | Ada_For_Loop_Stmt_Range
+                  | Ada_While_Loop_Stmt_Range
+                  | Ada_If_Stmt_Range
+                  | Ada_Case_Stmt_Range
+                  | Ada_Case_Stmt_Alternative_Range
+                  | Ada_Record_Type_Def_Range
+                  | Ada_Generic_Formal_Part_Range
+                  | Ada_Begin_Block_Range
+                  | Ada_Decl_Block_Range
+               =>
+                  Current_Indentation := Current_Indentation + Indentation;
+
+               when Ada_Declarative_Part_Range =>
+                  --  When we type declare, a DeclBlock is created but not a
+                  --  DeclarativePart one. Only when you close the block with
+                  --  an end the node is created.
+                  --  DeclarativePart is a node that adds indentation.
+                  --  We cannot simply make DeclBlock also add indentation
+                  --  because it would double indent. So only add indentation
+                  --  to DeclarativeParts if their parent is not  DeclBlock.
+                  if Parent.Parent.Kind not in Ada_Decl_Block_Range then
+                     Current_Indentation := Current_Indentation + Indentation;
+                  end if;
+
+               when Ada_Handled_Stmts_Range =>
+                  --  HandledStmts can be children of DeclBlock and BeginBlock.
+                  --  These two add indentation, so HandledStmts should not
+                  --  double add if its their child.
+                  if Parent.Parent.Kind not in
+                       Ada_Begin_Block_Range
+                       | Ada_Decl_Block_Range
+                  then
+                     Current_Indentation := Current_Indentation +  Indentation;
+                  end if;
+
+               when Ada_Subp_Spec_Range | Ada_Assign_Stmt_Range =>
+                  Current_Indentation :=
+                    Current_Indentation + Indentation_Continuation;
+
+               when Ada_Dotted_Name_Range =>
+                  Current_Indentation :=
+                    Natural (Parent.Sloc_Range.Start_Column) - 1
+                    + Indentation_Continuation;
+                  exit;
+
+               when Ada_Params_Range =>
+                  Current_Indentation :=
+                    Natural (Parent.Sloc_Range.Start_Column) - 1 + 1;
+                  exit;
+
+               when Ada_Assoc_List_Range | Ada_Component_List_Range =>
+                  Current_Indentation :=
+                    Natural (Parent.Sloc_Range.Start_Column) - 1;
+                  exit;
+
+               when others =>
+                  null;
+            end case;
+         end loop;
+
+         return Current_Indentation;
+      end Parent_Based_Indentation;
+
+      --------------------------
+      -- Get_Relevant_Parents --
+      --------------------------
+
+      function Get_Relevant_Parents
+        (Unit  : Libadalang.Analysis.Analysis_Unit;
+         Token : Token_Reference) return Ada_Node_Array
+      is
+         Previous : Token_Reference :=
+           (if Token = No_Token then No_Token
+            else LSP.Utils.Previous_Non_Trivia (Token));
+
+      begin
+         if Previous = No_Token then
+            return [];
+         end if;
+
+         if Kind (Data (Previous)) in Ada_Comma | Ada_Dot then
+            Previous := LSP.Utils.Previous_Non_Trivia (Previous);
+         end if;
+
+         declare
+            Node : constant Ada_Node :=
+              Unit.Root.Lookup (Start_Sloc (Sloc_Range (Data (Previous))));
+
+         begin
+            if (Node.Kind in Ada_Begin_Block_Range
+                and Kind (Data (Previous)) in Ada_Begin)
+              or (Node.Kind in Ada_Decl_Block_Range
+                  and Kind (Data (Previous)) in Ada_Declare)
+              or Kind (Data (Previous)) in Ada_Brack_Open
+              or Node.Kind in Ada_Params_Range
+            then
+               return Node.Parents;
+
+            elsif Node.Kind in Ada_Subp_Body_Range then
+               if Kind (Data (Previous)) in Ada_Is then
+                  return Node.As_Subp_Body.F_Decls.Parents;
+
+               elsif Kind (Data (Previous)) in Ada_Begin then
+                  return Node.As_Subp_Body.F_Stmts.Parents;
+               end if;
+
+            elsif Node.Kind in Ada_Package_Body_Range then
+               if Kind (Data (Previous)) in Ada_Is then
+                  return Node.As_Package_Body.F_Decls.Parents;
+
+               elsif Kind (Data (Previous)) in Ada_Begin then
+                  return Node.As_Package_Body.F_Stmts.Parents;
+               end if;
+
+            elsif Node.Kind in Ada_Package_Decl_Range then
+               if Kind (Data (Previous)) in Ada_Is then
+                  return Node.As_Package_Decl.F_Public_Part.Parents;
+
+               elsif Kind (Data (Previous)) in Ada_Private then
+                  return Node.As_Package_Decl.F_Private_Part.Parents;
+               end if;
+
+            elsif Node.Kind in Ada_Generic_Package_Internal_Range then
+               if Kind (Data (Previous)) in Ada_Is then
+                  return
+                    Node.As_Generic_Package_Internal.F_Public_Part.Parents;
+
+               elsif Kind (Data (Previous)) in Ada_Private then
+                  return
+                    Node.As_Generic_Package_Internal.F_Private_Part.Parents;
+               end if;
+
+            elsif Node.Kind in Ada_Generic_Formal_Part_Range then
+               if Kind (Data (Previous)) in Ada_Generic then
+                  return Node.As_Generic_Formal_Part.F_Decls.Parents;
+               end if;
+            end if;
+
+            return Node.Parents (With_Self => False);
+         end;
+      end Get_Relevant_Parents;
+
+      Unit        : constant Analysis_Unit := Self.Unit (Context);
+      Line_Number : constant Langkit_Support.Slocs.Line_Number :=
+        Self.To_Source_Location ((Line, 1)).Line;
+      Token       : constant Token_Reference :=
+        Unit.Lookup_Token (Source_Location'(Line_Number, 1));
+
+      Format_Options : constant Gnatformat.Configuration.Format_Options_Type :=
+        Context.Get_Format_Options;
+
+      Indentation              : constant Positive :=
+        Gnatformat.Configuration.Get_Indentation
+          (Format_Options, Unit.Get_Filename);
+      Indentation_Continuation : constant Positive :=
+        Gnatformat.Configuration.Get_Indentation_Continuation
+          (Format_Options, Unit.Get_Filename);
+
+   begin
+      return
+        VSS.Strings.Character_Count
+          (Parent_Based_Indentation
+             (Parents                  => Get_Relevant_Parents (Unit, Token),
+              Indentation              => Indentation,
+              Indentation_Continuation => Indentation_Continuation));
+   end Estimate_Indentation;
 
    -----------------
    -- Get_Node_At --

source/ada/lsp-ada_documents.ads

@@ -106,10 +106,8 @@ package LSP.Ada_Documents is
       Result   : out LSP.Structures.DocumentSymbol_Vector);
    --  Populate Result with a symbol hierarchy from the document.
 
-   function Get_Indentation
-     (Self    : Document;
-      Context : LSP.Ada_Contexts.Context;
-      Line    : Positive)
+   function Estimate_Indentation
+     (Self : Document; Context : LSP.Ada_Contexts.Context; Line : Positive)
       return VSS.Strings.Character_Count;
    --  Estimates the indention a line should have
 

source/ada/lsp-ada_handlers.adb

@@ -2577,6 +2577,10 @@ package body LSP.Ada_Handlers is
       use type VSS.Strings.Virtual_String;
 
       procedure Compute_Response;
+      --  Determines if how this document needs to be handled based on its
+      --  diagnostics and ALS settings. Dispatches to
+      --  Handle_Document_With_Diagnostics and
+      --  Handle_Document_Without_Diagnostics accordingly.
 
       procedure Handle_Document_With_Diagnostics;
       --  Simply adds indentation to the new line
@@ -2593,19 +2597,18 @@ package body LSP.Ada_Handlers is
       Response    : LSP.Structures.TextEdit_Vector_Or_Null;
       Indentation : constant VSS.Strings.Character_Count :=
         (declare
-            Indentation_First_Guess : constant VSS.Strings.Character_Count :=
-              Document.Get_Indentation (Context.all, Value.position.line);
+           Indentation_First_Guess : constant VSS.Strings.Character_Count :=
+             Document.Estimate_Indentation (Context.all, Value.position.line);
 
          begin
            (if Indentation_First_Guess
-                 >= VSS.Strings.Character_Count (Value.position.character)
-            then Indentation_First_Guess
-                   - VSS.Strings.Character_Count (Value.position.character)
+              >= VSS.Strings.Character_Count (Value.position.character)
+            then
+              Indentation_First_Guess
+              - VSS.Strings.Character_Count (Value.position.character)
             else 0));
       --  Do not add any indentation if the current cursor position is greater
       --  than the calculated one.
-      --  XXX position.character is counted as UTF-16 code units, actual
-      --  position need to be computed.
 
       ----------------------
       -- Compute_Response --
@@ -2615,8 +2618,8 @@ package body LSP.Ada_Handlers is
       begin
          if not LSP.Ada_Configurations.On_Type_Formatting then
             Self.Tracer.Trace
-              ("'onTypeFormatting' is not active, yet, ALS received a request - "
-               & "exiting earlier");
+              ("'onTypeFormatting' is not active, yet, ALS received a request "
+               & " - exiting earlier");
 
             return;
          end if;
@@ -2634,8 +2637,7 @@ package body LSP.Ada_Handlers is
          if Document.Has_Diagnostics (Context.all) then
             --  This is the unhappy path: when this Document has diagnostics.
             --  Get the previous node (based on the previous non whitespace
-            --  token), compute the indentation and format it (if configured to
-            --  to so).
+            --  token) and compute the indentation.
 
             Self.Tracer.Trace ("Document has diagnostics");
             Handle_Document_With_Diagnostics;
@@ -2644,13 +2646,12 @@ package body LSP.Ada_Handlers is
             --  This is the happy path: when this Document does not have any
             --  diagnostics.
             --  Get the previous node (based on the previous non whitespace
-            --  token) and compute the indentation.
+            --  token), compute the indentation and format it (if configured to
+            --  to so).
 
             Self.Tracer.Trace ("Document does not have any diagnostics");
             Handle_Document_Without_Diagnostics;
          end if;
-
-         Self.Tracer.Trace ("Exiting 'onTypeFormatting' Request");
       end Compute_Response;
 
       --------------------------------------
@@ -2661,9 +2662,7 @@ package body LSP.Ada_Handlers is
       begin
          Response.Append
            (LSP.Structures.TextEdit'
-              (a_range   =>
-                   (start  => Value.position,
-                    an_end => Value.position),
+              (a_range => (start  => Value.position, an_end => Value.position),
                newText => Indentation * VSS.Characters.Latin.Space));
       end Handle_Document_With_Diagnostics;
 
@@ -2778,37 +2777,24 @@ package body LSP.Ada_Handlers is
                Response => Response,
                Error    => Error);
 
-            if Success then
-               --  Result contains the Range_Format result.
-               --  Add indentation to the next line.
-
-               Response.Append
-                 (LSP.Structures.TextEdit'
-                    (a_range =>
-                         (start  => Value.position,
-                          an_end => Value.position),
-                     newText => Indentation * ' '));
-
-               return;
+            if not Success then
+               Self.Tracer.Trace
+                 ("The 'onTypeFormatting' has failed because of a "
+                  & "Range_Format error");
             end if;
 
-            Self.Tracer.Trace
-              ("The 'onTypeFormatting' has failed because of a "
-               & "Range_Format error");
-
             Response.Append
               (LSP.Structures.TextEdit'
                  (a_range =>
-                      (start  => Value.position,
-                       an_end => Value.position),
+                    (start  => Value.position, an_end => Value.position),
                   newText => Indentation * ' '));
          end;
       end Handle_Document_Without_Diagnostics;
 
    begin
       Self.Tracer.Trace ("On 'onTypeFormatting' Request");
-
       Compute_Response;
+      Self.Tracer.Trace ("Exiting 'onTypeFormatting' Request");
 
       Self.Sender.On_OnTypeFormatting_Response (Id, Response);
    end On_OnTypeFormatting_Request;