diff --git a/docs/development.md b/docs/development.md
index 4288ab10..98a21ed9 100644
--- a/docs/development.md
+++ b/docs/development.md
@@ -33,6 +33,23 @@ gradle test --tests GrammarDebugTest
 
 # Development Notes
 
+## Conventions
+
+### Generic Type Parameters
+
+Generic type parameters are named with the follwing rules:
+
+- `N` for `extends ASTNode`
+- `C` for `extends ParserRuleContext`
+- `T` for `extends ParseTree`
+- `Child` for `extends ASTNode` if it's the child parameter of an `ASTNode` sub class
+- `J` for `extends JobParameters`
+- `E` for extending some kind of Enum
+- `R` for some other return type
+- `V` for generic (unconstrained) values that aren't any of the above
+
+`P` can't be used because it makes javadoc think it's a `<p>` paragraph tag.
+
 ## AST Development
 
 ### AST Node Registration
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/data/ProxyArrayList.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/data/ProxyArrayList.java
index 9e3b4289..3d8f0cf2 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/data/ProxyArrayList.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/data/ProxyArrayList.java
@@ -8,8 +8,8 @@
  * is added or removed from the list. The notification methods should be
  * idempotent and reversible with the inverse other method.
  */
-public abstract class ProxyArrayList<T> extends ArrayList<T> {
-  private Set<T> elements = null;
+public abstract class ProxyArrayList<V> extends ArrayList<V> {
+  private Set<V> elements = null;
 
   public ProxyArrayList() {
   }
@@ -18,22 +18,22 @@ public ProxyArrayList(int initialCapacity) {
     super(initialCapacity);
   }
 
-  public ProxyArrayList(Collection<? extends T> c) {
+  public ProxyArrayList(Collection<? extends V> c) {
     this(c, true);
   }
 
-  public ProxyArrayList(Collection<? extends T> c, boolean notifyInitial) {
+  public ProxyArrayList(Collection<? extends V> c, boolean notifyInitial) {
     super(c);
     if (notifyInitial) {
       notifyAdditionSafe(c);
     }
   }
 
-  protected abstract void notifyAddition(T added);
+  protected abstract void notifyAddition(V added);
 
-  protected abstract void notifyRemoval(T removed);
+  protected abstract void notifyRemoval(V removed);
 
-  void notifyAdditionSafe(T added) {
+  void notifyAdditionSafe(V added) {
     if (added != null) {
       notifyAddition(added);
       if (elements != null) {
@@ -42,13 +42,13 @@ void notifyAdditionSafe(T added) {
     }
   }
 
-  void notifyAdditionSafe(Collection<? extends T> collection) {
-    for (var element : collection) {
+  void notifyAdditionSafe(Collection<? extends V> collection) {
+    for (V element : collection) {
       notifyAdditionSafe(element);
     }
   }
 
-  private void notifyRemovalSafe(T removed) {
+  private void notifyRemovalSafe(V removed) {
     if (removed != null) {
       notifyRemoval(removed);
       if (elements != null) {
@@ -57,13 +57,13 @@ private void notifyRemovalSafe(T removed) {
     }
   }
 
-  private void notifyRemovalSafe(Collection<? extends T> collection) {
-    for (var element : collection) {
+  private void notifyRemovalSafe(Collection<? extends V> collection) {
+    for (V element : collection) {
       notifyRemovalSafe(element);
     }
   }
 
-  private Set<T> getElements() {
+  private Set<V> getElements() {
     if (elements == null) {
       elements = new HashSet<>(this);
     }
@@ -71,8 +71,8 @@ private Set<T> getElements() {
   }
 
   @Override
-  public T set(int index, T element) {
-    var prev = super.set(index, element);
+  public V set(int index, V element) {
+    V prev = super.set(index, element);
     if (prev != element) {
       notifyRemovalSafe(prev);
       notifyAdditionSafe(element);
@@ -81,20 +81,20 @@ public T set(int index, T element) {
   }
 
   @Override
-  public boolean add(T e) {
+  public boolean add(V e) {
     var result = super.add(e);
     notifyAdditionSafe(e);
     return result;
   }
 
   @Override
-  public void add(int index, T element) {
+  public void add(int index, V element) {
     super.add(index, element);
     notifyAdditionSafe(element);
   }
 
   @Override
-  public boolean addAll(Collection<? extends T> c) {
+  public boolean addAll(Collection<? extends V> c) {
     var result = super.addAll(c);
     if (result) {
       notifyAdditionSafe(c);
@@ -103,7 +103,7 @@ public boolean addAll(Collection<? extends T> c) {
   }
 
   @Override
-  public boolean addAll(int index, Collection<? extends T> c) {
+  public boolean addAll(int index, Collection<? extends V> c) {
     var result = super.addAll(index, c);
     if (result) {
       notifyAdditionSafe(c);
@@ -112,8 +112,8 @@ public boolean addAll(int index, Collection<? extends T> c) {
   }
 
   @Override
-  public T remove(int index) {
-    var removed = super.remove(index);
+  public V remove(int index) {
+    V removed = super.remove(index);
     notifyRemovalSafe(removed);
     return removed;
   }
@@ -124,7 +124,7 @@ public boolean remove(Object o) {
     var result = super.remove(o);
     if (result) {
       // the cast is ok because only T-type elements could have been added
-      notifyRemovalSafe((T) o);
+      notifyRemovalSafe((V) o);
     }
     return result;
   }
@@ -136,7 +136,7 @@ public boolean removeAll(Collection<?> c) {
     if (result) {
       for (Object element : this) {
         if (getElements().contains(element)) {
-          notifyRemovalSafe((T) element);
+          notifyRemovalSafe((V) element);
         }
       }
     }
@@ -144,7 +144,7 @@ public boolean removeAll(Collection<?> c) {
   }
 
   @Override
-  public void replaceAll(UnaryOperator<T> operator) {
+  public void replaceAll(UnaryOperator<V> operator) {
     for (int i = 0; i < size(); i++) {
       set(i, operator.apply(get(i)));
     }
@@ -157,7 +157,7 @@ public boolean retainAll(Collection<?> c) {
     if (result) {
       for (Object element : this) {
         if (!getElements().contains(element)) {
-          notifyRemovalSafe((T) element);
+          notifyRemovalSafe((V) element);
         }
       }
     }
@@ -165,10 +165,10 @@ public boolean retainAll(Collection<?> c) {
   }
 
   @Override
-  public boolean removeIf(Predicate<? super T> filter) {
+  public boolean removeIf(Predicate<? super V> filter) {
     var result = super.removeIf(filter);
     if (result) {
-      for (var element : this) {
+      for (V element : this) {
         if (filter.test(element)) {
           notifyRemovalSafe(element);
         }
@@ -196,8 +196,8 @@ public void clear() {
 
   @Override
   @SuppressWarnings("unchecked")
-  public ProxyArrayList<T> clone() {
-    var result = (ProxyArrayList<T>) super.clone();
+  public ProxyArrayList<V> clone() {
+    var result = (ProxyArrayList<V>) super.clone();
     result.elements = null;
     return result;
   }
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/data/TypeUtil.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/data/TypeUtil.java
index efbde446..de85c7c7 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/data/TypeUtil.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/data/TypeUtil.java
@@ -3,8 +3,8 @@
 import org.antlr.v4.runtime.Token;
 
 public class TypeUtil {
-  public static <T extends TokenTyped> T enumFromToken(T[] enumValues, Token token) {
-    for (T value : enumValues) {
+  public static <E extends TokenTyped> E enumFromToken(E[] enumValues, Token token) {
+    for (E value : enumValues) {
       if (value.getTokenType() == token.getType()) {
         return value;
       }
@@ -12,7 +12,7 @@ public static <T extends TokenTyped> T enumFromToken(T[] enumValues, Token token
     throw new IllegalArgumentException("Unknown token: " + token.getText());
   }
 
-  public static <T> T enumFromToken(T[] values, int[] tokenTypes, Token token) {
+  public static <E> E enumFromToken(E[] values, int[] tokenTypes, Token token) {
     if (values.length != tokenTypes.length) {
       throw new IllegalArgumentException("values.length != tokenTypes.length");
     }
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/node/abstract_node/ASTNode.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/node/abstract_node/ASTNode.java
index da6bceb8..3eae2312 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/node/abstract_node/ASTNode.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/node/abstract_node/ASTNode.java
@@ -196,7 +196,7 @@ public ASTNode getAncestor(Predicate<ASTNode> predicate) {
    * @return the first ancestor that is an instance of the given class, or null
    *         otherwise
    */
-  public <T extends ASTNode> T getAncestor(Class<T> ancestorType) {
+  public <N extends ASTNode> N getAncestor(Class<N> ancestorType) {
     return ancestorType.cast(getAncestor(ancestorType::isInstance));
   }
 
@@ -217,9 +217,9 @@ public ASTNode getBranchAncestor(int limit, int skip, BiPredicate<ASTNode, ASTNo
   }
 
   @SuppressWarnings("unchecked")
-  public <T extends ASTNode> T getBranchAncestor(int limit, int skip, Class<T> branchClass,
-      Function<T, ? extends ASTNode> branchGetter) {
-    return (T) getBranchAncestor(limit, skip, (node, last) -> {
+  public <N extends ASTNode> N getBranchAncestor(int limit, int skip, Class<N> branchClass,
+      Function<N, ? extends ASTNode> branchGetter) {
+    return (N) getBranchAncestor(limit, skip, (node, last) -> {
       if (!branchClass.isInstance(node)) {
         return false;
       }
@@ -227,14 +227,14 @@ public <T extends ASTNode> T getBranchAncestor(int limit, int skip, Class<T> bra
     });
   }
 
-  public <T extends ASTNode> T getBranchAncestor(Class<T> branchClass,
-      Function<T, ? extends ASTNode> branchGetter) {
+  public <N extends ASTNode> N getBranchAncestor(Class<N> branchClass,
+      Function<N, ? extends ASTNode> branchGetter) {
     return getBranchAncestor(Integer.MAX_VALUE, 0, branchClass, branchGetter);
   }
 
-  public <T extends ASTNode, R extends ASTNode> R getBranchAncestorContinue(Class<T> branchClass,
-      Function<T, ? extends ASTNode> branchGetter, Class<R> continueClass) {
-    var result = getBranchAncestor(branchClass, branchGetter);
+  public <N extends ASTNode, R extends ASTNode> R getBranchAncestorContinue(Class<N> branchClass,
+      Function<N, ? extends ASTNode> branchGetter, Class<R> continueClass) {
+    N result = getBranchAncestor(branchClass, branchGetter);
     return result == null ? null : result.getAncestor(continueClass);
   }
 
@@ -438,14 +438,14 @@ public static boolean swap(ASTNode a, ASTNode b) {
    * already have a reference to the current root but will not be registered to it
    * yet.
    * 
-   * @param <NodeType> Type of the node for passthrough
+   * @param <N> Type of the node for passthrough
    * @param node       The node to add
    * @param setter     The setter to replace the node in this parent
    * @return The node itself
    */
-  public <NodeType extends ASTNode> NodeType setup(
-      NodeType node,
-      Consumer<? extends NodeType> setter) {
+  public <N extends ASTNode> N setup(
+      N node,
+      Consumer<? extends N> setter) {
     if (node != null) {
       node.setParent(this, setter);
     }
@@ -457,17 +457,17 @@ public <NodeType extends ASTNode> NodeType setup(
    * node. Both of them may be null if either the existing value is being removed
    * or a new value is being set.
    * 
-   * @param <NodeType>  The type of the nodes for pass-through
+   * @param <N>  The type of the nodes for pass-through
    * @param currentNode The current node
    * @param newNode     The new node
    * @param setter      The setter to replace the node in this parent (this is
    *                    usually a method reference to a setter method of the
    *                    parent, this node)
    */
-  public <NodeType extends ASTNode> void updateParents(
-      NodeType currentNode,
-      NodeType newNode,
-      Consumer<? extends NodeType> setter) {
+  public <N extends ASTNode> void updateParents(
+      N currentNode,
+      N newNode,
+      Consumer<? extends N> setter) {
     if (currentNode == newNode && newNode.getParent() == this) {
       return;
     }
@@ -501,18 +501,18 @@ public ASTNode cloneSeparate() {
   }
 
   @SuppressWarnings("unchecked") // the nodes clone themselves correctly
-  public static <T extends ASTNode> T clone(T node) {
+  public static <N extends ASTNode> N clone(N node) {
     if (node == null) {
       return null;
     }
     if (node.template == null) {
-      return (T) node.clone();
+      return (N) node.clone();
     }
-    var replacement = node.template.getReplacement(node);
-    return replacement == null ? (T) node.clone() : replacement;
+    N replacement = node.template.getReplacement(node);
+    return replacement == null ? (N) node.clone() : replacement;
   }
 
-  public static <T extends ASTNode> Stream<T> clone(ChildNodeList<T> nodes) {
+  public static <N extends ASTNode> Stream<N> clone(ChildNodeList<N> nodes) {
     return nodes == null ? null : nodes.getClonedStream();
   }
 }
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/Root.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/Root.java
index 0ac2ce87..dfabb736 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/Root.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/Root.java
@@ -130,13 +130,13 @@ protected static final synchronized <R> R withActiveBuildRoot(
    * either manually registered as it is being done here or added as a child to
    * another node with the root.
    * 
-   * @param <NodeType> The type of the node to build
-   * @param instance   The root to run the builder with
-   * @param builder    The builder to run
+   * @param <N>      The type of the node to build
+   * @param instance The root to run the builder with
+   * @param builder  The builder to run
    * @return The built and registered node
    */
-  public static synchronized <NodeType extends ASTNode> NodeType indexNodes(
-      Root instance, Supplier<NodeType> builder) {
+  public static synchronized <N extends ASTNode> N indexNodes(
+      Root instance, Supplier<N> builder) {
     return withActiveBuildRoot(instance, root -> {
       var result = builder.get();
       root.registerNode(result);
@@ -147,12 +147,12 @@ public static synchronized <NodeType extends ASTNode> NodeType indexNodes(
   /**
    * Runs the given builder supplier with a new root as the active build root.
    * 
-   * @param <NodeType> The type of the node to build
-   * @param builder    The builder to run
+   * @param <N>     The type of the node to build
+   * @param builder The builder to run
    * @return The built and registered node
    */
-  public static <NodeType extends ASTNode> NodeType indexNodes(
-      Supplier<NodeType> builder) {
+  public static <N extends ASTNode> N indexNodes(
+      Supplier<N> builder) {
     return indexNodes(new Root(), builder);
   }
 
@@ -160,13 +160,13 @@ public static <NodeType extends ASTNode> NodeType indexNodes(
    * Runs the given builder supplier with the same root as a given tree node as
    * the active build root.
    * 
-   * @param <NodeType>       The type of the node to build
+   * @param <N>              The type of the node to build
    * @param parentTreeMember The tree member to get the root from
    * @param builder          The builder to run
    * @return The built and registered node
    */
-  public static <NodeType extends ASTNode> NodeType indexNodes(
-      ASTNode parentTreeMember, Supplier<NodeType> builder) {
+  public static <N extends ASTNode> N indexNodes(
+      ASTNode parentTreeMember, Supplier<N> builder) {
     return indexNodes(parentTreeMember.getRoot(), builder);
   }
 
@@ -211,12 +211,12 @@ public static void indexBuildSession(ASTNode treeMember, Runnable session) {
    * function that takes a constructed node and registers it with the root. This
    * is helpful for constructing trees manually and registering them inline.
    * 
-   * @param <NodeType>         The type of the nodes to register
+   * @param <N>                The type of the nodes to register
    * @param instance           the root to register the nodes with
    * @param registererConsumer The consumer to run
    */
-  public static synchronized <NodeType extends ASTNode> void indexSeparateTrees(
-      Root instance, Consumer<Passthrough<NodeType>> registererConsumer) {
+  public static synchronized <N extends ASTNode> void indexSeparateTrees(
+      Root instance, Consumer<Passthrough<N>> registererConsumer) {
     withActiveBuildRoot(instance, root -> {
       registererConsumer.accept(Passthrough.of(root::registerNode));
       return null;
@@ -227,11 +227,11 @@ public static synchronized <NodeType extends ASTNode> void indexSeparateTrees(
    * Runs the given consumer of a registration pass-through function with a new
    * root as the active build root.
    * 
-   * @param <NodeType> The type of the nodes to register
+   * @param <N>        The type of the nodes to register
    * @param registerer The consumer to run
    */
-  public static <NodeType extends ASTNode> void indexSeparateTrees(
-      Consumer<Passthrough<NodeType>> registerer) {
+  public static <N extends ASTNode> void indexSeparateTrees(
+      Consumer<Passthrough<N>> registerer) {
     indexSeparateTrees(new Root(), registerer);
   }
 
@@ -239,12 +239,12 @@ public static <NodeType extends ASTNode> void indexSeparateTrees(
    * Runs the given consumer of a registration pass-through function with the same
    * root as a given tree node as the active build root.
    * 
-   * @param <NodeType> The type of the nodes to register
+   * @param <N>        The type of the nodes to register
    * @param treeMember The tree member to get the root from
    * @param registerer The consumer to run
    */
-  public static <NodeType extends ASTNode> void indexSeparateTrees(
-      ASTNode treeMember, Consumer<Passthrough<NodeType>> registerer) {
+  public static <N extends ASTNode> void indexSeparateTrees(
+      ASTNode treeMember, Consumer<Passthrough<N>> registerer) {
     indexSeparateTrees(treeMember.getRoot(), registerer);
   }
 
@@ -318,21 +318,21 @@ public boolean rename(String oldName, String newName) {
    * This method ensures there is no concurrent modification of the node index by
    * collecting the stream into a shared list.
    * 
-   * @param <T>      The type of the target nodes
+   * @param <N>      The type of the target nodes
    * @param targets  The stream of target nodes to process
    * @param replacer The consumer to process the target nodes with
    * @return Whether anything was processed
    */
   @SuppressWarnings("unchecked")
-  public <T extends ASTNode> boolean process(Stream<? extends T> targets, Consumer<? super T> replacer) {
+  public <N extends ASTNode> boolean process(Stream<? extends N> targets, Consumer<? super N> replacer) {
     ensureEmptyNodeList();
     if (targets == null) {
       return false;
     }
-    var typedList = (List<T>) nodeList;
+    var typedList = (List<N>) nodeList;
     targets.forEach(typedList::add);
     var activity = false;
-    for (var node : typedList) {
+    for (N node : typedList) {
       if (node != null) {
         replacer.accept(node);
         activity = true;
@@ -485,18 +485,18 @@ public static boolean replaceExpressionsConcurrent(
    * Processes all matches of nodes from the given stream matched with the given
    * matcher.
    * 
-   * @param <T>                 The type of the matched nodes
+   * @param <N>                 The type of the matched nodes
    * @param t                   The AST transformer
    * @param matchTargetChildren The stream of nodes to match
    * @param matcher             The matcher to match the nodes with
    * @param replacer            The consumer to process the matched nodes with
    * @return Whether anything was processed
    */
-  public <T extends ASTNode> boolean processMatches(
+  public <N extends ASTNode> boolean processMatches(
       ASTParser t,
       Stream<? extends ASTNode> matchTargetChildren,
-      Matcher<T> matcher,
-      Consumer<? super T> replacer) {
+      Matcher<N> matcher,
+      Consumer<? super N> replacer) {
     var matchClass = matcher.getPatternClass();
     return process(matchTargetChildren
         .map(node -> node.getAncestor(matchClass))
@@ -509,16 +509,16 @@ public <T extends ASTNode> boolean processMatches(
    * Processes all matches of nodes in the tree that match the given hinted
    * matcher. The hint is used to identify the nodes to match.
    * 
-   * @param <T>           The type of the matched nodes
+   * @param <N>           The type of the matched nodes
    * @param t             The AST transformer
    * @param hintedMatcher The matcher to match the nodes with
    * @param replacer      The consumer to process the matched nodes with
    * @return Whether anything was processed
    */
-  public <T extends ASTNode> boolean processMatches(
+  public <N extends ASTNode> boolean processMatches(
       ASTParser t,
-      HintedMatcher<T> hintedMatcher,
-      Consumer<? super T> replacer) {
+      HintedMatcher<N> hintedMatcher,
+      Consumer<? super N> replacer) {
     return processMatches(t,
         identifierIndex.getStream(hintedMatcher.getHint()), hintedMatcher, replacer);
   }
@@ -527,17 +527,17 @@ public <T extends ASTNode> boolean processMatches(
    * Replaces expressions from the given stream that match the given matcher with
    * new expressions created from the given string.
    * 
-   * @param <T>                 The type of the matched expression nodes
+   * @param <N>                 The type of the matched expression nodes
    * @param t                   The AST transformer
    * @param matchTargetChildren The stream of nodes to match
    * @param matcher             The matcher to match the nodes with
    * @param expression          The content of the replacement expression
    * @return Whether anything was processed
    */
-  public <T extends Expression> boolean replaceExpressionMatches(
+  public <N extends Expression> boolean replaceExpressionMatches(
       ASTParser t,
       Stream<? extends ASTNode> matchTargetChildren,
-      Matcher<T> matcher,
+      Matcher<N> matcher,
       String expression) {
     var matchClass = matcher.getPatternClass();
     return replaceExpressions(t,
@@ -552,15 +552,15 @@ public <T extends Expression> boolean replaceExpressionMatches(
    * Replaces expressions all matches of expression nodes in the tree that match
    * the given hinted matcher with new expressions created from the given string.
    * 
-   * @param <T>           The type of the matched expression nodes
+   * @param <N>           The type of the matched expression nodes
    * @param t             The AST transformer
    * @param hintedMatcher The matcher to match the nodes with
    * @param expression    The content of the replacement expression
    * @return Whether anything was processed
    */
-  public <T extends Expression> boolean replaceExpressionMatches(
+  public <N extends Expression> boolean replaceExpressionMatches(
       ASTParser t,
-      HintedMatcher<T> hintedMatcher,
+      HintedMatcher<N> hintedMatcher,
       String expression) {
     return replaceExpressionMatches(t,
         identifierIndex.getStream(hintedMatcher.getHint()), hintedMatcher, expression);
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/index/IdentifierIndex.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/index/IdentifierIndex.java
index 6c11b067..b511f2f8 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/index/IdentifierIndex.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/index/IdentifierIndex.java
@@ -54,7 +54,7 @@ public Stream<Identifier> getStream(String key) {
     return result == null ? Stream.empty() : result.stream();
   }
 
-  public <T extends ASTNode> Stream<T> getAncestors(String key, Class<T> ancestorType) {
+  public <N extends ASTNode> Stream<N> getAncestors(String key, Class<N> ancestorType) {
     return getStream(key)
         .map(id -> id.getAncestor(ancestorType))
         .filter(Objects::nonNull);
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/index/Index.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/index/Index.java
index 2d388f4b..e602248f 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/index/Index.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/index/Index.java
@@ -6,10 +6,10 @@
 
 import io.github.douira.glsl_transformer.ast.node.abstract_node.ASTNode;
 
-public interface Index<T extends ASTNode> {
-  void add(T node);
+public interface Index<N extends ASTNode> {
+  void add(N node);
 
-  void remove(T node);
+  void remove(N node);
 
   public static <V> Consumer<Set<V>> iterate(Consumer<V> consumer) {
     return set -> set.stream().forEach(consumer);
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/index/NodeIndex.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/index/NodeIndex.java
index 6da9151b..4f6eea78 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/index/NodeIndex.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/index/NodeIndex.java
@@ -66,39 +66,39 @@ public void remove(ASTNode node) {
   /**
    * Returns a set of all nodes with the given type.
    * 
-   * @param <T>  the type of the class
+   * @param <N>  the type of the class
    * @param type the class of nodes to return
    * @return a set of nodes with the given type
    */
   @SuppressWarnings("unchecked")
-  public <T extends ASTNode> Set<T> get(Class<T> type) {
-    var result = (Set<T>) index.get(type);
+  public <N extends ASTNode> Set<N> get(Class<N> type) {
+    var result = (Set<N>) index.get(type);
     return result == null ? Collections.emptySet() : result;
   }
 
   /**
    * Returns a stream of all nodes with the given type.
    * 
-   * @param <T>  the type of the class
+   * @param <N>  the type of the class
    * @param type the class of nodes to return
    * @return a stream of nodes with the given type
    */
   @SuppressWarnings("unchecked")
-  public <T extends ASTNode> Stream<T> getStream(Class<T> type) {
-    var result = (Set<T>) index.get(type);
+  public <N extends ASTNode> Stream<N> getStream(Class<N> type) {
+    var result = (Set<N>) index.get(type);
     return result == null ? Stream.empty() : result.stream();
   }
 
   /**
    * Returns an arbitrary node with the given type.
    * 
-   * @param <T>  the type of the class
+   * @param <N>  the type of the class
    * @param type the class of the node to return
    * @return an arbitrary node with the given type
    */
   @SuppressWarnings("unchecked")
-  public <T extends ASTNode> T getOne(Class<T> type) {
-    var result = (Set<T>) index.get(type);
+  public <N extends ASTNode> N getOne(Class<N> type) {
+    var result = (Set<N>) index.get(type);
     if (result == null) {
       return null;
     }
@@ -110,13 +110,13 @@ public <T extends ASTNode> T getOne(Class<T> type) {
    * Returns the only node with the given type. Throws an exception if there is
    * not exactly one node with the given type.
    * 
-   * @param <T>  the type of the class
+   * @param <N>  the type of the class
    * @param type the class of the node to return
    * @return the only node with the given type
    */
   @SuppressWarnings("unchecked")
-  public <T extends ASTNode> T getUnique(Class<T> type) {
-    var result = (Set<T>) index.get(type);
+  public <N extends ASTNode> N getUnique(Class<N> type) {
+    var result = (Set<N>) index.get(type);
     var resultCount = result == null ? 0 : result.size();
     if (resultCount != 1) {
       throw new IllegalStateException("Expected exactly one node of type " + type + " but found " + resultCount);
@@ -138,25 +138,25 @@ public boolean has(Class<? extends ASTNode> type) {
   /**
    * Returns the set of nodes that have the same class as the given node.
    * 
-   * @param <T>  The type of the nodes
+   * @param <N>  The type of the nodes
    * @param node The node to get the set of
    * @return The set of nodes that have the same class as the given node
    */
   @SuppressWarnings("unchecked")
-  public <T extends ASTNode> Set<T> get(T node) {
-    return (Set<T>) get(node.getClass());
+  public <N extends ASTNode> Set<N> get(N node) {
+    return (Set<N>) get(node.getClass());
   }
 
   /**
    * Returns an arbitrary node that has the same class as the given node.
    * 
-   * @param <T>  The type of the node
+   * @param <N>  The type of the node
    * @param node The node to get a node from the index for
    * @return An arbitrary node that has the same class as the given node
    */
   @SuppressWarnings("unchecked")
-  public <T extends ASTNode> T getOne(T node) {
-    return (T) getOne(node.getClass());
+  public <N extends ASTNode> N getOne(N node) {
+    return (N) getOne(node.getClass());
   }
 
   /**
@@ -164,13 +164,13 @@ public <T extends ASTNode> T getOne(T node) {
    * exception if there is not exactly one node with the same class as the given
    * node.
    * 
-   * @param <T>  The type of the node
+   * @param <N>  The type of the node
    * @param node The node to get a node from the index for
    * @return The only node that has the same class as the given node
    */
   @SuppressWarnings("unchecked")
-  public <T extends ASTNode> T getUnique(T node) {
-    return (T) getUnique(node.getClass());
+  public <N extends ASTNode> N getUnique(N node) {
+    return (N) getUnique(node.getClass());
   }
 
   /**
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/match/AutoHintedMatcher.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/match/AutoHintedMatcher.java
index 7843c30f..745109ef 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/match/AutoHintedMatcher.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/match/AutoHintedMatcher.java
@@ -15,32 +15,32 @@
  * best (most distinguishing) hint, then the manually hinted
  * {@link HintedMatcher} should be used instead.
  */
-public class AutoHintedMatcher<T extends ASTNode> extends HintedMatcher<T> {
-  public <RuleType extends ParserRuleContext> AutoHintedMatcher(String input,
-      Function<GLSLParser, RuleType> parseMethod,
-      BiFunction<ASTBuilder, RuleType, T> visitMethod, String wildcardPrefix) {
+public class AutoHintedMatcher<N extends ASTNode> extends HintedMatcher<N> {
+  public <C extends ParserRuleContext> AutoHintedMatcher(String input,
+      Function<GLSLParser, C> parseMethod,
+      BiFunction<ASTBuilder, C, N> visitMethod, String wildcardPrefix) {
     super(input, parseMethod, visitMethod, wildcardPrefix, null);
   }
 
-  public AutoHintedMatcher(T pattern, String wildcardPrefix) {
+  public AutoHintedMatcher(N pattern, String wildcardPrefix) {
     super(pattern, wildcardPrefix, null);
   }
 
-  public AutoHintedMatcher(T pattern) {
+  public AutoHintedMatcher(N pattern) {
     super(pattern, null);
   }
 
-  public <RuleType extends ParserRuleContext> AutoHintedMatcher(String input,
-      Function<GLSLParser, RuleType> parseMethod,
-      BiFunction<ASTBuilder, RuleType, T> visitMethod) {
+  public <C extends ParserRuleContext> AutoHintedMatcher(String input,
+      Function<GLSLParser, C> parseMethod,
+      BiFunction<ASTBuilder, C, N> visitMethod) {
     super(input, parseMethod, visitMethod, null);
   }
 
-  public AutoHintedMatcher(String input, Function<String, T> patternParser, String wildcardPrefix) {
+  public AutoHintedMatcher(String input, Function<String, N> patternParser, String wildcardPrefix) {
     super(input, patternParser, wildcardPrefix, null);
   }
 
-  public AutoHintedMatcher(String input, Function<String, T> patternParser) {
+  public AutoHintedMatcher(String input, Function<String, N> patternParser) {
     super(input, patternParser, null);
   }
 
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/match/HintedMatcher.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/match/HintedMatcher.java
index a34c482a..4e6baeba 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/match/HintedMatcher.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/match/HintedMatcher.java
@@ -13,37 +13,37 @@
  * identifiers whose matching ancestor might match the pattern. This makes
  * working with matchers much less verbose.
  */
-public class HintedMatcher<T extends ASTNode> extends Matcher<T> {
+public class HintedMatcher<N extends ASTNode> extends Matcher<N> {
   protected String hint;
 
-  public <RuleType extends ParserRuleContext> HintedMatcher(String input, Function<GLSLParser, RuleType> parseMethod,
-      BiFunction<ASTBuilder, RuleType, T> visitMethod, String wildcardPrefix, String hint) {
+  public <C extends ParserRuleContext> HintedMatcher(String input, Function<GLSLParser, C> parseMethod,
+      BiFunction<ASTBuilder, C, N> visitMethod, String wildcardPrefix, String hint) {
     super(input, parseMethod, visitMethod, wildcardPrefix);
     this.hint = hint;
   }
 
-  public HintedMatcher(T pattern, String wildcardPrefix, String hint) {
+  public HintedMatcher(N pattern, String wildcardPrefix, String hint) {
     super(pattern, wildcardPrefix);
     this.hint = hint;
   }
 
-  public HintedMatcher(T pattern, String hint) {
+  public HintedMatcher(N pattern, String hint) {
     super(pattern);
     this.hint = hint;
   }
 
-  public <RuleType extends ParserRuleContext> HintedMatcher(String input, Function<GLSLParser, RuleType> parseMethod,
-      BiFunction<ASTBuilder, RuleType, T> visitMethod, String hint) {
+  public <C extends ParserRuleContext> HintedMatcher(String input, Function<GLSLParser, C> parseMethod,
+      BiFunction<ASTBuilder, C, N> visitMethod, String hint) {
     super(input, parseMethod, visitMethod);
     this.hint = hint;
   }
 
-  public HintedMatcher(String input, Function<String, T> patternParser, String wildcardPrefix, String hint) {
+  public HintedMatcher(String input, Function<String, N> patternParser, String wildcardPrefix, String hint) {
     super(input, patternParser, wildcardPrefix);
     this.hint = hint;
   }
 
-  public HintedMatcher(String input, Function<String, T> patternParser, String hint) {
+  public HintedMatcher(String input, Function<String, N> patternParser, String hint) {
     super(input, patternParser);
     this.hint = hint;
   }
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/match/Matcher.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/match/Matcher.java
index 1a3d37a8..3f3debb7 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/match/Matcher.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/query/match/Matcher.java
@@ -20,11 +20,11 @@
  * Instances of the matcher can match a node against a stored pattern. This
  * avoids a separate equality implementation for each node type.
  */
-public class Matcher<T extends ASTNode> {
+public class Matcher<N extends ASTNode> {
   /**
    * The node of the pattern being matched.
    */
-  protected final T pattern;
+  protected final N pattern;
 
   protected final String wildcardPrefix;
   private Map<String, Object> dataMatches;
@@ -43,7 +43,7 @@ public class Matcher<T extends ASTNode> {
    * @param pattern        The pattern to match
    * @param wildcardPrefix The prefix for wildcard identifiers
    */
-  public Matcher(T pattern, String wildcardPrefix) {
+  public Matcher(N pattern, String wildcardPrefix) {
     this.pattern = pattern;
     this.wildcardPrefix = wildcardPrefix;
   }
@@ -53,7 +53,7 @@ public Matcher(T pattern, String wildcardPrefix) {
    * 
    * @param pattern The pattern to match
    */
-  public Matcher(T pattern) {
+  public Matcher(N pattern) {
     this(pattern, null);
   }
 
@@ -61,15 +61,15 @@ public Matcher(T pattern) {
    * Creates a new matcher that matches the pattern parsed from the given string,
    * parser method and visitor method. There is also a given wildcard prefix.
    * 
-   * @param <RuleType>     The type of the parser rule context
+   * @param <C>            The type of the parser rule context
    * @param input          The string to parse
    * @param parseMethod    The parser method to use
    * @param visitMethod    The build visitor method to use
    * @param wildcardPrefix The wildcard prefix
    */
-  public <RuleType extends ParserRuleContext> Matcher(String input,
-      Function<GLSLParser, RuleType> parseMethod,
-      BiFunction<ASTBuilder, RuleType, T> visitMethod,
+  public <C extends ParserRuleContext> Matcher(String input,
+      Function<GLSLParser, C> parseMethod,
+      BiFunction<ASTBuilder, C, N> visitMethod,
       String wildcardPrefix) {
     this(ASTBuilder.build(
         EnhancedParser.getInternalInstance().parse(input, parseMethod),
@@ -81,29 +81,29 @@ public <RuleType extends ParserRuleContext> Matcher(String input,
    * Creates a new matcher that matches the pattern parsed from the given string,
    * parser method and visitor method. There is no wildcard prefix.
    * 
-   * @param <RuleType>  The type of the parser rule context
+   * @param <C>         The type of the parser rule context
    * @param input       The string to parse
    * @param parseMethod The parser method to use
    * @param visitMethod The build visitor method to use
    */
-  public <RuleType extends ParserRuleContext> Matcher(String input,
-      Function<GLSLParser, RuleType> parseMethod,
-      BiFunction<ASTBuilder, RuleType, T> visitMethod) {
+  public <C extends ParserRuleContext> Matcher(String input,
+      Function<GLSLParser, C> parseMethod,
+      BiFunction<ASTBuilder, C, N> visitMethod) {
     this(input, parseMethod, visitMethod, null);
   }
 
-  public Matcher(String input, Function<String, T> patternParser, String wildcardPrefix) {
+  public Matcher(String input, Function<String, N> patternParser, String wildcardPrefix) {
     this(patternParser.apply(input), wildcardPrefix);
   }
 
-  public Matcher(String input, Function<String, T> patternParser) {
+  public Matcher(String input, Function<String, N> patternParser) {
     this(input, patternParser, null);
   }
 
-  private static <RuleType extends ParserRuleContext, ReturnType extends ASTNode> Function<String, ReturnType> makePatternParser(
-      Class<RuleType> ruleType,
-      Function<GLSLParser, RuleType> parseMethod,
-      BiFunction<ASTBuilder, RuleType, ReturnType> visitMethod) {
+  private static <C extends ParserRuleContext, N extends ASTNode> Function<String, N> makePatternParser(
+      Class<C> ruleType,
+      Function<GLSLParser, C> parseMethod,
+      BiFunction<ASTBuilder, C, N> visitMethod) {
     return input -> ASTParser.getInternalInstance().parseNodeSeparate(input, ruleType, parseMethod, visitMethod);
   }
 
@@ -249,7 +249,7 @@ public void visitVoidData(Object data) {
    * @param tree The tree to match
    * @return True if the tree matches the pattern, false otherwise
    */
-  public boolean matches(T tree) {
+  public boolean matches(N tree) {
     if (tree == null) {
       return false;
     }
@@ -277,7 +277,7 @@ private void ensureMatchMaps() {
    * @param tree The tree to match
    * @return True if the tree matches the pattern, false otherwise
    */
-  public boolean matchesExtract(T tree) {
+  public boolean matchesExtract(N tree) {
     ensureMatchMaps();
     dataMatches.clear();
     nodeMatches.clear();
@@ -301,7 +301,7 @@ public boolean matchesExtract(T tree) {
    * @return
    */
   public boolean matchesExtract(
-      T tree,
+      N tree,
       Map<String, Object> dataMatches,
       Map<String, ASTNode> nodeMatches) {
     this.dataMatches = dataMatches;
@@ -364,19 +364,19 @@ public ASTNode getNodeMatch(String name) {
   /**
    * Gets a node match with the given name if it is available as the given class.
    * 
-   * @param <R>  The type of the node match
+   * @param <NN> The type of the node match
    * @param name The name of the node match
    * @param type The class of the node match
    * @return The node match or null if not found or not of the given class
    */
-  public <R extends ASTNode> R getNodeMatch(String name, Class<R> type) {
+  public <NN extends ASTNode> NN getNodeMatch(String name, Class<NN> type) {
     var result = nodeMatches.get(name);
     return type.isInstance(result) ? type.cast(result) : null;
   }
 
   @SuppressWarnings("unchecked")
-  public Class<? extends T> getPatternClass() {
-    return (Class<? extends T>) pattern.getClass();
+  public Class<? extends N> getPatternClass() {
+    return (Class<? extends N>) pattern.getClass();
   }
 
   private void ensureWildcardMap() {
@@ -496,11 +496,11 @@ public void markClassWildcard(
     nodeWildcards.put(patternNode, new ClassWildcard(name, patternNode.getClass()));
   }
 
-  private static class ClassedPredicateWildcard<T extends ASTNode> extends NodeWildcard {
-    final Class<T> type;
-    final Predicate<T> predicate;
+  private static class ClassedPredicateWildcard<N extends ASTNode> extends NodeWildcard {
+    final Class<N> type;
+    final Predicate<N> predicate;
 
-    ClassedPredicateWildcard(String name, Class<T> type, Predicate<T> predicate) {
+    ClassedPredicateWildcard(String name, Class<N> type, Predicate<N> predicate) {
       super(name);
       this.type = type;
       this.predicate = predicate;
@@ -517,17 +517,17 @@ public boolean test(ASTNode node) {
    * wildcard will match any node in the same position in the tree that is an
    * instance of the given class and matches the predicate.
    * 
-   * @param <R>         The type of the node match
+   * @param <NN>        The type of the node match
    * @param name        The name of the wildcard
    * @param patternNode The node to mark as a classed predicate wildcard
    * @param type        The class to match the node with
    * @param predicate   The predicate to match the node with
    */
-  public <R extends ASTNode> void markClassedPredicateWildcard(
+  public <NN extends ASTNode> void markClassedPredicateWildcard(
       String name,
       ASTNode patternNode,
-      Class<R> type,
-      Predicate<R> predicate) {
+      Class<NN> type,
+      Predicate<NN> predicate) {
     markWildcard(patternNode, new ClassedPredicateWildcard<>(name, type, predicate));
   }
 }
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTBuilder.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTBuilder.java
index edec12ee..f08eed60 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTBuilder.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTBuilder.java
@@ -73,22 +73,22 @@ public static ASTNode build(Root rootInstance, ParseTree ctx) {
   /**
    * Builds an AST of a specific type from the given parse tree with a new root.
    * 
-   * @param <TreeType>   The type of the parse tree
-   * @param <ReturnType> The type of the AST node
-   * @param ctx          The parse tree
-   * @param visitMethod  The build method reference to this class
+   * @param <T>         The type of the parse tree
+   * @param <N>         The type of the AST node
+   * @param ctx         The parse tree
+   * @param visitMethod The build method reference to this class
    * @return The built AST
    */
-  public static <TreeType extends ParseTree, ReturnType extends ASTNode> ReturnType build(
-      TreeType ctx,
-      BiFunction<ASTBuilder, TreeType, ReturnType> visitMethod) {
+  public static <T extends ParseTree, N extends ASTNode> N build(
+      T ctx,
+      BiFunction<ASTBuilder, T, N> visitMethod) {
     return Root.indexNodes(() -> buildInternal(ctx, visitMethod));
   }
 
-  public static <TreeType extends ParseTree, ReturnType extends ASTNode> ReturnType build(
+  public static <T extends ParseTree, N extends ASTNode> N build(
       Root rootInstance,
-      TreeType ctx,
-      BiFunction<ASTBuilder, TreeType, ReturnType> visitMethod) {
+      T ctx,
+      BiFunction<ASTBuilder, T, N> visitMethod) {
     return Root.indexNodes(rootInstance, () -> buildInternal(ctx, visitMethod));
   }
 
@@ -107,17 +107,17 @@ public static ASTNode buildSubtree(ASTNode parentTreeMember, ParseTree ctx) {
    * Builds a subtree of a specific type that has the same root as the given AST
    * node.
    * 
-   * @param <TreeType>       The type of the parse tree
-   * @param <ReturnType>     The type of the AST node
+   * @param <T>              The type of the parse tree
+   * @param <N>              The type of the AST node
    * @param parentTreeMember The parent tree member
    * @param ctx              The parse tree
    * @param visitMethod      The build method reference to this class
    * @return The built AST
    */
-  public static <TreeType extends ParseTree, ReturnType extends ASTNode> ReturnType buildSubtree(
+  public static <T extends ParseTree, N extends ASTNode> N buildSubtree(
       ASTNode parentTreeMember,
-      TreeType ctx,
-      BiFunction<ASTBuilder, TreeType, ReturnType> visitMethod) {
+      T ctx,
+      BiFunction<ASTBuilder, T, N> visitMethod) {
     return Root.indexNodes(parentTreeMember, () -> buildInternal(ctx, visitMethod));
   }
 
@@ -125,9 +125,9 @@ private static ASTNode buildInternal(ParseTree ctx) {
     return new ASTBuilder().visit(ctx);
   }
 
-  private static <TreeType extends ParseTree, ReturnType extends ASTNode> ReturnType buildInternal(
-      TreeType ctx,
-      BiFunction<ASTBuilder, TreeType, ReturnType> visitMethod) {
+  private static <T extends ParseTree, N extends ASTNode> N buildInternal(
+      T ctx,
+      BiFunction<ASTBuilder, T, N> visitMethod) {
     return visitMethod.apply(new ASTBuilder(), ctx);
   }
 
@@ -154,10 +154,10 @@ private static void endConstruction() {
     sourceLineStack.pop();
   }
 
-  private static <R extends ASTNode> R constructSimple(
-      ParseTree ctx, Supplier<R> constructor) {
+  private static <N extends ASTNode> N constructSimple(
+      ParseTree ctx, Supplier<N> constructor) {
     startConstruction(ctx);
-    var result = constructor.get();
+    N result = constructor.get();
     endConstruction();
     return result;
   }
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTParser.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTParser.java
index eb577154..9af1c8ae 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTParser.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTParser.java
@@ -112,12 +112,12 @@ public void setTokenFilter(TokenFilter<?> setTokenFilter) {
   }
 
   @SuppressWarnings("unchecked") // consistent use of the cache results in the same type
-  public <RuleType extends ParserRuleContext, ReturnType extends ASTNode> ReturnType parseNode(
+  public <C extends ParserRuleContext, N extends ASTNode> N parseNode(
       String input,
       ASTNode parentTreeMember,
-      Class<RuleType> ruleType,
-      Function<GLSLParser, RuleType> parseMethod,
-      BiFunction<ASTBuilder, RuleType, ReturnType> visitMethod) throws RecognitionException {
+      Class<C> ruleType,
+      Function<GLSLParser, C> parseMethod,
+      BiFunction<ASTBuilder, C, N> visitMethod) throws RecognitionException {
     if (ruleType == TranslationUnitContext.class) {
       throw new IllegalArgumentException("Translation units may not be parsed into another node, that makes no sense.");
     }
@@ -126,24 +126,24 @@ public <RuleType extends ParserRuleContext, ReturnType extends ASTNode> ReturnTy
       return ASTBuilder.buildSubtree(parentTreeMember, parser.parse(input, ruleType, parseMethod), visitMethod);
     } else {
       // cache and possibly build, always clone to return new trees
-      return (ReturnType) buildCache.cachedGet(input, ruleType,
+      return (N) buildCache.cachedGet(input, ruleType,
           () -> ASTBuilder.build(new EmptyRoot(), parser.parse(input, ruleType, parseMethod), visitMethod))
           .cloneInto(parentTreeMember);
     }
   }
 
   @SuppressWarnings("unchecked") // consistent use of the cache results in the same type
-  public <RuleType extends ParserRuleContext, ReturnType extends ASTNode> ReturnType parseNodeSeparate(
+  public <C extends ParserRuleContext, N extends ASTNode> N parseNodeSeparate(
       String input,
-      Class<RuleType> ruleType,
-      Function<GLSLParser, RuleType> parseMethod,
-      BiFunction<ASTBuilder, RuleType, ReturnType> visitMethod) throws RecognitionException {
+      Class<C> ruleType,
+      Function<GLSLParser, C> parseMethod,
+      BiFunction<ASTBuilder, C, N> visitMethod) throws RecognitionException {
     if (astCacheStrategy == ASTCacheStrategy.NONE
         || astCacheStrategy == ASTCacheStrategy.ALL_EXCLUDING_TRANSLATION_UNIT
             && ruleType == TranslationUnitContext.class) {
       return ASTBuilder.build(parser.parse(input, ruleType, parseMethod), visitMethod);
     } else {
-      return (ReturnType) buildCache.cachedGet(input, ruleType,
+      return (N) buildCache.cachedGet(input, ruleType,
           () -> ASTBuilder.build(new EmptyRoot(), parser.parse(input, ruleType, parseMethod), visitMethod))
           .cloneSeparate();
     }
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTTransformer.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTTransformer.java
index 1de7b793..36cce1bf 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTTransformer.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTTransformer.java
@@ -8,19 +8,19 @@
  * the same kind of output. The implementations of this class determine how it
  * works in detail.
  */
-public abstract class ASTTransformer<T extends JobParameters, V> extends ASTParser
-    implements ParameterizedTransformer<T, V> {
-  private T jobParameters;
+public abstract class ASTTransformer<J extends JobParameters, V> extends ASTParser
+    implements ParameterizedTransformer<J, V> {
+  private J jobParameters;
   private static final PrintType defaultPrintType = PrintType.COMPACT;
   private PrintType printType = defaultPrintType;
 
   @Override
-  public T getJobParameters() {
+  public J getJobParameters() {
     return jobParameters;
   }
 
   @Override
-  public void setJobParameters(T parameters) {
+  public void setJobParameters(J parameters) {
     jobParameters = parameters;
   }
 
@@ -28,7 +28,7 @@ public void setJobParameters(T parameters) {
   @SuppressWarnings("unchecked")
   public void setTokenFilter(TokenFilter<?> tokenFilter) {
     super.setTokenFilter(tokenFilter);
-    ((TokenFilter<T>) tokenFilter).setJobParametersSupplier(this::getJobParameters);
+    ((TokenFilter<J>) tokenFilter).setJobParametersSupplier(this::getJobParameters);
   }
 
   public void setPrintType(PrintType printType) {
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/EnumASTTransformer.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/EnumASTTransformer.java
index a1d9a91d..2e44ab6b 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/EnumASTTransformer.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/EnumASTTransformer.java
@@ -5,8 +5,8 @@
 
 import io.github.douira.glsl_transformer.ast.node.TranslationUnit;
 
-public class EnumASTTransformer<T extends JobParameters, E extends Enum<E>>
-    extends GroupedASTTransformer<T, E, EnumMap<E, String>, EnumMap<E, TranslationUnit>> {
+public class EnumASTTransformer<J extends JobParameters, E extends Enum<E>>
+    extends GroupedASTTransformer<J, E, EnumMap<E, String>, EnumMap<E, TranslationUnit>> {
   public EnumASTTransformer(Consumer<EnumMap<E, TranslationUnit>> transformation, Class<E> enumClass) {
     super(transformation, () -> new EnumMap<>(enumClass), () -> new EnumMap<>(enumClass));
   }
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/GroupedASTTransformer.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/GroupedASTTransformer.java
index 24716c69..d0ef7d71 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/GroupedASTTransformer.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/GroupedASTTransformer.java
@@ -11,8 +11,8 @@
 /**
  * The grouped AST transformer parses multiple strings stored in an arbitrarily
  */
-public class GroupedASTTransformer<T extends JobParameters, K, M extends Map<K, String>, N extends Map<K, TranslationUnit>>
-    extends ASTTransformer<T, Map<K, String>> {
+public class GroupedASTTransformer<J extends JobParameters, K, M extends Map<K, String>, N extends Map<K, TranslationUnit>>
+    extends ASTTransformer<J, Map<K, String>> {
   private Consumer<N> transformation;
   private Supplier<N> tuMapSupplier;
   private Supplier<M> resultMapSupplier;
@@ -34,7 +34,7 @@ public GroupedASTTransformer(
   }
 
   public GroupedASTTransformer(
-      BiConsumer<N, T> transformation,
+      BiConsumer<N, J> transformation,
       Supplier<N> tuMapSupplier,
       Supplier<M> resultMapSupplier) {
     setTransformation(transformation);
@@ -53,7 +53,7 @@ public void setTransformation(Consumer<N> transformation) {
     this.transformation = transformation;
   }
 
-  public void setTransformation(BiConsumer<N, T> transformation) {
+  public void setTransformation(BiConsumer<N, J> transformation) {
     this.transformation = trees -> transformation.accept(trees, getJobParameters());
   }
 
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ParameterHolder.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ParameterHolder.java
index 144fd1cf..5307ae56 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ParameterHolder.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ParameterHolder.java
@@ -2,10 +2,10 @@
 
 import java.util.function.Supplier;
 
-public interface ParameterHolder<T> {
-  T getJobParameters();
+public interface ParameterHolder<J> {
+  J getJobParameters();
 
-  void setJobParameters(T parameters);
+  void setJobParameters(J parameters);
 
   /**
    * Runs a function with job parameters available set in the context.
@@ -16,7 +16,7 @@ public interface ParameterHolder<T> {
    *                   job parameters
    * @return The value returned by the supplier function
    */
-  default <R> R withJobParameters(T parameters, Supplier<R> run) {
+  default <R> R withJobParameters(J parameters, Supplier<R> run) {
     setJobParameters(parameters);
     var value = run.get();
     setJobParameters(null);
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ParameterizedTransformer.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ParameterizedTransformer.java
index e61ce05b..ef849a1f 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ParameterizedTransformer.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ParameterizedTransformer.java
@@ -2,8 +2,8 @@
 
 import org.antlr.v4.runtime.RecognitionException;
 
-public interface ParameterizedTransformer<T, V> extends ParameterHolder<T>, Transformer<V> {
-  default V transform(V str, T parameters) throws RecognitionException {
+public interface ParameterizedTransformer<J, V> extends ParameterHolder<J>, Transformer<V> {
+  default V transform(V str, J parameters) throws RecognitionException {
     return withJobParameters(parameters, () -> transform(str));
   }
 }
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/SingleASTTransformer.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/SingleASTTransformer.java
index 1e45293c..1bd71ed0 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/SingleASTTransformer.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/SingleASTTransformer.java
@@ -13,7 +13,7 @@
  * The AST transformer takes parses a string, turns it into an AST, transforms
  * it with the given transformation and then prints it back.
  */
-public class SingleASTTransformer<T extends JobParameters> extends ASTTransformer<T, String> {
+public class SingleASTTransformer<J extends JobParameters> extends ASTTransformer<J, String> {
   public static final Consumer<TranslationUnit> IDENTITY_TRANSFORMATION = (tu) -> {
   };
 
@@ -32,7 +32,7 @@ public SingleASTTransformer(BiConsumer<TranslationUnit, Root> transformation) {
     setTransformation(transformation);
   }
 
-  public SingleASTTransformer(TriConsumer<TranslationUnit, Root, T> transformation) {
+  public SingleASTTransformer(TriConsumer<TranslationUnit, Root, J> transformation) {
     super();
     setTransformation(transformation);
   }
@@ -45,7 +45,7 @@ public void setTransformation(BiConsumer<TranslationUnit, Root> transformation)
     this.transformation = wrapTransformation(this, transformation);
   }
 
-  public void setTransformation(TriConsumer<TranslationUnit, Root, T> transformation) {
+  public void setTransformation(TriConsumer<TranslationUnit, Root, J> transformation) {
     this.transformation = wrapTransformation(this, transformation);
   }
 
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/Template.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/Template.java
index 3e4ac190..5f1c6027 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/Template.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/Template.java
@@ -9,17 +9,17 @@
 import io.github.douira.glsl_transformer.ast.node.statement.Statement;
 import io.github.douira.glsl_transformer.ast.query.Root;
 
-public class Template<T extends ASTNode> {
+public class Template<N extends ASTNode> {
   private final Map<ASTNode, Supplier<ASTNode>> replacements = new HashMap<>();
   private int localReplacementsMarked = 0;
   private List<ASTNode> localReplacements = Collections.emptyList();
-  protected final T source;
+  protected final N source;
 
-  public Template(T source) {
+  public Template(N source) {
     this.source = source;
   }
 
-  public T getSource() {
+  public N getSource() {
     return source;
   }
 
@@ -35,18 +35,18 @@ public <R> R getReplacement(R original) {
   }
 
   @SuppressWarnings("unchecked") // all ASTNodes clone themselves with the right type
-  public T getSeparateInstance() {
-    return (T) source.cloneSeparate();
+  public N getSeparateInstance() {
+    return (N) source.cloneSeparate();
   }
 
   @SuppressWarnings("unchecked") // all ASTNodes clone themselves with the right type
-  public T getInstanceFor(Root root) {
-    return (T) source.cloneInto(root);
+  public N getInstanceFor(Root root) {
+    return (N) source.cloneInto(root);
   }
 
   @SuppressWarnings("unchecked") // all ASTNodes clone themselves with the right type
-  public T getInstanceFor(ASTNode treeMember) {
-    return (T) source.cloneInto(treeMember);
+  public N getInstanceFor(ASTNode treeMember) {
+    return (N) source.cloneInto(treeMember);
   }
 
   public void supplyLocalReplacements(List<ASTNode> replacements) {
@@ -68,47 +68,47 @@ public void supplyLocalReplacements(ASTNode... replacements) {
     supplyLocalReplacements(Arrays.asList(replacements));
   }
 
-  public T getSeparateInstance(List<ASTNode> localReplacements) {
+  public N getSeparateInstance(List<ASTNode> localReplacements) {
     supplyLocalReplacements(localReplacements);
     return getSeparateInstance();
   }
 
-  public T getInstanceFor(Root root, List<ASTNode> localReplacements) {
+  public N getInstanceFor(Root root, List<ASTNode> localReplacements) {
     supplyLocalReplacements(localReplacements);
     return getInstanceFor(root);
   }
 
-  public T getInstanceFor(ASTNode treeMember, List<ASTNode> localReplacements) {
+  public N getInstanceFor(ASTNode treeMember, List<ASTNode> localReplacements) {
     supplyLocalReplacements(localReplacements);
     return getInstanceFor(treeMember);
   }
 
-  public T getSeparateInstance(ASTNode localReplacement) {
+  public N getSeparateInstance(ASTNode localReplacement) {
     supplyLocalReplacements(localReplacement);
     return getSeparateInstance();
   }
 
-  public T getInstanceFor(Root root, ASTNode localReplacement) {
+  public N getInstanceFor(Root root, ASTNode localReplacement) {
     supplyLocalReplacements(localReplacement);
     return getInstanceFor(root);
   }
 
-  public T getInstanceFor(ASTNode treeMember, ASTNode localReplacement) {
+  public N getInstanceFor(ASTNode treeMember, ASTNode localReplacement) {
     supplyLocalReplacements(localReplacement);
     return getInstanceFor(treeMember);
   }
 
-  public T getSeparateInstance(ASTNode... localReplacements) {
+  public N getSeparateInstance(ASTNode... localReplacements) {
     supplyLocalReplacements(localReplacements);
     return getSeparateInstance();
   }
 
-  public T getInstanceFor(Root root, ASTNode... localReplacements) {
+  public N getInstanceFor(Root root, ASTNode... localReplacements) {
     supplyLocalReplacements(localReplacements);
     return getInstanceFor(root);
   }
 
-  public T getInstanceFor(ASTNode treeMember, ASTNode... localReplacements) {
+  public N getInstanceFor(ASTNode treeMember, ASTNode... localReplacements) {
     supplyLocalReplacements(localReplacements);
     return getInstanceFor(treeMember);
   }
@@ -138,13 +138,13 @@ public void markReplacement(ASTNode original, Supplier<ASTNode> replacement) {
   }
 
   @SuppressWarnings("unchecked")
-  public <R extends ASTNode> void markReplacement(String tag, Class<R> type, Supplier<R> replacement) {
+  public <NN extends ASTNode> void markReplacement(String tag, Class<NN> type, Supplier<NN> replacement) {
     markReplacement(source.getRoot().identifierIndex.getOne(tag).getAncestor(type), (Supplier<ASTNode>) replacement);
   }
 
   @SuppressWarnings("unchecked") // all ASTNodes clone themselves with the right type
-  public static <T extends ASTNode> Template<T> ofCloned(T source) {
-    return new Template<T>((T) source.cloneSeparate());
+  public static <N extends ASTNode> Template<N> ofCloned(N source) {
+    return new Template<N>((N) source.cloneSeparate());
   }
 
   public static Template<ExternalDeclaration> withExternalDeclaration(String input) {
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriASTTransformer.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriASTTransformer.java
index ec8ec474..5aa6436e 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriASTTransformer.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriASTTransformer.java
@@ -8,7 +8,7 @@
 import io.github.douira.glsl_transformer.ast.node.TranslationUnit;
 import io.github.douira.glsl_transformer.util.*;
 
-public class TriASTTransformer<T extends JobParameters, E extends Enum<E>> extends EnumASTTransformer<T, E> {
+public class TriASTTransformer<J extends JobParameters, E extends Enum<E>> extends EnumASTTransformer<J, E> {
   private final E aType, bType, cType;
   private final Class<E> enumClass;
 
@@ -54,7 +54,7 @@ public TriASTTransformer(
   }
 
   public TriASTTransformer(
-      TriFullTransformation<TranslationUnit, T> transformation,
+      TriFullTransformation<TranslationUnit, J> transformation,
       Class<E> enumClass,
       E aType,
       E bType,
@@ -79,7 +79,7 @@ public void setTransformation(TriRootOnlyTransformation<TranslationUnit> transfo
     });
   }
 
-  public void setTransformation(TriFullTransformation<TranslationUnit, T> transformation) {
+  public void setTransformation(TriFullTransformation<TranslationUnit, J> transformation) {
     super.setTransformation(map -> {
       final var a = map.get(aType);
       final var b = map.get(bType);
@@ -106,7 +106,7 @@ public EnumMap<E, String> transform(String a, String b, String c)
     return transform(items);
   }
 
-  public EnumMap<E, String> transform(String a, String b, String c, T parameters)
+  public EnumMap<E, String> transform(String a, String b, String c, J parameters)
       throws RecognitionException {
     return withJobParameters(parameters, () -> transform(a, b, c));
   }
@@ -116,7 +116,7 @@ public Triple<String> transform(Triple<String> str) throws RecognitionException
     return new Triple<>(result.get(aType), result.get(bType), result.get(cType));
   }
 
-  public Triple<String> transform(Triple<String> str, T parameters) throws RecognitionException {
+  public Triple<String> transform(Triple<String> str, J parameters) throws RecognitionException {
     return withJobParameters(parameters, () -> transform(str));
   }
 }
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriFullTransformation.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriFullTransformation.java
index 45aecc8d..1237dccf 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriFullTransformation.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriFullTransformation.java
@@ -4,6 +4,6 @@
 import io.github.douira.glsl_transformer.ast.query.Root;
 
 @FunctionalInterface
-public interface TriFullTransformation<A extends ASTNode, T extends JobParameters> {
-  void accept(A a, A b, A c, Root rootA, Root rootB, Root rootC, T jobParameters);
+public interface TriFullTransformation<N extends ASTNode, J extends JobParameters> {
+  void accept(N a, N b, N c, Root rootA, Root rootB, Root rootC, J jobParameters);
 }
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriRootOnlyTransformation.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriRootOnlyTransformation.java
index 1a5cc864..e8f3b7f5 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriRootOnlyTransformation.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriRootOnlyTransformation.java
@@ -4,6 +4,6 @@
 import io.github.douira.glsl_transformer.ast.query.Root;
 
 @FunctionalInterface
-public interface TriRootOnlyTransformation<A extends ASTNode> {
-  void accept(A a, A b, A c, Root rootA, Root rootB, Root rootC);
+public interface TriRootOnlyTransformation<N extends ASTNode> {
+  void accept(N a, N b, N c, Root rootA, Root rootB, Root rootC);
 }
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/traversal/ASTListenerVisitor.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/traversal/ASTListenerVisitor.java
index 86b016c3..69583bcc 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/traversal/ASTListenerVisitor.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/traversal/ASTListenerVisitor.java
@@ -7,8 +7,8 @@ public ASTListenerVisitor() {
     this.listener = this;
   }
 
-  public static <T> T walkAndListen(ASTNode node) {
-    return new ASTListenerVisitor<T>().visit(node);
+  public static <R> R walkAndListen(ASTNode node) {
+    return new ASTListenerVisitor<R>().visit(node);
   }
 
   @Override
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/traversal/ASTWalker.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/traversal/ASTWalker.java
index af16f8b5..ddb94a25 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/traversal/ASTWalker.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/traversal/ASTWalker.java
@@ -12,8 +12,8 @@ private ASTWalker(ASTListener listener) {
     this.listener = listener;
   }
 
-  public static <T> T walk(ASTListener listener, ASTNode node) {
-    return new ASTWalker<T>(listener).startVisit(node);
+  public static <R> R walk(ASTListener listener, ASTNode node) {
+    return new ASTWalker<R>(listener).startVisit(node);
   }
 
   @Override
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/parser/CachingParser.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/parser/CachingParser.java
index 59b4f72f..bab3564f 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/parser/CachingParser.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/parser/CachingParser.java
@@ -48,21 +48,21 @@ public TranslationUnitContext parse(String str) {
   }
 
   @Override
-  public <RuleType extends ParserRuleContext> RuleType parse(
+  public <C extends ParserRuleContext> C parse(
       String str,
-      Class<RuleType> ruleType,
-      Function<GLSLParser, RuleType> parseMethod) {
+      Class<C> ruleType,
+      Function<GLSLParser, C> parseMethod) {
     return parse(str, null, ruleType, parseMethod);
   }
 
   @Override
   @SuppressWarnings("unchecked")
-  public <RuleType extends ParserRuleContext> RuleType parse(
+  public <C extends ParserRuleContext> C parse(
       String str,
       ParserRuleContext parent,
-      Class<RuleType> ruleType,
-      Function<GLSLParser, RuleType> parseMethod) {
-    return (RuleType) parseCache.cachedGet(str, ruleType,
+      Class<C> ruleType,
+      Function<GLSLParser, C> parseMethod) {
+    return (C) parseCache.cachedGet(str, ruleType,
         () -> parse(str, parent, parseMethod));
   }
 
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/parser/EnhancedParser.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/parser/EnhancedParser.java
index a5124ebc..9655d947 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/parser/EnhancedParser.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/parser/EnhancedParser.java
@@ -201,45 +201,45 @@ public TranslationUnitContext parse(String str) {
   /**
    * Parses a string using a parser method reference into a parse tree.
    * 
-   * @param <RuleType>  The type of the resulting parsed node
+   * @param <C>         The type of the resulting parsed node
    * @param str         The string to parse
    * @param parseMethod The parser method reference to use for parsing
    * @return The parsed string as a parse tree that has the given type
    */
-  public <RuleType extends ParserRuleContext> RuleType parse(
+  public <C extends ParserRuleContext> C parse(
       String str,
-      Function<GLSLParser, RuleType> parseMethod) {
+      Function<GLSLParser, C> parseMethod) {
     return parse(str, (ParserRuleContext) null, parseMethod);
   }
 
-  public <RuleType extends ParserRuleContext> RuleType parse(
+  public <C extends ParserRuleContext> C parse(
       String str,
-      Class<RuleType> ruleType,
-      Function<GLSLParser, RuleType> parseMethod) {
+      Class<C> ruleType,
+      Function<GLSLParser, C> parseMethod) {
     return parse(str, (ParserRuleContext) null, parseMethod);
   }
 
   /**
    * Parses a string using a parser method reference into a parse tree.
    * 
-   * @param <RuleType>  The type of the resulting parsed node
+   * @param <C>         The type of the resulting parsed node
    * @param str         The string to parse
    * @param parent      The parent to attach to the parsed node
    * @param parseMethod The parser method reference to use for parsing
    * @return The parsed string as a parse tree that has the given type
    */
-  public <RuleType extends ParserRuleContext> RuleType parse(
+  public <C extends ParserRuleContext> C parse(
       String str,
       ParserRuleContext parent,
-      Function<GLSLParser, RuleType> parseMethod) {
+      Function<GLSLParser, C> parseMethod) {
     return parse(CharStreams.fromString(str), parent, parseMethod);
   }
 
-  public <RuleType extends ParserRuleContext> RuleType parse(
+  public <C extends ParserRuleContext> C parse(
       String str,
       ParserRuleContext parent,
-      Class<RuleType> ruleType,
-      Function<GLSLParser, RuleType> parseMethod) {
+      Class<C> ruleType,
+      Function<GLSLParser, C> parseMethod) {
     return parse(CharStreams.fromString(str), parent, parseMethod);
   }
 
@@ -248,16 +248,16 @@ public <RuleType extends ParserRuleContext> RuleType parse(
    * reference into a parse tree. This method exists so non-string streams can
    * also be parsed.
    * 
-   * @param <RuleType>  The type of the resulting parsed node
+   * @param <C>         The type of the resulting parsed node
    * @param stream      The int stream to parse
    * @param parent      The parent to attach to the parsed node
    * @param parseMethod The parser method reference to use for parsing
    * @return The parsed string as a parse tree that has the given type
    */
-  private <RuleType extends ParserRuleContext> RuleType parse(
+  private <C extends ParserRuleContext> C parse(
       IntStream stream,
       ParserRuleContext parent,
-      Function<GLSLParser, RuleType> parseMethod) {
+      Function<GLSLParser, C> parseMethod) {
     // setup lexer
     input = stream;
     lexer.setInputStream(input);
@@ -274,7 +274,7 @@ private <RuleType extends ParserRuleContext> RuleType parse(
     parser.setTokenStream(tokenStream);
     parser.reset();
 
-    RuleType node;
+    C node;
     if (parsingStrategy == ParsingStrategy.SLL_AND_LL_ON_ERROR) {
       // never throw SLL errors
       parser.removeErrorListener(ThrowingErrorListener.INSTANCE);
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/ChannelFilter.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/ChannelFilter.java
index d86c5894..c10158a8 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/ChannelFilter.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/ChannelFilter.java
@@ -10,7 +10,7 @@
  * The channel filter accepts all tokens that are not from a lexer channel that
  * is on the given list of disallowed channels.
  */
-public class ChannelFilter<T extends JobParameters> extends TokenFilter<T> {
+public class ChannelFilter<J extends JobParameters> extends TokenFilter<J> {
   private final EnumSet<TokenChannel> disallowedChannels;
 
   /**
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/MultiFilter.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/MultiFilter.java
index 08452c8d..17e0e6a6 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/MultiFilter.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/MultiFilter.java
@@ -18,8 +18,8 @@
  * filter has disallowed it. Since filters can have state, it can be desirerable
  * to notify all of them of all tokens.
  */
-public class MultiFilter<T extends JobParameters> extends TokenFilter<T> {
-  private Collection<TokenFilter<T>> subfilters;
+public class MultiFilter<J extends JobParameters> extends TokenFilter<J> {
+  private Collection<TokenFilter<J>> subfilters;
 
   /**
    * If this is true, then it will require all filters to allow a token for it to
@@ -44,7 +44,7 @@ public class MultiFilter<T extends JobParameters> extends TokenFilter<T> {
    * @param conjunction  The conjunction flag state
    * @param shortCircuit The short circuit flag state
    */
-  public MultiFilter(Collection<TokenFilter<T>> subfilters, boolean conjunction, boolean shortCircuit) {
+  public MultiFilter(Collection<TokenFilter<J>> subfilters, boolean conjunction, boolean shortCircuit) {
     this(subfilters);
     this.conjunction = conjunction;
     this.shortCircuit = shortCircuit;
@@ -104,7 +104,7 @@ public MultiFilter() {
    * 
    * @param subfilters The subfilters to add initially
    */
-  public MultiFilter(Collection<? extends TokenFilter<T>> subfilters) {
+  public MultiFilter(Collection<? extends TokenFilter<J>> subfilters) {
     this.subfilters = new ArrayList<>(subfilters);
   }
 
@@ -132,7 +132,7 @@ public void setShortCircuit(boolean shortCircuit) {
    * @param filter The filter to add
    * @return {@code true} if the underlying collection changed
    */
-  public boolean add(TokenFilter<T> filter) {
+  public boolean add(TokenFilter<J> filter) {
     return subfilters.add(filter);
   }
 
@@ -142,7 +142,7 @@ public boolean add(TokenFilter<T> filter) {
    * @param newSubfilters The filters to add
    * @return {@code true} if the underlying collection changed
    */
-  public boolean addAll(Collection<? extends TokenFilter<T>> newSubfilters) {
+  public boolean addAll(Collection<? extends TokenFilter<J>> newSubfilters) {
     return subfilters.addAll(newSubfilters);
   }
 
@@ -153,7 +153,7 @@ public boolean addAll(Collection<? extends TokenFilter<T>> newSubfilters) {
    * @param other The other multi filter to take subfilters from
    * @return {@code true} if the underlying collection changed
    */
-  public boolean addAll(MultiFilter<T> other) {
+  public boolean addAll(MultiFilter<J> other) {
     return addAll(other.subfilters);
   }
 
@@ -161,8 +161,8 @@ public boolean addAll(MultiFilter<T> other) {
    * Creates a shallow clone of this multi filter. It copies over the collection
    * of subfilters shallowly and copies the settings.
    */
-  public MultiFilter<T> clone() {
-    return new MultiFilter<T>(subfilters, conjunction, shortCircuit);
+  public MultiFilter<J> clone() {
+    return new MultiFilter<J>(subfilters, conjunction, shortCircuit);
   }
 
   @Override
@@ -174,7 +174,7 @@ public void resetState() {
   }
 
   @Override
-  public void setJobParametersSupplier(Supplier<T> jobParametersSupplier) {
+  public void setJobParametersSupplier(Supplier<J> jobParametersSupplier) {
     super.setJobParametersSupplier(jobParametersSupplier);
     for (var filter : subfilters) {
       filter.setJobParametersSupplier(jobParametersSupplier);
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/NewlineFilter.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/NewlineFilter.java
index fc6b5934..8330a2a1 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/NewlineFilter.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/NewlineFilter.java
@@ -9,7 +9,7 @@
  * The newline filter filters out regular unnecessary newlines if there is more
  * than one.
  */
-public class NewlineFilter<T extends JobParameters> extends TokenFilter<T> {
+public class NewlineFilter<J extends JobParameters> extends TokenFilter<J> {
   private boolean lastWasNewline;
 
   @Override
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/StringFilter.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/StringFilter.java
index e1857550..ed94f6a9 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/StringFilter.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/StringFilter.java
@@ -11,7 +11,7 @@
  * The string token filter disallows tokens that are matched against a set of
  * disallowed strings.
  */
-public class StringFilter<T extends JobParameters> extends TokenFilter<T> {
+public class StringFilter<J extends JobParameters> extends TokenFilter<J> {
   private Set<String> disallowed;
 
   /**
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/TokenFilter.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/TokenFilter.java
index d7b89f6c..bce13e05 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/TokenFilter.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/token_filter/TokenFilter.java
@@ -10,8 +10,8 @@
  * A token filter is an object that can check if given tokens should be printed
  * or not.
  */
-public abstract class TokenFilter<T extends JobParameters> {
-  private Supplier<T> jobParametersSupplier;
+public abstract class TokenFilter<J extends JobParameters> {
+  private Supplier<J> jobParametersSupplier;
 
   /**
    * Checks if the token should be printed.
@@ -32,7 +32,7 @@ public void resetState() {
    * 
    * @param jobParametersSupplier The job parameters supplier
    */
-  public void setJobParametersSupplier(Supplier<T> jobParametersSupplier) {
+  public void setJobParametersSupplier(Supplier<J> jobParametersSupplier) {
     this.jobParametersSupplier = jobParametersSupplier;
   }
 
@@ -41,7 +41,7 @@ public void setJobParametersSupplier(Supplier<T> jobParametersSupplier) {
    * 
    * @return The job parameters
    */
-  protected T getJobParameters() {
+  protected J getJobParameters() {
     return jobParametersSupplier.get();
   }
 
@@ -54,20 +54,20 @@ protected T getJobParameters() {
    * If a multi filter is generated, the settings from the first multi filter in
    * the parameters are copied.
    * 
-   * @param <R> The job parameter type
+   * @param <J> The job parameter type
    * @param a   A token filter. May be {@code null}.
    * @param b   A token filter. May be {@code null}.
    * @return The joined token filter
    */
-  public static <R extends JobParameters> TokenFilter<R> join(TokenFilter<R> a, TokenFilter<R> b) {
+  public static <J extends JobParameters> TokenFilter<J> join(TokenFilter<J> a, TokenFilter<J> b) {
     if (a == null) {
       return b;
     } else if (b == null) {
       return a;
     } else if (MultiFilter.class.isInstance(b)) {
       if (MultiFilter.class.isInstance(a)) {
-        MultiFilter<R> bMulti = (MultiFilter<R>) b;
-        MultiFilter<R> aMulti = (MultiFilter<R>) a;
+        MultiFilter<J> bMulti = (MultiFilter<J>) b;
+        MultiFilter<J> aMulti = (MultiFilter<J>) a;
         var multi = aMulti.clone();
         multi.addAll(bMulti);
         return multi;
@@ -75,12 +75,12 @@ public static <R extends JobParameters> TokenFilter<R> join(TokenFilter<R> a, To
         return join(b, a);
       }
     } else if (MultiFilter.class.isInstance(a)) {
-      MultiFilter<R> aMulti = (MultiFilter<R>) a;
+      MultiFilter<J> aMulti = (MultiFilter<J>) a;
       var multi = aMulti.clone();
       multi.add(b);
       return multi;
     } else {
-      var multi = new MultiFilter<R>();
+      var multi = new MultiFilter<J>();
       multi.add(a);
       multi.add(b);
       return multi;
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/util/CompatUtil.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/util/CompatUtil.java
index 0125ed02..a0d694f8 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/util/CompatUtil.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/util/CompatUtil.java
@@ -40,24 +40,24 @@ public static String repeat(String str, int n) {
    * Creates a {@link java.util.HashSet} that contains the given items. The heap
    * pollution warning is suppressed as it is in {@link java.util.Arrays}.
    * 
-   * @param <T>   The type of the items
+   * @param <V>   The type of the items
    * @param items The items to add to the set
    * @return The set with the given items
    */
   @SafeVarargs
-  public static <T> Set<T> setOf(T... items) {
+  public static <V> Set<V> setOf(V... items) {
     return new HashSet<>(Arrays.asList(items));
   }
 
   /**
    * Creates a {@link java.util.HashSet} that contains the given item.
    * 
-   * @param <T>  The type of the item
+   * @param <V>  The type of the item
    * @param item The item to add to the set
    * @return The set with the given item
    */
-  public static <T> Set<T> setOf(T item) {
-    var set = new HashSet<T>();
+  public static <V> Set<V> setOf(V item) {
+    var set = new HashSet<V>();
     set.add(item);
     return set;
   }
@@ -65,13 +65,13 @@ public static <T> Set<T> setOf(T item) {
   /**
    * Creates a {@link java.util.HashSet} that contains the given items.
    * 
-   * @param <T>   The type of the items
+   * @param <V>   The type of the items
    * @param itemA The first item to add to the set
    * @param itemB The second item to add to the set
    * @return The set with the given items
    */
-  public static <T> Set<T> setOf(T itemA, T itemB) {
-    var set = new HashSet<T>();
+  public static <V> Set<V> setOf(V itemA, V itemB) {
+    var set = new HashSet<V>();
     set.add(itemA);
     set.add(itemB);
     return set;
@@ -82,12 +82,12 @@ public static <T> Set<T> setOf(T itemA, T itemB) {
    * same order. This is likely cheaper for making a collection than using
    * {@link #setOf(Object...)}.
    * 
-   * @param <T>   The type of the items
+   * @param <V>   The type of the items
    * @param items The items to create the list out of
    * @return The list with the given items
    */
   @SafeVarargs
-  public static <T> List<T> listOf(T... items) {
+  public static <V> List<V> listOf(V... items) {
     return Arrays.asList(items);
   }
 
@@ -125,7 +125,7 @@ public static <T> List<T> listOf(T... items) {
    * predicate for subsequent elements. For any given element an action may
    * be performed in whatever thread the library chooses.
    *
-   * @param <T>     the type of stream elements
+   * @param <V>     the type of stream elements
    * @param seed    the initial element
    * @param hasNext a predicate to apply to elements to determine when the
    *                stream must terminate.
@@ -134,20 +134,20 @@ public static <T> List<T> listOf(T... items) {
    * @return a new sequential {@code Stream}
    * @implNote The implementation was taken from the JDK 9 source code.
    */
-  public static <T> Stream<T> iterateStream(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
+  public static <V> Stream<V> iterateStream(V seed, Predicate<? super V> hasNext, UnaryOperator<V> next) {
     Objects.requireNonNull(next);
     Objects.requireNonNull(hasNext);
-    Spliterator<T> spliterator = new Spliterators.AbstractSpliterator<>(Long.MAX_VALUE,
+    Spliterator<V> spliterator = new Spliterators.AbstractSpliterator<>(Long.MAX_VALUE,
         Spliterator.ORDERED | Spliterator.IMMUTABLE) {
-      T prev;
+      V prev;
       boolean started, finished;
 
       @Override
-      public boolean tryAdvance(Consumer<? super T> action) {
+      public boolean tryAdvance(Consumer<? super V> action) {
         Objects.requireNonNull(action);
         if (finished)
           return false;
-        T t;
+        V t;
         if (started)
           t = next.apply(prev);
         else {
@@ -164,12 +164,12 @@ public boolean tryAdvance(Consumer<? super T> action) {
       }
 
       @Override
-      public void forEachRemaining(Consumer<? super T> action) {
+      public void forEachRemaining(Consumer<? super V> action) {
         Objects.requireNonNull(action);
         if (finished)
           return;
         finished = true;
-        T t = started ? next.apply(prev) : seed;
+        V t = started ? next.apply(prev) : seed;
         prev = null;
         while (hasNext.test(t)) {
           action.accept(t);
diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/util/ConfigUtil.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/util/ConfigUtil.java
index 92baa18a..72a116ff 100644
--- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/util/ConfigUtil.java
+++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/util/ConfigUtil.java
@@ -14,12 +14,12 @@ public class ConfigUtil {
    * writing getter methods in core classes that use the chaining configuration
    * pattern.
    * 
-   * @param <V>              The value type
+   * @param <R>              The value type
    * @param setValue         The value set for this configuration by the user
    * @param defaultGenerator The default value generator
    * @return The set value or the generated value
    */
-  public static <V> V withDefault(V setValue, Supplier<V> defaultGenerator) {
+  public static <R> R withDefault(R setValue, Supplier<R> defaultGenerator) {
     return setValue == null ? withDefault(setValue, defaultGenerator.get()) : setValue;
   }
 
@@ -29,26 +29,26 @@ public static <V> V withDefault(V setValue, Supplier<V> defaultGenerator) {
    * methods in core classes that use the chaining configuration pattern. Note
    * that nothing special happens if the set value generator returns null.
    * 
-   * @param <V>              The value type
+   * @param <R>              The value type
    * @param setValueSupplier The value generator set for this configuration by the
    *                         user
    * @param defaultValue     The default value
    * @return The generated value or the default value
    */
-  public static <V> V withDefault(Supplier<V> setValueSupplier, V defaultValue) {
-    return setValueSupplier == null ? withDefault((V) null, defaultValue) : setValueSupplier.get();
+  public static <R> R withDefault(Supplier<R> setValueSupplier, R defaultValue) {
+    return setValueSupplier == null ? withDefault((R) null, defaultValue) : setValueSupplier.get();
   }
 
   /**
    * Returns the set value if it is not null and returns the default value
    * otherwise. If the default is also null it throws an error.
    * 
-   * @param <V>          The value type
+   * @param <R>          The value type
    * @param setValue     The value set for this configuration by the user
    * @param defaultValue The default value
    * @return The set value or the default value
    */
-  public static <V> V withDefault(V setValue, V defaultValue) {
+  public static <R> R withDefault(R setValue, R defaultValue) {
     if (setValue == null) {
       Objects.requireNonNull(defaultValue, "Generated default value is null!");
       return defaultValue;
diff --git a/glsl-transformer/src/test/java/io/github/douira/glsl_transformer/token_filter/MultiFilterTest.java b/glsl-transformer/src/test/java/io/github/douira/glsl_transformer/token_filter/MultiFilterTest.java
index 15af0413..d2077037 100644
--- a/glsl-transformer/src/test/java/io/github/douira/glsl_transformer/token_filter/MultiFilterTest.java
+++ b/glsl-transformer/src/test/java/io/github/douira/glsl_transformer/token_filter/MultiFilterTest.java
@@ -11,15 +11,15 @@
 public class MultiFilterTest {
   int nextIndex;
 
-  static <T extends JobParameters> void assertPrintFilterResult(
-      String expected, String input, T parameters, TokenFilter<T> filter, String message) {
-    var t = new SingleASTTransformer<T>(SingleASTTransformer.IDENTITY_TRANSFORMATION);
+  static <J extends JobParameters> void assertPrintFilterResult(
+      String expected, String input, J parameters, TokenFilter<J> filter, String message) {
+    var t = new SingleASTTransformer<J>(SingleASTTransformer.IDENTITY_TRANSFORMATION);
     t.setTokenFilter(filter);
     assertEquals(expected, t.transform(input, parameters), message);
   }
 
-  static <T extends JobParameters> void assertPrintFilterResult(
-      String expected, String input, TokenFilter<T> filter, String message) {
+  static <J extends JobParameters> void assertPrintFilterResult(
+      String expected, String input, TokenFilter<J> filter, String message) {
     assertPrintFilterResult(expected, input, null, filter, message);
   }