fix: invalidate cached lexical features on configuration changes

Track configuration mutations as well as object identity, preserve the public token manager configuration, and avoid caching dynamic subclass values. Cover parser reuse, in-place changes, replacement, and direct lexer APIs with 33 regression checks.

Signed-off-by: 付典 <fudianchn@gmail.com>

Author: fudianchn

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

@@ -68,22 +68,24 @@ public class SimpleCharStream {
     String mySqlCommentError;
     boolean mySqlMinusSubstitution;
 
-    // derived from featureConfiguration, refreshed on identity change: the
-    // configuration is wired before parsing starts and is not mutated mid-parse
+    // ReInit retains the configuration, which callers can mutate between parses.
     private FeatureConfiguration derivedFrom;
+    private long derivedModificationCount;
     private boolean derivedMySqlDialect;
     private boolean derivedBlankLineSeparator = true;
     private boolean derivedAllowHashLineComments;
 
     private void refreshDerivedFeatures() {
-        derivedFrom = featureConfiguration;
         derivedMySqlDialect = featureConfiguration != null
                 && AbstractJSqlParser.Dialect.MYSQL.name()
                         .equals(featureConfiguration.getValue(Feature.dialect));
         derivedBlankLineSeparator = featureConfiguration == null
                 || featureConfiguration.getAsBoolean(Feature.allowBlankLinesAsStatementSeparator);
         derivedAllowHashLineComments = featureConfiguration != null
                 && featureConfiguration.getAsBoolean(Feature.allowHashLineComments);
+        derivedFrom = featureConfiguration;
+        derivedModificationCount = featureConfiguration == null ? 0
+                : featureConfiguration.getModificationCount();
     }
 
     /**
@@ -219,7 +221,9 @@ public final char BeginToken() throws java.io.IOException {
 
         absoluteTokenBegin = totalCharsRead;
 
-        if (featureConfiguration != derivedFrom) {
+        if (featureConfiguration != derivedFrom || featureConfiguration != null
+                && (featureConfiguration.getModificationCount() != derivedModificationCount
+                        || featureConfiguration.getClass() != FeatureConfiguration.class)) {
             refreshDerivedFeatures();
         }
 

src/main/java/net/sf/jsqlparser/parser/feature/FeatureConfiguration.java

@@ -20,6 +20,7 @@ public class FeatureConfiguration {
     private static final Logger LOG = Logger.getLogger(FeatureConfiguration.class.getName());
 
     private final Map<Feature, Object> featureEnabled = new EnumMap<>(Feature.class);
+    private long modificationCount;
 
     public FeatureConfiguration() {
         // set default-value for all switchable features
@@ -35,6 +36,7 @@ public FeatureConfiguration() {
     public FeatureConfiguration setValue(Feature feature, Object value) {
         if (feature.isConfigurable()) {
             featureEnabled.put(feature, value);
+            modificationCount++;
         } else {
             if (LOG.isLoggable(Level.WARNING)) {
                 LOG.warning(feature.name() + " is not switchable - cannot set enabled = " + value);
@@ -43,6 +45,11 @@ public FeatureConfiguration setValue(Feature feature, Object value) {
         return this;
     }
 
+    /** Returns a change stamp for caches of derived feature values. */
+    public long getModificationCount() {
+        return modificationCount;
+    }
+
     /**
      * @param feature
      * @return the configured feature value - can be <code>null</code>

src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt

@@ -2713,92 +2713,64 @@ PARSER_END(CCJSqlParser)
 TOKEN_MGR_DECLS : {
     public FeatureConfiguration configuration = new FeatureConfiguration();
 
-    // The configuration is wired before parsing starts (CCJSqlParser.getConfiguration /
-    // withConfiguration) and no lexical action mutates it mid-parse. Cache the dialect and
-    // flag lookups the per-token actions need, keyed on the wired configuration's identity,
-    // so every token pays a field read instead of a map lookup.
+    // The public configuration can be replaced or mutated, including between ReInit calls.
+    // Subclasses may provide dynamic values without going through setValue.
     private FeatureConfiguration lexicalConfiguration;
+    private long lexicalModificationCount;
     private boolean lexicalPostgreSqlDialect;
     private boolean lexicalBigQueryDialect;
     private boolean lexicalAllowHashLineComments;
     private boolean lexicalAllowBackslashEscapes;
     private boolean lexicalAllowDoubleQuotedStrings;
     private boolean lexicalAllowSquareBracketQuotation;
 
-    private void refreshLexicalConfiguration(FeatureConfiguration wired) {
-        lexicalConfiguration = wired;
-        Object dialect = wired.getValue(Feature.dialect);
+    private void refreshLexicalConfiguration() {
+        long modificationCount = configuration.getModificationCount();
+        if (configuration == lexicalConfiguration && modificationCount == lexicalModificationCount
+                && configuration.getClass() == FeatureConfiguration.class) {
+            return;
+        }
+        Object dialect = configuration.getValue(Feature.dialect);
         lexicalPostgreSqlDialect = AbstractJSqlParser.Dialect.POSTGRESQL.name().equals(dialect);
         lexicalBigQueryDialect = AbstractJSqlParser.Dialect.BIGQUERY.name().equals(dialect);
-        lexicalAllowHashLineComments = Boolean.TRUE.equals(wired.getValue(Feature.allowHashLineComments));
-        lexicalAllowBackslashEscapes = wired.getAsBoolean(Feature.allowBackslashEscapeCharacter);
-        lexicalAllowDoubleQuotedStrings = wired.getAsBoolean(Feature.allowDoubleQuotedStrings);
-        lexicalAllowSquareBracketQuotation = wired.getAsBoolean(Feature.allowSquareBracketQuotation);
+        lexicalAllowHashLineComments = Boolean.TRUE.equals(configuration.getValue(Feature.allowHashLineComments));
+        lexicalAllowBackslashEscapes = configuration.getAsBoolean(Feature.allowBackslashEscapeCharacter);
+        lexicalAllowDoubleQuotedStrings = configuration.getAsBoolean(Feature.allowDoubleQuotedStrings);
+        lexicalAllowSquareBracketQuotation = configuration.getAsBoolean(Feature.allowSquareBracketQuotation);
+        lexicalConfiguration = configuration;
+        lexicalModificationCount = modificationCount;
     }
 
     private boolean isPostgreSqlDialect() {
-        FeatureConfiguration wired = input_stream.featureConfiguration;
-        if (wired == null) {
-            return false;
-        }
-        if (wired != lexicalConfiguration) {
-            refreshLexicalConfiguration(wired);
-        }
+        refreshLexicalConfiguration();
         return lexicalPostgreSqlDialect;
     }
 
     private boolean isBigQueryDialect() {
-        FeatureConfiguration wired = input_stream.featureConfiguration;
-        if (wired == null) {
-            return false;
-        }
-        if (wired != lexicalConfiguration) {
-            refreshLexicalConfiguration(wired);
-        }
+        refreshLexicalConfiguration();
         return lexicalBigQueryDialect;
     }
 
     private boolean isAllowHashLineComments() {
-        FeatureConfiguration wired = input_stream.featureConfiguration;
-        if (wired == null) {
+        if (input_stream.featureConfiguration == null) {
             return false;
         }
-        if (wired != lexicalConfiguration) {
-            refreshLexicalConfiguration(wired);
-        }
+        refreshLexicalConfiguration();
         return lexicalAllowHashLineComments;
     }
 
     private boolean isAllowBackslashEscapes() {
-        FeatureConfiguration wired = input_stream.featureConfiguration;
-        if (wired == null) {
-            return false;
-        }
-        if (wired != lexicalConfiguration) {
-            refreshLexicalConfiguration(wired);
-        }
+        refreshLexicalConfiguration();
         return lexicalAllowBackslashEscapes;
     }
 
     private boolean isAllowDoubleQuotedStrings() {
-        FeatureConfiguration wired = input_stream.featureConfiguration;
-        if (wired == null) {
-            return false;
-        }
-        if (wired != lexicalConfiguration) {
-            refreshLexicalConfiguration(wired);
-        }
+        refreshLexicalConfiguration();
         return lexicalAllowDoubleQuotedStrings;
     }
 
     private boolean isAllowSquareBracketQuotation() {
-        FeatureConfiguration wired = input_stream.featureConfiguration;
-        if (wired == null) {
-            return false;
-        }
-        if (wired != lexicalConfiguration) {
-            refreshLexicalConfiguration(wired);
-        }
+        refreshLexicalConfiguration();
         return lexicalAllowSquareBracketQuotation;
     }