Give ntVariable an end position

Same gap as the previous commit, same shape of fix. A variable declaration
produced a node positioned at its name with no end at all, so a declaration
whose type or initialiser spans lines reported only its first line:

  var
    Grid: array[0..1] of
      Integer;

VarDeclaration pushed ntVariables with FStack.Push, so the VarList that
RearrangeVarSection rebuilds each variable from had no extent to pass on.
Both now push compound nodes, and the rebuilt ntVariable inherits the end
via AssignEndPositionFrom - the second caller for the helper added in the
previous commit, which is the pattern it exists for.

The compound ntVariables nodes are the throwaway VarSect children that
VarSection frees, so the output footprint matches the constant change
exactly: VARIABLE gains begin/end, and the VARIABLES section node that
reaches the tree is untouched.

Names sharing one line (`A, B: Integer;`) each get the declaration's extent,
which is the whole declaration they share.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: Patrick Quist

Source/DelphiAST.pas

@@ -3210,9 +3210,11 @@ procedure TPasSyntaxTreeBuilder.VarAbsolute;
 
 procedure TPasSyntaxTreeBuilder.VarDeclaration;
 begin
-  FStack.Push(ntVariables);
+  //compound: a variable's type or initialiser can span lines, so record where it ends.
+  FStack.PushCompoundSyntaxNode(ntVariables);
   try
     inherited;
+    SetCurrentCompoundNodesEndPosition;
   finally
     FStack.Pop;
   end;
@@ -3303,9 +3305,12 @@ procedure TPasSyntaxTreeBuilder.RearrangeVarSection(const VarSect: TSyntaxNode);
     begin
       if Variable.Typ <> ntName then
         Continue;
-      Temp := FStack.Push(ntVariable);
+      //compound: start from the name, end from the VarList that measured the declaration.
+      Temp := FStack.PushCompoundSyntaxNode(ntVariable);
       try
         Temp.AssignPositionFrom(Variable);
+        if VarList is TCompoundSyntaxNode then
+          TCompoundSyntaxNode(Temp).AssignEndPositionFrom(TCompoundSyntaxNode(VarList));
         FStack.AddChild(Variable.Clone);
         if Assigned(TypeInfo) then
           FStack.AddChild(TypeInfo.Clone);

Test/UnitTests/DelphiAST.Tests.pas

@@ -210,6 +210,37 @@ procedure TestConstantEndPosition;
   end;
 end;
 
+procedure TestVariableEndPosition;
+var
+  Root, Node, Spanning, Single: TSyntaxNode;
+begin
+  Root := ParseSource('unit Vars;' + sLineBreak + 'interface' + sLineBreak + 'var' +
+    sLineBreak + '  Spanning: array[0..1] of' + sLineBreak + '    Integer;' + sLineBreak +
+    '  Single: Integer;' + sLineBreak + 'implementation' + sLineBreak + 'end.');
+  try
+    Spanning := nil;
+    Single := nil;
+    for Node in FindDescendant(Root, ntVariables).ChildNodes do
+      if Node.Typ = ntVariable then
+        if Node.Line = 4 then
+          Spanning := Node
+        else if Node.Line = 6 then
+          Single := Node;
+
+    AssertNotNil(Spanning, 'No variable starting on line 4');
+    AssertTrue(Spanning is TCompoundSyntaxNode,
+      'Variable node must be compound so it can carry an end position');
+    AssertEquals(5, TCompoundSyntaxNode(Spanning).EndLine,
+      'A variable whose declaration spans lines must reach its last line');
+
+    AssertNotNil(Single, 'No variable starting on line 6');
+    AssertEquals(6, TCompoundSyntaxNode(Single).EndLine,
+      'A single-line variable must end on its own line, not run on to what follows');
+  finally
+    Root.Free;
+  end;
+end;
+
 procedure TestInvalidSyntax;
 var
   Root: TSyntaxNode;
@@ -263,6 +294,7 @@ procedure RunAllTests;
   RunTest('Writer.LiteralsUnicodeAndXmlEscaping', TestLiteralsAndUnicode);
   RunTest('AST.SourcePositions', TestSourcePositions);
   RunTest('AST.ConstantEndPosition', TestConstantEndPosition);
+  RunTest('AST.VariableEndPosition', TestVariableEndPosition);
   RunTest('Parser.InvalidSyntax', TestInvalidSyntax);
   {$IFNDEF FPC}
   RunTest('Serialization.BinaryRoundTrip', TestBinarySerializationRoundTrip);