refactor: keep the ALTER constraint lookahead in the grammar

Move AlterConstraintLookahead from its own file into the grammar as a
private nested class, as done for TokenNesting in #2849. Split
needsSharedTableConstraint into a check for the forms only the shared
production accepts and a scan for constraint attributes. Codacy's PMD
reported an NPath complexity of 440 for the combined method; the
largest part is now 14. The nested class keeps its branches out of
CCJSqlParser.class. Behaviour does not change.

Signed-off-by: minleejae <mmj9808@gmail.com>

Author: minleejae

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

@@ -2530,6 +2530,85 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         }
     }
 
+    /**
+     * Decides whether an ALTER TABLE ADD table constraint needs the table-constraint production
+     * shared with CREATE TABLE in dialects that otherwise keep the generic ALTER representation. A
+     * nested class keeps its branches out of CCJSqlParser.class, whose constant pool is close to
+     * what JaCoCo can still instrument.
+     */
+    private static final class AlterConstraintLookahead {
+        private AlterConstraintLookahead() {}
+
+        /**
+         * Whether the action starting at {@code first} is an unnamed CHECK, a FOREIGN KEY,
+         * EXCLUDE, or uses a constraint attribute (INITIALLY IMMEDIATE|DEFERRED, NOT VALID, or
+         * ENFORCED outside CHECK) before the end of the action.
+         */
+        static boolean needsSharedTableConstraint(Token first, CCJSqlParserTokenManager source) {
+            Token second = next(first, source);
+            Token body = first.kind == K_CONSTRAINT ? next(second, source) : first;
+            if (isSharedOnlyConstraint(first, second, body, source)) {
+                return true;
+            }
+            return (first.kind == K_CONSTRAINT || first.kind == K_PRIMARY
+                    || first.kind == K_UNIQUE)
+                    && hasConstraintAttribute(first, body.kind == K_CHECK, source);
+        }
+
+        /** An unnamed CHECK, a FOREIGN KEY or an EXCLUDE constraint. */
+        private static boolean isSharedOnlyConstraint(Token first, Token second, Token body,
+                CCJSqlParserTokenManager source) {
+            return first.kind == K_CHECK && second.kind == OPENING_BRACKET
+                    || first.kind == K_FOREIGN || isExcludeConstraint(body, source);
+        }
+
+        /** Whether a constraint attribute follows at the top level before the end of the action. */
+        private static boolean hasConstraintAttribute(Token first, boolean check,
+                CCJSqlParserTokenManager source) {
+            int depth = 0;
+            for (Token token = first; token.kind != EOF; token = next(token, source)) {
+                if (token.kind == OPENING_BRACKET) {
+                    depth++;
+                } else if (token.kind == CLOSING_BRACKET) {
+                    if (depth-- == 0) {
+                        return false;
+                    }
+                } else if (depth == 0) {
+                    if (token.kind == ST_SEMICOLON || token.kind == K_COMMA) {
+                        return false;
+                    }
+                    if (isConstraintAttribute(token, next(token, source), check)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+        private static boolean isConstraintAttribute(Token token, Token next, boolean check) {
+            if ("INITIALLY".equalsIgnoreCase(token.image)) {
+                return "IMMEDIATE".equalsIgnoreCase(next.image)
+                        || "DEFERRED".equalsIgnoreCase(next.image);
+            }
+            return token.kind == K_NOT && "VALID".equalsIgnoreCase(next.image)
+                    || token.kind == K_ENFORCED && !check;
+        }
+
+        /** EXCLUDE starts an exclusion constraint only before USING, its elements or WHERE. */
+        private static boolean isExcludeConstraint(Token token, CCJSqlParserTokenManager source) {
+            int following = next(token, source).kind;
+            return token.kind == K_EXCLUDE && (following == K_USING
+                    || following == OPENING_BRACKET || following == K_WHERE);
+        }
+
+        private static Token next(Token token, CCJSqlParserTokenManager source) {
+            if (token.next == null) {
+                token.next = source.getNextToken();
+            }
+            return token.next;
+        }
+    }
+
     /**
      * True when an IS after a condition opens a postfix test
      * (IS [NOT] TRUE/FALSE/UNKNOWN/NULL/JSON) rather than IS DISTINCT FROM or