improve the ability for API users to configure the caching behavior of the ASTParser (and by extension the *ASTTransformers),

added two new parser classes: one that uses a different (smaller) cache for translation units and one that doesn't cache translation units at all,
added the ability to change which parser and AST build cache is used by an ASTParser, and removed methods that are now pointless

Author: douira

glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/data/TypedTreeCache.java

@@ -8,7 +8,7 @@
 import io.github.douira.glsl_transformer.util.LRUCache;
 
 public class TypedTreeCache<V> extends LRUCache<CacheKey, V> {
-  private static final int defaultCacheSize = 400;
+  private static final int DEFAULT_CACHE_SIZE = 400;
 
   public TypedTreeCache(int maxSize, float loadFactor) {
     super(maxSize, loadFactor);
@@ -19,7 +19,7 @@ public TypedTreeCache(int maxSize) {
   }
 
   public TypedTreeCache() {
-    super(defaultCacheSize);
+    super(DEFAULT_CACHE_SIZE);
   }
 
   public static class CacheKey {
@@ -55,11 +55,8 @@ public boolean equals(Object obj) {
       } else if (!input.equals(other.input))
         return false;
       if (ruleType == null) {
-        if (other.ruleType != null)
-          return false;
-      } else if (!ruleType.equals(other.ruleType))
-        return false;
-      return true;
+        return other.ruleType == null;
+      } else return ruleType.equals(other.ruleType);
     }
   }
 

glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTParser.java

@@ -27,8 +27,8 @@ public static ASTParser _getInternalInstance() {
     return INSTANCE;
   }
 
-  private EnhancedParser parser = new CachingParser();
-  private TypedTreeCache<ASTNode> buildCache = new TypedTreeCache<>();
+  private EnhancedParser parser;
+  private TypedTreeCache<ASTNode> buildCache;
   private ASTCacheStrategy astCacheStrategy = ASTCacheStrategy.ALL_EXCLUDING_TRANSLATION_UNIT;
   private boolean parseLineDirectives = false;
 
@@ -40,47 +40,66 @@ public enum ASTCacheStrategy {
 
   public enum ParsingCacheStrategy {
     ALL,
+    TWO_TIER,
+    ALL_EXCLUDING_TRANSLATION_UNIT,
     NONE
   }
 
-  public void setBuildCacheSizeAndClear(int size) {
-    buildCache = new TypedTreeCache<>(size);
+  public ASTParser(EnhancedParser parser, TypedTreeCache<ASTNode> buildCache) {
+    this.parser = parser;
+    this.buildCache = buildCache;
   }
 
-  public void setParseCacheSizeAndClear(int size) {
-    if (parser instanceof CachingParser cachingParser) {
-      cachingParser.setParseCacheSizeAndClear(size);
-    }
+  public ASTParser() {
+    this(new CachingParser(), new TypedTreeCache<>());
+  }
+
+  public void setParser(EnhancedParser parser) {
+    this.parser = parser;
+  }
+
+  public void setBuildCache(TypedTreeCache<ASTNode> buildCache) {
+    this.buildCache = buildCache;
   }
 
   /**
    * Sets the AST cache strategy. If set to ALL, the parser will cache all
    * generated ASTs. If set to ALL_EXCLUDING_TRANSLATION_UNIT, the parser will
    * cache all generated ASTs except for the TranslationUnit. If set to NONE, the
    * parser will cache nothing.
-   * 
+   *
    * @param astCacheStrategy the AST cache strategy
    */
   public void setASTCacheStrategy(ASTCacheStrategy astCacheStrategy) {
     this.astCacheStrategy = astCacheStrategy;
   }
 
   /**
-   * Sets the parsing cache strategy. If set to ALL, the parser will cache all
-   * parsed strings. If set to NONE, the parser will cache nothing. Only
-   * influences how the CST is parsed from the input and not the AST.
-   * 
+   * Sets the parsing cache strategy. If set to {@link ParsingCacheStrategy#ALL},
+   * the parser will cache all parsed strings. If set to
+   * {@link ParsingCacheStrategy#TWO_TIER}, the parser will cache all parsed strings
+   * in a two-tier cache. If set to {@link ParsingCacheStrategy#NONE},
+   * the parser will cache nothing. If set to
+   * {@link ParsingCacheStrategy#ALL_EXCLUDING_TRANSLATION_UNIT}, the parser
+   * will cache all parsed strings except for the {@link TranslationUnit}.
+   * This only influences how the CST is parsed from the input and not the AST.
+   *
    * @param parsingCacheStrategy the parsing cache strategy
    */
   public void setParsingCacheStrategy(ParsingCacheStrategy parsingCacheStrategy) {
-    parser = parsingCacheStrategy == ParsingCacheStrategy.ALL ? new CachingParser() : new EnhancedParser();
+    parser = switch (parsingCacheStrategy) {
+      case ALL -> new CachingParser();
+      case TWO_TIER -> new TwoTierCachingParser();
+      case ALL_EXCLUDING_TRANSLATION_UNIT -> new TranslationUnitFilterCachingParser();
+      case NONE -> new EnhancedParser();
+    };
   }
 
   /**
    * Sets whether the AST parser should handle line directives. If set to true,
    * the parser will parse line directives and add them to the AST. If set to
    * false, the parser will ignore line directives and not add them to the AST.
-   * 
+   *
    * @param parseLineDirectives whether the parser should parse line directives
    */
   public void setParseLineDirectives(boolean parseLineDirectives) {
@@ -179,7 +198,7 @@ public <C extends ParserRuleContext, N extends ASTNode> N parseNode(
       String input) {
     if (astCacheStrategy == ASTCacheStrategy.NONE
         || astCacheStrategy == ASTCacheStrategy.ALL_EXCLUDING_TRANSLATION_UNIT
-            && parseShape.ruleType == TranslationUnitContext.class) {
+        && parseShape.ruleType == TranslationUnitContext.class) {
       try {
         var parsed = parser.parse(input, parseShape);
         setBuilderTokenStream();

glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTTransformer.java

@@ -2,12 +2,15 @@
 
 import java.util.Objects;
 
+import io.github.douira.glsl_transformer.ast.data.TypedTreeCache;
 import io.github.douira.glsl_transformer.ast.node.TranslationUnit;
+import io.github.douira.glsl_transformer.ast.node.abstract_node.ASTNode;
 import io.github.douira.glsl_transformer.ast.node.expression.Expression;
 import io.github.douira.glsl_transformer.ast.node.external_declaration.ExternalDeclaration;
 import io.github.douira.glsl_transformer.ast.node.statement.Statement;
 import io.github.douira.glsl_transformer.ast.print.PrintType;
 import io.github.douira.glsl_transformer.ast.query.*;
+import io.github.douira.glsl_transformer.parser.EnhancedParser;
 import io.github.douira.glsl_transformer.token_filter.TokenFilter;
 
 /**

glsl-transformer/src/main/java/io/github/douira/glsl_transformer/parser/CachingParser.java

@@ -14,25 +14,16 @@
  * is safe to use this.
  */
 public class CachingParser extends EnhancedParser {
-  record CacheContents(ParserRuleContext parseTree, BufferedTokenStream tokenStream) {
+  protected record CacheContents(ParserRuleContext parseTree, BufferedTokenStream tokenStream) {
   }
 
-  private TypedTreeCache<CacheContents> parseCache;
+  protected TypedTreeCache<CacheContents> parseCache;
 
   public CachingParser(boolean throwParseErrors, int cacheSize) {
     super(throwParseErrors);
     parseCache = new TypedTreeCache<>(cacheSize);
   }
 
-  public CachingParser(int cacheSize) {
-    parseCache = new TypedTreeCache<>(cacheSize);
-  }
-
-  public CachingParser(boolean throwParseErrors) {
-    super(throwParseErrors);
-    parseCache = new TypedTreeCache<>();
-  }
-
   public CachingParser() {
     parseCache = new TypedTreeCache<>();
   }
@@ -49,19 +40,27 @@ public <C extends ParserRuleContext> C parse(
   }
 
   @Override
-  @SuppressWarnings("unchecked")
   public <C extends ParserRuleContext> C parse(
       String str,
       ParserRuleContext parent,
       ParseShape<C, ?> parseShape) {
-    var result = parseCache.cachedGet(str, parseShape.ruleType,
+    return parseWithCache(str, parent, parseShape, parseCache);
+  }
+
+  @SuppressWarnings("unchecked")
+  protected <C extends ParserRuleContext> C parseWithCache(
+      String str,
+      ParserRuleContext parent,
+      ParseShape<C, ?> parseShape,
+      TypedTreeCache<CacheContents> cache) {
+    var result = cache.cachedGet(str, parseShape.ruleType,
         () -> {
           var node = parse(str, parent, parseShape.parseMethod);
           return new CacheContents(node, getTokenStream());
         });
     if (result != null) {
       // so that when a cache hit happens, the getTokenStream method returns the
-      // correct token stream 
+      // correct token stream
       tokenStream = result.tokenStream;
       return (C) result.parseTree;
     } else {

glsl-transformer/src/main/java/io/github/douira/glsl_transformer/parser/EnhancedParser.java

@@ -85,7 +85,7 @@ public enum ParsingStrategy {
    * It filters the tokens coming from the lexer before the parser consumes them.
    * The contained token filter can be {@code null} if no filter is to be used.
    */
-  private FilterTokenSource tokenSource = new FilterTokenSource(lexer);
+  private final FilterTokenSource tokenSource = new FilterTokenSource(lexer);
 
   /**
    * Creates a new parser and specifies if parse errors should be
@@ -196,13 +196,13 @@ public TranslationUnitContext parse(String str) {
   public <C extends ParserRuleContext> C parse(
       String str,
       Function<GLSLParser, C> parseMethod) {
-    return parse(str, (ParserRuleContext) null, parseMethod);
+    return parse(str, null, parseMethod);
   }
 
   public <C extends ParserRuleContext> C parse(
       String str,
       ParseShape<C, ?> parseShape) {
-    return parse(str, (ParserRuleContext) null, parseShape.parseMethod);
+    return parse(str, null, parseShape.parseMethod);
   }
 
   /**

glsl-transformer/src/main/java/io/github/douira/glsl_transformer/parser/TranslationUnitFilterCachingParser.java

@@ -0,0 +1,22 @@
+package io.github.douira.glsl_transformer.parser;
+
+import io.github.douira.glsl_transformer.GLSLParser;
+import org.antlr.v4.runtime.ParserRuleContext;
+
+public class TranslationUnitFilterCachingParser extends CachingParser {
+  public TranslationUnitFilterCachingParser(boolean throwParseErrors, int cacheSize) {
+    super(throwParseErrors, cacheSize);
+  }
+
+  public TranslationUnitFilterCachingParser() {
+    super();
+  }
+
+  @Override
+  public <C extends ParserRuleContext> C parse(String str, ParserRuleContext parent, ParseShape<C, ?> parseShape) {
+    if (parseShape.ruleType == GLSLParser.TranslationUnitContext.class) {
+      return parse(str, parent, parseShape);
+    }
+    return super.parse(str, parent, parseShape);
+  }
+}

glsl-transformer/src/main/java/io/github/douira/glsl_transformer/parser/TwoTierCachingParser.java

@@ -0,0 +1,47 @@
+package io.github.douira.glsl_transformer.parser;
+
+import io.github.douira.glsl_transformer.GLSLParser;
+import io.github.douira.glsl_transformer.ast.data.TypedTreeCache;
+import io.github.douira.glsl_transformer.token_filter.TokenFilter;
+import org.antlr.v4.runtime.ParserRuleContext;
+
+public class TwoTierCachingParser extends CachingParser {
+  private static final int DEFAULT_SECONDARY_CACHE_SIZE = 10;
+  
+  protected TypedTreeCache<CacheContents> secondaryCache;
+
+  public TwoTierCachingParser() {
+    super();
+    secondaryCache = new TypedTreeCache<>(DEFAULT_SECONDARY_CACHE_SIZE);
+  }
+
+  public TwoTierCachingParser(boolean throwParseErrors, int cacheSize, int secondaryCacheSize) {
+    super(throwParseErrors, cacheSize);
+    secondaryCache = new TypedTreeCache<>(secondaryCacheSize);
+  }
+
+  @Override
+  public void setParseCacheSizeAndClear(int size) {
+    throw new UnsupportedOperationException(
+        "This parser uses a two-tier cache. Use setTwoTierCacheSizesAndClear instead.");
+  }
+  
+  public void setTwoTierCacheSizesAndClear(int primarySize, int secondarySize) {
+    parseCache = new TypedTreeCache<>(primarySize);
+    secondaryCache = new TypedTreeCache<>(secondarySize);
+  }
+
+  @Override
+  public <C extends ParserRuleContext> C parse(String str, ParserRuleContext parent, ParseShape<C, ?> parseShape) {
+    if (parseShape.ruleType == GLSLParser.TranslationUnitContext.class) {
+      return parseWithCache(str, parent, parseShape, secondaryCache);
+    }
+    return super.parse(str, parent, parseShape);
+  }
+
+  @Override
+  public void setTokenFilter(TokenFilter<?> tokenFilter) {
+    super.setTokenFilter(tokenFilter);
+    secondaryCache.clear();
+  }
+}

glsl-transformer/src/test/java/io/github/douira/glsl_transformer/ParsingPerformanceTest.java

@@ -100,7 +100,7 @@ void testDeepParenExpressionParsing() {
   @Test
   void testDeepParenExpressionParsingCaching() {
     // with warmup, the caching parser needs basically no time
-    parser = new CachingParser(true);
+    parser = new CachingParser();
     parser.setSLLOnly();
     assertFilePerformance(10, FileLocation.DEEP_PAREN_EXPRESSION_TEST);
   }