fix: link statements nested in others, and position every comment

Statements that never pass through SingleStatement get their node where
they are built: data-modifying CTEs, statements inside an Oracle block,
CREATE SCHEMA elements, CREATE TABLE ... AS EXECUTE and the GRANT or
REVOKE of ALTER DEFAULT PRIVILEGES. An IF statement's range takes in the
semicolon it prints.

A RangeNode that widens a tree node answers its children, id and dump
too, so a WITH statement's node still shows the tree beneath it.

Comments are positioned in one backwards pass over the recorded match
begins, and comments before the end of input are positioned once
parsing ends, since the end-of-file token gets no token action.

Values in a primary expression, string literals, expression lists and
row patterns get a RangeNode only once something wraps them, so a
production's own tree node is the only node most of them get. On a
20,000-row INSERT ... VALUES this cuts the added allocation from 12.9%
to 3.2%.

The coverage test parses the Oracle tests in the Oracle dialect, checks
that getParent() encloses each range, and runs its checks over the
statements above, which the test corpus does not contain.

Author: knutwannheden

src/main/java/net/sf/jsqlparser/parser/RangeNode.java

@@ -12,7 +12,7 @@
 /**
  * A node outside the parse tree that records the tokens an object spans. It serves an object no
  * grammar rule opens a tree node for, or one whose text runs past its tree node. In that second
- * case it answers the tree node's parent, which the object's {@code getParent()} then reports.
+ * case it stands in for the tree node, answering its parent, children and id, with the wider range.
  */
 public final class RangeNode extends Node {
     private final Node treeNode;
@@ -28,4 +28,44 @@ public RangeNode(Token first, Token last, Node treeNode) {
     public Node jjtGetParent() {
         return treeNode == null ? null : treeNode.jjtGetParent();
     }
+
+    @Override
+    public Node[] jjtGetChildren() {
+        return treeNode == null ? super.jjtGetChildren() : treeNode.jjtGetChildren();
+    }
+
+    @Override
+    public Node jjtGetChild(int i) {
+        return treeNode == null ? super.jjtGetChild(i) : treeNode.jjtGetChild(i);
+    }
+
+    @Override
+    public int jjtGetNumChildren() {
+        return treeNode == null ? super.jjtGetNumChildren() : treeNode.jjtGetNumChildren();
+    }
+
+    @Override
+    public Object childrenAccept(CCJSqlParserVisitor visitor, Object data) {
+        return treeNode == null ? super.childrenAccept(visitor, data)
+                : treeNode.childrenAccept(visitor, data);
+    }
+
+    @Override
+    public int getId() {
+        return treeNode == null ? super.getId() : treeNode.getId();
+    }
+
+    @Override
+    public String toString() {
+        return treeNode == null ? super.toString() : treeNode.toString();
+    }
+
+    @Override
+    public void dump(String prefix) {
+        if (treeNode == null) {
+            super.dump(prefix);
+        } else {
+            treeNode.dump(prefix);
+        }
+    }
 }

src/main/java/net/sf/jsqlparser/parser/SimpleCharStream.java

@@ -48,7 +48,7 @@ public class SimpleCharStream {
     protected boolean trackLineColumn = true;
     protected int totalCharsRead = 0;
     protected int absoluteTokenBegin = 0;
-    // line, column and absolute position of each match begun since the last forgetMatchBegins()
+    // line, column and absolute position of each match begun since the last positionSpecialTokens()
     private int[] matchBegins = new int[24];
     private int matchBeginCount = 0;
     int bufsize;
@@ -111,20 +111,25 @@ public final int getAbsoluteTokenBegin() {
     }
 
     /**
-     * The absolute position of the match that began at the given line and column since the last
-     * {@link #forgetMatchBegins()}, or 0 when none did. Lets a comment, which no token action sees,
-     * take its position from where its match began.
+     * Gives the comments in front of {@code token} the positions where their matches began, from
+     * the begins recorded since the last call, and forgets those. Comments come through no token
+     * action, so this is how they get a position. The comments chain backwards from the token while
+     * the begins are recorded forwards, so one backwards pass pairs them.
      */
-    public final int getAbsoluteBegin(int line, int column) {
-        for (int i = 0; i < matchBeginCount; i += 3) {
-            if (matchBegins[i] == line && matchBegins[i + 1] == column) {
-                return matchBegins[i + 2];
+    public final void positionSpecialTokens(Token token) {
+        int i = matchBeginCount - 3;
+        for (Token comment = token.specialToken; comment != null; comment = comment.specialToken) {
+            while (i >= 0 && (matchBegins[i] != comment.beginLine
+                    || matchBegins[i + 1] != comment.beginColumn)) {
+                i -= 3;
             }
+            if (i < 0) {
+                break;
+            }
+            comment.absoluteBegin = matchBegins[i + 2];
+            comment.absoluteEnd = comment.absoluteBegin + comment.image.length();
+            i -= 3;
         }
-        return 0;
-    }
-
-    public final void forgetMatchBegins() {
         matchBeginCount = 0;
     }